TEI for manuscript descriptions of the e-ZRC project
xsd:anyURIseparated by whitespace
string
xsd:anyURIseparated by whitespace
xsd:double | xsd:decimal
xsd:double | xsd:decimal
xsd:double | xsd:decimal
xsd:double | xsd:decimal
xsd:anyURI
xsd:Name
xsd:nonNegativeInteger
xsd:date
| xsd:gYear
| xsd:gMonth
| xsd:gDay
| xsd:gYearMonth
| xsd:gMonthDay
| xsd:time
| xsd:dateTime
| token { pattern = "[0-9.,DHMPRSTWYZ/:+\-]+" }The following are examples of ISO date, time, and date & time formats that are not valid W3C format normalizations.
All of the examples of the
The second occurence of time could have been encoded with the
xsd:date
| xsd:gYear
| xsd:gMonth
| xsd:gDay
| xsd:gYearMonth
| xsd:gMonthDay
| xsd:time
| xsd:dateTime
| token { pattern = "[0-9.,DHMPRSTWYZ/:+\-]+" }
xsd:date
| xsd:gYear
| xsd:gMonth
| xsd:gDay
| xsd:gYearMonth
| xsd:gMonthDay
| xsd:time
| xsd:dateTime
| token { pattern = "[0-9.,DHMPRSTWYZ/:+\-]+" }
xsd:date
| xsd:gYear
| xsd:gMonth
| xsd:gDay
| xsd:gYearMonth
| xsd:gMonthDay
| xsd:time
| xsd:dateTime
| token { pattern = "[0-9.,DHMPRSTWYZ/:+\-]+" }
xsd:date
| xsd:gYear
| xsd:gMonth
| xsd:gDay
| xsd:gYearMonth
| xsd:gMonthDay
| xsd:time
| xsd:dateTime
| token { pattern = "[0-9.,DHMPRSTWYZ/:+\-]+" }
xsd:anyURI
xsd:date
| xsd:gYear
| xsd:gMonth
| xsd:gDay
| xsd:gYearMonth
| xsd:gMonthDay
| xsd:time
| xsd:dateTimeExamples of W3C date, time, and date & time formats.
xsd:date
| xsd:gYear
| xsd:gMonth
| xsd:gDay
| xsd:gYearMonth
| xsd:gMonthDay
| xsd:time
| xsd:dateTime
xsd:date
| xsd:gYear
| xsd:gMonth
| xsd:gDay
| xsd:gYearMonth
| xsd:gMonthDay
| xsd:time
| xsd:dateTime
xsd:date
| xsd:gYear
| xsd:gMonth
| xsd:gDay
| xsd:gYearMonth
| xsd:gMonthDay
| xsd:time
| xsd:dateTime
xsd:date
| xsd:gYear
| xsd:gMonth
| xsd:gDay
| xsd:gYearMonth
| xsd:gMonthDay
| xsd:time
| xsd:dateTime
xsd:boolean
xsd:anyURIseparated by whitespace
xsd:Name
xsd:double | xsd:decimal
token { pattern = "(\p{L}|\p{N}|\p{P}|\p{S})+" }separated by whitespace
xsd:double | xsd:decimal
xsd:double | xsd:decimal
xsd:double | xsd:decimal
xsd:double | xsd:decimal
"high" | "medium" | "low" | "unknown"
xsd:Name
"high" | "medium" | "low" | "unknown"
xsd:anyURIseparated by whitespace
xsd:Name
xsd:anyURIseparated by whitespace
xsd:Name
xsd:ID
token { pattern = "(\p{L}|\p{N}|\p{P}|\p{S})+" }separated by whitespace
xsd:language
token { pattern = "(\p{L}|\p{N}|\p{P}|\p{S})+" }separated by whitespace
xsd:anyURIseparated by whitespace
xsd:anyURI
xsd:anyURIseparated by whitespace
xsd:anyURIseparated by whitespace
xsd:anyURIseparated by whitespace
xsd:anyURI
xsd:anyURI
xsd:anyURI
xsd:anyURI
xsd:anyURIseparated by whitespace
xsd:anyURIseparated by whitespace
xsd:Name
xsd:Nameseparated by whitespace
xsd:Name
token { pattern = "(\p{L}|\p{N}|\p{P}|\p{S})+" }
xsd:Name
xsd:double | xsd:decimal
token { pattern = "(\p{L}|\p{N}|\p{P}|\p{S})+" }separated by whitespace
token
token
token
xsd:boolean | "unknown" | "inapplicable"
xsd:anyURIseparated by whitespace
xsd:nonNegativeInteger
xsd:Nameseparated by whitespace
xsd:Name
xsd:Nameseparated by whitespace
token { pattern = "(\p{L}|\p{N}|\p{P}|\p{S})+" }separated by whitespace
xsd:anyURIseparated by whitespace
xsd:Name
xsd:anyURIseparated by whitespace
xsd:anyURI
xsd:Name
xsd:nonNegativeInteger
xsd:nonNegativeInteger
xsd:anyURIseparated by whitespace
xsd:Name
xsd:Name
xsd:nonNegativeInteger
xsd:anyURI
xsd:anyURI
xsd:anyURI
xsd:Name
xsd:nonNegativeInteger
token { pattern = "(\p{L}|\p{N}|\p{P}|\p{S})+" }
xsd:Name
xsd:Namemacro.anyXML = element * { ( attribute * - (xml:id | xml:lang) { text } | text | macro.anyXML )* }
macro.limitedContent = ( text | model.limitedPhrase | model.inter )*
macro.paraContent = ( text | model.gLike | model.phrase | model.inter | model.global )*
macro.phraseSeq = ( text | model.gLike | model.phrase | model.global )*
macro.phraseSeq.limited = ( text | model.limitedPhrase | model.global )*
macro.specialPara =
(
text
| model.gLike
| model.phrase
| model.inter
| model.divPart
| model.global
)*macro.xtext = ( text | model.gLike )*
xsd:decimalelement TEI { att.global.attributes, attribute version { xsd:decimal }?, ( teiHeader, ( ( model.resourceLike+, text? ) | text ) ) }
element ab { att.global.attributes, att.typed.attributes, att.declaring.attributes, attribute part { "Y" | "N" | "I" | "M" | "F" }?, macro.paraContent }
xsd:Nameelement abbr { att.global.attributes, attribute type { xsd:Name }?, macro.phraseSeq }
element accMat { att.global.attributes, att.typed.attributes, macro.specialPara }
element acquisition { att.global.attributes, att.datable.attributes, macro.specialPara }
element add { att.global.attributes, att.transcriptional.attributes, att.placement.attributes, att.typed.attributes, macro.paraContent }
element addName { att.global.attributes, att.personal.attributes, att.typed.attributes, macro.phraseSeq }
element addSpan { att.global.attributes, att.transcriptional.attributes, att.placement.attributes, att.typed.attributes, att.spanning.attributes, empty }
element additional { att.global.attributes, ( adminInfo?, surrogates?, listBibl? ) }
element additions { att.global.attributes, macro.specialPara }
element addrLine { att.global.attributes, macro.phraseSeq }element address { att.global.attributes, ( model.global*, ( ( model.addrPart ), model.global* )+ ) }
element adminInfo { att.global.attributes, ( recordHist?, availability?, custodialHist?, model.noteLike? ) }
element affiliation { att.global.attributes, att.editLike.attributes, att.datable.attributes, att.naming.attributes, macro.phraseSeq }
xsd:nonNegativeIntegerelement age { att.global.attributes, att.editLike.attributes, att.datable.attributes, attribute value { xsd:nonNegativeInteger }?, macro.phraseSeq.limited }
xsd:anyURIseparated by whitespace
xsd:double { minInclusive = "0" maxInclusive = "1" }separated by whitespaceelement alt { att.global.attributes, att.pointing.attributes, attribute targets { list { xsd:anyURI, xsd:anyURI+ } }, attribute mode { "excl" | "incl" }?, attribute weights { list { xsd:double { minInclusive = "0" maxInclusive = "1" }, xsd:double { minInclusive = "0" maxInclusive = "1" }+ } }?, empty }
element altGrp { att.global.attributes, att.pointing.group.attributes, attribute mode { "excl" | "incl" }?, ( alt | ptr )* }
element altIdentifier { att.global.attributes, att.typed.attributes, ( model.placeNamePart_sequenceOptional, institution?, repository?, collection?, idno, note? ) }
element am { att.global.attributes, att.editLike.attributes, macro.xtext }element analytic { att.global.attributes, ( author | editor | respStmt | title )* }
element anchor { att.global.attributes, att.typed.attributes, empty }
xsd:Name
xsd:anyURI
xsd:anyURI
token { pattern = "(\p{L}|\p{N}|\p{P}|\p{S})+" }separated by whitespaceelement app { att.global.attributes, attribute type { xsd:Name }?, attribute from { xsd:anyURI }?, attribute to { xsd:anyURI }?, attribute loc { list { token { pattern = "(\p{L}|\p{N}|\p{P}|\p{S})+" }+ } }?, ( model.global*, ( lem, model.global*, ( wit, model.global* )? )?, ( ( model.rdgLike, model.global*, ( wit, model.global* )? ) | ( rdgGrp, model.global*, ( wit, model.global* )? ) )* ) }
element appInfo { att.global.attributes, model.applicationLike+ }
xsd:Name
token { pattern = "[\d]+[a-z]*[\d]*(\.[\d]+[a-z]*[\d]*){0,3}" }element application { att.global.attributes, att.typed.attributes, att.datable.attributes, attribute ident { xsd:Name }, attribute version { token { pattern = "[\d]+[a-z]*[\d]*(\.[\d]+[a-z]*[\d]*){0,3}" } }, ( model.labelLike+, ( model.ptrLike* | model.pLike* ) ) }
This example shows an appInfo element documenting the fact that version 1.5 of the Image Markup Tool1 application has an interest in two parts of a document which was last saved on June 6 2006. The parts concerned are accessible at the URLs given as target for the two ptr elements.
element argument { att.global.attributes, ( ( model.global | model.headLike )*, ( ( model.common ), model.global* )+ ) }
element author { att.global.attributes, att.canonical.attributes, macro.phraseSeq }
element authority { att.global.attributes, macro.phraseSeq.limited }element availability { att.global.attributes, att.declarable.attributes, attribute status { "free" | "unknown" | "restricted" }?, model.pLike+ }
element back { att.global.attributes, att.declaring.attributes, ( ( model.frontPart | model.pLike.front | model.global )*, ( ( ( ( model.div1Like ), ( model.frontPart | model.div1Like | model.global )* ) | ( ( model.divLike ), ( model.frontPart | model.divLike | model.global )* ) )? ), ( ( ( model.divBottomPart ), ( model.divBottomPart | model.global )* )? ) ) }
element bibl { att.global.attributes, att.declarable.attributes, att.typed.attributes, ( text | model.gLike | model.highlighted | model.pPart.data | model.pPart.edit | model.segLike | model.ptrLike | model.biblPart | model.global )* }
element biblFull { att.global.attributes, att.declarable.attributes, ( ( titleStmt, editionStmt?, extent?, publicationStmt, seriesStmt?, notesStmt? ), sourceDesc* ) }
xsd:Nameelement biblScope { att.global.attributes, attribute type { "vol" | "issue" | "pp" | "chap" | "part" | xsd:Name }?, macro.phraseSeq }
element biblStruct { att.global.attributes, att.declarable.attributes, att.typed.attributes, ( analytic*, ( monogr, series* )+, ( model.noteLike | idno | relatedItem )* ) }
token
{
pattern = "[\-+]?\d+(\.\d+)?(%|cm|mm|in|pt|pc|px|em|ex|gd|rem|vw|vh|vm)"
}
token
{
pattern = "[\-+]?\d+(\.\d+)?(%|cm|mm|in|pt|pc|px|em|ex|gd|rem|vw|vh|vm)"
}
xsd:double | xsd:decimal
token { pattern = "(\p{L}|\p{N}|\p{P}|\p{S})+" }separated by whitespaceelement binaryObject { att.global.attributes, att.internetMedia.attributes, attribute width { token { pattern = "[\-+]?\d+(\.\d+)?(%|cm|mm|in|pt|pc|px|em|ex|gd|rem|vw|vh|vm)" } }?, attribute height { token { pattern = "[\-+]?\d+(\.\d+)?(%|cm|mm|in|pt|pc|px|em|ex|gd|rem|vw|vh|vm)" } }?, attribute scale { xsd:double | xsd:decimal }?, attribute encoding { list { token { pattern = "(\p{L}|\p{N}|\p{P}|\p{S})+" }+ } }?, text }
xsd:boolean | "unknown" | "inapplicable"element binding { att.global.attributes, att.datable.attributes, attribute contemporary { xsd:boolean | "unknown" | "inapplicable" }?, ( model.pLike | condition | decoNote )+ }
element bindingDesc { att.global.attributes, ( ( model.pLike | decoNote | condition )+ | binding+ ) }
element birth { att.global.attributes, att.editLike.attributes, att.datable.attributes, att.naming.attributes, macro.phraseSeq }
element bloc { att.global.attributes, att.naming.attributes, att.typed.attributes, att.datable.attributes, macro.phraseSeq }
element body { att.global.attributes, att.declaring.attributes, ( model.global*, ( ( model.divTop ), ( model.global | model.divTop )* )?, ( ( model.divGenLike ), ( model.global | model.divGenLike )* )?, ( ( ( model.divLike ), ( model.global | model.divGenLike )* )+ | ( ( model.div1Like ), ( model.global | model.divGenLike )* )+ | ( ( ( model.common ), model.global* )+, ( ( ( model.divLike ), ( model.global | model.divGenLike )* )+ | ( ( model.div1Like ), ( model.global | model.divGenLike )* )+ )? ) ), ( ( model.divBottom ), model.global* )* ) }
element byline { att.global.attributes, ( text | model.gLike | model.phrase | docAuthor | model.global )* }
token
textelement cRefPattern { att.global.attributes, attribute matchPattern { token }, attribute replacementPattern { text }, model.pLike* }
element caesura { att.global.attributes, empty }element catDesc { att.global.attributes, ( text | model.limitedPhrase | model.catDescPart )* }
xsd:anyURIseparated by whitespace
xsd:anyURIelement catRef { att.global.attributes, attribute target { list { xsd:anyURI+ } }, attribute scheme { xsd:anyURI }?, empty }
element catchwords { att.global.attributes, macro.phraseSeq }element category { att.global.attributes, ( ( catDesc | model.glossLike* ), category* ) }
element cb { att.global.attributes, att.typed.attributes, att.sourced.attributes, empty }
Markup of an early English dictionary printed in two columns:
element cell { att.global.attributes, att.tableDecoration.attributes, macro.paraContent }
xsd:date
| xsd:gYear
| xsd:gMonth
| xsd:gDay
| xsd:gYearMonth
| xsd:gMonthDay
| xsd:time
| xsd:dateTimeelement change { att.global.attributes, att.ascribed.attributes, attribute when { xsd:date | xsd:gYear | xsd:gMonth | xsd:gDay | xsd:gYearMonth | xsd:gMonthDay | xsd:time | xsd:dateTime }?, ( text | model.limitedPhrase | model.inter | model.global )* }
element choice { att.global.attributes, ( model.choicePart | choice )* }An American encoding of Gulliver's Travels which retains the British spelling but also provides a version regularized to American spelling might be encoded as follows.
element cit { att.global.attributes, att.typed.attributes, ( model.qLike | model.biblLike | model.ptrLike | model.global | model.entryPart )+ }
xsd:anyURIelement classCode { att.global.attributes, attribute scheme { xsd:anyURI }, macro.phraseSeq.limited }
element classDecl { att.global.attributes, taxonomy+ }element climate { att.global.attributes, att.datable.attributes, att.editLike.attributes, att.naming.attributes, att.typed.attributes, ( model.headLike*, ( ( model.pLike+ ) | ( model.labelLike+ ) ), ( model.noteLike | model.biblLike )*, climate* ) }
element closer { att.global.attributes, ( text | model.gLike | signed | dateline | salute | model.phrase | model.global )* }
element collation { att.global.attributes, macro.specialPara }element collection { att.global.attributes, att.naming.attributes, macro.xtext }
element colophon { att.global.attributes, macro.phraseSeq }
element condition { att.global.attributes, macro.specialPara }element corr { att.global.attributes, att.editLike.attributes, att.typed.attributes, macro.paraContent }
If all that is desired is to call attention to the fact that the copy text has been corrected, corr may be used alone:
It is also possible, using the choice and sic elements, to provide an uncorrected reading:
element correction { att.global.attributes, att.declarable.attributes, attribute status { "high" | "medium" | "low" | "unknown" }?, attribute method { "silent" | "markup" }?, model.pLike+ }
element country { att.global.attributes, att.naming.attributes, att.typed.attributes, att.datable.attributes, macro.phraseSeq }
element creation { att.global.attributes, macro.phraseSeq.limited }element custEvent { att.global.attributes, att.datable.attributes, att.typed.attributes, macro.specialPara }
element custodialHist { att.global.attributes, ( model.pLike+ | custEvent+ ) }element damage { att.global.attributes, att.typed.attributes, att.damaged.attributes, macro.paraContent }
element damageSpan { att.global.attributes, att.damaged.attributes, att.typed.attributes, att.spanning.attributes, empty }
xsd:Nameelement date { att.global.attributes, att.datable.attributes, att.editLike.attributes, att.typed.attributes, attribute calendar { "Gregorian" | "Julian" | "Islamic" | "Hebrew" | "Revolutionary" | "Iranian" | "Coptic" | "Chinese" | xsd:Name }?, ( text | model.gLike | model.phrase | model.global )* }
element dateline { att.global.attributes, macro.phraseSeq }element death { att.global.attributes, att.editLike.attributes, att.datable.attributes, att.naming.attributes, macro.phraseSeq }
element decoDesc { att.global.attributes, ( model.pLike+ | decoNote+ ) }element decoNote { att.global.attributes, att.typed.attributes, macro.specialPara }
element del { att.global.attributes, att.transcriptional.attributes, att.typed.attributes, macro.paraContent }
element delSpan { att.global.attributes, att.transcriptional.attributes, att.typed.attributes, att.spanning.attributes, empty }
element depth { att.global.attributes, att.dimensions.attributes, macro.xtext }element desc { att.global.attributes, att.translatable.attributes, macro.limitedContent }
xsd:Nameelement dimensions { att.global.attributes, att.dimensions.attributes, attribute type { xsd:Name }?, ( height?, width?, depth? ) }
When simple numeric quantities are involved, they may be
expressed on the
xsd:Name
xsd:anyURI
xsd:anyURI
xsd:anyURIelement distinct { att.global.attributes, attribute type { xsd:Name }?, attribute time { xsd:anyURI }?, attribute space { xsd:anyURI }?, attribute social { xsd:anyURI }?, macro.phraseSeq }
element distributor { att.global.attributes, macro.phraseSeq }element district { att.global.attributes, att.naming.attributes, att.typed.attributes, att.datable.attributes, macro.phraseSeq }
element div { att.global.attributes, att.divLike.attributes, att.typed.attributes, att.declaring.attributes, ( ( model.divTop | model.global )*, ( ( ( ( ( model.divLike | model.divGenLike ), model.global* )+ ) | ( ( ( model.common ), model.global* )+, ( ( model.divLike | model.divGenLike ), model.global* )* ) ), ( ( model.divBottom ), model.global* )* )? ) }
element div1 { att.global.attributes, att.divLike.attributes, att.typed.attributes, att.declaring.attributes, ( ( model.divTop | model.global )*, ( ( ( ( model.div2Like | model.divGenLike ), model.global* )+ | ( ( ( model.common ), model.global* )+, ( ( model.div2Like | model.divGenLike ), model.global* )* ) ), ( ( model.divBottom ), model.global* )* )? ) }
element div2 { att.global.attributes, att.divLike.attributes, att.typed.attributes, att.declaring.attributes, ( ( model.divTop | model.global )*, ( ( ( ( model.div3Like | model.divGenLike ), model.global* )+ | ( ( ( model.common ), model.global* )+, ( ( model.div3Like | model.divGenLike ), model.global* )* ) ), ( ( model.divBottom ), model.global* )* )? ) }
element div3 { att.global.attributes, att.divLike.attributes, att.typed.attributes, att.declaring.attributes, ( ( model.divTop | model.global )*, ( ( ( ( model.div4Like | model.divGenLike ), model.global* )+ | ( ( ( model.common ), model.global* )+, ( ( model.div4Like | model.divGenLike ), model.global* )* ) ), ( ( model.divBottom ), model.global* )* )? ) }
element div4 { att.global.attributes, att.divLike.attributes, att.typed.attributes, att.declaring.attributes, ( ( model.divTop | model.global )*, ( ( ( ( model.div5Like | model.divGenLike ), model.global* )+ | ( ( ( model.common ), model.global* )+, ( ( model.div5Like | model.divGenLike ), model.global* )* ) ), ( ( model.divBottom ), model.global* )* )? ) }
element div5 { att.global.attributes, att.divLike.attributes, att.typed.attributes, att.declaring.attributes, ( ( model.divTop | model.global )*, ( ( ( ( model.div6Like | model.divGenLike ), model.global* )+ | ( ( ( model.common ), model.global* )+, ( ( model.div6Like | model.divGenLike ), model.global* )* ) ), ( ( model.divBottom ), model.global* )* )? ) }
element div6 { att.global.attributes, att.divLike.attributes, att.typed.attributes, att.declaring.attributes, ( ( model.divTop | model.global )*, ( ( ( ( model.div7Like | model.divGenLike ), model.global* )+ | ( ( ( model.common ), model.global* )+, ( ( model.div7Like | model.divGenLike ), model.global* )* ) ), ( ( model.divBottom ), model.global* )* )? ) }
element div7 { att.global.attributes, att.divLike.attributes, att.typed.attributes, att.declaring.attributes, ( ( model.divTop | model.global )*, ( ( ( model.common ), model.global* )+, ( ( model.divBottom ), model.global* )* )? ) }
xsd:Nameelement divGen { att.global.attributes, attribute type { xsd:Name }?, model.headLike* }
One use for this element is to allow document preparation
software to generate an index and insert it in the appropriate place in
the output. The example below assumes that the
Another use for divGen is to specify the location of an automatically produced table of contents:
element docAuthor { att.global.attributes, att.canonical.attributes, macro.phraseSeq }
xsd:date
| xsd:gYear
| xsd:gMonth
| xsd:gDay
| xsd:gYearMonth
| xsd:gMonthDay
| xsd:time
| xsd:dateTimeelement docDate { att.global.attributes, attribute when { xsd:date | xsd:gYear | xsd:gMonth | xsd:gDay | xsd:gYearMonth | xsd:gMonthDay | xsd:time | xsd:dateTime }?, macro.phraseSeq }
element docEdition { att.global.attributes, macro.paraContent }element docImprint { att.global.attributes, ( text | model.gLike | model.phrase | pubPlace | docDate | publisher | model.global )* }
element docTitle { att.global.attributes, att.canonical.attributes, ( model.global*, ( titlePart, model.global* )+ ) }
element edition { att.global.attributes, macro.phraseSeq }element editionStmt { att.global.attributes, ( model.pLike+ | ( edition, respStmt* ) ) }
xsd:Nameelement editor { att.global.attributes, attribute role { xsd:Name }?, macro.phraseSeq }
element editorialDecl { att.global.attributes, att.declarable.attributes, ( model.pLike+ | model.editorialDeclPart+ ) }
element education { att.global.attributes, att.editLike.attributes, att.datable.attributes, att.naming.attributes, macro.phraseSeq }
element email { att.global.attributes, macro.phraseSeq }
element emph { att.global.attributes, macro.paraContent }element encodingDesc { att.global.attributes, ( ( model.encodingPart | model.pLike )+ ) }
element epigraph { att.global.attributes, ( model.common | model.global )* }
xsd:anyURIelement event { att.global.attributes, att.datable.attributes, att.editLike.attributes, att.typed.attributes, att.naming.attributes, attribute where { xsd:anyURI }?, ( model.headLike*, ( ( model.pLike+ ) | ( model.labelLike+ ) ), ( model.noteLike | model.biblLike )*, event* ) }
element ex { att.global.attributes, att.editLike.attributes, macro.xtext }element expan { att.global.attributes, att.editLike.attributes, macro.phraseSeq }
element explicit { att.global.attributes, att.typed.attributes, att.msExcerpt.attributes, macro.phraseSeq }
element extent { att.global.attributes, macro.phraseSeq }element facsimile { att.global.attributes, att.declaring.attributes, ( front?, ( model.graphicLike | surface )+, back? ) }
element faith { att.global.attributes, att.editLike.attributes, att.datable.attributes, macro.phraseSeq }
element figDesc { att.global.attributes, macro.limitedContent }element figure { att.global.attributes, att.placement.attributes, ( model.headLike | model.pLike | figDesc | model.graphicLike | model.egLike | floatingText | figure | model.global )* }
element fileDesc { att.global.attributes, ( ( titleStmt, editionStmt?, extent?, publicationStmt, seriesStmt?, notesStmt? ), sourceDesc+ ) }
element filiation { att.global.attributes, att.typed.attributes, macro.specialPara }
In this example, the reference to ‘Dujchev N17’ includes a link to some other manuscript description which has the identifier DN17.
element finalRubric { att.global.attributes, att.typed.attributes, macro.phraseSeq }
element floatingText { att.global.attributes, att.declaring.attributes, att.typed.attributes, ( model.global*, ( front, model.global* )?, ( body | group ), model.global*, ( back, model.global* )? ) }
element floruit { att.global.attributes, att.datable.attributes, att.editLike.attributes, macro.phraseSeq }
element foliation { att.global.attributes, macro.specialPara }
element foreign { att.global.attributes, macro.phraseSeq }element forename { att.global.attributes, att.personal.attributes, att.typed.attributes, macro.phraseSeq }
xsd:anyURIelement formula { att.global.attributes, attribute notation { xsd:anyURI }?, ( text | model.graphicLike )* }
element front { att.global.attributes, att.declaring.attributes, ( ( model.frontPart | model.pLike.front | model.global )*, ( ( ( ( model.div1Like ), ( model.frontPart | model.div1Like | model.global )* ) | ( ( model.divLike ), ( model.frontPart | model.divLike | model.global )* ) )? ), ( ( ( model.divBottomPart ), ( model.divBottomPart | model.global )* )? ) ) }
element funder { att.global.attributes, macro.phraseSeq.limited }
xsd:Nameelement fw { att.global.attributes, att.placement.attributes, attribute type { xsd:Name }?, macro.phraseSeq }
token { pattern = "(\p{L}|\p{N}|\p{P}|\p{S})+" }separated by whitespace
xsd:anyURI
xsd:Nameelement gap { att.global.attributes, att.editLike.attributes, attribute reason { list { token { pattern = "(\p{L}|\p{N}|\p{P}|\p{S})+" }+ } }?, attribute hand { xsd:anyURI }?, attribute agent { xsd:Name }?, model.glossLike* }
element genName { att.global.attributes, att.personal.attributes, att.typed.attributes, macro.phraseSeq }
element geo { att.global.attributes, text }
xsd:Nameelement geoDecl { att.global.attributes, att.declarable.attributes, attribute datum { "WGS84" | "MGRS" | "OSGB36" | "ED50" | xsd:Name }?, macro.phraseSeq }
element geogFeat { att.global.attributes, att.naming.attributes, att.typed.attributes, att.datable.attributes, macro.xtext }
xsd:Nameelement geogName { att.global.attributes, att.naming.attributes, attribute type { xsd:Name }?, macro.phraseSeq }
xsd:anyURI
xsd:anyURIelement gloss { att.global.attributes, att.declaring.attributes, att.translatable.attributes, att.typed.attributes, ( attribute target { xsd:anyURI }? | attribute cRef { xsd:anyURI }? ), macro.phraseSeq }
token
{
pattern = "[\-+]?\d+(\.\d+)?(%|cm|mm|in|pt|pc|px|em|ex|gd|rem|vw|vh|vm)"
}
token
{
pattern = "[\-+]?\d+(\.\d+)?(%|cm|mm|in|pt|pc|px|em|ex|gd|rem|vw|vh|vm)"
}
xsd:double | xsd:decimal
xsd:anyURIelement graphic { att.global.attributes, att.internetMedia.attributes, att.declaring.attributes, attribute width { token { pattern = "[\-+]?\d+(\.\d+)?(%|cm|mm|in|pt|pc|px|em|ex|gd|rem|vw|vh|vm)" } }?, attribute height { token { pattern = "[\-+]?\d+(\.\d+)?(%|cm|mm|in|pt|pc|px|em|ex|gd|rem|vw|vh|vm)" } }?, attribute scale { xsd:double | xsd:decimal }?, attribute url { xsd:anyURI }?, empty }
element group { att.global.attributes, att.declaring.attributes, ( ( model.divTop | model.global )*, ( ( text | group ), ( text | group | model.global )* ), model.divBottom* ) }
xsd:nonNegativeIntegerelement handDesc { att.global.attributes, attribute hands { xsd:nonNegativeInteger }?, ( model.pLike+ | ( summary?, handNote+ ) ) }
element handNote { att.global.attributes, att.handFeatures.attributes, macro.specialPara }
element handNotes { att.global.attributes, handNote+ }
xsd:anyURI
xsd:anyURIelement handShift { att.global.attributes, att.handFeatures.attributes, attribute new { xsd:anyURI }?, attribute resp { xsd:anyURI }?, empty }
element head { att.global.attributes, att.typed.attributes, macro.paraContent }The most common use for the head element is to mark the headings of sections. In older writings, the headings or incipits may be rather longer than usual in modern works. If a section has an explicit ending as well as a heading, it should be marked as a trailer, as in this example:
The head element is also used to mark headings of other units, such as lists:
element headItem { att.global.attributes, macro.phraseSeq }
element headLabel { att.global.attributes, macro.phraseSeq }element height { att.global.attributes, att.dimensions.attributes, macro.xtext }
element heraldry { att.global.attributes, macro.phraseSeq }
element hi { att.global.attributes, macro.paraContent }element history { att.global.attributes, ( model.pLike+ | ( summary?, origin?, provenance*, acquisition? ) ) }
element hyphenation { att.global.attributes, att.declarable.attributes, attribute eol { "all" | "some" | "hard" | "none" }?, model.pLike+ }
xsd:Name
element idno { att.global.attributes, attribute type { xsd:Name }?, text }
element imprimatur { att.global.attributes, macro.paraContent }element imprint { att.global.attributes, ( ( ( model.imprintPart ) | ( model.dateLike ) ), model.global* )+ }
element incipit { att.global.attributes, att.typed.attributes, att.msExcerpt.attributes, macro.phraseSeq }
xsd:Nameelement index { att.global.attributes, att.spanning.attributes, attribute indexName { xsd:Name }?, ( term, index? )* }
element institution { att.global.attributes, att.naming.attributes, macro.xtext }
element interpretation { att.global.attributes, att.declarable.attributes, model.pLike+ }
element item { att.global.attributes, macro.specialPara }
xsd:anyURIseparated by whitespace
xsd:Nameelement join { att.global.attributes, att.pointing.attributes, attribute targets { list { xsd:anyURI, xsd:anyURI+ } }, attribute result { xsd:Name }?, attribute scope { "root" | "branches" }?, model.glossLike* }
The following example is discussed in section ??:
The join element here identifies a linegroup (lg)
comprising the three lines indicated by the
In this example, the attribute
xsd:Nameelement joinGrp { att.global.attributes, att.pointing.group.attributes, attribute result { xsd:Name }?, ( model.glossLike*, ( join | ptr )+ ) }
xsd:anyURIelement keywords { att.global.attributes, attribute scheme { xsd:anyURI }, ( term+ | list ) }
element l { att.global.attributes, att.metrical.attributes, att.enjamb.attributes, attribute part { "Y" | "N" | "I" | "M" | "F" }?, macro.paraContent }
element label { att.global.attributes, macro.phraseSeq }Labels are most commonly used for the headwords in glossary lists; note the use of the
global
Labels may also be used to record explicitly the numbers or letters which mark list items
in ordered lists, as in this extract from Gibbon's Autobiography. In this
usage the label element is synonymous with the
Labels may also be used for other structured list items, as in this extract from the journal of Edward Gibbon:
element lacunaEnd { att.global.attributes, att.rdgPart.attributes, empty }
element lacunaStart { att.global.attributes, att.rdgPart.attributes, empty }
xsd:languageseparated by whitespaceelement langKnowledge { att.global.attributes, att.datable.attributes, att.editLike.attributes, attribute tags { list { xsd:language+ } }?, ( model.pLike | langKnown+ ) }
xsd:language
token { pattern = "(\p{L}|\p{N}|\p{P}|\p{S})+" }element langKnown { att.global.attributes, att.datable.attributes, att.editLike.attributes, attribute tag { xsd:language }, attribute level { token { pattern = "(\p{L}|\p{N}|\p{P}|\p{S})+" } }?, macro.phraseSeq.limited }
element langUsage { att.global.attributes, att.declarable.attributes, language+ }
xsd:language
xsd:nonNegativeInteger { maxInclusive = "100" }element language { att.global.attributes, attribute ident { xsd:language }, attribute usage { xsd:nonNegativeInteger { maxInclusive = "100" } }?, macro.phraseSeq.limited }
xsd:nonNegativeIntegerseparated by whitespace
xsd:nonNegativeIntegerseparated by whitespace
xsd:nonNegativeIntegerseparated by whitespaceelement layout { att.global.attributes, attribute columns { list { xsd:nonNegativeInteger, xsd:nonNegativeInteger? } }?, attribute ruledLines { list { xsd:nonNegativeInteger, xsd:nonNegativeInteger? } }?, attribute writtenLines { list { xsd:nonNegativeInteger, xsd:nonNegativeInteger? } }?, macro.specialPara }
element layoutDesc { att.global.attributes, ( model.pLike+ | layout+ ) }element lb { att.global.attributes, att.typed.attributes, att.sourced.attributes, empty }
Indicating typographical line breaks within metrical lines, where they occur at different places in different editions:
Indicating line structure of title page, display text, etc.:
element lem { att.global.attributes, att.textCritical.attributes, ( text | model.gLike | model.phrase | model.inter | model.global | model.rdgPart )* }
element lg { att.global.attributes, att.divLike.attributes, att.typed.attributes, att.declaring.attributes, ( ( model.divTop | model.global )*, ( model.lLike | lg ), ( model.lLike | lg | model.global )*, ( ( model.divBottom ), model.global* )* ) }
xsd:anyURIseparated by whitespaceelement link { att.global.attributes, att.pointing.attributes, attribute targets { list { xsd:anyURI, xsd:anyURI+ } }, empty }
element linkGrp { att.global.attributes, att.pointing.group.attributes, ( link | ptr )+ }
xsd:Nameelement list { att.global.attributes, attribute type { "ordered" | "bulleted" | "simple" | "gloss" | xsd:Name }?, ( ( ( model.divTop ) | ( model.global ) )*, ( ( item, model.global* )+ | ( headLabel?, headItem?, ( label, model.global*, item, model.global* )+ ) ), ( ( model.divBottom ), model.global* )* ) }
The following example treats the short numbered clauses of Anglo-Saxon legal codes as lists of items. The text is from an ordinance of King Athelstan (924–939):
Note that nested lists have been used so the tagging mirrors the structure indicated by the two-level numbering of the clauses. The clauses could have been treated as a one-level list with irregular numbering, if desired.
element listBibl { att.global.attributes, att.declarable.attributes, att.typed.attributes, ( model.headLike*, ( model.biblLike | model.milestoneLike | listBibl )+ ) }
element listEvent { att.global.attributes, att.typed.attributes, att.declarable.attributes, ( model.headLike*, ( event | listEvent )+, ( relation | relationGrp )* ) }
element listNym { att.global.attributes, att.typed.attributes, att.declarable.attributes, ( model.headLike*, ( nym | listNym )+, ( relationGrp | relation )* ) }
element listOrg { att.global.attributes, att.typed.attributes, att.declarable.attributes, ( model.headLike*, ( org | listOrg )+, ( relationGrp | relation )* ) }
element listPerson { att.global.attributes, att.typed.attributes, att.declarable.attributes, ( model.headLike*, ( model.personLike | listPerson )+, ( relation | relationGrp )* ) }
element listPlace { att.global.attributes, att.typed.attributes, att.declarable.attributes, ( model.headLike*, ( model.placeLike | listPlace )+, ( relationGrp | relation )* ) }
element listWit { att.global.attributes, ( model.headLike?, ( witness | listWit )+ ) }
element location { att.global.attributes, att.typed.attributes, att.datable.attributes, att.editLike.attributes, ( model.labelLike | model.placeNamePart | model.offsetLike | model.measureLike | model.addressLike | model.noteLike | model.biblLike )* }
xsd:anyURI
token { pattern = "(\p{L}|\p{N}|\p{P}|\p{S})+" }
token { pattern = "(\p{L}|\p{N}|\p{P}|\p{S})+" }
xsd:anyURIseparated by whitespaceelement locus { att.global.attributes, attribute scheme { xsd:anyURI }?, attribute from { token { pattern = "(\p{L}|\p{N}|\p{P}|\p{S})+" } }?, attribute to { token { pattern = "(\p{L}|\p{N}|\p{P}|\p{S})+" } }?, attribute target { list { xsd:anyURI+ } }?, macro.xtext }
The
xsd:anyURIelement locusGrp { att.global.attributes, attribute scheme { xsd:anyURI }?, locus+ }
element material { att.global.attributes, macro.phraseSeq }
xsd:Nameelement measure { att.global.attributes, att.measurement.attributes, attribute type { xsd:Name }?, macro.phraseSeq }
element measureGrp { att.global.attributes, att.measurement.attributes, att.typed.attributes, ( text | model.gLike | model.measureLike )* }
element meeting { att.global.attributes, macro.limitedContent }
element mentioned { att.global.attributes, macro.phraseSeq }
xsd:Nameseparated by whitespace
tokenelement metDecl { att.global.attributes, att.declarable.attributes, attribute type { list { ( "met" | "real" | "rhyme" ), ( "met" | "real" | "rhyme" )?, ( "met" | "real" | "rhyme" )? } }?, attribute pattern { token }?, ( ( model.pLike | model.noteLike )+ | metSym+ ) }
This example is intended for the far more restricted case typified by the Shakespearean iambic pentameter. Only metrical patterns containing exactly ten syllables, alternately stressed and unstressed, (except for the first two which may be in either order) to each metrical line can be expressed using this notation.
token { pattern = "(\p{L}|\p{N}|\p{P}|\p{S})+" }separated by whitespace
xsd:booleanelement metSym { att.global.attributes, attribute value { list { token { pattern = "(\p{L}|\p{N}|\p{P}|\p{S})+" }+ } }, attribute terminal { xsd:boolean }?, macro.phraseSeq.limited }
xsd:Nameelement milestone { att.global.attributes, att.typed.attributes, att.sourced.attributes, attribute unit { "page" | "column" | "line" | "book" | "poem" | "canto" | "speaker" | "stanza" | "act" | "scene" | "section" | "absent" | "unnumbered" | xsd:Name }, empty }
element monogr { att.global.attributes, ( ( ( ( author | editor | respStmt ), ( author | editor | respStmt )*, title+, ( idno | editor | respStmt )* ) | ( title+, ( idno | author | editor | respStmt )* ) )?, ( model.noteLike | meeting )*, ( edition, ( idno | editor | respStmt )* )*, imprint, ( imprint | extent | biblScope )* ) }
xsd:anyURIelement msContents { att.global.attributes, att.msExcerpt.attributes, attribute class { xsd:anyURI }?, ( model.pLike+ | ( summary?, textLang?, titlePage?, ( msItem | msItemStruct )* ) ) }
element msDesc { att.global.attributes, ( msIdentifier, model.headLike*, ( model.pLike+ | ( msContents?, physDesc?, history?, additional?, msPart* ) ) ) }
element msIdentifier { att.global.attributes, ( ( ( model.placeNamePart_sequenceOptional, institution?, repository, collection?, idno? ) | msName ), ( altIdentifier | msName )* ) }
xsd:anyURIelement msItem { att.global.attributes, att.msExcerpt.attributes, attribute class { xsd:anyURI }?, ( ( locus | locusGrp )*, ( model.pLike+ | ( model.titlepagePart | model.msItemPart | model.global )+ ) ) }
xsd:anyURIelement msItemStruct { att.global.attributes, att.msExcerpt.attributes, attribute class { xsd:anyURI }?, ( locus?, ( model.pLike+ | ( author*, respStmt*, title*, rubric?, incipit?, msItemStruct*, explicit?, finalRubric?, colophon*, decoNote*, listBibl*, bibl*, filiation*, model.noteLike*, textLang? ) ) ) }
element msName { att.global.attributes, att.typed.attributes, macro.xtext }element msPart { att.global.attributes, ( altIdentifier, model.headLike*, ( model.pLike+ | ( msContents?, physDesc?, history?, additional?, msPart* ) ) ) }
element musicNotation { att.global.attributes, macro.specialPara }element name { att.global.attributes, att.naming.attributes, att.typed.attributes, macro.phraseSeq }
element nameLink { att.global.attributes, att.typed.attributes, macro.phraseSeq }
xsd:anyURIelement namespace { att.global.attributes, attribute name { xsd:anyURI }, tagUsage+ }
element nationality { att.global.attributes, att.datable.attributes, att.editLike.attributes, att.naming.attributes, macro.phraseSeq }
xsd:anyURIelement normalization { att.global.attributes, att.declarable.attributes, attribute source { xsd:anyURI }?, attribute method { "silent" | "markup" }?, model.pLike+ }
xsd:Name
xsd:anyURI
xsd:boolean
xsd:anyURIseparated by whitespace
xsd:anyURIseparated by whitespaceelement note { att.global.attributes, att.placement.attributes, attribute type { xsd:Name }?, attribute resp { xsd:anyURI }?, attribute anchored { xsd:boolean }?, attribute target { list { xsd:anyURI+ } }?, attribute targetEnd { list { xsd:anyURI+ } }?, macro.specialPara }
element notesStmt { att.global.attributes, model.noteLike+ }
xsd:Name
xsd:double | xsd:decimalelement num { att.global.attributes, attribute type { "cardinal" | "ordinal" | "fraction" | "percentage" | xsd:Name }?, attribute value { xsd:double | xsd:decimal }?, macro.phraseSeq }
xsd:anyURIseparated by whitespaceelement nym { att.global.attributes, att.typed.attributes, attribute parts { list { xsd:anyURI, xsd:anyURI* } }?, ( ( model.entryPart* ), ( model.pLike* ), ( nym* ) ) }
xsd:Nameelement objectDesc { att.global.attributes, attribute form { xsd:Name }?, ( model.pLike+ | ( supportDesc?, layoutDesc? ) ) }
xsd:anyURI
xsd:anyURIelement occupation { att.global.attributes, att.datable.attributes, att.editLike.attributes, att.naming.attributes, attribute scheme { xsd:anyURI }?, attribute code { xsd:anyURI }?, macro.phraseSeq }
element offset { att.global.attributes, att.typed.attributes, macro.xtext }element opener { att.global.attributes, ( text | model.gLike | model.phrase | argument | byline | dateline | epigraph | salute | signed | model.global )* }
token { pattern = "(\p{L}|\p{N}|\p{P}|\p{S})+" }separated by whitespaceelement org { att.global.attributes, att.typed.attributes, att.editLike.attributes, attribute role { list { token { pattern = "(\p{L}|\p{N}|\p{P}|\p{S})+" }+ } }?, ( model.headLike*, ( ( model.pLike* ) | ( model.labelLike | model.nameLike | model.placeLike )* ), ( model.noteLike | model.biblLike )*, model.personLike* ) }
element orgName { att.global.attributes, att.datable.attributes, att.editLike.attributes, att.personal.attributes, att.typed.attributes, macro.phraseSeq }
element orig { att.global.attributes, macro.paraContent }If all that is desired is to call attention to the original version in the copy text, orig may be used alone:
More usually, an orig will be combined with a regularized form within a choice element:
element origDate { att.global.attributes, att.datable.attributes, att.editLike.attributes, att.typed.attributes, text }
element origPlace { att.global.attributes, att.datable.attributes, att.editLike.attributes, macro.xtext }
element origin { att.global.attributes, att.editLike.attributes, att.datable.attributes, macro.specialPara }
element p { att.global.attributes, att.declaring.attributes, macro.paraContent }
element pb { att.global.attributes, att.typed.attributes, att.sourced.attributes, empty }
Page numbers may vary in different editions of a text.
A page break may be associated with a facsimile image of the page it introduces by means
of the
element persName { att.global.attributes, att.datable.attributes, att.editLike.attributes, att.personal.attributes, att.typed.attributes, macro.phraseSeq }
xsd:Nameseparated by whitespace
"0" | "1" | "2" | "9"
xsd:Nameelement person { att.global.attributes, att.editLike.attributes, attribute role { list { xsd:Name+ } }?, attribute sex { "0" | "1" | "2" | "9" }?, attribute age { xsd:Name }?, ( model.pLike+ | ( model.personPart | model.global )* ) }
xsd:Name
( "0" | "1" | "2" | "9" ) | "mixed"
xsd:Name
token { pattern = "(\p{L}|\p{N}|\p{P}|\p{S})+" }separated by whitespaceelement personGrp { att.global.attributes, attribute role { xsd:Name }?, attribute sex { ( "0" | "1" | "2" | "9" ) | "mixed" }?, attribute age { xsd:Name }?, attribute size { list { token { pattern = "(\p{L}|\p{N}|\p{P}|\p{S})+" }+ } }?, ( model.pLike+ | model.personPart* ) }
element physDesc { att.global.attributes, ( model.pLike*, ( model.physDescPart_sequenceOptional ) ) }
element place { att.global.attributes, att.typed.attributes, att.editLike.attributes, ( model.headLike*, ( ( model.pLike* ) | ( model.labelLike | model.placeStateLike | model.placeTraitLike | model.placeEventLike )* ), ( model.noteLike | model.biblLike )*, ( model.placeLike | listPlace )* ) }
element placeName { att.global.attributes, att.naming.attributes, att.typed.attributes, att.datable.attributes, att.editLike.attributes, macro.phraseSeq }
element population { att.global.attributes, att.datable.attributes, att.editLike.attributes, att.naming.attributes, att.typed.attributes, ( model.headLike*, ( ( ( model.pLike+ ) | ( model.labelLike+ ) ), ( model.noteLike | model.biblLike )* )?, population* ) }
element postBox { att.global.attributes, text }
element postCode { att.global.attributes, text }element postscript { att.global.attributes, ( ( model.common ) | ( model.global ) )* }
element principal { att.global.attributes, macro.phraseSeq.limited }element profileDesc { att.global.attributes, ( creation?, model.profileDescPart* ) }
element projectDesc { att.global.attributes, att.declarable.attributes, model.pLike+ }
element provenance { att.global.attributes, att.datable.attributes, macro.specialPara }
xsd:anyURIseparated by whitespace
token { pattern = "(\p{L}|\p{N}|\p{P}|\p{S})+" }separated by whitespaceelement ptr { att.global.attributes, att.pointing.attributes, att.declaring.attributes, ( attribute target { list { xsd:anyURI+ } } | attribute cRef { list { token { pattern = "(\p{L}|\p{N}|\p{P}|\p{S})+" }+ } } ), empty }
element pubPlace { att.global.attributes, att.naming.attributes, macro.phraseSeq }
element publicationStmt { att.global.attributes, ( model.pLike+ | model.publicationStmtPart+ ) }
element publisher { att.global.attributes, macro.phraseSeq }
xsd:Nameelement q { att.global.attributes, att.ascribed.attributes, attribute type { "spoken" | "thought" | "written" | "soCalled" | "foreign" | "distinct" | "term" | "emph" | "mentioned" | xsd:Name }?, macro.specialPara }
element quotation { att.global.attributes, att.declarable.attributes, attribute marks { "none" | "some" | "all" }?, attribute form { text }?, model.pLike+ }
element quote { att.global.attributes, att.typed.attributes, att.msExcerpt.attributes, macro.specialPara }
element rdg { att.global.attributes, att.textCritical.attributes, ( text | model.gLike | model.phrase | model.inter | model.global | model.rdgPart )* }
element rdgGrp { att.global.attributes, att.textCritical.attributes, ( ( ( rdgGrp, wit? ) | ( ( lem, wit? )?, ( model.rdgLike, wit? ) )* )+ ) }
element recordHist { att.global.attributes, ( model.pLike+ | ( source, change* ) ) }
xsd:anyURIseparated by whitespace
token { pattern = "(\p{L}|\p{N}|\p{P}|\p{S})+" }separated by whitespaceelement ref { att.global.attributes, att.pointing.attributes, att.declaring.attributes, ( attribute target { list { xsd:anyURI+ } }? | attribute cRef { list { token { pattern = "(\p{L}|\p{N}|\p{P}|\p{S})+" }+ } }? ), macro.paraContent }
xsd:Name
xsd:nonNegativeInteger
textelement refState { att.global.attributes, att.sourced.attributes, attribute unit { "page" | "column" | "line" | "book" | "poem" | "canto" | "stanza" | "act" | "scene" | "section" | "absent" | xsd:Name }, attribute length { xsd:nonNegativeInteger }?, attribute delim { text }?, empty }
element refsDecl { att.global.attributes, att.declarable.attributes, ( model.pLike+ | cRefPattern+ | refState+ ) }
This example is a formal representation for the referencing scheme described informally in the following example.
element reg { att.global.attributes, att.editLike.attributes, att.typed.attributes, macro.paraContent }
If all that is desired is to call attention to the fact that the copy text has been regularized, reg may be used alone:
It is also possible to identify the individual responsible for the regularization, and, using the choice and orig elements, to provide both the original and regularized readings:
element region { att.global.attributes, att.naming.attributes, att.typed.attributes, att.datable.attributes, macro.phraseSeq }
element relatedItem { att.global.attributes, att.typed.attributes, ( model.biblLike | model.ptrLike ) }
xsd:Name
xsd:Name
xsd:anyURIseparated by whitespace
xsd:anyURIseparated by whitespace
xsd:anyURIseparated by whitespaceelement relation { att.global.attributes, att.datable.attributes, att.editLike.attributes, att.naming.attributes, attribute type { "social" | "personal" | "other" | xsd:Name }?, attribute name { xsd:Name }, attribute passive { list { xsd:anyURI+ } }?, ( attribute active { list { xsd:anyURI+ } }? | attribute mutual { list { xsd:anyURI+ } }? ), desc? }
This indicates that the person with identifier p1 is supervisor of persons p2, p3, and p4.
This indicates that p2, p3, and p4 are all friends.
element relationGrp { att.global.attributes, att.typed.attributes, ( model.pLike+ | relation+ ) }
The persons with identifiers p1 and p2 are the parents of p3 and p4; they are also married to each other; p1 is the employer of p3, p5, p6, and p7.
element rendition { att.global.attributes, attribute scheme { "css" | "xslfo" | "free" | "other" }?, macro.limitedContent }
element repository { att.global.attributes, att.naming.attributes, macro.xtext }
element residence { att.global.attributes, att.datable.attributes, att.editLike.attributes, att.naming.attributes, macro.phraseSeq }
element resp { att.global.attributes, att.canonical.attributes, macro.phraseSeq.limited }
element respStmt { att.global.attributes, ( ( resp+, model.nameLike.agent+ ) | ( model.nameLike.agent+, resp+ ) ) }
element restore { att.global.attributes, att.transcriptional.attributes, att.typed.attributes, macro.paraContent }
element revisionDesc { att.global.attributes, ( list | change+ ) }
token { pattern = "(\p{L}|\p{N}|\p{P}|\p{S})+" }element rhyme { att.global.attributes, att.typed.attributes, attribute label { token { pattern = "(\p{L}|\p{N}|\p{P}|\p{S})+" } }?, macro.paraContent }
element roleName { att.global.attributes, att.personal.attributes, att.typed.attributes, macro.phraseSeq }
element row { att.global.attributes, att.tableDecoration.attributes, cell+ }
xsd:Nameelement rs { att.global.attributes, att.naming.attributes, attribute type { xsd:Name }?, macro.phraseSeq }
element rubric { att.global.attributes, att.typed.attributes, macro.phraseSeq }
xsd:boolean | "unknown" | "inapplicable"
xsd:boolean | "unknown" | "inapplicable"element said { att.global.attributes, att.ascribed.attributes, attribute aloud { xsd:boolean | "unknown" | "inapplicable" }?, attribute direct { xsd:boolean | "unknown" | "inapplicable" }?, macro.specialPara }
element salute { att.global.attributes, macro.phraseSeq }element samplingDecl { att.global.attributes, att.declarable.attributes, model.pLike+ }
xsd:boolean | "unknown" | "inapplicable"element seal { att.global.attributes, att.typed.attributes, att.datable.attributes, attribute contemporary { xsd:boolean | "unknown" | "inapplicable" }?, ( model.pLike | decoNote )+ }
element sealDesc { att.global.attributes, ( model.pLike+ | ( decoNote | seal | condition )+ ) }
element secFol { att.global.attributes, macro.phraseSeq }element seg { att.global.attributes, att.segLike.attributes, att.typed.attributes, macro.paraContent }
element segmentation { att.global.attributes, att.declarable.attributes, model.pLike+ }
element series { att.global.attributes, ( text | model.gLike | title | editor | respStmt | biblScope | model.global )* }
element seriesStmt { att.global.attributes, ( model.pLike+ | ( title+, ( idno | respStmt )* ) ) }
element settlement { att.global.attributes, att.naming.attributes, att.typed.attributes, att.datable.attributes, macro.phraseSeq }
"0" | "1" | "2" | "9"element sex { att.global.attributes, att.editLike.attributes, att.datable.attributes, attribute value { "0" | "1" | "2" | "9" }?, macro.phraseSeq }
element sic { att.global.attributes, macro.paraContent }If all that is desired is to call attention to the apparent problem in the copy text, sic may be used alone:
It is also possible, using the choice and corr elements, to provide a corrected reading:
element signatures { att.global.attributes, macro.phraseSeq }
element signed { att.global.attributes, macro.phraseSeq }
element soCalled { att.global.attributes, macro.phraseSeq }
xsd:anyURI
xsd:anyURIelement socecStatus { att.global.attributes, att.datable.attributes, att.editLike.attributes, att.naming.attributes, attribute scheme { xsd:anyURI }?, attribute code { xsd:anyURI }?, macro.phraseSeq }
element source { att.global.attributes, macro.specialPara }element sourceDesc { att.global.attributes, att.declarable.attributes, ( model.pLike+ | ( model.biblLike | model.sourceDescPart | model.listLike )+ ) }
element sp { att.global.attributes, att.ascribed.attributes, ( model.global*, ( speaker, model.global* )?, ( ( model.lLike | lg | model.pLike | model.stageLike | model.qLike ), model.global* )+ ) }
xsd:anyURIelement space { att.global.attributes, att.dimensions.attributes, attribute dim { "horizontal" | "vertical" }?, attribute resp { xsd:anyURI }?, empty }
element speaker { att.global.attributes, macro.phraseSeq }
element sponsor { att.global.attributes, macro.phraseSeq.limited }
xsd:Nameelement stage { att.global.attributes, attribute type { "setting" | "entrance" | "exit" | "business" | "novelistic" | "delivery" | "modifier" | "location" | "mixed" | xsd:Name }?, macro.specialPara }
element stamp { att.global.attributes, att.typed.attributes, att.datable.attributes, macro.phraseSeq }
element state { att.global.attributes, att.datable.attributes, att.editLike.attributes, att.typed.attributes, att.naming.attributes, ( state+ | ( model.headLike*, model.pLike+, ( model.noteLike | model.biblLike )* ) | ( ( model.labelLike | model.noteLike | model.biblLike )* ) ) }
element stdVals { att.global.attributes, att.declarable.attributes, model.pLike+ }
element street { att.global.attributes, macro.phraseSeq }element subst { att.global.attributes, att.transcriptional.attributes, ( ( model.pPart.transcriptional ), model.pPart.transcriptional+ ) }
element summary { att.global.attributes, macro.phraseSeq }
token { pattern = "(\p{L}|\p{N}|\p{P}|\p{S})+" }separated by whitespaceelement supplied { att.global.attributes, att.editLike.attributes, attribute reason { list { token { pattern = "(\p{L}|\p{N}|\p{P}|\p{S})+" }+ } }?, macro.paraContent }
element support { att.global.attributes, macro.specialPara }
xsd:Nameelement supportDesc { att.global.attributes, attribute material { xsd:Name }?, ( model.pLike+ | ( support?, extent?, foliation*, collation?, condition? ) ) }
xsd:anyURIelement surface { att.global.attributes, att.coordinated.attributes, att.declaring.attributes, attribute start { xsd:anyURI }?, ( model.glossLike*, model.graphicLike*, zone* ) }
element surname { att.global.attributes, att.personal.attributes, att.typed.attributes, macro.phraseSeq }
element surrogates { att.global.attributes, macro.specialPara }
xsd:nonNegativeInteger
xsd:nonNegativeIntegerelement table { att.global.attributes, attribute rows { xsd:nonNegativeInteger }?, attribute cols { xsd:nonNegativeInteger }?, ( ( model.headLike | model.global )*, ( row, model.global* )+ ) }
xsd:Name
xsd:nonNegativeInteger
xsd:nonNegativeInteger
xsd:anyURIelement tagUsage { att.global.attributes, attribute gi { xsd:Name }, attribute occurs { xsd:nonNegativeInteger }?, attribute withId { xsd:nonNegativeInteger }?, attribute render { xsd:anyURI }?, macro.limitedContent }
element tagsDecl { att.global.attributes, ( rendition*, namespace* ) }element taxonomy { att.global.attributes, ( model.glossLike* | category+ | ( ( model.biblLike ), category* ) ) }
xsd:decimalelement teiCorpus { att.global.attributes, attribute version { xsd:decimal }?, ( teiHeader, ( TEI | teiCorpus )+ ) }
xsd:Nameelement teiHeader { att.global.attributes, attribute type { xsd:Name }?, ( fileDesc, model.headerPart*, revisionDesc? ) }
token { pattern = "(\p{L}|\p{N}|\p{P}|\p{S})+" }
xsd:anyURI
xsd:anyURIelement term { att.global.attributes, att.declaring.attributes, att.typed.attributes, att.canonical.attributes, attribute sortKey { token { pattern = "(\p{L}|\p{N}|\p{P}|\p{S})+" } }?, ( attribute target { xsd:anyURI }? | attribute cRef { xsd:anyURI }? ), macro.phraseSeq }
element terrain { att.global.attributes, att.datable.attributes, att.editLike.attributes, att.naming.attributes, att.typed.attributes, ( model.headLike*, ( ( model.pLike+ ) | ( model.labelLike+ ) ), ( model.noteLike | model.biblLike )*, terrain* ) }
element text { att.global.attributes, att.declaring.attributes, att.typed.attributes, ( model.global*, ( front, model.global* )?, ( body | group ), model.global*, ( back, model.global* )? ) }
The body of a text may be replaced by a group of nested texts, as in the following schematic:
element textClass { att.global.attributes, att.declarable.attributes, ( classCode | catRef | keywords )* }
xsd:language
xsd:languageseparated by whitespaceelement textLang { att.global.attributes, attribute mainLang { xsd:language }?, attribute otherLangs { list { xsd:language* } }?, macro.phraseSeq }
element time { att.global.attributes, att.datable.attributes, att.editLike.attributes, att.typed.attributes, ( text | model.gLike | model.phrase | model.global )* }
xsd:anyURI
xsd:Name
xsd:float { minExclusive = "0" } | "regular" | "irregular"element timeline { att.global.attributes, attribute origin { xsd:anyURI }, attribute unit { "d" | "h" | "min" | "s" | "ms" | xsd:Name }?, attribute interval { xsd:float { minExclusive = "0" } | "regular" | "irregular" }?, when+ }
xsd:Nameelement title { att.global.attributes, att.canonical.attributes, attribute level { "a" | "m" | "j" | "s" | "u" }?, attribute type { xsd:Name }?, macro.paraContent }
xsd:Nameelement titlePage { att.global.attributes, attribute type { xsd:Name }?, ( model.global*, ( model.titlepagePart ), ( model.titlepagePart | model.global )* ) }
xsd:Nameelement titlePart { att.global.attributes, attribute type { "main" | "sub" | "alt" | "short" | "desc" | xsd:Name }?, macro.paraContent }
element titleStmt { att.global.attributes, ( title+, model.respLike* ) }
element trailer { att.global.attributes, macro.phraseSeq }element trait { att.global.attributes, att.datable.attributes, att.editLike.attributes, att.naming.attributes, att.typed.attributes, ( trait+ | ( model.headLike*, model.pLike+, ( model.noteLike | model.biblLike )* ) | ( ( model.labelLike | model.noteLike | model.biblLike )* ) ) }
element typeDesc { att.global.attributes, ( model.pLike+ | ( summary?, typeNote+ ) ) }
element typeNote { att.global.attributes, att.handFeatures.attributes, macro.specialPara }
token { pattern = "(\p{L}|\p{N}|\p{P}|\p{S})+" }separated by whitespace
xsd:anyURI
xsd:Nameelement unclear { att.global.attributes, att.editLike.attributes, attribute reason { list { token { pattern = "(\p{L}|\p{N}|\p{P}|\p{S})+" }+ } }?, attribute hand { xsd:anyURI }?, attribute agent { xsd:Name }?, macro.paraContent }
element variantEncoding { att.global.attributes, attribute method { "location-referenced" | "double-end-point" | "parallel-segmentation" }, attribute location { "internal" | "external" }, empty }
element watermark { att.global.attributes, macro.phraseSeq }
xsd:date
| xsd:gYear
| xsd:gMonth
| xsd:gDay
| xsd:gYearMonth
| xsd:gMonthDay
| xsd:time
| xsd:dateTime
xsd:Name
xsd:float { minExclusive = "0" } | "unknown"
xsd:anyURIelement when { att.global.attributes, attribute absolute { xsd:date | xsd:gYear | xsd:gMonth | xsd:gDay | xsd:gYearMonth | xsd:gMonthDay | xsd:time | xsd:dateTime }?, attribute unit { "d" | "h" | "min" | "s" | "ms" | xsd:Name }?, attribute interval { xsd:float { minExclusive = "0" } | "unknown" }?, attribute since { xsd:anyURI }?, empty }
element width { att.global.attributes, att.dimensions.attributes, macro.xtext }
element wit { att.global.attributes, att.rdgPart.attributes, macro.phraseSeq }
xsd:anyURIseparated by whitespace
xsd:anyURI
xsd:anyURIseparated by whitespace
xsd:Nameelement witDetail { att.global.attributes, att.placement.attributes, attribute target { list { xsd:anyURI+ } }, attribute resp { xsd:anyURI }?, attribute wit { list { xsd:anyURI+ } }, attribute type { xsd:Name }?, macro.phraseSeq }
element witEnd { att.global.attributes, att.rdgPart.attributes, empty }
element witStart { att.global.attributes, att.rdgPart.attributes, empty }
element witness { att.global.attributes, macro.limitedContent }element zone { att.global.attributes, att.coordinated.attributes, ( model.glossLike*, model.graphicLike* ) }