namespace a = "http://relaxng.org/ns/compatibility/annotations/1.0"
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 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"

# DocBook NG: The "Mezcal" Release

# See http://docbook.org/ns/docbook

# DocBook NG: The "Mezcal" Release

# See http://docbook.org/ns/docbook

# This file is part of DocBook NG: The "Mezcal" Release.

# This schema is a "work-in-progress". It validates a DocBook-like grammar that
# may, in some incarnation, form the basis for DocBook V.next. Or it may not.
# At the moment, it's just an exploration by Norm. It has utterly no normative
# value at all.
# 
# Author: Norman Walsh, <ndw@nwalsh.com>
# Source: Derived from DocBook XML V4.3
# Release: $Id: docbook.rnc,v 1.2 2005/07/07 14:28:25 nwalsh Exp $
# 
# ======================================================================
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 =
    element * - (db:* | html:*) {
      ((attribute * { text }
        | text
        | db._any)*)
      >> a:documentation [
           "Any element from any namespace except the DocBook namespace"
         ]
    }
}
db.effectivity.attributes =
  
  ## Designates the computer or chip architecture to which the element applies
  attribute arch { text }?,
  
  ## provides a standard place for application-specific effectivity
  attribute condition { text }?,
  
  ## Indicates standards conformance characteristics of the element
  attribute conformance { text }?,
  
  ## Indicates the operating system to which the element is applicable
  attribute os { text }?,
  
  ## Indicates the editorial revision to which the element belongs
  attribute revision { text }?,
  
  ## Indicates something about the security level associated with the element to which it applies
  attribute security { text }?,
  
  ## Indicates the level of user experience for which the element applies
  attribute userlevel { text }?,
  
  ## Indicates the computer vendor to which the element applies.
  attribute vendor { text }?,
  
  ## Indicates the word size (width in bits) of the computer architecture to which the element applies
  attribute wordsize { text }?
db.linkend.attribute =
  attribute linkend {
    xsd:IDREF
    >> a:documentation [
         "Points to an internal link target by identifying the value of its xml:id attribute"
       ]
  }
db.linkends.attribute =
  attribute linkends {
    xsd:IDREFS
    >> a:documentation [
         "Points to one or more internal link targets by identifying the value of their xml:id attributes"
       ]
  }
db.xlink.href.attribute =
  
  ## Identifies a link target with a URI
  attribute xlink:href { text }
db.xlink.type.attribute =
  attribute xlink:type {
    
    ## Identifies the element as an XLink simple link
    "simple"
  }
db.xlink.role.attribute =
  attribute xlink:role {
    xsd:anyURI
    >> a:documentation [ "Identifies the XLink role of the link" ]
  }
db.xlink.arcrole.attribute =
  attribute xlink:arcrole {
    xsd:anyURI
    >> a:documentation [ "Identifies the XLink arcrole of the link" ]
  }
db.xlink.title.attribute =
  
  ## Identifies the XLink title of the link
  attribute xlink:title { text }?
db.xlink.show.enumeration = "new" | "replace" | "embed" | "other"
db.xlink.show.attribute =
  attribute xlink:show {
    db.xlink.show.enumeration
    >> a:documentation [
         "Identifies the XLink show behavior of the link"
       ]
  }
db.xlink.actuate.enumeration = "onLoad" | "onRequest" | "other" | "none"
db.xlink.actuate.attribute =
  attribute xlink:actuate {
    db.xlink.actuate.enumeration
    >> a:documentation [
         "Identifies the XLink actuate behavior of the link"
       ]
  }
db.href.attribute =
  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 =
  attribute xml:id {
    xsd:ID
    >> a:documentation [
         "Identifies the unique ID value of the element"
       ]
  }
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 { text }
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.revisionflag.enumeration = "changed" | "added" | "deleted" | "off"
db.revisionflag.attribute =
  attribute revisionflag {
    db.revisionflag.enumeration
    >> a:documentation [
         "Identifies the revision status of the element"
       ]
  }
db.common.attributes =
  db.xml.id.attribute?
  & db.version.attribute?
  & db.xml.lang.attribute?
  & db.xml.base.attribute?
  & db.remap.attribute?
  & db.xreflabel.attribute?
  & db.revisionflag.attribute?
  & db.effectivity.attributes
  & db.annotations.attribute?
db.common.idreq.attributes =
  db.xml.id.attribute
  & db.version.attribute?
  & db.xml.lang.attribute?
  & db.xml.base.attribute?
  & db.remap.attribute?
  & db.xreflabel.attribute?
  & db.revisionflag.attribute?
  & db.effectivity.attributes
  & db.annotations.attribute?
db.common.linking.attributes =
  (db.linkend.attribute | db.href.attribute)?
db.common.req.linking.attributes =
  db.linkend.attribute | db.href.attribute
db.common.data.attributes =
  attribute format { text }?,
  (attribute fileref { xsd:anyURI }
   | attribute entityref { xsd:ENTITY })
db.verbatim.continuation.enumeration = "continues" | "restarts"
db.verbatim.continuation.attribute =
  attribute continuation { db.verbatim.continuation.enumeration }
db.verbatim.linenumbering.enumeration = "numbered" | "unnumbered"
db.verbatim.linenumbering.attribute =
  attribute linenumbering { db.verbatim.linenumbering.enumeration }
db.verbatim.startinglinenumber.attribute =
  attribute startinglinenumber { xsd:integer }
db.verbatim.language.attribute = attribute language { text }
db.verbatim.xml.space.attribute = attribute xml:space { "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.spacing.enumeration = "compact" | "normal"
db.spacing.attribute = attribute spacing { db.spacing.enumeration }
db.pgwide.enumeration = "0" | "1"
db.pgwide.attribute =
  attribute pgwide {
    db.pgwide.enumeration
    >> a:documentation [
         "Indicates if the element is rendered across the column or the page"
       ]
  }
db.language.attribute = attribute language { text }
db.performance.enumeration = "optional" | "required"
db.performance.attribute =
  attribute performance { db.performance.enumeration }
db.floatstyle.attribute = attribute floatstyle { text }
db.halign.enumeration = "center" | "char" | "justify" | "left" | "right"
db.valign.enumeration = "bottom" | "middle" | "top"
db.biblio.class.enumeration =
  "doi"
  | "isbn"
  | "isrn"
  | "issn"
  | "libraryofcongress"
  | "pubnumber"
  | "uri"
db.biblio.class-enum.attribute =
  attribute class {
    db.biblio.class.enumeration
    >> a:documentation [
         "Identifies the kind of bibliographic identifier"
       ]
  }?
db.biblio.class-other.attribute =
  attribute otherclass {
    xsd:NMTOKEN
    >> a:documentation [
         "Provides an identifier for elements with the class 'other'"
       ]
  }
db.biblio.class-other.attributes =
  attribute class { "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._phrase = element phrase { db.phrase.attlist, db._text }
db._emphasis =
  element emphasis { db.emphasis.attlist, (db._text | db._emphasis)* }
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.req?, 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.error.inlines
   | db.os.inlines
   | db.programming.inlines
   | db.markup.inlines
   | db.gui.inlines
   | db.keyboard.inlines)
  | db.math.inlines
db.technical.inlines =
  (db.replaceable
   | db.systemitem
   | db.option
   | db.optional
   | db.package
   | db.property
   | db.termdef)
  | db.nonterminal
db.error.inlines =
  db.errorcode | db.errortext | db.errorname | db.errortype
db.oo.inlines = db.ooclass | db.ooexception | db.oointerface
db.programming.inlines =
  db.function
  | db.parameter
  | db.varname
  | db.returnvalue
  | db.type
  | db.classname
  | db.exceptionname
  | db.interfacename
  | db.methodname
  | db.modifier
  | db.initializer
  | db.oo.inlines
db.product.inlines =
  db.productnumber
  | db.productname
  | db.database
  | db.application
  | db.hardware
  | db.trademark
db.os.inlines =
  db.prompt
  | db.envar
  | db.filename
  | db.command
  | db.computeroutput
  | db.userinput
db.markup.inlines =
  db.tag
  | db.markup
  | db.token
  | db.symbol
  | db.literal
  | db.code
  | db.constant
  | db.email
  | db.uri
db.bibliography.inlines =
  db.citation
  | db.citerefentry
  | db.citetitle
  | db.citebiblioid
  | db.author
  | db.personname
  | db.orgname
  | db.editor
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.gui.inlines =
  db.guiicon
  | db.guibutton
  | db.guimenuitem
  | db.guimenu
  | db.guisubmenu
  | db.guilabel
  | db.menuchoice
  | db.mousebutton
db.keyboard.inlines =
  db.keycombo
  | db.keycap
  | db.keycode
  | db.keysym
  | db.shortcut
  | db.accel
db.link.inlines =
  (db.xref | db.link | db.olink | db.anchor) | db.biblioref
db.extension.inlines = notAllowed
db.nopara.blocks =
  (db.list.blocks
   | db.admonition.blocks
   | db.formal.blocks
   | db.informal.blocks
   | db.publishing.blocks
   | db.graphic.blocks
   | db.technical.blocks
   | db.verbatim.blocks
   | db.synopsis.blocks
   | db.bridgehead
   | db.remark
   | db.revhistory)
  | db.indexterm
  | db.math.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.informal.blocks =
  db.informalexample | db.informalfigure | db.informaltable
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.admonition.blocks =
  db.caution | db.important | db.note | db.tip | db.warning
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.programlisting | db.screen | db.literallayout | db.synopsis)
  | (db.programlistingco | db.screenco)
db.synopsis.blocks =
  db.cmdsynopsis
  | db.funcsynopsis
  | db.classsynopsis
  | db.methodsynopsis
  | db.constructorsynopsis
  | db.destructorsynopsis
  | db.fieldsynopsis
db.extension.blocks = notAllowed
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.date
   | db.edition
   | db.editor
   | db.issuenum
   | db.keywordset
   | db.legalnotice
   | db.mediaobject
   | db.orgname
   | db.othercredit
   | db.pagenums
   | db.printhistory
   | db.productname
   | db.productnumber
   | db.pubdate
   | db.publisher
   | db.publishername
   | db.releaseinfo
   | db.revhistory
   | db.seriesvolnums
   | db.subjectset
   | db.volumenum)
  | db.extendedlink
  | (db.bibliomisc | db.bibliomset | db.bibliorelation | db.biblioset)
  | db.itermset
db.bibliographic.elements =
  db.info.elements
  | db.abbrev
  | db.citerefentry
  | db.citetitle
  | db.citebiblioid
  | db.personname
  | db.subtitle
  | db.title
div {
  db.title.role.attribute = attribute role { text }
  db.title.attlist =
    db.title.role.attribute?
    & db.common.attributes
    & db.common.linking.attributes
  db.title =
    element title {
      db.title.attlist,
      (db.all.inlines*)
      >> a:documentation [
           "The text of the title of a section of a document or of a formal block-level element"
         ]
    }
}
div {
  db.titleabbrev.role.attribute = attribute role { text }
  db.titleabbrev.attlist =
    db.titleabbrev.role.attribute?
    & db.common.attributes
    & db.common.linking.attributes
  db.titleabbrev =
    element titleabbrev {
      db.titleabbrev.attlist,
      (db.all.inlines*)
      >> a:documentation [ "The abbreviation of a Title" ]
    }
}
div {
  db.subtitle.role.attribute = attribute role { text }
  db.subtitle.attlist =
    db.subtitle.role.attribute?
    & db.common.attributes
    & db.common.linking.attributes
  db.subtitle =
    element subtitle {
      db.subtitle.attlist,
      (db.all.inlines*)
      >> a:documentation [ "The subtitle of a document" ]
    }
}
div {
  db.info.role.attribute = attribute role { text }
  db.info.attlist = db.info.role.attribute? & db.common.attributes
  db.info =
    element info {
      db.info.attlist,
      db._title,
      (db.info.elements*)
      >> a:documentation [
           "A wrapper for information about a component or other block"
         ]
    }
}
div {
  db.titlereq.info.role.attribute = attribute role { text }
  db.titlereq.info.attlist =
    db.titlereq.info.role.attribute? & db.common.attributes
  db.titlereq.info =
    element info {
      db.titlereq.info.attlist,
      db._title.req,
      (db.info.elements*)
      >> a:documentation [
           "A wrapper for information about a component or other block with a required title"
         ]
    }
}
div {
  db.titleonly.info.role.attribute = attribute role { text }
  db.titleonly.info.attlist =
    db.titleonly.info.role.attribute? & db.common.attributes
  db.titleonly.info =
    element info {
      db.titleonly.info.attlist,
      db._title.only,
      (db.info.elements*)
      >> a:documentation [
           "A wrapper for information about a component or other block with only a title"
         ]
    }
}
div {
  db.titleonlyreq.info.role.attribute = attribute role { text }
  db.titleonlyreq.info.attlist =
    db.titleonlyreq.info.role.attribute? & db.common.attributes
  db.titleonlyreq.info =
    element info {
      db.titleonlyreq.info.attlist,
      db._title.onlyreq,
      (db.info.elements*)
      >> a:documentation [
           "A wrapper for information about a component or other block with only a required title"
         ]
    }
}
div {
  db.titleforbidden.info.role.attribute = attribute role { text }
  db.titleforbidden.info.attlist =
    db.titleforbidden.info.role.attribute? & db.common.attributes
  db.titleforbidden.info =
    element info {
      db.titleforbidden.info.attlist,
      (db.info.elements*)
      >> a:documentation [
           "A wrapper for information about a component or other block without a title"
         ]
    }
}
div {
  db.subjectset.role.attribute = attribute role { text }
  db.subjectset.scheme.attribute = attribute scheme { xsd:NMTOKEN }
  db.subjectset.attlist =
    db.subjectset.role.attribute?
    & db.common.attributes
    & db.common.linking.attributes
    & db.subjectset.scheme.attribute?
  db.subjectset =
    element subjectset {
      db.subjectset.attlist,
      (db.subject+)
      >> a:documentation [
           "A set of terms describing the subject matter of a document"
         ]
    }
}
div {
  db.subject.role.attribute = attribute role { text }
  db.subject.weight.attribute = attribute weight { text }
  db.subject.attlist =
    db.subject.role.attribute?
    & db.common.attributes
    & db.common.linking.attributes
    & db.subject.weight.attribute?
  db.subject =
    element subject {
      db.subject.attlist,
      (db.subjectterm+)
      >> a:documentation [
           "One of a group of terms describing the subject matter of a document"
         ]
    }
}
div {
  db.subjectterm.role.attribute = attribute role { text }
  db.subjectterm.attlist =
    db.subjectterm.role.attribute?
    & db.common.attributes
    & db.common.linking.attributes
  db.subjectterm =
    element subjectterm {
      db.subjectterm.attlist,
      text
      >> a:documentation [
           "A term in a group of terms describing the subject matter of a document"
         ]
    }
}
div {
  db.keywordset.role.attribute = attribute role { text }
  db.keywordset.attlist =
    db.keywordset.role.attribute?
    & db.common.attributes
    & db.common.linking.attributes
  db.keywordset =
    element keywordset {
      db.keywordset.attlist,
      (db.keyword+)
      >> a:documentation [
           "A set of keywords describing the content of a document"
         ]
    }
}
div {
  db.keyword.role.attribute = attribute role { text }
  db.keyword.attlist =
    db.keyword.role.attribute?
    & db.common.attributes
    & db.common.linking.attributes
  db.keyword =
    element keyword {
      db.keyword.attlist,
      text
      >> a:documentation [
           "One of a set of keywords describing the content of a document"
         ]
    }
}
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 =
    element procedure {
      db.procedure.attlist,
      db.procedure.info,
      db.all.blocks*,
      (db.step+)
      >> a:documentation [
           "A list of operations to be performed in a well-defined sequence"
         ]
    }
}
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
  db.step =
    element step {
      db.step.attlist,
      db.step.info,
      db.all.blocks*,
      (db.substeps | db.stepalternatives)?,
      (db.all.blocks*)
      >> a:documentation [ "A unit of action in a procedure" ]
    }
}
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 =
    element stepalternatives {
      db.stepalternatives.attlist,
      db.stepalternatives.info,
      (db.step+)
      >> a:documentation [ "Alternative steps in a procedure" ]
    }
}
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 =
    element substeps {
      db.substeps.attlist,
      (db.step+)
      >> a:documentation [
           "A wrapper for steps that occur within steps in a procedure"
         ]
    }
}
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 =
    [
      s:rule [
        context = "db:sidebar"
        "\x{a}" ~
        "          "
        s:assert [
          test = "not(.//db:sidebar)"
          "sidebar must not occur in the descendants of sidebar"
        ]
        "\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}" ~
        "        "
      ]
    ]
    element sidebar {
      db.sidebar.attlist,
      db.sidebar.info,
      (db.all.blocks+)
      >> a:documentation [
           "A portion of a document that is isolated from the main narrative flow"
         ]
    }
}
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 =
    element abstract {
      db.abstract.attlist,
      db.abstract.info,
      (db.para.blocks+) >> a:documentation [ "A summary" ]
    }
}
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 =
    element personblurb {
      db.personblurb.attlist,
      db.personblurb.info,
      (db.para.blocks+)
      >> a:documentation [
           "A short description or note about a person"
         ]
    }
}
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 =
    element blockquote {
      db.blockquote.attlist,
      db.blockquote.info,
      db.attribution?,
      (db.all.blocks+)
      >> a:documentation [ "A quotation set off from the main text" ]
    }
}
div {
  db.attribution.role.attribute = attribute role { text }
  db.attribution.attlist =
    db.attribution.role.attribute?
    & db.common.attributes
    & db.common.linking.attributes
  db.attribution =
    element attribution {
      db.attribution.attlist,
      ((db._text | db.personname | db.citetitle | db.citation)*)
      >> a:documentation [ "The source of a block quote or epigraph" ]
    }
}
div {
  db.bridgehead.role.attribute = attribute role { text }
  db.bridgehead.renderas.enumeration =
    "other" | "sect1" | "sect2" | "sect3" | "sect4" | "sect5"
  db.bridgehead.renderas.attribute =
    attribute renderas { db.bridgehead.renderas.enumeration }
  db.bridgehead.attlist =
    db.bridgehead.role.attribute?
    & db.common.attributes
    & db.common.linking.attributes
    & db.bridgehead.renderas.attribute?
  db.bridgehead =
    element bridgehead {
      db.bridgehead.attlist,
      (db.all.inlines*) >> a:documentation [ "A free-floating heading" ]
    }
}
div {
  db.remark.role.attribute = attribute role { text }
  db.remark.attlist =
    db.remark.role.attribute?
    & db.common.attributes
    & db.common.linking.attributes
  db.remark =
    element remark {
      db.remark.attlist,
      db._text
      >> a:documentation [
           "A remark (or comment) intended for presentation in a draft manuscript"
         ]
    }
}
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 =
    element epigraph {
      db.epigraph.attlist,
      db.epigraph.info,
      db.attribution?,
      ((db.para.blocks | db.literallayout)+)
      >> a:documentation [
           "A short inscription at the beginning of a document or component"
         ]
    }
}
div {
  db.footnote.role.attribute = attribute role { text }
  db.footnote.label.attribute = attribute label { text }
  db.footnote.attlist =
    db.footnote.role.attribute?
    & db.common.attributes
    & db.common.linking.attributes
    & db.footnote.label.attribute?
  db.footnote =
    [
      s:rule [
        context = "db:footnote"
        "\x{a}" ~
        "          "
        s:assert [
          test = "not(.//db:footnote)"
          "footnote must not occur in the descendants of footnote"
        ]
        "\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}" ~
        "        "
      ]
      s:rule [
        context = "db:footnote"
        "\x{a}" ~
        "          "
        s:assert [
          test = "not(.//db:figure)"
          "figure must not occur in the descendants of footnote"
        ]
        "\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}" ~
        "        "
      ]
      s:rule [
        context = "db:footnote"
        "\x{a}" ~
        "          "
        s:assert [
          test = "not(.//db:table)"
          "table must not occur in the descendants of footnote"
        ]
        "\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}" ~
        "        "
      ]
      s:rule [
        context = "db:footnote"
        "\x{a}" ~
        "          "
        s:assert [
          test = "not(.//db:important)"
          "important must not occur in the descendants of footnote"
        ]
        "\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}" ~
        "        "
      ]
      s:rule [
        context = "db:footnote"
        "\x{a}" ~
        "          "
        s:assert [
          test = "not(.//db:tip)"
          "tip must not occur in the descendants of footnote"
        ]
        "\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}" ~
        "        "
      ]
      s:rule [
        context = "db:footnote"
        "\x{a}" ~
        "          "
        s:assert [
          test = "not(.//db:indexterm)"
          "indexterm must not occur in the descendants of footnote"
        ]
        "\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}" ~
        "        "
      ]
      s:rule [
        context = "db:footnote"
        "\x{a}" ~
        "          "
        s:assert [
          test = "not(.//db:indexterm)"
          "indexterm must not occur in the descendants of footnote"
        ]
        "\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}" ~
        "        "
      ]
      s:rule [
        context = "db:footnote"
        "\x{a}" ~
        "          "
        s:assert [
          test = "not(.//db:task)"
          "task must not occur in the descendants of footnote"
        ]
        "\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}" ~
        "        "
      ]
      s:rule [
        context = "db:footnote"
        "\x{a}" ~
        "          "
        s:assert [
          test = "not(.//db:footnote)"
          "footnote must not occur in the descendants of footnote"
        ]
        "\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}" ~
        "        "
      ]
      s:rule [
        context = "db:footnote"
        "\x{a}" ~
        "          "
        s:assert [
          test = "not(.//db:figure)"
          "figure must not occur in the descendants of footnote"
        ]
        "\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}" ~
        "        "
      ]
      s:rule [
        context = "db:footnote"
        "\x{a}" ~
        "          "
        s:assert [
          test = "not(.//db:table)"
          "table must not occur in the descendants of footnote"
        ]
        "\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}" ~
        "        "
      ]
      s:rule [
        context = "db:footnote"
        "\x{a}" ~
        "          "
        s:assert [
          test = "not(.//db:important)"
          "important must not occur in the descendants of footnote"
        ]
        "\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}" ~
        "        "
      ]
      s:rule [
        context = "db:footnote"
        "\x{a}" ~
        "          "
        s:assert [
          test = "not(.//db:tip)"
          "tip must not occur in the descendants of footnote"
        ]
        "\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}" ~
        "        "
      ]
      s:rule [
        context = "db:footnote"
        "\x{a}" ~
        "          "
        s:assert [
          test = "not(.//db:indexterm)"
          "indexterm must not occur in the descendants of footnote"
        ]
        "\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}" ~
        "        "
      ]
      s:rule [
        context = "db:footnote"
        "\x{a}" ~
        "          "
        s:assert [
          test = "not(.//db:indexterm)"
          "indexterm must not occur in the descendants of footnote"
        ]
        "\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}" ~
        "        "
      ]
      s:rule [
        context = "db:footnote"
        "\x{a}" ~
        "          "
        s:assert [
          test = "not(.//db:task)"
          "task must not occur in the descendants of footnote"
        ]
        "\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}" ~
        "        "
      ]
    ]
    element footnote {
      db.footnote.attlist,
      (db.all.blocks+) >> a:documentation [ "A footnote" ]
    }
}
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 =
    element formalpara {
      db.formalpara.attlist,
      db.formalpara.info,
      db.indexing.inlines*,
      db.para >> a:documentation [ "A paragraph with a title" ]
    }
}
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 =
    [
      s:rule [
        context = "/db:para"
        "\x{a}" ~
        "          "
        s:assert [
          test = "@version"
          "The root element must have a version attribute."
        ]
        "\x{a}" ~
        "        "
      ]
      s:rule [
        context = "/db:para"
        "\x{a}" ~
        "          "
        s:assert [
          test = "@version"
          "The root element must have a version attribute."
        ]
        "\x{a}" ~
        "        "
      ]
    ]
    element para {
      db.para.attlist,
      db.para.info,
      ((db.all.inlines | db.nopara.blocks)*)
      >> a:documentation [ "A paragraph" ]
    }
}
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 =
    element simpara {
      db.simpara.attlist,
      db.simpara.info,
      (db.all.inlines*)
      >> a:documentation [
           "A paragraph that contains only text and inline markup, no block elements"
         ]
    }
}
db.admonition.contentmodel = db._info.title.only, db.all.blocks+
div {
  db.caution.role.attribute = attribute role { text }
  db.caution.attlist =
    db.caution.role.attribute?
    & db.common.attributes
    & db.common.linking.attributes
  db.caution =
    [
      s:rule [
        context = "db:caution"
        "\x{a}" ~
        "          "
        s:assert [
          test = "not(.//db:caution)"
          "caution must not occur in the descendants of caution"
        ]
        "\x{a}" ~
        "        "
      ]
      s:rule [
        context = "db:caution"
        "\x{a}" ~
        "          "
        s:assert [
          test = "not(.//db:important)"
          "important must not occur in the descendants of caution"
        ]
        "\x{a}" ~
        "        "
      ]
      s:rule [
        context = "db:caution"
        "\x{a}" ~
        "          "
        s:assert [
          test = "not(.//db:note)"
          "note must not occur in the descendants of caution"
        ]
        "\x{a}" ~
        "        "
      ]
      s:rule [
        context = "db:caution"
        "\x{a}" ~
        "          "
        s:assert [
          test = "not(.//db:tip)"
          "tip must not occur in the descendants of caution"
        ]
        "\x{a}" ~
        "        "
      ]
      s:rule [
        context = "db:caution"
        "\x{a}" ~
        "          "
        s:assert [
          test = "not(.//db:warning)"
          "warning must not occur in the descendants of caution"
        ]
        "\x{a}" ~
        "        "
      ]
      s:rule [
        context = "db:caution"
        "\x{a}" ~
        "          "
        s:assert [
          test = "not(.//db:caution)"
          "caution must not occur in the descendants of caution"
        ]
        "\x{a}" ~
        "        "
      ]
      s:rule [
        context = "db:caution"
        "\x{a}" ~
        "          "
        s:assert [
          test = "not(.//db:important)"
          "important must not occur in the descendants of caution"
        ]
        "\x{a}" ~
        "        "
      ]
      s:rule [
        context = "db:caution"
        "\x{a}" ~
        "          "
        s:assert [
          test = "not(.//db:note)"
          "note must not occur in the descendants of caution"
        ]
        "\x{a}" ~
        "        "
      ]
      s:rule [
        context = "db:caution"
        "\x{a}" ~
        "          "
        s:assert [
          test = "not(.//db:tip)"
          "tip must not occur in the descendants of caution"
        ]
        "\x{a}" ~
        "        "
      ]
      s:rule [
        context = "db:caution"
        "\x{a}" ~
        "          "
        s:assert [
          test = "not(.//db:warning)"
          "warning must not occur in the descendants of caution"
        ]
        "\x{a}" ~
        "        "
      ]
    ]
    element caution {
      db.caution.attlist,
      db.admonition.contentmodel
      >> a:documentation [ "A note of caution" ]
    }
}
div {
  db.important.role.attribute = attribute role { text }
  db.important.attlist =
    db.important.role.attribute?
    & db.common.attributes
    & db.common.linking.attributes
  db.important =
    [
      s:rule [
        context = "db:important"
        "\x{a}" ~
        "          "
        s:assert [
          test = "not(.//db:caution)"
          "caution must not occur in the descendants of important"
        ]
        "\x{a}" ~
        "        "
      ]
      s:rule [
        context = "db:important"
        "\x{a}" ~
        "          "
        s:assert [
          test = "not(.//db:important)"
          "important must not occur in the descendants of important"
        ]
        "\x{a}" ~
        "        "
      ]
      s:rule [
        context = "db:important"
        "\x{a}" ~
        "          "
        s:assert [
          test = "not(.//db:note)"
          "note must not occur in the descendants of important"
        ]
        "\x{a}" ~
        "        "
      ]
      s:rule [
        context = "db:important"
        "\x{a}" ~
        "          "
        s:assert [
          test = "not(.//db:tip)"
          "tip must not occur in the descendants of important"
        ]
        "\x{a}" ~
        "        "
      ]
      s:rule [
        context = "db:important"
        "\x{a}" ~
        "          "
        s:assert [
          test = "not(.//db:warning)"
          "warning must not occur in the descendants of important"
        ]
        "\x{a}" ~
        "        "
      ]
      s:rule [
        context = "db:important"
        "\x{a}" ~
        "          "
        s:assert [
          test = "not(.//db:caution)"
          "caution must not occur in the descendants of important"
        ]
        "\x{a}" ~
        "        "
      ]
      s:rule [
        context = "db:important"
        "\x{a}" ~
        "          "
        s:assert [
          test = "not(.//db:important)"
          "important must not occur in the descendants of important"
        ]
        "\x{a}" ~
        "        "
      ]
      s:rule [
        context = "db:important"
        "\x{a}" ~
        "          "
        s:assert [
          test = "not(.//db:note)"
          "note must not occur in the descendants of important"
        ]
        "\x{a}" ~
        "        "
      ]
      s:rule [
        context = "db:important"
        "\x{a}" ~
        "          "
        s:assert [
          test = "not(.//db:tip)"
          "tip must not occur in the descendants of important"
        ]
        "\x{a}" ~
        "        "
      ]
      s:rule [
        context = "db:important"
        "\x{a}" ~
        "          "
        s:assert [
          test = "not(.//db:warning)"
          "warning must not occur in the descendants of important"
        ]
        "\x{a}" ~
        "        "
      ]
    ]
    element important {
      db.important.attlist,
      db.admonition.contentmodel
      >> a:documentation [ "An admonition set off from the text" ]
    }
}
div {
  db.note.role.attribute = attribute role { text }
  db.note.attlist =
    db.note.role.attribute?
    & db.common.attributes
    & db.common.linking.attributes
  db.note =
    [
      s:rule [
        context = "db:note"
        "\x{a}" ~
        "          "
        s:assert [
          test = "not(.//db:caution)"
          "caution must not occur in the descendants of note"
        ]
        "\x{a}" ~
        "        "
      ]
      s:rule [
        context = "db:note"
        "\x{a}" ~
        "          "
        s:assert [
          test = "not(.//db:important)"
          "important must not occur in the descendants of note"
        ]
        "\x{a}" ~
        "        "
      ]
      s:rule [
        context = "db:note"
        "\x{a}" ~
        "          "
        s:assert [
          test = "not(.//db:note)"
          "note must not occur in the descendants of note"
        ]
        "\x{a}" ~
        "        "
      ]
      s:rule [
        context = "db:note"
        "\x{a}" ~
        "          "
        s:assert [
          test = "not(.//db:tip)"
          "tip must not occur in the descendants of note"
        ]
        "\x{a}" ~
        "        "
      ]
      s:rule [
        context = "db:note"
        "\x{a}" ~
        "          "
        s:assert [
          test = "not(.//db:warning)"
          "warning must not occur in the descendants of note"
        ]
        "\x{a}" ~
        "        "
      ]
      s:rule [
        context = "db:note"
        "\x{a}" ~
        "          "
        s:assert [
          test = "not(.//db:caution)"
          "caution must not occur in the descendants of note"
        ]
        "\x{a}" ~
        "        "
      ]
      s:rule [
        context = "db:note"
        "\x{a}" ~
        "          "
        s:assert [
          test = "not(.//db:important)"
          "important must not occur in the descendants of note"
        ]
        "\x{a}" ~
        "        "
      ]
      s:rule [
        context = "db:note"
        "\x{a}" ~
        "          "
        s:assert [
          test = "not(.//db:note)"
          "note must not occur in the descendants of note"
        ]
        "\x{a}" ~
        "        "
      ]
      s:rule [
        context = "db:note"
        "\x{a}" ~
        "          "
        s:assert [
          test = "not(.//db:tip)"
          "tip must not occur in the descendants of note"
        ]
        "\x{a}" ~
        "        "
      ]
      s:rule [
        context = "db:note"
        "\x{a}" ~
        "          "
        s:assert [
          test = "not(.//db:warning)"
          "warning must not occur in the descendants of note"
        ]
        "\x{a}" ~
        "        "
      ]
    ]
    element note {
      db.note.attlist,
      db.admonition.contentmodel
      >> a:documentation [ "A message set off from the text" ]
    }
}
div {
  db.tip.role.attribute = attribute role { text }
  db.tip.attlist =
    db.tip.role.attribute?
    & db.common.attributes
    & db.common.linking.attributes
  db.tip =
    [
      s:rule [
        context = "db:tip"
        "\x{a}" ~
        "          "
        s:assert [
          test = "not(.//db:caution)"
          "caution must not occur in the descendants of tip"
        ]
        "\x{a}" ~
        "        "
      ]
      s:rule [
        context = "db:tip"
        "\x{a}" ~
        "          "
        s:assert [
          test = "not(.//db:important)"
          "important must not occur in the descendants of tip"
        ]
        "\x{a}" ~
        "        "
      ]
      s:rule [
        context = "db:tip"
        "\x{a}" ~
        "          "
        s:assert [
          test = "not(.//db:note)"
          "note must not occur in the descendants of tip"
        ]
        "\x{a}" ~
        "        "
      ]
      s:rule [
        context = "db:tip"
        "\x{a}" ~
        "          "
        s:assert [
          test = "not(.//db:tip)"
          "tip must not occur in the descendants of tip"
        ]
        "\x{a}" ~
        "        "
      ]
      s:rule [
        context = "db:tip"
        "\x{a}" ~
        "          "
        s:assert [
          test = "not(.//db:warning)"
          "warning must not occur in the descendants of tip"
        ]
        "\x{a}" ~
        "        "
      ]
      s:rule [
        context = "db:tip"
        "\x{a}" ~
        "          "
        s:assert [
          test = "not(.//db:caution)"
          "caution must not occur in the descendants of tip"
        ]
        "\x{a}" ~
        "        "
      ]
      s:rule [
        context = "db:tip"
        "\x{a}" ~
        "          "
        s:assert [
          test = "not(.//db:important)"
          "important must not occur in the descendants of tip"
        ]
        "\x{a}" ~
        "        "
      ]
      s:rule [
        context = "db:tip"
        "\x{a}" ~
        "          "
        s:assert [
          test = "not(.//db:note)"
          "note must not occur in the descendants of tip"
        ]
        "\x{a}" ~
        "        "
      ]
      s:rule [
        context = "db:tip"
        "\x{a}" ~
        "          "
        s:assert [
          test = "not(.//db:tip)"
          "tip must not occur in the descendants of tip"
        ]
        "\x{a}" ~
        "        "
      ]
      s:rule [
        context = "db:tip"
        "\x{a}" ~
        "          "
        s:assert [
          test = "not(.//db:warning)"
          "warning must not occur in the descendants of tip"
        ]
        "\x{a}" ~
        "        "
      ]
    ]
    element tip {
      db.tip.attlist,
      db.admonition.contentmodel
      >> a:documentation [
           "A suggestion to the user, set off from the text"
         ]
    }
}
div {
  db.warning.role.attribute = attribute role { text }
  db.warning.attlist =
    db.warning.role.attribute?
    & db.common.attributes
    & db.common.linking.attributes
  db.warning =
    [
      s:rule [
        context = "db:warning"
        "\x{a}" ~
        "          "
        s:assert [
          test = "not(.//db:caution)"
          "caution must not occur in the descendants of warning"
        ]
        "\x{a}" ~
        "        "
      ]
      s:rule [
        context = "db:warning"
        "\x{a}" ~
        "          "
        s:assert [
          test = "not(.//db:important)"
          "important must not occur in the descendants of warning"
        ]
        "\x{a}" ~
        "        "
      ]
      s:rule [
        context = "db:warning"
        "\x{a}" ~
        "          "
        s:assert [
          test = "not(.//db:note)"
          "note must not occur in the descendants of warning"
        ]
        "\x{a}" ~
        "        "
      ]
      s:rule [
        context = "db:warning"
        "\x{a}" ~
        "          "
        s:assert [
          test = "not(.//db:tip)"
          "tip must not occur in the descendants of warning"
        ]
        "\x{a}" ~
        "        "
      ]
      s:rule [
        context = "db:warning"
        "\x{a}" ~
        "          "
        s:assert [
          test = "not(.//db:warning)"
          "warning must not occur in the descendants of warning"
        ]
        "\x{a}" ~
        "        "
      ]
      s:rule [
        context = "db:warning"
        "\x{a}" ~
        "          "
        s:assert [
          test = "not(.//db:caution)"
          "caution must not occur in the descendants of warning"
        ]
        "\x{a}" ~
        "        "
      ]
      s:rule [
        context = "db:warning"
        "\x{a}" ~
        "          "
        s:assert [
          test = "not(.//db:important)"
          "important must not occur in the descendants of warning"
        ]
        "\x{a}" ~
        "        "
      ]
      s:rule [
        context = "db:warning"
        "\x{a}" ~
        "          "
        s:assert [
          test = "not(.//db:note)"
          "note must not occur in the descendants of warning"
        ]
        "\x{a}" ~
        "        "
      ]
      s:rule [
        context = "db:warning"
        "\x{a}" ~
        "          "
        s:assert [
          test = "not(.//db:tip)"
          "tip must not occur in the descendants of warning"
        ]
        "\x{a}" ~
        "        "
      ]
      s:rule [
        context = "db:warning"
        "\x{a}" ~
        "          "
        s:assert [
          test = "not(.//db:warning)"
          "warning must not occur in the descendants of warning"
        ]
        "\x{a}" ~
        "        "
      ]
    ]
    element warning {
      db.warning.attlist,
      db.admonition.contentmodel
      >> a:documentation [ "An admonition set off from the text" ]
    }
}
div {
  db.itemizedlist.role.attribute = attribute role { text }
  db.itemizedlist.mark.attribute = attribute mark { text }
  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 =
    element itemizedlist {
      db.itemizedlist.attlist,
      db.itemizedlist.info,
      db.all.blocks*,
      (db.listitem+)
      >> a:documentation [
           "A list in which each entry is marked with a bullet or other dingbat"
         ]
    }
}
div {
  db.orderedlist.role.attribute = attribute role { text }
  db.orderedlist.continuation.enumeration = "continues" | "restarts"
  db.orderedlist.continuation.attribute =
    attribute continuation { db.orderedlist.continuation.enumeration }
  db.orderedlist.inheritnum.enumeration = "ignore" | "inherit"
  db.orderedlist.inheritnum.attribute =
    attribute inheritnum { db.orderedlist.inheritnum.enumeration }
  db.orderedlist.numeration.enumeration =
    "arabic" | "upperalpha" | "loweralpha" | "upperroman" | "lowerroman"
  db.orderedlist.numeration.attribute =
    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.inheritnum.attribute?
    & db.orderedlist.numeration.attribute?
  db.orderedlist.info = db._info.title.only
  db.orderedlist =
    element orderedlist {
      db.orderedlist.attlist,
      db.orderedlist.info,
      db.all.blocks*,
      (db.listitem+)
      >> a:documentation [
           "A list in which each entry is marked with a sequentially incremented label"
         ]
    }
}
div {
  db.listitem.role.attribute = attribute role { text }
  db.listitem.override.attribute = attribute override { text }
  db.listitem.attlist =
    db.listitem.role.attribute?
    & db.common.attributes
    & db.common.linking.attributes
    & db.listitem.override.attribute?
  db.listitem =
    element listitem {
      db.listitem.attlist,
      (db.all.blocks+)
      >> a:documentation [ "A wrapper for the elements of a list item" ]
    }
}
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 =
    element segmentedlist {
      db.segmentedlist.attlist,
      db.segmentedlist.info,
      db.segtitle+,
      (db.seglistitem+)
      >> a:documentation [
           "A segmented list, a list of sets of elements"
         ]
    }
}
div {
  db.segtitle.role.attribute = attribute role { text }
  db.segtitle.attlist =
    db.segtitle.role.attribute?
    & db.common.attributes
    & db.common.linking.attributes
  db.segtitle =
    element segtitle {
      db.segtitle.attlist,
      (db.all.inlines*)
      >> a:documentation [
           "The title of an element of a list item in a segmented list"
         ]
    }
}
div {
  db.seglistitem.role.attribute = attribute role { text }
  db.seglistitem.attlist =
    db.seglistitem.role.attribute?
    & db.common.attributes
    & db.common.linking.attributes
  db.seglistitem =
    [
      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}" ~
        "        "
      ]
    ]
    element seglistitem {
      db.seglistitem.attlist,
      (db.seg+) >> a:documentation [ "A list item in a segmented list" ]
    }
}
div {
  db.seg.role.attribute = attribute role { text }
  db.seg.attlist =
    db.seg.role.attribute?
    & db.common.attributes
    & db.common.linking.attributes
  db.seg =
    element seg {
      db.seg.attlist,
      (db.all.inlines*)
      >> a:documentation [
           "An element of a list item in a segmented list"
         ]
    }
}
div {
  db.simplelist.role.attribute = attribute role { text }
  db.simplelist.type.enumeration = "horiz" | "vert" | "inline"
  db.simplelist.type.attribute =
    attribute type { db.simplelist.type.enumeration }
  db.simplelist.columns.attribute = 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 =
    element simplelist {
      db.simplelist.attlist,
      (db.member+)
      >> a:documentation [
           "An undecorated list of single words or short phrases"
         ]
    }
}
div {
  db.member.role.attribute = attribute role { text }
  db.member.attlist =
    db.member.role.attribute?
    & db.common.attributes
    & db.common.linking.attributes
  db.member =
    element member {
      db.member.attlist,
      (db.all.inlines*)
      >> a:documentation [ "An element of a simple list" ]
    }
}
div {
  db.variablelist.role.attribute = attribute role { text }
  db.variablelist.termlength.attribute = 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 =
    element variablelist {
      db.variablelist.attlist,
      db.variablelist.info,
      db.all.blocks*,
      (db.varlistentry+)
      >> a:documentation [
           "A list in which each entry is composed of a set of one or more terms and an associated description"
         ]
    }
}
div {
  db.varlistentry.role.attribute = attribute role { text }
  db.varlistentry.attlist =
    db.varlistentry.role.attribute?
    & db.common.attributes
    & db.common.linking.attributes
  db.varlistentry =
    element varlistentry {
      db.varlistentry.attlist,
      db.term+,
      db.listitem
      >> a:documentation [
           "A wrapper for a set of terms and the associated description in a variable list"
         ]
    }
}
div {
  db.term.role.attribute = attribute role { text }
  db.term.attlist =
    db.term.role.attribute?
    & db.common.attributes
    & db.common.linking.attributes
  db.term =
    element term {
      db.term.attlist,
      (db.all.inlines*)
      >> a:documentation [
           "The word or phrase being defined or described in a variable list"
         ]
    }
}
div {
  db.example.role.attribute = attribute role { text }
  db.example.label.attribute = attribute label { text }
  db.example.width.attribute = attribute width { text }
  db.example.attlist =
    db.example.role.attribute?
    & db.common.attributes
    & db.common.linking.attributes
    & db.example.label.attribute?
    & db.floatstyle.attribute?
    & db.example.width.attribute?
  db.example.info = db._info.title.onlyreq
  db.example =
    [
      s:rule [
        context = "db:example"
        "\x{a}" ~
        "          "
        s:assert [
          test = "not(.//db:example)"
          "example must not occur in the descendants of example"
        ]
        "\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}" ~
        "        "
      ]
      s:rule [
        context = "db:example"
        "\x{a}" ~
        "          "
        s:assert [
          test = "not(.//db:table)"
          "table must not occur in the descendants of example"
        ]
        "\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}" ~
        "        "
      ]
      s:rule [
        context = "db:example"
        "\x{a}" ~
        "          "
        s:assert [
          test = "not(.//db:caution)"
          "caution must not occur in the descendants of example"
        ]
        "\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}" ~
        "        "
      ]
      s:rule [
        context = "db:example"
        "\x{a}" ~
        "          "
        s:assert [
          test = "not(.//db:note)"
          "note must not occur in the descendants of example"
        ]
        "\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}" ~
        "        "
      ]
      s:rule [
        context = "db:example"
        "\x{a}" ~
        "          "
        s:assert [
          test = "not(.//db:warning)"
          "warning must not occur in the descendants of example"
        ]
        "\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}" ~
        "        "
      ]
      s:rule [
        context = "db:example"
        "\x{a}" ~
        "          "
        s:assert [
          test = "not(.//db:figure)"
          "figure must not occur in the descendants of example"
        ]
        "\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}" ~
        "        "
      ]
      s:rule [
        context = "db:example"
        "\x{a}" ~
        "          "
        s:assert [
          test = "not(.//db:table)"
          "table must not occur in the descendants of example"
        ]
        "\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}" ~
        "        "
      ]
      s:rule [
        context = "db:example"
        "\x{a}" ~
        "          "
        s:assert [
          test = "not(.//db:important)"
          "important must not occur in the descendants of example"
        ]
        "\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}" ~
        "        "
      ]
      s:rule [
        context = "db:example"
        "\x{a}" ~
        "          "
        s:assert [
          test = "not(.//db:tip)"
          "tip must not occur in the descendants of example"
        ]
        "\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}" ~
        "        "
      ]
    ]
    element example {
      db.example.attlist,
      db.example.info,
      db.all.blocks+,
      (db.caption?)
      >> a:documentation [ "A formal example, with a title" ]
    }
}
div {
  db.informalexample.role.attribute = attribute role { text }
  db.informalexample.width.attribute = attribute width { text }
  db.informalexample.attlist =
    db.informalexample.role.attribute?
    & db.common.attributes
    & db.common.linking.attributes
    & db.floatstyle.attribute?
    & db.informalexample.width.attribute?
  db.informalexample.info = db._info.title.forbidden
  db.informalexample =
    element informalexample {
      db.informalexample.attlist,
      db.informalexample.info,
      db.all.blocks+,
      (db.caption?)
      >> a:documentation [ "A displayed example without a title" ]
    }
}
db.verbatim.inlines = (db.all.inlines | db.lineannotation) | db.co
db.verbatim.contentmodel =
  db._info.title.forbidden, (db.textobject | db.verbatim.inlines*)
div {
  db.programlisting.role.attribute = attribute role { text }
  db.programlisting.width.attribute = attribute width { text }
  db.programlisting.attlist =
    db.programlisting.role.attribute?
    & db.common.attributes
    & db.common.linking.attributes
    & db.verbatim.attributes
    & db.programlisting.width.attribute?
  db.programlisting =
    element programlisting {
      db.programlisting.attlist,
      db.verbatim.contentmodel
      >> a:documentation [
           "A literal listing of all or part of a program"
         ]
    }
}
div {
  db.literallayout.role.attribute = attribute role { text }
  db.literallayout.class.enumeration = "monospaced" | "normal"
  db.literallayout.class.attribute =
    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 =
    element literallayout {
      db.literallayout.attlist,
      db.verbatim.contentmodel
      >> a:documentation [
           "A block of text in which line breaks and white space are to be reproduced faithfully"
         ]
    }
}
div {
  db.screen.role.attribute = attribute role { text }
  db.screen.width.attribute = attribute width { text }
  db.screen.attlist =
    db.screen.role.attribute?
    & db.common.attributes
    & db.common.linking.attributes
    & db.verbatim.attributes
    & db.screen.width.attribute?
  db.screen =
    element screen {
      db.screen.attlist,
      db.verbatim.contentmodel
      >> a:documentation [
           "Text that a user sees or might see on a computer screen"
         ]
    }
}
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 =
    element screenshot {
      db.screenshot.attlist,
      db.screenshot.info,
      db.mediaobject
      >> a:documentation [
           "A representation of what the user sees or might see on a computer screen"
         ]
    }
}
div {
  db.figure.role.attribute = attribute role { text }
  db.figure.label.attribute = attribute label { text }
  db.figure.attlist =
    db.figure.role.attribute?
    & db.common.attributes
    & db.common.linking.attributes
    & db.figure.label.attribute?
    & db.pgwide.attribute?
    & db.floatstyle.attribute?
  db.figure.info = db._info.title.onlyreq
  db.figure =
    [
      s:rule [
        context = "db:figure"
        "\x{a}" ~
        "          "
        s:assert [
          test = "not(.//db:example)"
          "example must not occur in the descendants of figure"
        ]
        "\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}" ~
        "        "
      ]
      s:rule [
        context = "db:figure"
        "\x{a}" ~
        "          "
        s:assert [
          test = "not(.//db:table)"
          "table must not occur in the descendants of figure"
        ]
        "\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}" ~
        "        "
      ]
      s:rule [
        context = "db:figure"
        "\x{a}" ~
        "          "
        s:assert [
          test = "not(.//db:caution)"
          "caution must not occur in the descendants of figure"
        ]
        "\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}" ~
        "        "
      ]
      s:rule [
        context = "db:figure"
        "\x{a}" ~
        "          "
        s:assert [
          test = "not(.//db:note)"
          "note must not occur in the descendants of figure"
        ]
        "\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}" ~
        "        "
      ]
      s:rule [
        context = "db:figure"
        "\x{a}" ~
        "          "
        s:assert [
          test = "not(.//db:warning)"
          "warning must not occur in the descendants of figure"
        ]
        "\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}" ~
        "        "
      ]
      s:rule [
        context = "db:figure"
        "\x{a}" ~
        "          "
        s:assert [
          test = "not(.//db:figure)"
          "figure must not occur in the descendants of figure"
        ]
        "\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}" ~
        "        "
      ]
      s:rule [
        context = "db:figure"
        "\x{a}" ~
        "          "
        s:assert [
          test = "not(.//db:table)"
          "table must not occur in the descendants of figure"
        ]
        "\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}" ~
        "        "
      ]
      s:rule [
        context = "db:figure"
        "\x{a}" ~
        "          "
        s:assert [
          test = "not(.//db:important)"
          "important must not occur in the descendants of figure"
        ]
        "\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}" ~
        "        "
      ]
      s:rule [
        context = "db:figure"
        "\x{a}" ~
        "          "
        s:assert [
          test = "not(.//db:tip)"
          "tip must not occur in the descendants of figure"
        ]
        "\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}" ~
        "        "
      ]
    ]
    element figure {
      db.figure.attlist,
      db.figure.info,
      db.all.blocks+,
      (db.caption?)
      >> a:documentation [
           "A formal figure, generally an illustration, with a title"
         ]
    }
}
div {
  db.informalfigure.role.attribute = attribute role { text }
  db.informalfigure.label.attribute = attribute label { text }
  db.informalfigure.attlist =
    db.informalfigure.role.attribute?
    & db.common.attributes
    & db.common.linking.attributes
    & db.informalfigure.label.attribute?
    & db.pgwide.attribute?
    & db.floatstyle.attribute?
  db.informalfigure.info = db._info.title.forbidden
  db.informalfigure =
    element informalfigure {
      db.informalfigure.attlist,
      db.informalfigure.info,
      db.all.blocks+,
      (db.caption?) >> a:documentation [ "A untitled figure" ]
    }
}
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 =
    element mediaobject {
      db.mediaobject.attlist,
      db.mediaobject.info,
      db.alt?,
      db.mediaobject.content+,
      (db.caption?)
      >> a:documentation [
           "A displayed media object (video, audio, image, etc.)"
         ]
    }
}
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 =
    element inlinemediaobject {
      db.inlinemediaobject.attlist,
      db.inlinemediaobject.info,
      db.alt?,
      (db.mediaobject.content+)
      >> a:documentation [
           "An inline media object (video, audio, image, and so on)"
         ]
    }
}
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 =
    element videoobject {
      db.videoobject.attlist,
      db.videoobject.info,
      db.videodata
      >> a:documentation [
           "A wrapper for video data and its associated meta-information"
         ]
    }
}
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 =
    element audioobject {
      db.audioobject.attlist,
      db.audioobject.info,
      db.audiodata
      >> a:documentation [
           "A wrapper for audio data and its associated meta-information"
         ]
    }
}
db.imageobject.content = db.imagedata | db._any.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 =
    element imageobject {
      db.imageobject.attlist,
      db.imageobject.info,
      db.imageobject.content
      >> a:documentation [
           "A wrapper for image data and its associated meta-information"
         ]
    }
}
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 =
    element textobject {
      db.textobject.attlist,
      db.textobject.info,
      (db.phrase | db.textdata | db.all.blocks+)
      >> a:documentation [
           "A wrapper for a text description of an object and its associated meta-information"
         ]
    }
}
div {
  db.videodata.role.attribute = attribute role { text }
  db.videodata.align.enumeration = db.halign.enumeration
  db.videodata.align.attribute =
    attribute align { db.videodata.align.enumeration }
  db.videodata.valign.enumeration = db.valign.enumeration
  db.videodata.valign.attribute =
    attribute valign { db.videodata.valign.enumeration }
  db.videodata.width.attribute = attribute width { text }
  db.videodata.contentwidth.attribute = attribute contentwidth { text }
  db.videodata.scalefit.enumeration = "0" | "1"
  db.videodata.scalefit.attribute =
    attribute scalefit { db.videodata.scalefit.enumeration }
  db.videodata.scale.attribute = attribute scale { text }
  db.videodata.depth.attribute = attribute depth { text }
  db.videodata.contentdepth.attribute = attribute contentdepth { text }
  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 =
    element videodata {
      db.videodata.attlist,
      db.videodata.info
      >> a:documentation [ "Pointer to external video data" ]
    }
}
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 =
    element audiodata {
      db.audiodata.attlist,
      db.audiodata.info
      >> a:documentation [ "Pointer to external audio data" ]
    }
}
div {
  db.imagedata.role.attribute = attribute role { text }
  db.imagedata.align.enumeration = db.halign.enumeration
  db.imagedata.align.attribute =
    attribute align { db.imagedata.align.enumeration }
  db.imagedata.valign.enumeration = db.valign.enumeration
  db.imagedata.valign.attribute =
    attribute valign { db.imagedata.valign.enumeration }
  db.imagedata.width.attribute = attribute width { text }
  db.imagedata.contentwidth.attribute = attribute contentwidth { text }
  db.imagedata.scalefit.enumeration = "0" | "1"
  db.imagedata.scalefit.attribute =
    attribute scalefit { db.imagedata.scalefit.enumeration }
  db.imagedata.scale.attribute = attribute scale { text }
  db.imagedata.depth.attribute = attribute depth { text }
  db.imagedata.contentdepth.attribute = attribute contentdepth { text }
  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 =
    element imagedata {
      db.imagedata.attlist,
      db.imagedata.info
      >> a:documentation [ "Pointer to external image data" ]
    }
}
div {
  db.textdata.role.attribute = attribute role { text }
  db.textdata.encoding.attribute = 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 =
    element textdata {
      db.textdata.attlist,
      db.textdata.info
      >> a:documentation [ "Pointer to external text data" ]
    }
}
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 =
    [
      s:rule [
        context = "db:caption"
        "\x{a}" ~
        "          "
        s:assert [
          test = "not(.//db:example)"
          "example must not occur in the descendants of caption"
        ]
        "\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}" ~
        "        "
      ]
      s:rule [
        context = "db:caption"
        "\x{a}" ~
        "          "
        s:assert [
          test = "not(.//db:table)"
          "table must not occur in the descendants of caption"
        ]
        "\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}" ~
        "        "
      ]
      s:rule [
        context = "db:caption"
        "\x{a}" ~
        "          "
        s:assert [
          test = "not(.//db:caution)"
          "caution must not occur in the descendants of caption"
        ]
        "\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}" ~
        "        "
      ]
      s:rule [
        context = "db:caption"
        "\x{a}" ~
        "          "
        s:assert [
          test = "not(.//db:note)"
          "note must not occur in the descendants of caption"
        ]
        "\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}" ~
        "        "
      ]
      s:rule [
        context = "db:caption"
        "\x{a}" ~
        "          "
        s:assert [
          test = "not(.//db:warning)"
          "warning must not occur in the descendants of caption"
        ]
        "\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}" ~
        "        "
      ]
      s:rule [
        context = "db:caption"
        "\x{a}" ~
        "          "
        s:assert [
          test = "not(.//db:task)"
          "task must not occur in the descendants of caption"
        ]
        "\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}" ~
        "        "
      ]
      s:rule [
        context = "db:caption"
        "\x{a}" ~
        "          "
        s:assert [
          test = "not(.//db:figure)"
          "figure must not occur in the descendants of caption"
        ]
        "\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}" ~
        "        "
      ]
      s:rule [
        context = "db:caption"
        "\x{a}" ~
        "          "
        s:assert [
          test = "not(.//db:table)"
          "table must not occur in the descendants of caption"
        ]
        "\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}" ~
        "        "
      ]
      s:rule [
        context = "db:caption"
        "\x{a}" ~
        "          "
        s:assert [
          test = "not(.//db:important)"
          "important must not occur in the descendants of caption"
        ]
        "\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}" ~
        "        "
      ]
      s:rule [
        context = "db:caption"
        "\x{a}" ~
        "          "
        s:assert [
          test = "not(.//db:tip)"
          "tip must not occur in the descendants of caption"
        ]
        "\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}" ~
        "        "
      ]
      s:rule [
        context = "db:caption"
        "\x{a}" ~
        "          "
        s:assert [
          test = "not(.//db:sidebar)"
          "sidebar must not occur in the descendants of caption"
        ]
        "\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}" ~
        "        "
      ]
    ]
    element caption {
      db.caption.attlist,
      db.caption.info,
      (db.all.blocks+) >> a:documentation [ "A caption" ]
    }
}
div {
  db.synopsis.role.attribute = attribute role { text }
  db.synopsis.label.attribute = attribute label { text }
  db.synopsis.attlist =
    db.synopsis.role.attribute?
    & db.common.attributes
    & db.common.linking.attributes
    & db.verbatim.attributes
    & db.synopsis.label.attribute?
  db.synopsis =
    element synopsis {
      db.synopsis.attlist,
      db.verbatim.contentmodel
      >> a:documentation [
           "A general-purpose element for representing the syntax of commands or functions"
         ]
    }
}
div {
  db.cmdsynopsis.role.attribute = attribute role { text }
  db.cmdsynopsis.sepchar.attribute = attribute sepchar { text }
  db.cmdsynopsis.cmdlength.attribute = attribute cmdlength { text }
  db.cmdsynopsis.label.attribute = attribute label { text }
  db.cmdsynopsis.attlist =
    db.cmdsynopsis.role.attribute?
    & db.common.attributes
    & db.common.linking.attributes
    & db.cmdsynopsis.sepchar.attribute?
    & db.cmdsynopsis.cmdlength.attribute?
    & db.cmdsynopsis.label.attribute?
  db.cmdsynopsis.info = db._info.title.forbidden
  db.cmdsynopsis =
    element cmdsynopsis {
      db.cmdsynopsis.attlist,
      db.cmdsynopsis.info,
      (db.command | db.arg | db.group | db.sbr)+,
      (db.synopfragment*)
      >> a:documentation [ "A syntax summary for a software command" ]
    }
}
db.rep.enumeration = "norepeat" | "repeat"
db.rep.attribute = attribute rep { db.rep.enumeration }
db.choice.enumeration = "opt" | "plain" | "req"
db.choice.attribute = attribute choice { db.choice.enumeration }
div {
  db.arg.role.attribute = attribute role { text }
  db.arg.attlist =
    db.arg.role.attribute?
    & db.common.attributes
    & db.common.linking.attributes
    & db.rep.attribute?
    & db.choice.attribute?
  db.arg =
    element arg {
      db.arg.attlist,
      ((db._text
        | db.arg
        | db.group
        | db.option
        | db.synopfragmentref
        | db.sbr)*)
      >> a:documentation [ "An argument in a CmdSynopsis" ]
    }
}
div {
  db.group.role.attribute = attribute role { text }
  db.group.attlist =
    db.group.role.attribute?
    & db.common.attributes
    & db.common.linking.attributes
    & db.rep.attribute?
    & db.choice.attribute?
  db.group =
    element group {
      db.group.attlist,
      ((db.arg
        | db.group
        | db.option
        | db.synopfragmentref
        | db.replaceable
        | db.sbr)+)
      >> a:documentation [ "A group of elements in a CmdSynopsis" ]
    }
}
div {
  db.sbr.role.attribute = attribute role { text }
  db.sbr.attlist = db.sbr.role.attribute? & db.common.attributes
  db.sbr =
    element sbr {
      db.sbr.attlist,
      empty
      >> a:documentation [
           "An explicit line break in a command synopsis"
         ]
    }
}
div {
  db.synopfragment.role.attribute = attribute role { text }
  db.synopfragment.attlist =
    db.synopfragment.role.attribute?
    & db.common.attributes
    & db.common.linking.attributes
  db.synopfragment =
    element synopfragment {
      db.synopfragment.attlist,
      ((db.arg | db.group)+)
      >> a:documentation [
           "A portion of a CmdSynopsis broken out from the main body of the synopsis"
         ]
    }
}
div {
  db.synopfragmentref.role.attribute = attribute role { text }
  db.synopfragmentref.attlist =
    db.synopfragmentref.role.attribute?
    & db.common.attributes
    & db.linkend.attribute
  db.synopfragmentref =
    [
      s:rule [
        context = "db:synopfragmentref"
        "\x{a}" ~
        "          "
        s:assert [
          test =
            "local-name(//*[@id=current()/@linkend]) = 'synopfragment' and namespace-uri(//*[@id=current()/@linkend]) = 'http://docbook.org/ns/docbook'"
          "@linkend on synopfragmentref must point to a synopfragment."
        ]
        "\x{a}" ~
        "        "
      ]
    ]
    element synopfragmentref {
      db.synopfragmentref.attlist,
      text
      >> a:documentation [
           "A reference to a fragment of a command synopsis"
         ]
    }
}
div {
  db.funcsynopsis.role.attribute = attribute role { text }
  db.funcsynopsis.attlist =
    db.funcsynopsis.role.attribute?
    & db.common.attributes
    & db.common.linking.attributes
    & db.language.attribute?
  db.funcsynopsis.info = db._info.title.forbidden
  db.funcsynopsis =
    element funcsynopsis {
      db.funcsynopsis.attlist,
      db.funcsynopsis.info,
      ((db.funcsynopsisinfo | db.funcprototype)+)
      >> a:documentation [
           "The syntax summary for a function definition"
         ]
    }
}
div {
  db.funcsynopsisinfo.role.attribute = attribute role { text }
  db.funcsynopsisinfo.attlist =
    db.funcsynopsisinfo.role.attribute?
    & db.common.attributes
    & db.common.linking.attributes
    & db.verbatim.attributes
  db.funcsynopsisinfo =
    element funcsynopsisinfo {
      db.funcsynopsisinfo.attlist,
      db.verbatim.contentmodel
      >> a:documentation [
           "Information supplementing the FuncDefs of a FuncSynopsis"
         ]
    }
}
div {
  db.funcprototype.role.attribute = attribute role { text }
  db.funcprototype.attlist =
    db.funcprototype.role.attribute?
    & db.common.attributes
    & db.common.linking.attributes
  db.funcprototype =
    element funcprototype {
      db.funcprototype.attlist,
      db.modifier*,
      db.funcdef,
      (db.void | db.varargs | (db.paramdef+, db.varargs?)),
      (db.modifier*)
      >> a:documentation [ "The prototype of a function" ]
    }
}
div {
  db.funcdef.role.attribute = attribute role { text }
  db.funcdef.attlist =
    db.funcdef.role.attribute?
    & db.common.attributes
    & db.common.linking.attributes
  db.funcdef =
    element funcdef {
      db.funcdef.attlist,
      ((db._text | db.type | db.function)*)
      >> a:documentation [
           "A function (subroutine) name and its return type"
         ]
    }
}
div {
  db.void.role.attribute = attribute role { text }
  db.void.attlist =
    db.void.role.attribute?
    & db.common.attributes
    & db.common.linking.attributes
  db.void =
    element void {
      db.void.attlist,
      empty
      >> a:documentation [
           "An empty element in a function synopsis indicating that the function in question takes no arguments"
         ]
    }
}
div {
  db.varargs.role.attribute = attribute role { text }
  db.varargs.attlist =
    db.varargs.role.attribute?
    & db.common.attributes
    & db.common.linking.attributes
  db.varargs =
    element varargs {
      db.varargs.attlist,
      empty
      >> a:documentation [
           "An empty element in a function synopsis indicating a variable number of arguments"
         ]
    }
}
div {
  db.paramdef.role.attribute = attribute role { text }
  db.paramdef.attlist =
    db.paramdef.role.attribute?
    & db.common.attributes
    & db.common.linking.attributes
    & db.choice.attribute?
  db.paramdef =
    element paramdef {
      db.paramdef.attlist,
      ((db._text
        | db.initializer
        | db.type
        | db.parameter
        | db.funcparams)*)
      >> a:documentation [
           "Information about a function parameter in a programming language"
         ]
    }
}
div {
  db.funcparams.role.attribute = attribute role { text }
  db.funcparams.attlist =
    db.funcparams.role.attribute?
    & db.common.attributes
    & db.common.linking.attributes
  db.funcparams =
    element funcparams {
      db.funcparams.attlist,
      db._text
      >> a:documentation [
           "Parameters for a function referenced through a function pointer in a synopsis"
         ]
    }
}
div {
  db.classsynopsis.role.attribute = attribute role { text }
  db.classsynopsis.class.enumeration = "class" | "interface"
  db.classsynopsis.class.attribute =
    attribute class { db.classsynopsis.class.enumeration }
  db.classsynopsis.attlist =
    db.classsynopsis.role.attribute?
    & db.common.attributes
    & db.common.linking.attributes
    & db.language.attribute?
    & db.classsynopsis.class.attribute?
  db.classsynopsis =
    element classsynopsis {
      db.classsynopsis.attlist,
      db.oo.inlines+,
      ((db.classsynopsisinfo
        | db.methodsynopsis
        | db.constructorsynopsis
        | db.destructorsynopsis
        | db.fieldsynopsis)*)
      >> a:documentation [ "The syntax summary for a class definition" ]
    }
}
div {
  db.classsynopsisinfo.role.attribute = attribute role { text }
  db.classsynopsisinfo.attlist =
    db.classsynopsisinfo.role.attribute?
    & db.common.attributes
    & db.common.linking.attributes
    & db.verbatim.attributes
  db.classsynopsisinfo =
    element classsynopsisinfo {
      db.classsynopsisinfo.attlist,
      db.verbatim.contentmodel
      >> a:documentation [
           "Information supplementing the contents of a ClassSynopsis"
         ]
    }
}
div {
  db.ooclass.role.attribute = attribute role { text }
  db.ooclass.attlist =
    db.ooclass.role.attribute?
    & db.common.attributes
    & db.common.linking.attributes
  db.ooclass =
    element ooclass {
      db.ooclass.attlist,
      (db.package | db.modifier)*,
      db.classname
      >> a:documentation [
           "A class in an object-oriented programming language"
         ]
    }
}
div {
  db.oointerface.role.attribute = attribute role { text }
  db.oointerface.attlist =
    db.oointerface.role.attribute?
    & db.common.attributes
    & db.common.linking.attributes
  db.oointerface =
    element oointerface {
      db.oointerface.attlist,
      (db.package | db.modifier)*,
      db.interfacename
      >> a:documentation [
           "An interface in an object-oriented programming language"
         ]
    }
}
div {
  db.ooexception.role.attribute = attribute role { text }
  db.ooexception.attlist =
    db.ooexception.role.attribute?
    & db.common.attributes
    & db.common.linking.attributes
  db.ooexception =
    element ooexception {
      db.ooexception.attlist,
      (db.package | db.modifier)*,
      db.exceptionname
      >> a:documentation [
           "An exception in an object-oriented programming language"
         ]
    }
}
div {
  db.modifier.role.attribute = attribute role { text }
  db.modifier.attlist =
    db.modifier.role.attribute?
    & db.common.attributes
    & db.common.linking.attributes
  db.modifier =
    element modifier {
      db.modifier.attlist,
      db._text >> a:documentation [ "Modifiers in a synopsis" ]
    }
}
div {
  db.interfacename.role.attribute = attribute role { text }
  db.interfacename.attlist =
    db.interfacename.role.attribute?
    & db.common.attributes
    & db.common.linking.attributes
  db.interfacename =
    element interfacename {
      db.interfacename.attlist,
      db._text >> a:documentation [ "The name of an interface" ]
    }
}
div {
  db.exceptionname.role.attribute = attribute role { text }
  db.exceptionname.attlist =
    db.exceptionname.role.attribute?
    & db.common.attributes
    & db.common.linking.attributes
  db.exceptionname =
    element exceptionname {
      db.exceptionname.attlist,
      db._text >> a:documentation [ "The name of an exception" ]
    }
}
div {
  db.fieldsynopsis.role.attribute = attribute role { text }
  db.fieldsynopsis.attlist =
    db.fieldsynopsis.role.attribute?
    & db.common.attributes
    & db.common.linking.attributes
    & db.language.attribute?
  db.fieldsynopsis =
    element fieldsynopsis {
      db.fieldsynopsis.attlist,
      db.modifier*,
      db.type?,
      db.varname,
      (db.initializer?)
      >> a:documentation [ "The name of a field in a class definition" ]
    }
}
div {
  db.initializer.role.attribute = attribute role { text }
  db.initializer.attlist =
    db.initializer.role.attribute?
    & db.common.attributes
    & db.common.linking.attributes
  db.initializer =
    element initializer {
      db.initializer.attlist,
      db._text
      >> a:documentation [ "The initializer for a FieldSynopsis" ]
    }
}
div {
  db.constructorsynopsis.role.attribute = attribute role { text }
  db.constructorsynopsis.attlist =
    db.constructorsynopsis.role.attribute?
    & db.common.attributes
    & db.common.linking.attributes
    & db.language.attribute?
  db.constructorsynopsis =
    element constructorsynopsis {
      db.constructorsynopsis.attlist,
      db.modifier*,
      db.methodname?,
      (db.methodparam+ | db.void?),
      (db.exceptionname*)
      >> a:documentation [ "A syntax summary for a constructor" ]
    }
}
div {
  db.destructorsynopsis.role.attribute = attribute role { text }
  db.destructorsynopsis.attlist =
    db.destructorsynopsis.role.attribute?
    & db.common.attributes
    & db.common.linking.attributes
    & db.language.attribute?
  db.destructorsynopsis =
    element destructorsynopsis {
      db.destructorsynopsis.attlist,
      db.modifier*,
      db.methodname?,
      (db.methodparam+ | db.void?),
      (db.exceptionname*)
      >> a:documentation [ "A syntax summary for a destructor" ]
    }
}
div {
  db.methodsynopsis.role.attribute = attribute role { text }
  db.methodsynopsis.attlist =
    db.methodsynopsis.role.attribute?
    & db.common.attributes
    & db.common.linking.attributes
    & db.language.attribute?
  db.methodsynopsis =
    element methodsynopsis {
      db.methodsynopsis.attlist,
      db.modifier*,
      (db.type | db.void)?,
      db.methodname,
      (db.methodparam+ | db.void),
      db.exceptionname*,
      (db.modifier*)
      >> a:documentation [ "A syntax summary for a method" ]
    }
}
div {
  db.methodname.role.attribute = attribute role { text }
  db.methodname.attlist =
    db.methodname.role.attribute?
    & db.common.attributes
    & db.common.linking.attributes
  db.methodname =
    element methodname {
      db.methodname.attlist,
      db._text >> a:documentation [ "The name of a method" ]
    }
}
div {
  db.methodparam.role.attribute = attribute role { text }
  db.methodparam.attlist =
    db.methodparam.role.attribute?
    & db.common.attributes
    & db.common.linking.attributes
    & db.rep.attribute?
    & db.choice.attribute?
  db.methodparam =
    element methodparam {
      db.methodparam.attlist,
      db.modifier*,
      db.type?,
      ((db.parameter, db.initializer?) | db.funcparams),
      (db.modifier*) >> a:documentation [ "Parameters to a method" ]
    }
}
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 =
    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.otheraddr)*)
      >> a:documentation [
           "A real-world address, generally a postal address"
         ]
    }
}
div {
  db.street.role.attribute = attribute role { text }
  db.street.attlist =
    db.street.role.attribute?
    & db.common.attributes
    & db.common.linking.attributes
  db.street =
    element street {
      db.street.attlist,
      db._text >> a:documentation [ "A street address in an address" ]
    }
}
div {
  db.pob.role.attribute = attribute role { text }
  db.pob.attlist =
    db.pob.role.attribute?
    & db.common.attributes
    & db.common.linking.attributes
  db.pob =
    element pob {
      db.pob.attlist,
      db._text >> a:documentation [ "A post office box in an address" ]
    }
}
div {
  db.postcode.role.attribute = attribute role { text }
  db.postcode.attlist =
    db.postcode.role.attribute?
    & db.common.attributes
    & db.common.linking.attributes
  db.postcode =
    element postcode {
      db.postcode.attlist,
      db._text >> a:documentation [ "A postal code in an address" ]
    }
}
div {
  db.city.role.attribute = attribute role { text }
  db.city.attlist =
    db.city.role.attribute?
    & db.common.attributes
    & db.common.linking.attributes
  db.city =
    element city {
      db.city.attlist,
      db._text >> a:documentation [ "The name of a city in an address" ]
    }
}
div {
  db.state.role.attribute = attribute role { text }
  db.state.attlist =
    db.state.role.attribute?
    & db.common.attributes
    & db.common.linking.attributes
  db.state =
    element state {
      db.state.attlist,
      db._text
      >> a:documentation [ "A state or province in an address" ]
    }
}
div {
  db.country.role.attribute = attribute role { text }
  db.country.attlist =
    db.country.role.attribute?
    & db.common.attributes
    & db.common.linking.attributes
  db.country =
    element country {
      db.country.attlist,
      db._text >> a:documentation [ "The name of a country" ]
    }
}
div {
  db.phone.role.attribute = attribute role { text }
  db.phone.attlist =
    db.phone.role.attribute?
    & db.common.attributes
    & db.common.linking.attributes
  db.phone =
    element phone {
      db.phone.attlist,
      db._text >> a:documentation [ "A telephone number" ]
    }
}
div {
  db.fax.role.attribute = attribute role { text }
  db.fax.attlist =
    db.fax.role.attribute?
    & db.common.attributes
    & db.common.linking.attributes
  db.fax =
    element fax {
      db.fax.attlist, db._text >> a:documentation [ "A fax number" ]
    }
}
div {
  db.otheraddr.role.attribute = attribute role { text }
  db.otheraddr.attlist =
    db.otheraddr.role.attribute?
    & db.common.attributes
    & db.common.linking.attributes
  db.otheraddr =
    element otheraddr {
      db.otheraddr.attlist,
      db._text
      >> a:documentation [ "Uncategorized information in address" ]
    }
}
div {
  db.affiliation.role.attribute = attribute role { text }
  db.affiliation.attlist =
    db.affiliation.role.attribute?
    & db.common.attributes
    & db.common.linking.attributes
  db.affiliation =
    element affiliation {
      db.affiliation.attlist,
      db.shortaffil?,
      db.jobtitle*,
      db.orgname?,
      db.orgdiv*,
      (db.address*)
      >> a:documentation [
           "The institutional affiliation of an individual"
         ]
    }
}
div {
  db.shortaffil.role.attribute = attribute role { text }
  db.shortaffil.attlist =
    db.shortaffil.role.attribute?
    & db.common.attributes
    & db.common.linking.attributes
  db.shortaffil =
    element shortaffil {
      db.shortaffil.attlist,
      db._text
      >> a:documentation [ "A brief description of an affiliation" ]
    }
}
div {
  db.jobtitle.role.attribute = attribute role { text }
  db.jobtitle.attlist =
    db.jobtitle.role.attribute?
    & db.common.attributes
    & db.common.linking.attributes
  db.jobtitle =
    element jobtitle {
      db.jobtitle.attlist,
      db._text
      >> a:documentation [
           "The title of an individual in an organization"
         ]
    }
}
div {
  db.orgname.class.enumeration =
    "consortium" | "corporation" | "informal" | "nonprofit"
  db.orgname.class-enum.attribute =
    attribute class { db.orgname.class.enumeration }
  db.orgname.class-other.attributes =
    attribute class { "other" }
    & 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 =
    element orgname {
      db.orgname.attlist,
      db._text
      >> a:documentation [
           "The name of an organization other than a corporation "
         ]
    }
}
div {
  db.orgdiv.role.attribute = attribute role { text }
  db.orgdiv.attlist =
    db.orgdiv.role.attribute?
    & db.common.attributes
    & db.common.linking.attributes
  db.orgdiv =
    element orgdiv {
      db.orgdiv.attlist,
      (db.all.inlines*)
      >> a:documentation [ "A division of an organization" ]
    }
}
div {
  db.artpagenums.role.attribute = attribute role { text }
  db.artpagenums.attlist =
    db.artpagenums.role.attribute?
    & db.common.attributes
    & db.common.linking.attributes
  db.artpagenums =
    element artpagenums {
      db.artpagenums.attlist,
      db._text
      >> a:documentation [
           "The page numbers of an article as published"
         ]
    }
}
div {
  db.personname.role.attribute = attribute role { text }
  db.personname.attlist =
    db.personname.role.attribute?
    & db.common.attributes
    & db.common.linking.attributes
  db.personname =
    element personname {
      db.personname.attlist,
      (db._text
       | (db.honorific
          | db.firstname
          | db.surname
          | db.lineage
          | db.othername)+)
      >> a:documentation [ "The personal name of an individual" ]
    }
}
db.person.author.contentmodel =
  db.personname,
  (db.personblurb
   | db.affiliation
   | db.email
   | db.address
   | db.contrib)*
db.org.author.contentmodel =
  db.orgname,
  (db.orgdiv | db.affiliation | db.email | 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 =
    element author {
      db.author.attlist,
      db.credit.contentmodel
      >> a:documentation [ "The name of an individual author" ]
    }
}
div {
  db.authorgroup.role.attribute = attribute role { text }
  db.authorgroup.attlist =
    db.authorgroup.role.attribute?
    & db.common.attributes
    & db.common.linking.attributes
  db.authorgroup =
    element authorgroup {
      db.authorgroup.attlist,
      ((db.author | db.editor | db.othercredit)+)
      >> a:documentation [
           "Wrapper for author information when a document has multiple authors or collabarators"
         ]
    }
}
div {
  db.collab.role.attribute = attribute role { text }
  db.collab.attlist =
    db.collab.role.attribute?
    & db.common.attributes
    & db.common.linking.attributes
  db.collab =
    element collab {
      db.collab.attlist,
      (db.personname | db.orgname)+,
      (db.affiliation*)
      >> a:documentation [ "Identifies a collaborator" ]
    }
}
div {
  db.authorinitials.role.attribute = attribute role { text }
  db.authorinitials.attlist =
    db.authorinitials.role.attribute?
    & db.common.attributes
    & db.common.linking.attributes
  db.authorinitials =
    element authorinitials {
      db.authorinitials.attlist,
      db._text
      >> a:documentation [
           "The initials or other short identifier for an author"
         ]
    }
}
div {
  db.confgroup.role.attribute = attribute role { text }
  db.confgroup.attlist =
    db.confgroup.role.attribute?
    & db.common.attributes
    & db.common.linking.attributes
  db.confgroup =
    element confgroup {
      db.confgroup.attlist,
      ((db.confdates
        | db.conftitle
        | db.confnum
        | db.confsponsor
        | db.address)*)
      >> a:documentation [
           "A wrapper for document meta-information about a conference"
         ]
    }
}
div {
  db.confdates.role.attribute = attribute role { text }
  db.confdates.attlist =
    db.confdates.role.attribute?
    & db.common.attributes
    & db.common.linking.attributes
  db.confdates =
    element confdates {
      db.confdates.attlist,
      db._text
      >> a:documentation [
           "The dates of a conference for which a document was written"
         ]
    }
}
div {
  db.conftitle.role.attribute = attribute role { text }
  db.conftitle.attlist =
    db.conftitle.role.attribute?
    & db.common.attributes
    & db.common.linking.attributes
  db.conftitle =
    element conftitle {
      db.conftitle.attlist,
      db._text
      >> a:documentation [
           "The title of a conference for which a document was written"
         ]
    }
}
div {
  db.confnum.role.attribute = attribute role { text }
  db.confnum.attlist =
    db.confnum.role.attribute?
    & db.common.attributes
    & db.common.linking.attributes
  db.confnum =
    element confnum {
      db.confnum.attlist,
      db._text
      >> a:documentation [
           "An identifier, frequently numerical, associated with a conference for which a document was written"
         ]
    }
}
div {
  db.confsponsor.role.attribute = attribute role { text }
  db.confsponsor.attlist =
    db.confsponsor.role.attribute?
    & db.common.attributes
    & db.common.linking.attributes
  db.confsponsor =
    element confsponsor {
      db.confsponsor.attlist,
      db._text
      >> a:documentation [
           "The sponsor of a conference for which a document was written"
         ]
    }
}
div {
  db.contractnum.role.attribute = attribute role { text }
  db.contractnum.attlist =
    db.contractnum.role.attribute?
    & db.common.attributes
    & db.common.linking.attributes
  db.contractnum =
    element contractnum {
      db.contractnum.attlist,
      db._text
      >> a:documentation [ "The contract number of a document" ]
    }
}
div {
  db.contractsponsor.role.attribute = attribute role { text }
  db.contractsponsor.attlist =
    db.contractsponsor.role.attribute?
    & db.common.attributes
    & db.common.linking.attributes
  db.contractsponsor =
    element contractsponsor {
      db.contractsponsor.attlist,
      db._text >> a:documentation [ "The sponsor of a contract" ]
    }
}
div {
  db.copyright.role.attribute = attribute role { text }
  db.copyright.attlist =
    db.copyright.role.attribute?
    & db.common.attributes
    & db.common.linking.attributes
  db.copyright =
    element copyright {
      db.copyright.attlist,
      db.year+,
      (db.holder*)
      >> a:documentation [ "Copyright information about a document" ]
    }
}
div {
  db.year.role.attribute = attribute role { text }
  db.year.attlist =
    db.year.role.attribute?
    & db.common.attributes
    & db.common.linking.attributes
  db.year =
    element year {
      db.year.attlist,
      db._text
      >> a:documentation [ "The year of publication of a document" ]
    }
}
div {
  db.holder.role.attribute = attribute role { text }
  db.holder.attlist =
    db.holder.role.attribute?
    & db.common.attributes
    & db.common.linking.attributes
  db.holder =
    element holder {
      db.holder.attlist,
      db._text
      >> a:documentation [
           "The name of the individual or organization that holds a copyright"
         ]
    }
}
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 =
    element date {
      db.date.attlist,
      db.date.contentmodel
      >> a:documentation [
           "The date of publication or revision of a document"
         ]
    }
}
div {
  db.edition.role.attribute = attribute role { text }
  db.edition.attlist =
    db.edition.role.attribute?
    & db.common.attributes
    & db.common.linking.attributes
  db.edition =
    element edition {
      db.edition.attlist,
      db._text
      >> a:documentation [
           "The name or number of an edition of a document"
         ]
    }
}
div {
  db.editor.role.attribute = attribute role { text }
  db.editor.attlist =
    db.editor.role.attribute?
    & db.common.attributes
    & db.common.linking.attributes
  db.editor =
    element editor {
      db.editor.attlist,
      db.credit.contentmodel
      >> a:documentation [ "The name of the editor of a document" ]
    }
}
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 =
    element biblioid {
      db.biblioid.attlist,
      db._text >> a:documentation [ "An identifier for a document" ]
    }
}
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 =
    element citebiblioid {
      db.citebiblioid.attlist,
      db._text
      >> a:documentation [ "A citation of a bibliographic identifier" ]
    }
}
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 =
    element bibliosource {
      db.bibliosource.attlist,
      db._text >> a:documentation [ "The source of a document" ]
    }
}
div {
  db.bibliorelation.type-enum.attribute =
    attribute type {
      "hasformat"
      | "haspart"
      | "hasversion"
      | "isformatof"
      | "ispartof"
      | "isreferencedby"
      | "isreplacedby"
      | "isrequiredby"
      | "isversionof"
      | "othertype"
      | "references"
      | "replaces"
      | "requires"
    }?
  db.bibliorelation.type-other.attributes =
    attribute type { "othertype" }?,
    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 =
    element bibliorelation {
      db.bibliorelation.attlist,
      db._text
      >> a:documentation [ "The relationship of a document to another" ]
    }
}
div {
  db.bibliocoverage.spacial.enumeration =
    "dcmipoint" | "iso3166" | "dcmibox" | "tgn"
  db.bibliocoverage.spatial-enum.attribute =
    attribute spatial { db.bibliocoverage.spacial.enumeration }?
  db.bibliocoverage.spatial-other.attributes =
    attribute spatial { "otherspatial" }?,
    attribute otherspatial { xsd:NMTOKEN }
  db.bibliocoverage.spatial.attribute =
    db.bibliocoverage.spatial-enum.attribute
    | db.bibliocoverage.spatial-other.attributes
  db.bibliocoverage.temporal.enumeration = "dcmiperiod" | "w3c-dtf"
  db.bibliocoverage.temporal-enum.attribute =
    attribute temporal { db.bibliocoverage.temporal.enumeration }?
  db.bibliocoverage.temporal-other.attributes =
    attribute temporal { "othertemporal" }?,
    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 =
    element bibliocoverage {
      db.bibliocoverage.attlist,
      db._text
      >> a:documentation [
           "The spatial or temporal coverage of a document"
         ]
    }
}
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 =
    element legalnotice {
      db.legalnotice.attlist,
      db.legalnotice.info,
      (db.all.blocks+)
      >> a:documentation [
           "A statement of legal obligations or requirements"
         ]
    }
}
div {
  db.othercredit.class.attribute =
    attribute class {
      "copyeditor"
      | "graphicdesigner"
      | "other"
      | "productioneditor"
      | "technicaleditor"
      | "translator"
    }?
  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 =
    element othercredit {
      db.othercredit.attlist,
      db.credit.contentmodel
      >> a:documentation [
           "A person or entity, other than an author or editor, credited in a document"
         ]
    }
}
div {
  db.pagenums.role.attribute = attribute role { text }
  db.pagenums.attlist =
    db.pagenums.role.attribute?
    & db.common.attributes
    & db.common.linking.attributes
  db.pagenums =
    element pagenums {
      db.pagenums.attlist,
      db._text
      >> a:documentation [
           "The numbers of the pages in a book, for use in a bibliographic entry"
         ]
    }
}
div {
  db.contrib.role.attribute = attribute role { text }
  db.contrib.attlist =
    db.contrib.role.attribute?
    & db.common.attributes
    & db.common.linking.attributes
  db.contrib =
    element contrib {
      db.contrib.attlist,
      db._text
      >> a:documentation [
           "A summary of the contributions made to a document by a credited source"
         ]
    }
}
div {
  db.honorific.role.attribute = attribute role { text }
  db.honorific.attlist =
    db.honorific.role.attribute?
    & db.common.attributes
    & db.common.linking.attributes
  db.honorific =
    element honorific {
      db.honorific.attlist,
      db._text >> a:documentation [ "The title of a person" ]
    }
}
div {
  db.firstname.role.attribute = attribute role { text }
  db.firstname.attlist =
    db.firstname.role.attribute?
    & db.common.attributes
    & db.common.linking.attributes
  db.firstname =
    element firstname {
      db.firstname.attlist,
      db._text >> a:documentation [ "The first name of a person" ]
    }
}
div {
  db.surname.role.attribute = attribute role { text }
  db.surname.attlist =
    db.surname.role.attribute?
    & db.common.attributes
    & db.common.linking.attributes
  db.surname =
    element surname {
      db.surname.attlist,
      db._text
      >> a:documentation [
           "A family name; in western cultures the last name"
         ]
    }
}
div {
  db.lineage.role.attribute = attribute role { text }
  db.lineage.attlist =
    db.lineage.role.attribute?
    & db.common.attributes
    & db.common.linking.attributes
  db.lineage =
    element lineage {
      db.lineage.attlist,
      db._text
      >> a:documentation [
           "The portion of a person's name indicating a relationship to ancestors"
         ]
    }
}
div {
  db.othername.role.attribute = attribute role { text }
  db.othername.attlist =
    db.othername.role.attribute?
    & db.common.attributes
    & db.common.linking.attributes
  db.othername =
    element othername {
      db.othername.attlist,
      db._text
      >> a:documentation [
           "A component of a persons name that is not a first name, surname, or lineage"
         ]
    }
}
div {
  db.printhistory.role.attribute = attribute role { text }
  db.printhistory.attlist =
    db.printhistory.role.attribute?
    & db.common.attributes
    & db.common.linking.attributes
  db.printhistory =
    element printhistory {
      db.printhistory.attlist,
      (db.para.blocks+)
      >> a:documentation [ "The printing history of a document" ]
    }
}
div {
  db.productname.role.attribute = attribute role { text }
  db.productname.class.enumeration =
    "copyright" | "registered" | "service" | "trade"
  db.productname.class.attribute =
    attribute class { db.productname.class.enumeration }
  db.productname.attlist =
    db.productname.role.attribute?
    & db.common.attributes
    & db.common.linking.attributes
    & db.productname.class.attribute?
  db.productname =
    element productname {
      db.productname.attlist,
      db._text >> a:documentation [ "The formal name of a product" ]
    }
}
div {
  db.productnumber.role.attribute = attribute role { text }
  db.productnumber.attlist =
    db.productnumber.role.attribute?
    & db.common.attributes
    & db.common.linking.attributes
  db.productnumber =
    element productnumber {
      db.productnumber.attlist,
      db._text >> a:documentation [ "A number assigned to a product" ]
    }
}
div {
  db.pubdate.role.attribute = attribute role { text }
  db.pubdate.attlist =
    db.pubdate.role.attribute?
    & db.common.attributes
    & db.common.linking.attributes
  db.pubdate =
    element pubdate {
      db.pubdate.attlist,
      db.date.contentmodel
      >> a:documentation [ "The date of publication of a document" ]
    }
}
div {
  db.publisher.role.attribute = attribute role { text }
  db.publisher.attlist =
    db.publisher.role.attribute?
    & db.common.attributes
    & db.common.linking.attributes
  db.publisher =
    element publisher {
      db.publisher.attlist,
      db.publishername,
      (db.address*) >> a:documentation [ "The publisher of a document" ]
    }
}
div {
  db.publishername.role.attribute = attribute role { text }
  db.publishername.attlist =
    db.publishername.role.attribute?
    & db.common.attributes
    & db.common.linking.attributes
  db.publishername =
    element publishername {
      db.publishername.attlist,
      db._text
      >> a:documentation [ "The name of the publisher of a document" ]
    }
}
div {
  db.releaseinfo.role.attribute = attribute role { text }
  db.releaseinfo.attlist =
    db.releaseinfo.role.attribute?
    & db.common.attributes
    & db.common.linking.attributes
  db.releaseinfo =
    element releaseinfo {
      db.releaseinfo.attlist,
      db._text
      >> a:documentation [
           "Information about a particular release of a document"
         ]
    }
}
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 =
    element revhistory {
      db.revhistory.attlist,
      db.revhistory.info,
      (db.revision+)
      >> a:documentation [ "A history of the revisions to a document" ]
    }
}
div {
  db.revision.role.attribute = attribute role { text }
  db.revision.attlist =
    db.revision.role.attribute?
    & db.common.attributes
    & db.common.linking.attributes
  db.revision =
    element revision {
      db.revision.attlist,
      db.revnumber?,
      db.date,
      (db.authorinitials | db.author)*,
      ((db.revremark | db.revdescription)?)
      >> a:documentation [
           "An entry describing a single revision in the history of the revisions to a document"
         ]
    }
}
div {
  db.revnumber.role.attribute = attribute role { text }
  db.revnumber.attlist =
    db.revnumber.role.attribute?
    & db.common.attributes
    & db.common.linking.attributes
  db.revnumber =
    element revnumber {
      db.revnumber.attlist,
      db._text >> a:documentation [ "A document revision number" ]
    }
}
div {
  db.revremark.role.attribute = attribute role { text }
  db.revremark.attlist =
    db.revremark.role.attribute?
    & db.common.attributes
    & db.common.linking.attributes
  db.revremark =
    element revremark {
      db.revremark.attlist,
      db._text
      >> a:documentation [ "A description of a revision to a document" ]
    }
}
div {
  db.revdescription.role.attribute = attribute role { text }
  db.revdescription.attlist =
    db.revdescription.role.attribute?
    & db.common.attributes
    & db.common.linking.attributes
  db.revdescription =
    element revdescription {
      db.revdescription.attlist,
      (db.all.blocks*)
      >> a:documentation [
           "A extended description of a revision to a document"
         ]
    }
}
div {
  db.seriesvolnums.role.attribute = attribute role { text }
  db.seriesvolnums.attlist =
    db.seriesvolnums.role.attribute?
    & db.common.attributes
    & db.common.linking.attributes
  db.seriesvolnums =
    element seriesvolnums {
      db.seriesvolnums.attlist,
      db._text
      >> a:documentation [
           "Numbers of the volumes in a series of books"
         ]
    }
}
div {
  db.volumenum.role.attribute = attribute role { text }
  db.volumenum.attlist =
    db.volumenum.role.attribute?
    & db.common.attributes
    & db.common.linking.attributes
  db.volumenum =
    element volumenum {
      db.volumenum.attlist,
      db._text
      >> a:documentation [
           "The volume number of a document in a set (as of books in a set or articles in a journal)"
         ]
    }
}
div {
  db.issuenum.role.attribute = attribute role { text }
  db.issuenum.attlist =
    db.issuenum.role.attribute?
    & db.common.attributes
    & db.common.linking.attributes
  db.issuenum =
    element issuenum {
      db.issuenum.attlist,
      db._text
      >> a:documentation [ "The number of an issue of a journal" ]
    }
}
div {
  db.accel.role.attribute = attribute role { text }
  db.accel.attlist =
    db.accel.role.attribute?
    & db.common.attributes
    & db.common.linking.attributes
  db.accel =
    element accel {
      db.accel.attlist,
      db._text
      >> a:documentation [
           "A graphical user interface (GUI) keyboard shortcut"
         ]
    }
}
div {
  db.application.class.enumeration = "hardware" | "software"
  db.application.class.attribute =
    attribute class { db.application.class.enumeration }
  db.application.role.attribute = attribute role { text }
  db.application.attlist =
    db.application.role.attribute?
    & db.common.attributes
    & db.common.linking.attributes
    & db.application.class.attribute?
  db.application =
    element application {
      db.application.attlist,
      db._text >> a:documentation [ "The name of a software program" ]
    }
}
div {
  db.package.role.attribute = attribute role { text }
  db.package.attlist =
    db.package.role.attribute?
    & db.common.attributes
    & db.common.linking.attributes
  db.package =
    element package {
      db.package.attlist,
      db._text
      >> a:documentation [ "A software or application package" ]
    }
}
div {
  db.classname.role.attribute = attribute role { text }
  db.classname.attlist =
    db.classname.role.attribute?
    & db.common.attributes
    & db.common.linking.attributes
  db.classname =
    element classname {
      db.classname.attlist,
      db._text
      >> a:documentation [
           "The name of a class, in the object-oriented programming sense"
         ]
    }
}
div {
  db.command.role.attribute = attribute role { text }
  db.command.attlist =
    db.command.role.attribute?
    & db.common.attributes
    & db.common.linking.attributes
  db.command =
    element command {
      db.command.attlist,
      db._text
      >> a:documentation [
           "The name of an executable program or other software command"
         ]
    }
}
db.computeroutput.inlines =
  (text
   | db.ubiq.inlines
   | db.os.inlines
   | db.technical.inlines
   | db.markup.inlines)
  | db.co
  | db.co
div {
  db.computeroutput.role.attribute = attribute role { text }
  db.computeroutput.attlist =
    db.computeroutput.role.attribute?
    & db.common.attributes
    & db.common.linking.attributes
  db.computeroutput =
    element computeroutput {
      db.computeroutput.attlist,
      (db.computeroutput.inlines*)
      >> a:documentation [
           "Data, generally text, displayed or presented by a computer"
         ]
    }
}
div {
  db.database.class.attribute =
    attribute class {
      "altkey"
      | "constraint"
      | "datatype"
      | "field"
      | "foreignkey"
      | "group"
      | "index"
      | "key1"
      | "key2"
      | "name"
      | "primarykey"
      | "procedure"
      | "record"
      | "rule"
      | "secondarykey"
      | "table"
      | "user"
      | "view"
    }
  db.database.role.attribute = attribute role { text }
  db.database.attlist =
    db.database.role.attribute?
    & db.common.attributes
    & db.common.linking.attributes
    & db.database.class.attribute?
  db.database =
    element database {
      db.database.attlist,
      db._text
      >> a:documentation [
           "The name of a database, or part of a database"
         ]
    }
}
div {
  db.email.role.attribute = attribute role { text }
  db.email.attlist =
    db.email.role.attribute?
    & db.common.attributes
    & db.common.linking.attributes
  db.email =
    element email {
      db.email.attlist,
      db._text >> a:documentation [ "An email address" ]
    }
}
div {
  db.envar.role.attribute = attribute role { text }
  db.envar.attlist =
    db.envar.role.attribute?
    & db.common.attributes
    & db.common.linking.attributes
  db.envar =
    element envar {
      db.envar.attlist,
      db._text >> a:documentation [ "A software environment variable" ]
    }
}
div {
  db.errorcode.role.attribute = attribute role { text }
  db.errorcode.attlist =
    db.errorcode.role.attribute?
    & db.common.attributes
    & db.common.linking.attributes
  db.errorcode =
    element errorcode {
      db.errorcode.attlist,
      db._text >> a:documentation [ "An error code" ]
    }
}
div {
  db.errorname.role.attribute = attribute role { text }
  db.errorname.attlist =
    db.errorname.role.attribute?
    & db.common.attributes
    & db.common.linking.attributes
  db.errorname =
    element errorname {
      db.errorname.attlist,
      db._text >> a:documentation [ "An error name" ]
    }
}
div {
  db.errortext.role.attribute = attribute role { text }
  db.errortext.attlist =
    db.errortext.role.attribute?
    & db.common.attributes
    & db.common.linking.attributes
  db.errortext =
    element errortext {
      db.errortext.attlist,
      db._text >> a:documentation [ "An error message." ]