namespace ctrl = "http://nwalsh.com/xmlns/schema-control/"
default namespace db = "http://docbook.org/ns/docbook"
namespace dbx =
  "http://sourceforge.net/projects/docbook/defguide/schema/extra-markup"
namespace dtd = "http://relaxng.org/ns/compatibility/annotations/1.0"
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 xlink = "http://www.w3.org/1999/xlink"

# DocBook NG: The "Lillet" Release

# See http://docbook.org/ns/docbook
start =
  (db.set
   | db.book
   | db.divisions
   | db.components
   | db.navigation.components
   | db.section
   | db.para)
  | (db.refentry | db.refsection)
  | db.setindex
[
  db:refname [ "*:*" ]
  db:refpurpose [
    "Any element from any namespace except the DocBook namespace"
  ]
]
div {
  db._any =
    element * - (db:* | html:*) {
      (attribute * { text }
       | text
       | db._any)*
    }
}
db.effectivity.attributes =
  [
    dbx:description [
      "\x{a}" ~
      "               "
      db:para [
        "The "
        db:tag [ class = "attribute" "arch" ]
        "\x{a}" ~
        " attribute designates the computer or chip architecture to which the element applies."
      ]
      "\x{a}" ~
      "            "
    ]
  ]
  attribute arch { text }?,
  [
    dbx:description [
      "\x{a}" ~
      "               "
      db:para [
        "The "
        db:tag [ class = "attribute" "condition" ]
        "\x{a}" ~
        " attribute provides a standard place for application-specific effectivity."
      ]
      "\x{a}" ~
      "               "
      db:para [
        "Many DocBook users observed that in order to add an effectivity condition that was unique to their environment required "
        db:quote [ "abusing" ]
        "\x{a}" ~
        " the semantics of one of the existing attributes, or adding their own, making their customization "
        db:link [
          linkend = "s-notdocbook"
          "an extension rather than a subset"
        ]
        "\x{a}" ~
        ". The"
        db:tag [ class = "attribute" "condition" ]
        "\x{a}" ~
        " attribute is a general-purpose effectivity attribute with no specified semantics."
      ]
      "\x{a}" ~
      "            "
    ]
  ]
  attribute condition { text }?,
  [
    dbx:description [
      "The "
      db:tag [ class = "attribute" "conformance" ]
      "\x{a}" ~
      " attribute indicates standards conformance characteristics of the item contained in the element. These characteristics are application-specific; DocBook provides no default semantics."
    ]
  ]
  attribute conformance { text }?,
  [
    dbx:description [
      "\x{a}" ~
      "               "
      db:para [
        "The "
        db:tag [ class = "attribute" "os" ]
        "\x{a}" ~
        " attribute indicates the operating system to which the element is applicable."
      ]
      "\x{a}" ~
      "            "
    ]
  ]
  attribute os { text }?,
  [
    dbx:description [
      "\x{a}" ~
      "               "
      db:para [
        "The "
        db:tag [ class = "attribute" "revision" ]
        "\x{a}" ~
        " attribute indicates the editorial revision to which the element belongs."
      ]
      "\x{a}" ~
      "            "
    ]
  ]
  attribute revision { text }?,
  [
    dbx:description [
      "\x{a}" ~
      "               "
      db:para [
        "The "
        db:tag [ class = "attribute" "security" ]
        "\x{a}" ~
        " attribute indicates something about the security level associated with the element to which it applies."
      ]
      "\x{a}" ~
      "            "
    ]
  ]
  attribute security { text }?,
  [
    dbx:description [
      "\x{a}" ~
      "               "
      db:para [
        "The "
        db:tag [ class = "attribute" "userlevel" ]
        "\x{a}" ~
        " attribute indicates the level of user experience to which element applies."
      ]
      "\x{a}" ~
      "            "
    ]
  ]
  attribute userlevel { text }?,
  [
    dbx:description [
      "\x{a}" ~
      "               "
      db:para [
        "The "
        db:tag [ class = "attribute" "vendor" ]
        "\x{a}" ~
        " attribute indicates the computer vendor to which the element applies."
      ]
      "\x{a}" ~
      "            "
    ]
  ]
  attribute vendor { text }?,
  [
    dbx:description [
      "\x{a}" ~
      "               "
      db:para [
        "The "
        db:tag [ class = "attribute" "wordsize" ]
        "\x{a}" ~
        " attribute indicates the word size (width in bits) of the computer architecture to which the element applies."
      ]
      "\x{a}" ~
      "            "
    ]
  ]
  attribute wordsize { text }?
db.linkend.attribute = attribute linkend { xsd:IDREF }
db.linkends.attribute = attribute linkends { xsd:IDREFS }
db.xlink.href.attribute = attribute xlink:href { text }
db.xlink.type.attribute = attribute xlink:type { "simple" }
db.xlink.role.attribute = attribute xlink:role { xsd:anyURI }
db.xlink.arcrole.attribute = attribute xlink:arcrole { xsd:anyURI }
db.xlink.title.attribute = attribute xlink:title { text }?
db.xlink.show.enumeration = "new" | "replace" | "embed" | "other"
db.xlink.show.attribute =
  attribute xlink:show { db.xlink.show.enumeration }
db.xlink.actuate.enumeration = "onLoad" | "onRequest" | "other" | "none"
db.xlink.actuate.attribute =
  attribute xlink:actuate { db.xlink.actuate.enumeration }
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 }
db.version.attribute = attribute version { text }
db.xml.lang.attribute = attribute xml:lang { text }
db.xml.base.attribute = attribute xml:base { text }
db.remap.attribute = attribute remap { text }
db.xreflabel.attribute = attribute xreflabel { text }
db.revisionflag.enumeration = "changed" | "added" | "deleted" | "off"
db.revisionflag.attribute =
  attribute revisionflag { db.revisionflag.enumeration }
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 =
  [
    dbx:description [
      "\x{a}" ~
      "            "
      db:para [
        "If "
        db:tag [ class = "attribute" "pgwide" ]
        "\x{a}" ~
        " has the value 0 (false), then the element  is rendered in the current text flow (with flow column width). A value of 1 (true) specifies that the element should be rendered across the full text page."
      ]
      "\x{a}" ~
      "         "
    ]
  ]
  attribute pgwide { db.pgwide.enumeration }
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"
ctrl:other-attribute [
  name = "db.biblio.class.attribute"
  enum-name = "db.biblio.class-enum.attribute"
  other-name = "db.biblio.class-other.attributes"
]
db.biblio.class.enumeration =
  "doi"
  | "isbn"
  | "isrn"
  | "issn"
  | "libraryofcongress"
  | "pubnumber"
  | "uri"
db.biblio.class-enum.attribute =
  [
    dbx:description [
      "\x{a}" ~
      "               "
      db:para [
        "The "
        db:tag [ class = "atribute" "class" ]
        "\x{a}" ~
        " identifies the kind of bibliographic identifier:"
      ]
      "\x{a}" ~
      "               "
      db:informaltable [
        "\x{a}" ~
        "                  "
        db:tgroup [
          cols = "2"
          "\x{a}" ~
          "                     "
          db:thead [
            "\x{a}" ~
            "                        "
            db:row [
              "\x{a}" ~
              "                           "
              db:entry [ "Value" ]
              "\x{a}" ~
              "                           "
              db:entry [ "Identifier" ]
              "\x{a}" ~
              "                        "
            ]
            "\x{a}" ~
            "                     "
          ]
          "\x{a}" ~
          "                     "
          db:tbody [
            "\x{a}" ~
            "                        "
            db:row [
              "\x{a}" ~
              "                           "
              db:entry [
                "\x{a}" ~
                "                              "
                db:tag [ class = "attvalue" "doi" ]
                "\x{a}" ~
                "                           "
              ]
              "\x{a}" ~
              "                           "
              db:entry [
                "\x{a}" ~
                "                              "
                db:para [
                  "A "
                  db:link [
                    xlink:href = "http://www.doi.org/"
                    "Digital Object Identifier"
                  ]
                  "\x{a}" ~
                  "."
                ]
                "\x{a}" ~
                "                           "
              ]
              "\x{a}" ~
              "                        "
            ]
            "\x{a}" ~
            "                        "
            db:row [
              "\x{a}" ~
              "                           "
              db:entry [
                "\x{a}" ~
                "                              "
                db:tag [ class = "attvalue" "isbn" ]
                "\x{a}" ~
                "                           "
              ]
              "\x{a}" ~
              "                           "
              db:entry [
                "\x{a}" ~
                "                              "
                db:para [
                  "An "
                  db:link [
                    xlink:href = "http://www.isbn.org/"
                    "International Standard Book Number"
                  ]
                  "\x{a}" ~
                  "."
                ]
                "\x{a}" ~
                "                           "
              ]
              "\x{a}" ~
              "                        "
            ]
            "\x{a}" ~
            "                        "
            db:row [
              "\x{a}" ~
              "                           "
              db:entry [
                "\x{a}" ~
                "                              "
                db:tag [ class = "attvalue" "isrn" ]
                "\x{a}" ~
                "                           "
              ]
              "\x{a}" ~
              "                           "
              db:entry [
                "\x{a}" ~
                "                              "
                db:para [
                  "An International Standard Technical Report Number as defined by ISO 10444:1994."
                ]
                "\x{a}" ~
                "                           "
              ]
              "\x{a}" ~
              "                        "
            ]
            "\x{a}" ~
            "                        "
            db:row [
              "\x{a}" ~
              "                           "
              db:entry [
                "\x{a}" ~
                "                              "
                db:tag [ class = "attvalue" "issn" ]
                "\x{a}" ~
                "                           "
              ]
              "\x{a}" ~
              "                           "
              db:entry [
                "\x{a}" ~
                "                              "
                db:para [
                  "An "
                  db:link [
                    xlink:href = "http://www.issn.org/"
                    "International Standard Serial Number"
                  ]
                  "\x{a}" ~
                  "."
                ]
                "\x{a}" ~
                "                           "
              ]
              "\x{a}" ~
              "                        "
            ]
            "\x{a}" ~
            "                        "
            db:row [
              "\x{a}" ~
              "                           "
              db:entry [
                "\x{a}" ~
                "                              "
                db:tag [ class = "attvalue" "libraryofcongress" ]
                "\x{a}" ~
                "                           "
              ]
              "\x{a}" ~
              "                           "
              db:entry [
                "\x{a}" ~
                "                              "
                db:para [ "A Library of Congress subject identifer" ]
                "\x{a}" ~
                "                           "
              ]
              "\x{a}" ~
              "                        "
            ]
            "\x{a}" ~
            "                        "
            db:row [
              "\x{a}" ~
              "                           "
              db:entry [
                "\x{a}" ~
                "                              "
                db:tag [ class = "attvalue" "pubnumber" ]
                "\x{a}" ~
                "                           "
              ]
              "\x{a}" ~
              "                           "
              db:entry [
                "\x{a}" ~
                "                              "
                db:para [
                  "A publication number, for example from a private or corporate numbering scheme."
                ]
                "\x{a}" ~
                "                           "
              ]
              "\x{a}" ~
              "                        "
            ]
            "\x{a}" ~
            "                        "
            db:row [
              "\x{a}" ~
              "                           "
              db:entry [
                "\x{a}" ~
                "                              "
                db:tag [ class = "attvalue" "uri" ]
                "\x{a}" ~
                "                           "
              ]
              "\x{a}" ~
              "                           "
              db:entry [
                "\x{a}" ~
                "                              "
                db:para [ "A Uniform Resource Identifier." ]
                "\x{a}" ~
                "                           "
              ]
              "\x{a}" ~
              "                        "
            ]
            "\x{a}" ~
            "                        "
            db:row [
              "\x{a}" ~
              "                           "
              db:entry [
                "\x{a}" ~
                "                              "
                db:tag [ class = "attvalue" "other" ]
                "\x{a}" ~
                "                           "
              ]
              "\x{a}" ~
              "                           "
              db:entry [
                "\x{a}" ~
                "                              "
                db:para [
                  "Some other kind of identifier. If the value "
                  db:tag [ class = "attvalue" "other" ]
                  "\x{a}" ~
                  " is specified, the "
                  db:tag [ class = "attribute" "otherclass" ]
                  "\x{a}" ~
                  " attribute must also be provided."
                ]
                "\x{a}" ~
                "                           "
              ]
              "\x{a}" ~
              "                        "
            ]
            "\x{a}" ~
            "                     "
          ]
          "\x{a}" ~
          "                  "
        ]
        "\x{a}" ~
        "               "
      ]
      "\x{a}" ~
      "            "
    ]
  ]
  attribute class { db.biblio.class.enumeration }?
db.biblio.class-other.attributes =
  attribute class { "other" }
  & [
      dbx:description [
        "\x{a}" ~
        "               "
        db:para [
          "The value of the "
          db:tag [ class = "attribute" "otherclass" ]
          "\x{a}" ~
          " attribute specifies some identifier for the class. It is required when the value "
          db:tag [ class = "attvalue" "other" ]
          "\x{a}" ~
          " is specified for the "
          db:tag [ class = "attribute" "class" ]
          "\x{a}" ~
          " attribute; it is forbidden otherwise."
        ]
        "\x{a}" ~
        "            "
      ]
    ]
    attribute otherclass { xsd:NMTOKEN }
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.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.html.input
     | db.html.button
     | db.html.label
     | db.html.select
     | db.html.textarea
     | db.html.fieldset)
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
ctrl:exclude [ from = "db.formal.blocks" exclude = "db.formal.blocks" ]
ctrl:exclude [
  from = "db.formal.blocks"
  exclude = "db.admonition.blocks"
]
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
ctrl:exclude [
  from = "db.admonition.blocks"
  exclude = "db.admonition.blocks"
]
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.html.form
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
[
  db:refname [ "title" ]
  db:refpurpose [
    "The text of the title of a section of a document or of a formal block-level element"
  ]
]
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* }
}
[
  db:refname [ "titleabbrev" ]
  db:refpurpose [ "The abbreviation of a Title" ]
]
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* }
}
[
  db:refname [ "subtitle" ]
  db:refpurpose [ "The subtitle of a document" ]
]
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* }
}
[
  db:refname [ "info" ]
  db:refpurpose [
    "A wrapper for information about a component or other block"
  ]
]
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* }
}
[
  db:refname [ "info" ]
  db:refpurpose [
    "A wrapper for information about a component or other block with a required title"
  ]
]
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*
    }
}
[
  db:refname [ "info" ]
  db:refpurpose [
    "A wrapper for information about a component or other block with only a 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*
    }
}
[
  db:refname [ "info" ]
  db:refpurpose [
    "A wrapper for information about a component or other block with only a required 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*
    }
}
[
  db:refname [ "info" ]
  db:refpurpose [
    "A wrapper for information about a component or other block without a 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* }
}
[
  db:refname [ "subjectset" ]
  db:refpurpose [
    "A set of terms describing the subject matter of a document"
  ]
]
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+ }
}
[
  db:refname [ "subject" ]
  db:refpurpose [
    "One of a group 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+ }
}
[
  db:refname [ "subjectterm" ]
  db:refpurpose [
    "A term in 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 }
}
[
  db:refname [ "keywordset" ]
  db:refpurpose [
    "A set of keywords describing the content 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+ }
}
[
  db:refname [ "keyword" ]
  db:refpurpose [
    "One of 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 }
}
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
[
  db:refname [ "procedure" ]
  db:refpurpose [
    "A list of operations to be performed in a well-defined sequence"
  ]
]
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+
    }
}
[
  db:refname [ "step" ]
  db:refpurpose [ "A unit of action in a procedure" ]
]
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*
    }
}
[
  db:refname [ "stepalternatives" ]
  db:refpurpose [ "Alternative steps 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+
    }
}
[
  db:refname [ "substeps" ]
  db:refpurpose [
    "A wrapper for steps that occur within 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+ }
}
[
  db:refname [ "sidebar" ]
  db:refpurpose [
    "A portion of a document that is isolated from the main narrative flow"
  ]
  ctrl:exclude [ from = "db.sidebar" exclude = "db.sidebar" ]
]
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}" ~
        "            "
      ]
    ]
    element sidebar {
      db.sidebar.attlist, db.sidebar.info, db.all.blocks+
    }
}
[ db:refname [ "abstract" ] db:refpurpose [ "A summary" ] ]
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+
    }
}
[
  db:refname [ "personblurb" ]
  db:refpurpose [ "A short description or note about a person" ]
]
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+
    }
}
[
  db:refname [ "blockquote" ]
  db:refpurpose [ "A quotation set off from the main text" ]
]
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+
    }
}
[
  db:refname [ "attribution" ]
  db:refpurpose [ "The source of a block quote or epigraph" ]
]
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)*
    }
}
[
  db:refname [ "bridgehead" ]
  db:refpurpose [ "A free-floating heading" ]
]
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* }
}
[
  db:refname [ "remark" ]
  db:refpurpose [
    "A remark (or comment) intended for presentation in a draft manuscript"
  ]
]
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 }
}
[
  db:refname [ "epigraph" ]
  db:refpurpose [
    "A short inscription at the beginning of a document or component"
  ]
]
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)+
    }
}
[
  db:refname [ "footnote" ]
  db:refpurpose [ "A footnote" ]
  ctrl:exclude [ from = "db.footnote" exclude = "db.footnote" ]
  ctrl:exclude [ from = "db.footnote" exclude = "db.formal.blocks" ]
  ctrl:exclude [ from = "db.footnote" exclude = "db.admonition.blocks" ]
  ctrl:exclude [ from = "db.footnote" exclude = "db.indexterm" ]
  ctrl:exclude [ from = "db.footnote" exclude = "db.sidebar" ]
  ctrl:exclude [ from = "db.footnote" exclude = "db.task" ]
  ctrl:exclude [ from = "db.footnote" exclude = "db.epigraph" ]
]
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}" ~
        "            "
      ]
    ]
    element footnote { db.footnote.attlist, db.all.blocks+ }
}
[
  db:refname [ "formalpara" ]
  db:refpurpose [ "A paragraph with a title" ]
]
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
    }
}
[ db:refname [ "para" ] db:refpurpose [ "A paragraph" ] ]
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}" ~
        "            "
      ]
    ]
    element para {
      db.para.attlist,
      db.para.info,
      (db.all.inlines | db.nopara.blocks)*
    }
}
[
  db:refname [ "simpara" ]
  db:refpurpose [
    "A paragraph that contains only text and inline markup, no block elements"
  ]
]
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*
    }
}
db.admonition.contentmodel = db._info.title.only, db.all.blocks+
[ db:refname [ "caution" ] db:refpurpose [ "A note of caution" ] ]
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}" ~
        "            "
      ]
    ]
    element caution { db.caution.attlist, db.admonition.contentmodel }
}
[
  db:refname [ "important" ]
  db:refpurpose [ "An admonition set off from the text" ]
]
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}" ~
        "            "
      ]
    ]
    element important {
      db.important.attlist, db.admonition.contentmodel
    }
}
[
  db:refname [ "note" ]
  db:refpurpose [ "A message 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}" ~
        "            "
      ]
    ]
    element note { db.note.attlist, db.admonition.contentmodel }
}
[
  db:refname [ "tip" ]
  db:refpurpose [ "A suggestion to the user, 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}" ~
        "            "
      ]
    ]
    element tip { db.tip.attlist, db.admonition.contentmodel }
}
[
  db:refname [ "warning" ]
  db:refpurpose [ "An admonition 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}" ~
        "            "
      ]
    ]
    element warning { db.warning.attlist, db.admonition.contentmodel }
}
[
  db:refname [ "itemizedlist" ]
  db:refpurpose [
    "A list in which each entry is marked with a bullet or other dingbat"
  ]
]
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+
    }
}
[
  db:refname [ "orderedlist" ]
  db:refpurpose [
    "A list in which each entry is marked with a sequentially incremented label"
  ]
]
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+
    }
}
[
  db:refname [ "listitem" ]
  db:refpurpose [ "A wrapper for the elements of a list item" ]
]
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+ }
}
[
  db:refname [ "segmentedlist" ]
  db:refpurpose [ "A segmented list, a list of sets of elements" ]
]
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+
    }
}
[
  db:refname [ "segtitle" ]
  db:refpurpose [
    "The title of an element of a list item in a segmented list"
  ]
]
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* }
}
[
  db:refname [ "seglistitem" ]
  db:refpurpose [ "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+ }
}
[
  db:refname [ "seg" ]
  db:refpurpose [ "An element of 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* }
}
[
  db:refname [ "simplelist" ]
  db:refpurpose [
    "An undecorated list of single words or short phrases"
  ]
]
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+ }
}
[
  db:refname [ "member" ]
  db:refpurpose [ "An element of a simple list" ]
]
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* }
}
[
  db:refname [ "variablelist" ]
  db:refpurpose [
    "A list in which each entry is composed of a set of one or more terms and an associated description"
  ]
]
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+
    }
}
[
  db:refname [ "varlistentry" ]
  db:refpurpose [
    "A wrapper for a set of terms and the associated description in a variable list"
  ]
]
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
    }
}
[
  db:refname [ "term" ]
  db:refpurpose [
    "The word or phrase being defined or described 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* }
}
[
  db:refname [ "example" ]
  db:refpurpose [ "A formal example, with a title" ]
]
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}" ~
        "            "
      ]
    ]
    element example {
      db.example.attlist, db.example.info, db.all.blocks+, db.caption?
    }
}
[
  db:refname [ "informalexample" ]
  db:refpurpose [ "A displayed example without 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?
    }
}
db.verbatim.inlines = (db.all.inlines | db.lineannotation) | db.co
db.verbatim.contentmodel =
  db._info.title.forbidden, (db.textobject | db.verbatim.inlines*)
[
  db:refname [ "programlisting" ]
  db:refpurpose [ "A literal listing of all or part of a program" ]
]
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
    }
}
[
  db:refname [ "literallayout" ]
  db:refpurpose [
    "A block of text in which line breaks and white space are to be reproduced faithfully"
  ]
]
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
    }
}
[
  db:refname [ "screen" ]
  db:refpurpose [
    "Text that a user sees or might see on a computer screen"
  ]
]
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 }
}
[
  db:refname [ "screenshot" ]
  db:refpurpose [
    "A representation of what the 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
    }
}
[
  db:refname [ "figure" ]
  db:refpurpose [
    "A formal figure, generally an illustration, with a title"
  ]
]
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}" ~
        "            "
      ]
    ]
    element figure {
      db.figure.attlist, db.figure.info, db.all.blocks+, db.caption?
    }
}
[
  db:refname [ "informalfigure" ]
  db:refpurpose [ "A untitled figure" ]
]
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?
    }
}
db.mediaobject.content =
  (db.videoobject | db.audioobject | db.imageobject | db.textobject)
  | db.imageobjectco
[
  db:refname [ "mediaobject" ]
  db:refpurpose [
    "A displayed media object (video, audio, image, etc.)"
  ]
]
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?
    }
}
[
  db:refname [ "inlinemediaobject" ]
  db:refpurpose [
    "An inline media object (video, audio, image, and so on)"
  ]
]
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+
    }
}
[
  db:refname [ "videoobject" ]
  db:refpurpose [
    "A wrapper for video data and its associated meta-information"
  ]
]
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
    }
}
[
  db:refname [ "audioobject" ]
  db:refpurpose [
    "A wrapper for audio 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
    }
}
db.imageobject.content = db.imagedata | db._any.svg
[
  db:refname [ "imageobject" ]
  db:refpurpose [
    "A wrapper for image data and its associated meta-information"
  ]
]
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
    }
}
[
  db:refname [ "textobject" ]
  db:refpurpose [
    "A wrapper for a text description of an object 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+)
    }
}
[
  db:refname [ "videodata" ]
  db:refpurpose [ "Pointer to external video data" ]
]
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 }
}
[
  db:refname [ "audiodata" ]
  db:refpurpose [ "Pointer to external audio 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 }
}
[
  db:refname [ "imagedata" ]
  db:refpurpose [ "Pointer to external image 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 }
}
[
  db:refname [ "textdata" ]
  db:refpurpose [ "Pointer to external text 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 }
}
[
  db:refname [ "caption" ]
  db:refpurpose [ "A caption" ]
  ctrl:exclude [ from = "db.caption" exclude = "db.formal.blocks" ]
  ctrl:exclude [ from = "db.caption" exclude = "db.admonition.blocks" ]
  ctrl:exclude [ from = "db.caption" exclude = "db.sidebar" ]
  ctrl:exclude [ from = "db.caption" exclude = "db.task" ]
]
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}" ~
        "            "
      ]
    ]
    element caption {
      db.caption.attlist, db.caption.info, db.all.blocks+
    }
}
[
  db:refname [ "synopsis" ]
  db:refpurpose [
    "A general-purpose element for representing the syntax of commands or functions"
  ]
]
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 }
}
[
  db:refname [ "cmdsynopsis" ]
  db:refpurpose [ "A syntax summary for a software command" ]
]
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*
    }
}
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 }
[
  db:refname [ "arg" ]
  db:refpurpose [ "An argument in a CmdSynopsis" ]
]
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)*
    }
}
[
  db:refname [ "group" ]
  db:refpurpose [ "A group of elements 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)+
    }
}
[
  db:refname [ "sbr" ]
  db:refpurpose [ "An explicit line break in a command synopsis" ]
]
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 }
}
[
  db:refname [ "synopfragment" ]
  db:refpurpose [
    "A portion of a CmdSynopsis broken out from the main body of the 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)+
    }
}
[
  db:refname [ "synopfragmentref" ]
  db:refpurpose [ "A reference to a fragment of a command 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 }
}
[
  db:refname [ "funcsynopsis" ]
  db:refpurpose [ "The syntax summary for a function definition" ]
]
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)+
    }
}
[
  db:refname [ "funcsynopsisinfo" ]
  db:refpurpose [
    "Information supplementing the FuncDefs of a FuncSynopsis"
  ]
]
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
    }
}
[
  db:refname [ "funcprototype" ]
  db:refpurpose [ "The prototype of a function" ]
]
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*
    }
}
[
  db:refname [ "funcdef" ]
  db:refpurpose [ "A function (subroutine) name and its return type" ]
]
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)*
    }
}
[
  db:refname [ "void" ]
  db:refpurpose [
    "An empty element in a function synopsis indicating that the function in question takes no arguments"
  ]
]
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 }
}
[
  db:refname [ "varargs" ]
  db:refpurpose [
    "An empty element in a function synopsis indicating a variable number of 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 }
}
[
  db:refname [ "paramdef" ]
  db:refpurpose [
    "Information about a function parameter in a programming language"
  ]
]
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)*
    }
}
[
  db:refname [ "funcparams" ]
  db:refpurpose [
    "Parameters for a function referenced through a function pointer in a synopsis"
  ]
]
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 }
}
[
  db:refname [ "classsynopsis" ]
  db:refpurpose [ "The syntax summary for a class definition" ]
]
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)*
    }
}
[
  db:refname [ "classsynopsisinfo" ]
  db:refpurpose [
    "Information supplementing the contents of a ClassSynopsis"
  ]
]
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
    }
}
[
  db:refname [ "ooclass" ]
  db:refpurpose [ "A class in an object-oriented programming language" ]
]
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
    }
}
[
  db:refname [ "oointerface" ]
  db:refpurpose [
    "An interface 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
    }
}
[
  db:refname [ "ooexception" ]
  db:refpurpose [
    "An exception 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
    }
}
[
  db:refname [ "modifier" ]
  db:refpurpose [ "Modifiers in a synopsis" ]
]
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 }
}
[
  db:refname [ "interfacename" ]
  db:refpurpose [ "The name of an interface" ]
]
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 }
}
[
  db:refname [ "exceptionname" ]
  db:refpurpose [ "The name of an exception" ]
]
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 }
}
[
  db:refname [ "fieldsynopsis" ]
  db:refpurpose [ "The name of a field in a class definition" ]
]
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?
    }
}
[
  db:refname [ "initializer" ]
  db:refpurpose [ "The initializer for a FieldSynopsis" ]
]
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 }
}
[
  db:refname [ "constructorsynopsis" ]
  db:refpurpose [ "A syntax summary for a constructor" ]
]
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*
    }
}
[
  db:refname [ "destructorsynopsis" ]
  db:refpurpose [ "A syntax summary for a destructor" ]
]
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*
    }
}
[
  db:refname [ "methodsynopsis" ]
  db:refpurpose [ "A syntax summary for a method" ]
]
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*
    }
}
[ db:refname [ "methodname" ] db:refpurpose [ "The name of 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 }
}
[
  db:refname [ "methodparam" ]
  db:refpurpose [ "Parameters to 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*
    }
}
[
  db:refname [ "address" ]
  db:refpurpose [ "A real-world address, generally a postal address" ]
]
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)*
    }
}
[
  db:refname [ "street" ]
  db:refpurpose [ "A street address in an 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 }
}
[
  db:refname [ "pob" ]
  db:refpurpose [ "A post office box 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 }
}
[
  db:refname [ "postcode" ]
  db:refpurpose [ "A postal code 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 }
}
[
  db:refname [ "city" ]
  db:refpurpose [ "The name of a city 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 }
}
[
  db:refname [ "state" ]
  db:refpurpose [ "A state or province 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 }
}
[ db:refname [ "country" ] db:refpurpose [ "The name of a country" ] ]
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 }
}
[ db:refname [ "phone" ] db:refpurpose [ "A telephone number" ] ]
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 }
}
[ db:refname [ "fax" ] db:refpurpose [ "A fax 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 }
}
[
  db:refname [ "otheraddr" ]
  db:refpurpose [ "Uncategorized information in address" ]
]
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 }
}
[
  db:refname [ "affiliation" ]
  db:refpurpose [ "The institutional affiliation of an individual" ]
]
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*
    }
}
[
  db:refname [ "shortaffil" ]
  db:refpurpose [ "A brief description of an affiliation" ]
]
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 }
}
[
  db:refname [ "jobtitle" ]
  db:refpurpose [ "The title of an individual in an organization" ]
]
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 }
}
[
  db:refname [ "orgname" ]
  db:refpurpose [
    "The name of an organization other than a corporation "
  ]
  ctrl:other-attribute [
    name = "db.orgname.class.attrib"
    enum-name = "db.orgname.class-enum.attribute"
    other-name = "db.orgname.class-other.attributes"
  ]
]
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 }
}
[
  db:refname [ "orgdiv" ]
  db:refpurpose [ "A division of an organization" ]
]
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* }
}
[
  db:refname [ "artpagenums" ]
  db:refpurpose [ "The page numbers of an article as published" ]
]
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 }
}
[
  db:refname [ "personname" ]
  db:refpurpose [ "The personal name of an individual" ]
]
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)+)
    }
}
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
[
  db:refname [ "author" ]
  db:refpurpose [ "The name of an individual author" ]
]
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 }
}
[
  db:refname [ "authorgroup" ]
  db:refpurpose [
    "Wrapper for author information when a document has multiple authors or collabarators"
  ]
]
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)+
    }
}
[
  db:refname [ "collab" ]
  db:refpurpose [ "Identifies a collaborator" ]
]
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*
    }
}
[
  db:refname [ "authorinitials" ]
  db:refpurpose [
    "The initials or other short identifier for an author"
  ]
]
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 }
}
[
  db:refname [ "confgroup" ]
  db:refpurpose [
    "A wrapper for document meta-information about a conference"
  ]
]
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)*
    }
}
[
  db:refname [ "confdates" ]
  db:refpurpose [
    "The dates of a conference for which a document was written"
  ]
]
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 }
}
[
  db:refname [ "conftitle" ]
  db:refpurpose [
    "The title 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 }
}
[
  db:refname [ "confnum" ]
  db:refpurpose [
    "An identifier, frequently numerical, associated with 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 }
}
[
  db:refname [ "confsponsor" ]
  db:refpurpose [
    "The sponsor of 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 }
}
[
  db:refname [ "contractnum" ]
  db:refpurpose [ "The contract number of a document" ]
]
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 }
}
[
  db:refname [ "contractsponsor" ]
  db:refpurpose [ "The sponsor of a contract" ]
]
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 }
}
[
  db:refname [ "copyright" ]
  db:refpurpose [ "Copyright information about a document" ]
]
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* }
}
[
  db:refname [ "year" ]
  db:refpurpose [ "The year of publication of 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 }
}
[
  db:refname [ "holder" ]
  db:refpurpose [
    "The name of the individual or organization that holds a copyright"
  ]
]
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 }
}
db.date.contentmodel =
  xsd:date | xsd:dateTime | xsd:gYearMonth | xsd:gYear | text
[
  db:refname [ "date" ]
  db:refpurpose [ "The date of publication or revision of a document" ]
]
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 }
}
[
  db:refname [ "edition" ]
  db:refpurpose [ "The name or number of an edition 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 }
}
[
  db:refname [ "editor" ]
  db:refpurpose [ "The name of the editor 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 }
}
[
  db:refname [ "biblioid" ]
  db:refpurpose [ "An identifier for 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 }
}
[
  db:refname [ "citebiblioid" ]
  db:refpurpose [ "A citation of a bibliographic identifier" ]
]
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 }
}
[
  db:refname [ "bibliosource" ]
  db:refpurpose [ "The source of a document" ]
]
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 }
}
[
  db:refname [ "bibliorelation" ]
  db:refpurpose [ "The relationship of a document to another" ]
  ctrl:other-attribute [
    name = "db.bibliorelation.type.attrib"
    enum-name = "db.bibliorelation.type-enum.attribute"
    other-name = "db.bibliorelation.type-other.attributes"
  ]
]
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 }
}
[
  db:refname [ "bibliocoverage" ]
  db:refpurpose [ "The spatial or temporal coverage of a document" ]
  ctrl:other-attribute [
    name = "db.bibliocoverage.spatial.attrib"
    enum-name = "db.bibliocoverage.spatial-enum.attribute"
    other-name = "db.bibliocoverage.spatial-other.attributes"
  ]
]
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
  ctrl:other-attribute [
    name = "db.bibliocoverage.temporal.attrib"
    enum-name = "db.bibliocoverage.temporal-enum.attribute"
    other-name = "db.bibliocoverage.temporal-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 }
}
[
  db:refname [ "legalnotice" ]
  db:refpurpose [ "A statement of legal obligations or requirements" ]
]
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+
    }
}
[
  db:refname [ "othercredit" ]
  db:refpurpose [
    "A person or entity, other than an author or editor, credited in a document"
  ]
]
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
    }
}
[
  db:refname [ "pagenums" ]
  db:refpurpose [
    "The numbers of the pages in a book, for use in a bibliographic entry"
  ]
]
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 }
}
[
  db:refname [ "contrib" ]
  db:refpurpose [
    "A summary of the contributions made to a document by a credited source"
  ]
]
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 }
}
[ db:refname [ "honorific" ] db:refpurpose [ "The title of a person" ] ]
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 }
}
[
  db:refname [ "firstname" ]
  db:refpurpose [ "The first name 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 }
}
[
  db:refname [ "surname" ]
  db:refpurpose [ "A family name; in western cultures the last name" ]
]
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 }
}
[
  db:refname [ "lineage" ]
  db:refpurpose [
    "The portion of a person's name indicating a relationship to ancestors"
  ]
]
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 }
}
[
  db:refname [ "othername" ]
  db:refpurpose [
    "A component of a persons name that is not a first name, surname, or lineage"
  ]
]
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 }
}
[
  db:refname [ "printhistory" ]
  db:refpurpose [ "The printing history of a document" ]
]
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+ }
}
[
  db:refname [ "productname" ]
  db:refpurpose [ "The formal name of a product" ]
]
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 }
}
[
  db:refname [ "productnumber" ]
  db:refpurpose [ "A number assigned to 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 }
}
[
  db:refname [ "pubdate" ]
  db:refpurpose [ "The date of publication of a document" ]
]
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 }
}
[
  db:refname [ "publisher" ]
  db:refpurpose [ "The publisher 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*
    }
}
[
  db:refname [ "publishername" ]
  db:refpurpose [ "The name of 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 }
}
[
  db:refname [ "releaseinfo" ]
  db:refpurpose [
    "Information about a particular release 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 }
}
[
  db:refname [ "revhistory" ]
  db:refpurpose [ "A history of the revisions to 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+
    }
}
[
  db:refname [ "revision" ]
  db:refpurpose [
    "An entry describing a single revision in the 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)?
    }
}
[
  db:refname [ "revnumber" ]
  db:refpurpose [ "A document revision number" ]
]
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 }
}
[
  db:refname [ "revremark" ]
  db:refpurpose [ "A description of a revision to a document" ]
]
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 }
}
[
  db:refname [ "revdescription" ]
  db:refpurpose [ "A extended 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* }
}
[
  db:refname [ "seriesvolnums" ]
  db:refpurpose [ "Numbers of the volumes in a series of books" ]
]
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 }
}
[
  db:refname [ "volumenum" ]
  db:refpurpose [
    "The volume number of a document in a set (as of books in a set or articles in a journal)"
  ]
]
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 }
}
[
  db:refname [ "issuenum" ]
  db:refpurpose [ "The number of an issue of 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 }
}
[
  db:refname [ "accel" ]
  db:refpurpose [ "A graphical user interface (GUI) keyboard shortcut" ]
]
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 }
}
[
  db:refname [ "application" ]
  db:refpurpose [ "The name of a software program" ]
]
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 }
}
[
  db:refname [ "package" ]
  db:refpurpose [ "A software or application package" ]
]
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 }
}
[
  db:refname [ "classname" ]
  db:refpurpose [
    "The name of a class, in the object-oriented programming sense"
  ]
]
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 }
}
[
  db:refname [ "command" ]
  db:refpurpose [
    "The name of an executable program or other software command"
  ]
]
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 }
}
db.computeroutput.inlines =
  (text
   | db.ubiq.inlines
   | db.os.inlines
   | db.technical.inlines
   | db.markup.inlines)
  | db.co
  | db.co
[
  db:refname [ "computeroutput" ]
  db:refpurpose [
    "Data, generally text, displayed or presented by a computer"
  ]
]
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*
    }
}
[
  db:refname [ "database" ]
  db:refpurpose [ "The name of a database, or part of a database" ]
]
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 }
}
[ db:refname [ "email" ] db:refpurpose [ "An email address" ] ]
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 }
}
[
  db:refname [ "envar" ]
  db:refpurpose [ "A software environment variable" ]
]
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 }
}
[ db:refname [ "errorcode" ] db:refpurpose [ "An error code" ] ]
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 }
}
[ db:refname [ "errorname" ] db:refpurpose [ "An error name" ] ]
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 }
}
[ db:refname [ "errortext" ] db:refpurpose [ "An error message." ] ]
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 }
}
[
  db:refname [ "errortype" ]
  db:refpurpose [ "The classification of an error message" ]
]
div {
  db.errortype.role.attribute = attribute role { text }
  db.errortype.attlist =
    db.errortype.role.attribute?
    & db.common.attributes
    & db.common.linking.attributes
  db.errortype = element errortype { db.errortype.attlist, db._text }
}
[ db:refname [ "filename" ] db:refpurpose [ "The name of a file" ] ]
div {
  db.filename.path.attribute = attribute path { text }
  db.filename.class.attribute =
    attribute class {
      "devicefile"
      | "directory"
      | "extension"
      | "headerfile"
      | "libraryfile"
      | "partition"
      | "symlink"
    }
  db.filename.role.attribute = attribute role { text }
  db.filename.attlist =
    db.filename.role.attribute?
    & db.common.attributes
    & db.common.linking.attributes
    & db.filename.path.attribute?
    & db.filename.class.attribute?
  db.filename = element filename { db.filename.attlist, db._text }
}
[
  db:refname [ "function" ]
  db:refpurpose [
    "The name of a function or subroutine, as in a programming language"
  ]
]
div {
  db.function.role.attribute = attribute role { text }
  db.function.attlist =
    db.function.role.attribute?
    & db.common.attributes
    & db.common.linking.attributes
  db.function = element function { db.function.attlist, db._text }
}
[
  db:refname [ "guibutton" ]
  db:refpurpose [ "The text on a button in a GUI" ]
]
div {
  db.guibutton.role.attribute = attribute role { text }
  db.guibutton.attlist =
    db.guibutton.role.attribute?
    & db.common.attributes
    & db.common.linking.attributes
  db.guibutton =
    element guibutton {
      db.guibutton.attlist,
      (db._text | db.accel | db.superscript | db.subscript)*
    }
}
[
  db:refname [ "guiicon" ]
  db:refpurpose [ "Graphic and/or text appearing as a icon in a GUI" ]
]
div {
  db.guiicon.role.attribute = attribute role { text }
  db.guiicon.attlist =
    db.guiicon.role.attribute?
    & db.common.attributes
    & db.common.linking.attributes
  db.guiicon =
    element guiicon {
      db.guiicon.attlist,
      (db._text | db.accel | db.superscript | db.subscript)*
    }
}
[
  db:refname [ "guilabel" ]
  db:refpurpose [ "The text of a label in a GUI" ]
]
div {
  db.guilabel.role.attribute = attribute role { text }
  db.guilabel.attlist =
    db.guilabel.role.attribute?
    & db.common.attributes
    & db.common.linking.attributes
  db.guilabel =
    element guilabel {
      db.guilabel.attlist,
      (db._text | db.accel | db.superscript | db.subscript)*
    }
}
[
  db:refname [ "guimenu" ]
  db:refpurpose [ "The name of a menu in a GUI" ]
]
div {
  db.guimenu.role.attribute = attribute role { text }
  db.guimenu.attlist =
    db.guimenu.role.attribute?
    & db.common.attributes
    & db.common.linking.attributes
  db.guimenu =
    element guimenu {
      db.guimenu.attlist,
      (db._text | db.accel | db.superscript | db.subscript)*
    }
}
[
  db:refname [ "guimenuitem" ]
  db:refpurpose [ "The name of a terminal menu item in a GUI" ]
]
div {
  db.guimenuitem.role.attribute = attribute role { text }
  db.guimenuitem.attlist =
    db.guimenuitem.role.attribute?
    & db.common.attributes
    & db.common.linking.attributes
  db.guimenuitem =
    element guimenuitem {
      db.guimenuitem.attlist,
      (db._text | db.accel | db.superscript | db.subscript)*
    }
}
[
  db:refname [ "guisubmenu" ]
  db:refpurpose [ "The name of a submenu in a GUI" ]
]
div {
  db.guisubmenu.role.attribute = attribute role { text }
  db.guisubmenu.attlist =
    db.guisubmenu.role.attribute?
    & db.common.attributes
    & db.common.linking.attributes
  db.guisubmenu =
    element guisubmenu {
      db.guisubmenu.attlist,
      (db._text | db.accel | db.superscript | db.subscript)*
    }
}
[
  db:refname [ "hardware" ]
  db:refpurpose [ "A physical part of a computer system" ]
]
div {
  db.hardware.role.attribute = attribute role { text }
  db.hardware.attlist =
    db.hardware.role.attribute?
    & db.common.attributes
    & db.common.linking.attributes
  db.hardware = element hardware { db.hardware.attlist, db._text }
}
[
  db:refname [ "keycap" ]
  db:refpurpose [ "The text printed on a key on a keyboard" ]
  ctrl:other-attribute [
    name = "db.keycap.function.attrib"
    enum-name = "db.keycap.function-enum.attribute"
    other-name = "db.keycap.function-other.attributes"
  ]
]
div {
  db.keycap.function-enum.attribute =
    attribute function {
      "alt"
      | "backspace"
      | "command"
      | "control"
      | "delete"
      | "down"
      | "end"
      | "enter"
      | "escape"
      | "home"
      | "insert"
      | "left"
      | "meta"
      | "option"
      | "pagedown"
      | "pageup"
      | "right"
      | "shift"
      | "space"
      | "tab"
      | "up"
    }?
  db.keycap.function-other.attributes =
    attribute function { "other" }?,
    attribute otherfunction { text }
  db.keycap.function.attrib =
    db.keycap.function-enum.attribute
    | db.keycap.function-other.attributes
  db.keycap.role.attribute = attribute role { text }
  db.keycap.attlist =
    db.keycap.role.attribute?
    & db.common.attributes
    & db.common.linking.attributes
    & db.keycap.function.attrib
  db.keycap = element keycap { db.keycap.attlist, db._text }
}
[
  db:refname [ "keycode" ]
  db:refpurpose [
    "The internal, frequently numeric, identifier for a key on a keyboard"
  ]
]
div {
  db.keycode.role.attribute = attribute role { text }
  db.keycode.a