default namespace = ""
namespace a = "http://relaxng.org/ns/compatibility/annotations/1.0"
namespace rng = "http://relaxng.org/ns/structure/1.0"
namespace teix = "http://www.tei-c.org/ns/Examples"

# Schema generated 2006-01-30T20:27:40Z

# 
# This template file is freely available and you are
#           hereby authorised to copy, modify, and redistribute it in
#           any way without further reference or permissions.
# When making such modifications, you are strongly
#           recommended to change the present text to include an
#           accurate statement of the licencing conditions applicable
#           to your modified text.

# Set predeclared macros
data.certainty = "high" | "medium" | "low" | "unknown"
data.probability = xsd:double { minInclusive = "0" maxInclusive = "1" }
data.numeric = xsd:double | xsd:decimal
data.count = xsd:nonNegativeInteger
data.temporal =
  xsd:date
  | xsd:gYear
  | xsd:gMonth
  | xsd:gDay
  | xsd:gYearMonth
  | xsd:gMonthDay
  | xsd:time
  | xsd:dateTime
  | xsd:token {
      pattern =
        "(-?[0-9]{4}-(0[1-9]|1[0-2])-(0[1-9]|[12][0-9]|3[01])T)?([01][0-9]|2[0-3])(:[0-5][0-9])?(Z|[+\-]((0[0-9]|1[0-3]):[0-5][0-9]|14:00))?"
    }
data.duration = xsd:duration
data.truthValue = xsd:boolean
data.xTruthValue = xsd:boolean | "unknown" | "inapplicable"
data.language = xsd:language
data.sex = "0" | "1" | "2" | "9"
data.namespace = xsd:anyURI
data.outputMeasurement =
  xsd:token {
    pattern =
      "[\-+]?\d+(\.\d+)?(%|cm|mm|in|pt|pc|px|em|ex|gd|rem|vw|vh|vm)"
  }
data.pattern = xsd:token
data.pointer = xsd:anyURI
data.pointers = list { data.pointer+ }
data.code = xsd:anyURI
data.enumerated = xsd:token
data.key = xsd:string
data.word = xsd:token { pattern = "(\p{L}|\p{N}|\p{P}|\p{S})+" }
data.names = list { data.name+ }
data.words = list { data.word+ }
data.name = xsd:Name
macro.bodyPart.div = \div, (\div | divGen | model.global)*
macro.bodyPart.div0 = (divGen | model.global)*
macro.bodyPart.div1 = (divGen | model.global)*
macro.bodyPart.pre = (divGen, model.global*)*
macro.bodyPart.main =
  macro.bodyPart.pre,
  (macro.bodyPart.div | macro.bodyPart.div0 | macro.bodyPart.div1)
mix.drama = notAllowed
mix.spoken = notAllowed
mix.dictionaries = notAllowed
macro.component =
  model.common | mix.drama | mix.spoken | mix.dictionaries
macro.componentSeq = (macro.component | model.global)*
macro.paraContent =
  (text | model.gLike | model.phrase | model.inter | model.global)*
macro.phraseSeq = (text | model.gLike | model.phrase | model.global)*
macro.specialPara =
  (text
   | model.gLike
   | model.phrase
   | model.inter
   | model.divPart
   | model.global)*
macro.xtext = (text | model.gLike)*
macro.fileDescPart =
  titleStmt,
  editionStmt?,
  extent?,
  publicationStmt,
  seriesStmt?,
  notesStmt?
macro.glossSeq = altIdent?, equiv*, gloss*, desc*
att.ascribed.attributes = att.ascribed.attribute.who
att.ascribed.attribute.who =
  
  ## indicates the person, or group of
  ##	people, to whom the element content is ascribed.
  attribute who { data.pointers }?
att.datable.attributes =
  att.datable.attribute.notBefore, att.datable.attribute.notAfter
att.datable.attribute.notBefore =
  
  ## specifies the earliest possible date for the event in
  ##	standard form, e.g. yyyy-mm-dd.
  attribute notBefore { data.temporal }?
att.datable.attribute.notAfter =
  
  ## specifies the latest possible date for the event in
  ##	standard form, e.g. yyyy-mm-dd.
  attribute notAfter { data.temporal }?
att.declarable.attributes = att.declarable.attribute.default
att.declarable.attribute.default =
  
  ## indicates whether or not this element is selected by default when
  ## its parent is selected.
  [ a:defaultValue = "false" ]
  attribute default {
    
    ## (This element is selected if its parent is selected) 
    "true"
    | 
      ## (This element can only be selected explicitly, unless it is the
      ## only one of its kind, in which case it is selected if its parent is selected.) 
      "false"
  }?
att.declaring.attributes = att.declaring.attribute.decls
att.declaring.attribute.decls =
  
  ## identifies one or more declarable elements within the
  ## header, which are understood to apply to the element bearing this
  ## attribute and its content.
  attribute decls { data.pointers }?
att.divLike.attributes =
  att.divLike.attribute.type,
  att.divLike.attribute.org,
  att.divLike.attribute.sample,
  att.divLike.attribute.part
att.divLike.attribute.type =
  
  ## specifies a name conventionally used for this level of
  ##		subdivision, e.g. act, volume, book,
  ##		section, canto, etc.
  attribute type { data.enumerated }?
att.divLike.attribute.org =
  
  ## specifies how the content of the division is organized.
  [ a:defaultValue = "uniform" ]
  attribute org {
    
    ## (composite content: i.e. no claim is made about the
    ##		  sequence in which the immediate contents of this division
    ##		  are to be processed, or their inter-relationships.) 
    "composite"
    | 
      ## (uniform content: i.e. the immediate contents of this
      ##		  element are regarded as forming a logical unit, to be
      ##		  processed in sequence.) 
      "uniform"
  }?
att.divLike.attribute.sample =
  
  ## indicates whether this division is a sample of the
  ##		original source and if so, from which part.
  [ a:defaultValue = "complete" ]
  attribute sample {
    
    ## (division lacks material present at end in source.) 
    "initial"
    | 
      ## (division lacks material at start and end.) 
      "medial"
    | 
      ## (division lacks material at start.) 
      "final"
    | 
      ## (position of sampled material within original unknown.) 
      "unknown"
    | 
      ## (division is not a sample.) 
      "complete"
  }?
att.divLike.attribute.part =
  
  ## specifies whether or not the division is fragmented by
  ##		some other structural element, for example a speech which is
  ##		divided between two or more verse stanzas.
  [ a:defaultValue = "N" ]
  attribute part {
    
    ## (the division is incomplete in some respect) 
    "Y"
    | 
      ## (either the division is complete, or no claim is made as to its completeness.) 
      "N"
    | 
      ## (the initial part of an incomplete division) 
      "I"
    | 
      ## (a medial part of an incomplete division) 
      "M"
    | 
      ## (the final part of an incomplete division) 
      "F"
  }?
att.interpLike.attributes =
  att.interpLike.attribute.resp,
  att.interpLike.attribute.type,
  att.interpLike.attribute.inst
att.interpLike.attribute.resp =
  
  ## indicates who is responsible for the interpretation.
  attribute resp { data.pointer }?
att.interpLike.attribute.type =
  
  ## indicates what kind of phenomenon is being noted in the passage.
  attribute type { data.enumerated }?
att.interpLike.attribute.inst =
  
  ## points to instances of the analysis or interpretation represented
  ## by the current element.
  attribute inst { data.pointers }?
att.editLike.attributes =
  att.editLike.attribute.cert,
  att.editLike.attribute.resp,
  att.editLike.attribute.evidence
att.editLike.attribute.cert =
  
  ## signifies the degree of certainty associated with the
  ##	intervention or interpretation.
  attribute cert { data.enumerated }?
att.editLike.attribute.resp =
  
  ## indicates the agency responsible for the
  ##	intervention or interpretation, for example an editor or transcriber.
  attribute resp { data.pointer }?
att.editLike.attribute.evidence =
  
  ## indicates the nature of the evidence supporting the reliability or
  ##   accuracy of the intervention or interpretation.
  attribute evidence { data.enumerated }?
att.global.attributes =
  att.global.attribute.id,
  att.global.attribute.rend,
  att.global.attribute.n
att.global.attribute.id =
  
  ##
  attribute id { text }?
att.global.attribute.rend =
  
  ##
  attribute rend { text }?
att.global.attribute.n =
  
  ##
  attribute n { text }?
att.measured.attributes =
  att.measured.attribute.unit, att.measured.attribute.scope
att.measured.attribute.unit =
  
  ## names the units used for the measurement.
  attribute unit { data.enumerated }?
att.measured.attribute.scope =
  
  ## specifies the applicability of this measurement, where
  ##    more than one object is being measured.
  attribute scope { data.enumerated }?
att.measurement.attributes =
  att.measurement.attribute.unit,
  att.measurement.attribute.quantity,
  att.measurement.attribute.commodity
att.measurement.attribute.unit =
  
  ## indicates the units used for the measurement, usually
  ##       using the standard symbol for the desired units.
  attribute unit { data.enumerated }?
att.measurement.attribute.quantity =
  
  ## specifies the number of the specified units that
  ##       comprise the measurement
  attribute quantity { data.numeric }?
att.measurement.attribute.commodity =
  
  ## indicates the substance that is being measured
  attribute commodity { data.words }?
att.naming.attributes = att.naming.attribute.key
att.naming.attribute.key =
  
  ## provides a means of locating a full definition for the entity being named
  ## such as a database record key or URI.
  attribute key { data.key }?
att.segLike.attributes =
  att.segLike.attribute.type,
  att.segLike.attribute.function,
  att.segLike.attribute.part
att.segLike.attribute.type =
  
  ## characterizes the type of segment.
  attribute type { data.enumerated }?
att.segLike.attribute.function =
  
  ## characterizes the function of the segment.
  attribute function { data.enumerated }?
att.segLike.attribute.part =
  
  ## specifies whether or not the segment is fragmented by some other
  ## structural element, for example a clause which is divided between two
  ## or more sentences.
  [ a:defaultValue = "N" ]
  attribute part {
    
    ## (the segment is incomplete in some respect) 
    "Y"
    | 
      ## (either the segment is complete, or no claim is made as to
      ## its completeness) 
      "N"
    | 
      ## (the initial part of an incomplete segment) 
      "I"
    | 
      ## (a medial part of an incomplete segment) 
      "M"
    | 
      ## (the final part of an incomplete segment) 
      "F"
  }?
att.spanning.attributes = att.spanning.attribute.spanTo
att.spanning.attribute.spanTo =
  
  ## indicates the end of a span initiated by the element
  ##	bearing this attribute.
  attribute spanTo { data.pointer }?
att.timed.attributes =
  att.timed.attribute.start,
  att.timed.attribute.end,
  att.timed.attribute.dur
att.timed.attribute.start =
  
  ## indicates the location within a temporal alignment
  ##       at which this element begins.
  attribute start { data.pointer }?
att.timed.attribute.end =
  
  ## indicates the location within a temporal alignment at which
  ##    this element ends.
  attribute end { data.pointer }?
att.timed.attribute.dur =
  
  ## indicates the length of this element in time, using either
  ##          specific units or the units specified on the associated temporal
  ##          alignment.
  ##    
  attribute dur { xsd:duration }?
att.typed.attributes =
  att.typed.attribute.type, att.typed.attribute.subtype
att.typed.attribute.type =
  
  ## characterizes the element in some sense, using any convenient
  ##  classification scheme or typology.
  attribute type { data.word }?
att.typed.attribute.subtype =
  
  ## provides a sub-categorization of the element, if needed
  attribute subtype { data.word }?
model.nameLike.agent = name
model.segLike = notAllowed
model.hiLike = emph | hi | soCalled | gloss | term | title
model.dateLike = date
model.timeLike = notAllowed
model.measureLike = notAllowed
model.graphicLike = graphic | binaryObject
model.pPart.msdesc = notAllowed
model.pPart.edit = choice | abbr
model.ptrLike = ptr | ref | xptr | xref
model.lPart = notAllowed
model.global.meta = notAllowed
model.milestoneLike = lb
model.gLike = notAllowed
model.oddDecl = notAllowed
model.oddRef = notAllowed
model.oddPhr = notAllowed
model.qLike = q | quote
model.biblLike = bibl | biblItem | biblStruct | biblFull
model.listLike = \list | listBibl
model.noteLike = note
model.stageLike = notAllowed
model.complexVal = notAllowed
model.singleVal = notAllowed
model.entryParts.top = note
model.global.edit = notAllowed
model.divPart = p | ab
model.blockLike = notAllowed
model.pLike = p | ab
model.publicationStmtPart =
  address
  | date
  | publisher
  | pubPlace
  | distributor
  | authority
  | idno
  | availability
model.glossLike = altIdent | desc | equiv | gloss
model.quoteLike = quote
model.respLike = author | editor | respStmt
model.personPart = note | bibl
model.divWrapper.bottom = trailer
model.divWrapper = head | docAuthor | docDate
model.frontPart.drama = notAllowed
model.pLike.front =
  head
  | docTitle
  | titlePart
  | docAuthor
  | docEdition
  | docImprint
  | docDate
model.titlepagePart =
  graphic
  | binaryObject
  | docTitle
  | titlePart
  | docAuthor
  | docEdition
  | docImprint
  | docDate
  | figure
model.msItemPart = model.respLike | q | note | bibl | listBibl | title
model.choicePart = abbr
model.lLike = notAllowed
model.recordingPart = model.dateLike | respStmt | equipment | broadcast
model.imprintPart = publisher | biblScope | pubPlace
model.catDescPart = notAllowed
model.nameLike = model.nameLike.agent
model.global =
  model.global.meta | model.milestoneLike | model.global.edit | anchor
model.featureVal = model.complexVal | model.singleVal
model.common =
  model.oddDecl
  | model.oddRef
  | model.qLike
  | model.biblLike
  | model.listLike
  | model.noteLike
  | model.divPart
  | label
  | table
  | figure
  | Exercise
  | Output
  | Program
  | Screen
model.biblPart =
  model.respLike
  | model.imprintPart
  | note
  | series
  | edition
  | extent
  | distributor
  | idno
model.frontPart = model.frontPart.drama | divGen | titlePage
model.addrPart = model.nameLike | addrLine | email
model.pPart.data =
  model.dateLike
  | model.timeLike
  | model.measureLike
  | model.nameLike
  | address
  | Button
  | Code
  | Command
  | Field
  | Filespec
  | Icon
  | Input
  | Keyword
  | Key
  | Label
  | Link
  | Menu
  | Name
  | Prompt
  | Software
  | Value
model.inter =
  model.oddDecl
  | model.oddRef
  | model.qLike
  | model.biblLike
  | model.listLike
  | model.noteLike
  | model.stageLike
  | label
  | \text
  | table
  | figure
  | Output
  | Program
  | Screen
model.phrase =
  model.segLike
  | model.hiLike
  | model.graphicLike
  | model.pPart.msdesc
  | model.pPart.edit
  | model.ptrLike
  | model.lPart
  | model.oddPhr
  | model.pPart.data
p =
  
  ## (paragraph) marks paragraphs in prose.
  element p { p.content, p.attributes }
p.content = macro.paraContent
p.attributes =
  att.global.attribute.id,
  att.global.attribute.rend,
  att.global.attribute.n,
  empty
emph =
  
  ## (emphasized) marks words or phrases which are stressed or emphasized for
  ## linguistic or rhetorical effect.
  element emph { emph.content, emph.attributes }
emph.content = macro.paraContent
emph.attributes =
  att.global.attribute.id,
  att.global.attribute.rend,
  att.global.attribute.n,
  empty
hi =
  
  ## (highlighted) marks a word or phrase as graphically distinct from the
  ## surrounding text, for reasons concerning which no claim is
  ## made. 
  element hi { hi.content, hi.attributes }
hi.content = macro.paraContent
hi.attributes =
  att.global.attribute.id,
  att.global.attribute.rend,
  att.global.attribute.n,
  empty
q =
  
  ## (quoted speech, thought, or writing) contains material which is
  ## marked as (ostensibly) quoted from elsewhere; in narrative, this element is used to mark direct or
  ## indirect speech; in dictionaries, it ay be used to mark
  ## real or contrived examples of usage; in manuscript descriptions or
  ## other metadata, to mark extracts quoted from the source being documented.
  element q { q.content, q.attributes }
q.content = macro.specialPara
q.attributes =
  att.global.attribute.id,
  att.global.attribute.rend,
  att.global.attribute.n,
  att.ascribed.attribute.who,
  
  ## may be used to indicate whether the quoted matter is spoken
  ## or thought, or to characterize it more finely.
  attribute type { data.enumerated }?,
  
  ## may be used to indicate whether the quoted matter is regarded
  ## as direct or indirect speech.
  [ a:defaultValue = "unknown" ]
  attribute direct {
    
    ## (speech or thought is represented directly.) 
    "true"
    | 
      ## (speech or thought is represented indirectly,
      ## e.g. by use of a marked verbal aspect.) 
      "false"
    | 
      ## (no claim is made.) 
      "unknown"
  }?,
  empty
quote =
  
  ## (quotation) contains a phrase or passage attributed by the narrator or
  ## author to some agency external to the text. 
  element quote { quote.content, quote.attributes }
quote.content = macro.specialPara
quote.attributes =
  att.global.attribute.id,
  att.global.attribute.rend,
  att.global.attribute.n,
  empty
soCalled =
  
  ## (so called) contains a word or phrase for which the author or narrator
  ## indicates a disclaiming of responsibility, for example by the use
  ## of scare quotes or italics.
  element soCalled { soCalled.content, soCalled.attributes }
soCalled.content = macro.phraseSeq
soCalled.attributes =
  att.global.attribute.id,
  att.global.attribute.rend,
  att.global.attribute.n,
  empty
altIdent =
  
  ## supplies the recommended XML name for an element, class,
  ##   attribute, etc. in some language.
  element altIdent { altIdent.content, altIdent.attributes }
altIdent.content = macro.xtext
altIdent.attributes =
  att.global.attribute.id,
  att.global.attribute.rend,
  att.global.attribute.n,
  att.typed.attribute.type,
  att.typed.attribute.subtype,
  empty
desc =
  
  ## (description) contains a brief description of the purpose and application for
  ## an element, attribute, or attribute value.
  element desc { desc.content, desc.attributes }
desc.content = macro.paraContent
desc.attributes =
  att.global.attribute.id,
  att.global.attribute.rend,
  att.global.attribute.n,
  empty
equiv =
  
  ## specifies a component which is considered equivalent to the
  ##   parent element, either by co-reference, or by external link.
  element equiv { equiv.content, equiv.attributes }
equiv.content = empty
equiv.attributes =
  att.global.attribute.id,
  att.global.attribute.rend,
  att.global.attribute.n,
  
  ## names the underlying concept of which the parent is a
  ##   representation
  attribute name { data.name }?,
  
  ## references the underlying concept of which the parent is a
  ##   representation by means of some external identifier
  attribute uri { data.pointer }?,
  
  ## references an external script which contains a method to
  ## transform instances of this element to canonical TEI
  ##	
  attribute filter { xsd:anyURI }?,
  
  ## MIME type of external filter script
  attribute mimeType { data.word }?,
  empty
gloss =
  
  ## identifies a phrase or word used to provide a gloss or
  ##   definition for some other word or phrase.
  element gloss { gloss.content, gloss.attributes }
gloss.content = macro.phraseSeq
gloss.attributes =
  att.global.attribute.id,
  att.global.attribute.rend,
  att.global.attribute.n,
  att.declaring.attribute.decls,
  (
   ## identifies the associated term element by an
   ##       absolute or relative URI reference
   attribute target { data.pointer }
   | 
     ## identifies the associated term element using a canonical
     ##       reference from a scheme defined in a refsDecl element
     ##       in the TEI header
     attribute cRef { data.pointer })?,
  empty
term =
  
  ## contains a single-word, multi-word, or symbolic designation
  ##   which is regarded as a technical term.
  element term { term.content, term.attributes }
term.content = macro.phraseSeq
term.attributes =
  att.global.attribute.id,
  att.global.attribute.rend,
  att.global.attribute.n,
  att.declaring.attribute.decls,
  att.typed.attribute.type,
  att.typed.attribute.subtype,
  
  ## supplies the sort key for this term in an index.
  attribute sortKey { data.word }?,
  (
   ## identifies the associated gloss element by an
   ##	absolute or relative URI reference
   attribute target { data.pointer }
   | 
     ## identifies the associated gloss element using a
     ##	canonical reference from a scheme defined in a
     ##	refsDecl element in the TEI header
     attribute cRef { data.pointer })?,
  empty
choice =
  
  ## groups a number of alternative encodings for the same point in
  ##   a text.
  element choice { choice.content, choice.attributes }
choice.content = (model.choicePart | choice)*
choice.attributes =
  att.global.attribute.id,
  att.global.attribute.rend,
  att.global.attribute.n,
  empty
name =
  
  ## (name, proper noun) contains a proper noun or noun phrase.
  element name { name.content, name.attributes }
name.content = macro.phraseSeq
name.attributes =
  att.global.attribute.id,
  att.global.attribute.rend,
  att.global.attribute.n,
  att.naming.attribute.key,
  
  ## indicates the type of the object which is being named by the
  ##       phrase.
  attribute type { data.enumerated }?,
  empty
address =
  
  ## contains a postal or other address, for example of a
  ## publisher, an organization, or an individual.
  element address { address.content, address.attributes }
address.content = model.global*, (model.addrPart, model.global*)+
address.attributes =
  att.global.attribute.id,
  att.global.attribute.rend,
  att.global.attribute.n,
  empty
addrLine =
  
  ## contains one line of a postal or other address.
  element addrLine { addrLine.content, addrLine.attributes }
addrLine.content = macro.phraseSeq
addrLine.attributes =
  att.global.attribute.id,
  att.global.attribute.rend,
  att.global.attribute.n,
  empty
date =
  
  ## contains a date in any format.
  element date { date.content, date.attributes }
date.content = macro.phraseSeq
date.attributes =
  att.global.attribute.id,
  att.global.attribute.rend,
  att.global.attribute.n,
  att.editLike.attribute.cert,
  att.editLike.attribute.resp,
  att.editLike.attribute.evidence,
  
  ## indicates the system or calendar to which the date belongs.
  attribute calendar { data.enumerated }?,
  
  ## gives the value of the date in standard form, i.e. yyyy-mm-dd.
  attribute value { data.temporal }?,
  
  ## indicates the degree of precision associated with the date.
  attribute precision { data.certainty }?,
  empty
abbr =
  
  ## (abbreviation) contains an abbreviation of any sort.
  element abbr { abbr.content, abbr.attributes }
abbr.content = macro.phraseSeq
abbr.attributes =
  att.global.attribute.id,
  att.global.attribute.rend,
  att.global.attribute.n,
  
  ## allows the encoder to classify the abbreviation according to
  ## some convenient typology.
  attribute type { data.enumerated }?,
  empty
ptr =
  
  ## defines a pointer to another location.
  element ptr { ptr.content, ptr.attributes }
ptr.content = empty
ptr.attributes =
  att.global.attribute.id,
  att.global.attribute.rend,
  att.global.attribute.n,
  att.pointing.attribute.type,
  att.pointing.attribute.evaluate,
  att.declaring.attribute.decls,
  (
   ## specifies the destination of the pointer by supplying one or
   ##       more URI References
   attribute target { data.pointers }
   | 
     ## specifies the destination of the pointer by supplying a
     ##       canonical reference from a scheme defined in a refsDecl
     ##       element in the TEI header
     attribute cRef { data.pointers })?,
  empty
ref =
  
  ## defines a reference to another location, possibly
  ##   modified by additional text or comment.
  element ref { ref.content, ref.attributes }
ref.content = macro.paraContent
ref.attributes =
  att.global.attribute.id,
  att.global.attribute.rend,
  att.global.attribute.n,
  att.pointing.attribute.type,
  att.pointing.attribute.evaluate,
  att.declaring.attribute.decls,
  (
   ## specifies the destination of the reference by supplying one
   ##     or more URI References
   attribute target { data.pointers }
   | 
     ## specifies the destination of the reference by supplying a
     ##       canonical reference from a scheme defined in a refsDecl
     ##       element in the TEI header
     attribute cRef { data.pointers })?,
  empty
\list =
  
  ## contains any sequence of items organized as a list.
  element list { list.content, list.attributes }
list.content = item+ | (label, item)+
list.attributes =
  
  ## describes the form of the list.
  [ a:defaultValue = "simple" ] attribute type { data.enumerated }?,
  att.global.attribute.id,
  att.global.attribute.rend,
  att.global.attribute.n,
  empty
item =
  
  ## contains one
  ## component of a list.
  element item { item.content, item.attributes }
item.content = macro.specialPara
item.attributes =
  att.global.attribute.id,
  att.global.attribute.rend,
  att.global.attribute.n,
  empty
label =
  
  ## contains the label associated with an item in a list; in
  ## glossaries, marks the term being defined.
  element label { label.content, label.attributes }
label.content = macro.phraseSeq
label.attributes =
  att.global.attribute.id,
  att.global.attribute.rend,
  att.global.attribute.n,
  empty
head =
  
  ## (heading) contains any type of heading, for example the title of a section,
  ## or the heading of a list, glossary, manuscript description, etc.
  element head { head.content, head.attributes }
head.content = macro.paraContent
head.attributes =
  att.global.attribute.id,
  att.global.attribute.rend,
  att.global.attribute.n,
  
  ## categorizes the heading in any way meaningful 
  ##          to the encoder. 
  attribute type { data.enumerated }?,
  empty
note =
  
  ## contains a note or
  ## annotation.
  element note { note.content, note.attributes }
note.content = macro.specialPara
note.attributes =
  att.global.attribute.id,
  att.global.attribute.rend,
  att.global.attribute.n,
  
  ## describes the type of note.
  attribute type { data.enumerated }?,
  
  ## indicates who is responsible for the annotation: author,
  ##	editor, translator, etc.
  attribute resp { data.pointer }?,
  
  ## indicates where the note appears in the source text.
  [ a:defaultValue = "unspecified" ] attribute place { data.code }?,
  
  ## indicates whether the copy text shows the exact place of reference
  ## for the note.
  [ a:defaultValue = "true" ]
  attribute anchored {
    
    ## (copy text indicates the place of attachment for the note.
    ##     ) 
    "true"
    | 
      ## (copy text indicates no place of attachment for the note.) 
      "false"
  }?,
  
  ## indicates the point (or points) of attachment for a note, or the beginning of
  ## the span to which the note is attached.
  attribute target { data.pointers }?,
  
  ## points to the end of the span to which the note is attached, if
  ## the note is not embedded in the text at that point.
  attribute targetEnd { data.pointers }?,
  empty
divGen =
  
  ## (automatically generated text division) indicates the location at which a textual division generated
  ## automatically by a text-processing application is to appear.
  element divGen { divGen.content, divGen.attributes }
divGen.content = model.divWrapper*
divGen.attributes =
  att.global.attribute.id,
  att.global.attribute.rend,
  att.global.attribute.n,
  
  ## specifies what type of generated text division (e.g. index,
  ## table of contents, etc.) is to appear.
  attribute type { data.enumerated }?,
  empty
graphic =
  
  ## indicates the location of an inline graphic, illustration, or figure.
  element graphic { graphic.content, graphic.attributes }
graphic.content = empty
graphic.attributes =
  att.global.attribute.id,
  att.global.attribute.rend,
  att.global.attribute.n,
  
  ## The display width of the image
  attribute width { data.outputMeasurement }?,
  
  ## The display height of the image
  attribute height { data.outputMeasurement }?,
  
  ## A scale factor to be applied to the image to make it the desired display size
  attribute scale { data.probability }?,
  
  ## The target URL
  attribute url { data.pointer }?,
  
  ## The MIME type
  attribute mimeType { data.word }?,
  empty
binaryObject =
  
  ## provides encoded binary data representing an inline graphic or other object.
  element binaryObject { binaryObject.content, binaryObject.attributes }
binaryObject.content = text
binaryObject.attributes =
  att.global.attribute.id,
  att.global.attribute.rend,
  att.global.attribute.n,
  
  ## The display width of the object
  attribute width { data.outputMeasurement }?,
  
  ## The display height of the object
  attribute height { data.outputMeasurement }?,
  
  ## A scale factor to be applied to the object to make it the desired display size
  attribute scale { data.numeric }?,
  
  ## The MIME type
  attribute mimeType { data.word }?,
  
  ## The encoding used to encode the binary data. If not
  ##       specified, this is assumed to be Base64
  attribute encoding { data.words }?,
  empty
lb =
  
  ## (line break) marks the start of a new (typographic) line in some
  ## edition or version of a text.
  element lb { lb.content, lb.attributes }
lb.content = empty
lb.attributes =
  att.global.attribute.id,
  att.global.attribute.rend,
  att.global.attribute.n,
  
  ## indicates the edition or version in which the line break is located
  ## at this point
  attribute ed { data.code }?,
  empty
bibl =
  
  ## (bibliographic citation) contains a loosely-structured bibliographic citation of which
  ## the sub-components may or may not be explicitly tagged. 
  element bibl { bibl.content, bibl.attributes }
bibl.content =
  (text
   | model.gLike
   | model.hiLike
   | model.pPart.data
   | model.pPart.edit
   | model.segLike
   | model.ptrLike
   | model.biblPart
   | model.global)*
bibl.attributes =
  att.global.attribute.id,
  att.global.attribute.rend,
  att.global.attribute.n,
  att.declarable.attribute.default,
  empty
biblItem =
  
  ## (bibliographic citation) contains a bibliographic citation in which only bibliographic
  ##   subelements appear.
  element biblItem { biblItem.content, biblItem.attributes }
biblItem.content =
  (title
   | biblItem
   | imprint
   | model.nameLike
   | model.biblPart
   | model.dateLike)+
biblItem.attributes =
  att.global.attribute.id,
  att.global.attribute.rend,
  att.global.attribute.n,
  att.declarable.attribute.default,
  att.typed.attribute.type,
  att.typed.attribute.subtype,
  
  ## indicates the physical form of the object of this bibliographic entry.
  attribute form { xsd:token }?,
  
  ## indicates the publication status of the object of this bibliographic entry.
  attribute status { text }?,
  
  ## indicates the relationship of this bibliographic entry to
  ##       that of its parent bibl or biblItem.
  attribute role { text }?,
  empty
biblStruct =
  
  ## (structured bibliographic citation) contains a structured bibliographic citation, in which only
  ## bibliographic subelements appear and in a specified order. 
  element biblStruct { biblStruct.content, biblStruct.attributes }
biblStruct.content =
  analytic*, (monogr, series*)+, (model.noteLike | idno)*
biblStruct.attributes =
  att.global.attribute.id,
  att.global.attribute.rend,
  att.global.attribute.n,
  att.declarable.attribute.default,
  empty
biblFull =
  
  ## contains a fully-structured bibliographic citation, in which all
  ## components of the TEI file description
  ## are present.
  element biblFull { biblFull.content, biblFull.attributes }
biblFull.content = macro.fileDescPart, sourceDesc*
biblFull.attributes =
  att.global.attribute.id,
  att.global.attribute.rend,
  att.global.attribute.n,
  att.declarable.attribute.default,
  empty
listBibl =
  
  ## (citation list) contains a list of bibliographic citations of any kind. 
  element listBibl { listBibl.content, listBibl.attributes }
listBibl.content =
  (model.divWrapper | model.global)*,
  (model.biblLike, model.global*)+,
  (model.divWrapper.bottom, model.global*)*
listBibl.attributes =
  att.global.attribute.id,
  att.global.attribute.rend,
  att.global.attribute.n,
  att.declarable.attribute.default,
  empty
analytic =
  
  ## (analytic level) contains bibliographic elements describing an item (e.g. an
  ## article or poem) published within a monograph or journal and not as an
  ## independent publication.
  element analytic { analytic.content, analytic.attributes }
analytic.content = (author | editor | respStmt | title)*
analytic.attributes =
  att.global.attribute.id,
  att.global.attribute.rend,
  att.global.attribute.n,
  empty
monogr =
  
  ## (monographic level) contains bibliographic elements describing an item (e.g. a book
  ## or journal) published as an independent item (i.e. as a separate
  ## physical object).
  element monogr { monogr.content, monogr.attributes }
monogr.content =
  (((author | editor | respStmt),
    (author | editor | respStmt)*,
    title+,
    (editor | respStmt)*)
   | (title+, (author | editor | respStmt)*))?,
  (model.noteLike)*,
  (edition, (editor | respStmt)*)*,
  imprint,
  (imprint | extent | biblScope)*
monogr.attributes =
  att.global.attribute.id,
  att.global.attribute.rend,
  att.global.attribute.n,
  empty
series =
  
  ## (series information) contains information about the series in which a book or other
  ## bibliographic item has appeared.
  element series { series.content, series.attributes }
series.content =
  (text
   | model.gLike
   | title
   | editor
   | respStmt
   | biblScope
   | model.global)*
series.attributes =
  att.global.attribute.id,
  att.global.attribute.rend,
  att.global.attribute.n,
  empty
author =
  
  ## in a bibliographic reference, contains the name of the author(s),
  ## personal or corporate,
  ## of a work; the primary statement of responsibility for any
  ## bibliographic item. 
  element author { author.content, author.attributes }
author.content = macro.phraseSeq
author.attributes =
  att.global.attribute.id,
  att.global.attribute.rend,
  att.global.attribute.n,
  empty
editor =
  
  ## (editor) secondary statement of responsibility for a
  ## bibliographic item, for example the name of an individual, institution
  ## or organization, (or of several such) acting as editor, compiler,
  ## translator, etc. 
  element editor { editor.content, editor.attributes }
editor.content = macro.phraseSeq
editor.attributes =
  att.global.attribute.id,
  att.global.attribute.rend,
  att.global.attribute.n,
  
  ## specifies the nature of the intellectual responsibility
  [ a:defaultValue = "editor" ] attribute role { data.enumerated }?,
  empty
respStmt =
  
  ## (statement of responsibility) supplies a statement of responsibility for someone responsible
  ##   for the intellectual content of a text, edition, recording, or
  ##   series, where the specialized elements for authors, editors, etc. do
  ##   not suffice or do not apply.
  element respStmt { respStmt.content, respStmt.attributes }
respStmt.content =
  model.nameLike.agent+ | (model.nameLike.agent, model.nameLike.agent*)
respStmt.attributes =
  att.global.attribute.id,
  att.global.attribute.rend,
  att.global.attribute.n,
  empty
title =
  
  ## contains the full title of a work of any kind.
  element title { title.content, title.attributes }
title.content = macro.paraContent
title.attributes =
  att.global.attribute.id,
  att.global.attribute.rend,
  att.global.attribute.n,
  
  ## indicates the bibliographic level for a title, that is,
  ##	whether it identifies  an article, book, journal,
  ## series, or unpublished material.
  attribute level {
    
    ## (analytic title (article, poem, or other item published as
    ##           part of a larger item)
    ##     ) 
    "a"
    | 
      ## (monographic title (book, collection, or other item published
      ##           as a distinct item, including single volumes of multi-volume
      ##           works)
      ##     ) 
      "m"
    | 
      ## (journal title
      ##     ) 
      "j"
    | 
      ## (series title
      ##     ) 
      "s"
    | 
      ## (title of unpublished material (including theses and
      ##           dissertations unless published by a commercial press)) 
      "u"
  }?,
  
  ## classifies the title according to some convenient typology.
  attribute type { data.enumerated }?,
  empty
imprint =
  
  ## groups information relating to the publication or distribution
  ##   of a bibliographic item.
  element imprint { imprint.content, imprint.attributes }
imprint.content = ((model.imprintPart | model.dateLike), model.global*)+
imprint.attributes =
  att.global.attribute.id,
  att.global.attribute.rend,
  att.global.attribute.n,
  empty
publisher =
  
  ## provides the name of the organization responsible for
  ## the publication or distribution of a bibliographic item.
  element publisher { publisher.content, publisher.attributes }
publisher.content = macro.phraseSeq
publisher.attributes =
  att.global.attribute.id,
  att.global.attribute.rend,
  att.global.attribute.n,
  empty
biblScope =
  
  ## (scope of citation) defines the scope of a bibliographic reference, for example as a
  ## list of pagenumbers, or a named subdivision of a larger work.
  element biblScope { biblScope.content, biblScope.attributes }
biblScope.content = macro.phraseSeq
biblScope.attributes =
  att.global.attribute.id,
  att.global.attribute.rend,
  att.global.attribute.n,
  
  ## identifies the type of information conveyed by the element, e.g.
  ## pages, volume.
  attribute type { data.enumerated }?,
  empty
pubPlace =
  
  ## contains the name of the place where a bibliographic item was
  ## published.
  element pubPlace { pubPlace.content, pubPlace.attributes }
pubPlace.content = macro.phraseSeq
pubPlace.attributes =
  att.global.attribute.id,
  att.global.attribute.rend,
  att.global.attribute.n,
  att.naming.attribute.key,
  empty
teiCorpus =
  
  ## (TEI corpus) contains the whole of a TEI encoded corpus, comprising a
  ## single corpus header and one or more TEI elements, each containing
  ## a single text header and a text.
  element teiCorpus { teiCorpus.content, teiCorpus.attributes }
teiCorpus.content = teiHeader, (TEI | teiCorpus)+
teiCorpus.attributes =
  att.global.attribute.id,
  att.global.attribute.rend,
  att.global.attribute.n,
  
  ## The version of the TEI scheme
  [ a:defaultValue = "5.0" ] attribute version { xsd:decimal }?,
  empty
teiHeader =
  
  ## (TEI Header) supplies the descriptive and declarative information making
  ##	up an electronic title page prefixed to every TEI-conformant
  ##	text.
  element teiHeader { teiHeader.content, teiHeader.attributes }
teiHeader.content = fileDesc, model.headerPart*, revisionDesc?
teiHeader.attributes =
  att.global.attribute.id,
  att.global.attribute.rend,
  att.global.attribute.n,
  
  ## specifies the kind of document to which the header is attached.
  [ a:defaultValue = "text" ] attribute type { data.enumerated }?,
  empty
fileDesc =
  
  ## (File Description) contains a full bibliographic description of an electronic
  ## file.
  element fileDesc { fileDesc.content, fileDesc.attributes }
fileDesc.content = macro.fileDescPart, sourceDesc+
fileDesc.attributes =
  att.global.attribute.id,
  att.global.attribute.rend,
  att.global.attribute.n,
  empty
titleStmt =
  
  ## (title statement) groups information about the title of a work and those
  ## responsible for its intellectual content.
  element titleStmt { titleStmt.content, titleStmt.attributes }
titleStmt.content =
  title+, (author | editor | sponsor | funder | principal | respStmt)*
titleStmt.attributes =
  att.global.attribute.id,
  att.global.attribute.rend,
  att.global.attribute.n,
  empty
sponsor =
  
  ## specifies the name of a sponsoring organization or
  ## institution.
  element sponsor { sponsor.content, sponsor.attributes }
sponsor.content = macro.phraseSeq
sponsor.attributes =
  att.global.attribute.id,
  att.global.attribute.rend,
  att.global.attribute.n,
  empty
funder =
  
  ## (Funding body) specifies the name of an individual, institution, or organization
  ## responsible for the funding of a project or text.
  element funder { funder.content, funder.attributes }
funder.content = macro.phraseSeq
funder.attributes =
  att.global.attribute.id,
  att.global.attribute.rend,
  att.global.attribute.n,
  empty
principal =
  
  ## (principal researcher) supplies the name of the principal researcher responsible for the
  ## creation of an electronic text.
  element principal { principal.content, principal.attributes }
principal.content = macro.phraseSeq
principal.attributes =
  att.global.attribute.id,
  att.global.attribute.rend,
  att.global.attribute.n,
  empty
editionStmt =
  
  ## (edition statement) groups information relating to one edition of a text.
  element editionStmt { editionStmt.content, editionStmt.attributes }
editionStmt.content = model.pLike+ | (edition, respStmt*)
editionStmt.attributes =
  att.global.attribute.id,
  att.global.attribute.rend,
  att.global.attribute.n,
  empty
edition =
  
  ## (Edition) describes the particularities of one edition of a text.
  element edition { edition.content, edition.attributes }
edition.content = macro.phraseSeq
edition.attributes =
  att.global.attribute.id,
  att.global.attribute.rend,
  att.global.attribute.n,
  empty
extent =
  
  ## describes the approximate size of the electronic text as stored on
  ## some carrier medium, specified in any convenient units.
  element extent { extent.content, extent.attributes }
extent.content = macro.phraseSeq
extent.attributes =
  att.global.attribute.id,
  att.global.attribute.rend,
  att.global.attribute.n,
  empty
publicationStmt =
  
  ## (publication statement) groups information concerning the publication or distribution
  ## of an electronic or other text. 
  element publicationStmt {
    publicationStmt.content, publicationStmt.attributes
  }
publicationStmt.content =
  model.pLike+
  | (publisher
     | distributor
     | authority
     | pubPlace
     | address
     | idno
     | availability
     | date)+
publicationStmt.attributes =
  att.global.attribute.id,
  att.global.attribute.rend,
  att.global.attribute.n,
  empty
distributor =
  
  ## supplies the name of a person or other agency responsible for the
  ## distribution of a text.
  element distributor { distributor.content, distributor.attributes }
distributor.content = macro.phraseSeq
distributor.attributes =
  att.global.attribute.id,
  att.global.attribute.rend,
  att.global.attribute.n,
  empty
authority =
  
  ## (release authority) supplies the name of a person or other agency responsible for
  ##   making an electronic file available, other than a publisher or
  ##   distributor.
  element authority { authority.content, authority.attributes }
authority.content = macro.phraseSeq
authority.attributes =
  att.global.attribute.id,
  att.global.attribute.rend,
  att.global.attribute.n,
  empty
idno =
  
  ## (identifying number) supplies any standard or non-standard number used to identify a
  ## bibliographic item.
  element idno { idno.content, idno.attributes }
idno.content = text
idno.attributes =
  att.global.attribute.id,
  att.global.attribute.rend,
  att.global.attribute.n,
  
  ## categorizes the number, for example as an ISBN or other
  ##          standard series.
  ##    
  attribute type { data.enumerated }?,
  empty
availability =
  
  ## supplies information about the availability of a text, for
  ##   example any restrictions on its use or distribution, its copyright
  ##   status, etc.
  element availability { availability.content, availability.attributes }
availability.content = model.pLike+
availability.attributes =
  att.global.attribute.id,
  att.global.attribute.rend,
  att.global.attribute.n,
  
  ## supplies a code identifying the current availability of the
  ## text.
  ##    
  [ a:defaultValue = "unknown" ]
  attribute status {
    
    ## (the text is freely available.
    ##     ) 
    "free"
    | 
      ## (the status of the text is unknown.
      ##     ) 
      "unknown"
    | 
      ## (the text is not freely available.
      ##    ) 
      "restricted"
  }?,
  empty
seriesStmt =
  
  ## (series statement) groups information about the series, if any, to which
  ## a publication belongs.
  element seriesStmt { seriesStmt.content, seriesStmt.attributes }
seriesStmt.content =
  model.pLike+
  | (title+, (idno | respStmt)*)
seriesStmt.attributes =
  att.global.attribute.id,
  att.global.attribute.rend,
  att.global.attribute.n,
  empty
notesStmt =
  
  ## (Notes statement) collects together any notes providing information about a text
  ## additional to that recorded in other parts of the bibliographic
  ## description.
  element notesStmt { notesStmt.content, notesStmt.attributes }
notesStmt.content = model.noteLike+
notesStmt.attributes =
  att.global.attribute.id,
  att.global.attribute.rend,
  att.global.attribute.n,
  empty
sourceDesc =
  
  ## supplies a description of the source text(s) from
  ## which an electronic text was derived or generated.
  element sourceDesc { sourceDesc.content, sourceDesc.attributes }
sourceDesc.content =
  model.pLike+ | listBibl | (model.biblLike | model.sourceDescPart)+
sourceDesc.attributes =
  att.global.attribute.id,
  att.global.attribute.rend,
  att.global.attribute.n,
  att.declarable.attribute.default,
  empty
scriptStmt =
  
  ## (script statement) contains a citation giving details of the script used for
  ## a spoken text.
  element scriptStmt { scriptStmt.content, scriptStmt.attributes }
scriptStmt.content = model.pLike+ | model.biblLike
scriptStmt.attributes =
  att.global.attribute.id,
  att.global.attribute.rend,
  att.global.attribute.n,
  att.declarable.attribute.default,
  empty
recordingStmt =
  
  ## (recording statement) describes a set of recordings used in transcription of a
  ## spoken text.
  element recordingStmt {
    recordingStmt.content, recordingStmt.attributes
  }
recordingStmt.content = model.pLike+ | recording+
recordingStmt.attributes =
  att.global.attribute.id,
  att.global.attribute.rend,
  att.global.attribute.n,
  empty
recording =
  
  ## (recording event) details of an audio or video recording event
  ## used as the source of a spoken text, either directly or from
  ## a public broadcast. 
  element recording { recording.content, recording.attributes }
recording.content = model.pLike+ | model.recordingPart*
recording.attributes =
  att.global.attribute.id,
  att.global.attribute.rend,
  att.global.attribute.n,
  att.declarable.attribute.default,
  
  ## the kind of recording.
  [ a:defaultValue = "audio" ]
  attribute type {
    
    ## (audio recording) 
    "audio"
    | 
      ## (audio and video recording) 
      "video"
  }?,
  
  ## the original duration of the recording. 
  attribute dur { data.duration }?,
  empty
equipment =
  
  ## (equipment) provides technical details of the equipment and media used for
  ## an audio or video recording used as the source for a spoken text.
  element equipment { equipment.content, equipment.attributes }
equipment.content = model.pLike+
equipment.attributes =
  att.global.attribute.id,
  att.global.attribute.rend,
  att.global.attribute.n,
  att.declarable.attribute.default,
  empty
broadcast =
  
  ## (broadcast) describes a broadcast used as the source of a spoken text.
  element broadcast { broadcast.content, broadcast.attributes }
broadcast.content = model.pLike+ | model.biblLike | recording
broadcast.attributes =
  att.global.attribute.id,
  att.global.attribute.rend,
  att.global.attribute.n,
  att.declarable.attribute.default,
  empty
encodingDesc =
  
  ## (Encoding description) documents the relationship between an electronic text and the
  ## source or sources from which it was derived.
  element encodingDesc { encodingDesc.content, encodingDesc.attributes }
encodingDesc.content = (model.encodingPart | model.pLike)+
encodingDesc.attributes =
  att.global.attribute.id,
  att.global.attribute.rend,
  att.global.attribute.n,
  empty
projectDesc =
  
  ## (project description) describes in detail the aim or purpose for which an electronic
  ## file was encoded, together with any other relevant information
  ## concerning the process by which it was assembled or collected.
  element projectDesc { projectDesc.content, projectDesc.attributes }
projectDesc.content = model.pLike+
projectDesc.attributes =
  att.global.attribute.id,
  att.global.attribute.rend,
  att.global.attribute.n,
  att.declarable.attribute.default,
  empty
samplingDecl =
  
  ## (sampling declaration) contains a prose description of the rationale and methods used
  ## in sampling texts in the creation of a corpus or collection.
  element samplingDecl { samplingDecl.content, samplingDecl.attributes }
samplingDecl.content = model.pLike+
samplingDecl.attributes =
  att.global.attribute.id,
  att.global.attribute.rend,
  att.global.attribute.n,
  att.declarable.attribute.default,
  empty
editorialDecl =
  
  ## (editorial practice declaration) provides details of editorial principles and practices applied
  ## during the encoding of a text.
  element editorialDecl {
    editorialDecl.content, editorialDecl.attributes
  }
editorialDecl.content = model.pLike+ | model.editorialDeclPart+
editorialDecl.attributes =
  att.global.attribute.id,
  att.global.attribute.rend,
  att.global.attribute.n,
  att.declarable.attribute.default,
  empty
correction =
  
  ## (correction principles) states how and under what circumstances corrections have been
  ## made in the text.
  element correction { correction.content, correction.attributes }
correction.content = model.pLike+
correction.attributes =
  att.global.attribute.id,
  att.global.attribute.rend,
  att.global.attribute.n,
  att.declarable.attribute.default,
  
  ## indicates the degree of correction applied to the text.
  ##    
  [ a:defaultValue = "unknown" ]
  attribute status {
    
    ## (the text has been thoroughly checked and
    ##                        proofread.
    ##     ) 
    "high"
    | 
      ## (the text has been checked at least once.
      ##     ) 
      "medium"
    | 
      ## (the text has not been checked.
      ##     ) 
      "low"
    | 
      ## (the correction status of the text is unknown.
      ##    ) 
      "unknown"
  }?,
  
  ## indicates the method adopted to indicate corrections within the
  ##          text.
  ##    
  [ a:defaultValue = "silent" ]
  attribute method {
    
    ## (corrections have been made silently
    ##     ) 
    "silent"
    | 
      ## (corrections have been represented using editorial tags
      ##    ) 
      "tags"
  }?,
  empty
normalization =
  
  ## indicates the extent of normalization or regularization of the
  ## original source carried out in converting it to electronic form.
  element normalization {
    normalization.content, normalization.attributes
  }
normalization.content = model.pLike+
normalization.attributes =
  att.global.attribute.id,
  att.global.attribute.rend,
  att.global.attribute.n,
  att.declarable.attribute.default,
  
  ## indicates the authority for any normalization carried out.
  ##     
  attribute source { data.pointer }?,
  
  ## indicates the method adopted to indicate normalizations within
  ##          the text.
  ##    
  [ a:defaultValue = "silent" ]
  attribute method {
    
    ## (normalization made silently
    ##   ) 
    "silent"
    | 
      ## (normalization represented using editorial tags
      ##    ) 
      "tags"
  }?,
  empty
quotation =
  
  ## specifies editorial practice adopted with respect to quotation
  ##   marks in the original. 
  element quotation { quotation.content, quotation.attributes }
quotation.content = model.pLike+
quotation.attributes =
  att.global.attribute.id,
  att.global.attribute.rend,
  att.global.attribute.n,
  att.declarable.attribute.default,
  
  ## indicates whether or not quotation marks have been retained as
  ##       content within the text. 
  [ a:defaultValue = "all" ]
  attribute marks {
    
    ## (no quotation marks have been retained ) 
    "none"
    | 
      ## (some quotation marks have been retained ) 
      "some"
    | 
      ## (all quotation marks have been retained ) 
      "all"
  }?,
  
  ## specifies how quotation marks are indicated within the
  ##       text.
  [ a:defaultValue = "unknown" ]
  attribute form {
    
    ## (quotation marks are retained as data.) 
    "data"
    | 
      ## (the rendition attribute is consistently used to
      ##           indicate the form of quotation marks.) 
      "rend"
    | 
      ## (use of quotation marks has been standardized.) 
      "std"
    | 
      ## (quotation marks are represented inconsistently.) 
      "nonstd"
    | 
      ## (use of quotation marks is unknown.) 
      "unknown"
  }?,
  empty
hyphenation =
  
  ## (Hyphenation) summarizes the way in which hyphenation in a source text has been
  ## treated in an encoded version of it.
  element hyphenation { hyphenation.content, hyphenation.attributes }
hyphenation.content = model.pLike+
hyphenation.attributes =
  att.global.attribute.id,
  att.global.attribute.rend,
  att.global.attribute.n,
  att.declarable.attribute.default,
  
  ## indicates whether or not end-of-line hyphenation has been
  ##	retained in a text.
  [ a:defaultValue = "some" ]
  attribute eol {
    
    ## (all end-of-line hyphenation has been retained,
    ##                    even though the lineation of the original
    ##                    may not have been.
    ##    ) 
    "all"
    | 
      ## (end-of-line hyphenation has been retained in some
      ##                    cases.
      ##    ) 
      "some"
    | 
      ## (all soft end-of-line hyphenation has been removed:
      ##                    any remaining end-od-line hyphenation should be retained.
      ##   ) 
      "hard"
    | 
      ## (all end-of-line hyphenation has been removed:
      ##                   any remaining hyphenation occurred within the line.
      ##    ) 
      "none"
  }?,
  empty
segmentation =
  
  ## describes the principles according to which the text has been
  ## segmented, for example into sentences, tone-units, graphemic strata,
  ## etc.
  element segmentation { segmentation.content, segmentation.attributes }
segmentation.content = model.pLike+
segmentation.attributes =
  att.global.attribute.id,
  att.global.attribute.rend,
  att.global.attribute.n,
  att.declarable.attribute.default,
  empty
stdVals =
  
  ## (Standard values) specifies the format used when standardized date or number
  ## values are supplied.
  element stdVals { stdVals.content, stdVals.attributes }
stdVals.content = model.pLike+
stdVals.attributes =
  att.global.attribute.id,
  att.global.attribute.rend,
  att.global.attribute.n,
  att.declarable.attribute.default,
  empty
interpretation =
  
  ## describes the scope of any analytic or interpretive information
  ## added to the text in addition to the transcription. 
  element interpretation {
    interpretation.content, interpretation.attributes
  }
interpretation.content = model.pLike+
interpretation.attributes =
  att.global.attribute.id,
  att.global.attribute.rend,
  att.global.attribute.n,
  att.declarable.attribute.default,
  empty
tagsDecl =
  
  ## (tagging declaration) provides detailed information about the tagging applied to an SGML or XML document.
  element tagsDecl { tagsDecl.content, tagsDecl.attributes }
tagsDecl.content = rendition*, tagUsage*
tagsDecl.attributes =
  att.global.attribute.id,
  att.global.attribute.rend,
  att.global.attribute.n,
  empty
tagUsage =
  
  ## (tagUsage) supplies information about the usage of a specific element
  ## within a text. 
  element tagUsage { tagUsage.content, tagUsage.attributes }
tagUsage.content = macro.paraContent
tagUsage.attributes =
  att.global.attribute.id,
  att.global.attribute.rend,
  att.global.attribute.n,
  
  ## the name (generic identifier)
  ## of the element indicated by the tag.
  attribute gi { data.name },
  
  ## specifies the number of occurrences of this element within the text.
  ##  
  attribute occurs { data.count }?,
  
  ## specifies the number of occurrences of this element within the text
  ## which bear a distinct value for the global xml:id attribute. 
  attribute withId { data.count }?,
  
  ## specifies the identifier of a rendition element which
  ## defines how this element is to be rendered.
  attribute render { data.pointer }?,
  empty
rendition =
  
  ## (rendition) supplies information about the intended rendition of one or more
  ## elements.
  element rendition { rendition.content, rendition.attributes }
rendition.content = macro.paraContent
rendition.attributes =
  att.global.attribute.id,
  att.global.attribute.rend,
  att.global.attribute.n,
  empty
refsDecl =
  
  ## (references declaration) specifies how canonical references are constructed for this
  ##   text.
  element refsDecl { refsDecl.content, refsDecl.attributes }
refsDecl.content = model.pLike+ | cRefPattern+ | state+
refsDecl.attributes =
  att.global.attribute.id,
  att.global.attribute.rend,
  att.global.attribute.n,
  att.declarable.attribute.default,
  
  ## identifies the document type within which
  ##       this reference declaration is used.
  [ a:defaultValue = "TEI" ] attribute doctype { data.name }?,
  empty
cRefPattern =
  
  ## (defines how to convert a canonical reference into a URI) specifies an expression and replacement pattern for
  ##   tranforming a canonical reference into a URI
  element cRefPattern { cRefPattern.content, cRefPattern.attributes }
cRefPattern.content = model.pLike*
cRefPattern.attributes =
  att.global.attribute.id,
  att.global.attribute.rend,
  att.global.attribute.n,
  
  ## specifies a regular expression against which the values of
  ##       cRef attributes can be matched.
  attribute matchPattern { data.pattern },
  
  ## specifies a replacement pattern
  ##       which, once subpattern substitution has been performed, provides
  ##       a URI.
  attribute replacementPattern { text },
  empty
state =
  
  ## specifies one component of a canonical reference defined by
  ## the milestone method.
  element state { state.content, state.attributes }
state.content = empty
state.attributes =
  att.global.attribute.id,
  att.global.attribute.rend,
  att.global.attribute.n,
  
  ## indicates which edition or version the milestone applies to.
  attribute ed { data.code }?,
  
  ## indicates what kind of state is changing at this milestone.
  attribute unit { data.enumerated },
  
  ## specifies the fixed length of the reference component.
  attribute length { data.count }?,
  
  ## supplies a delimiting string following the reference
  ##           component.
  attribute delim { text }?,
  empty
classDecl =
  
  ## (classification declarations) contains one or more taxonomies defining any classificatory
  ## codes used elsewhere in the text.
  element classDecl { classDecl.content, classDecl.attributes }
classDecl.content = taxonomy+
classDecl.attributes =
  att.global.attribute.id,
  att.global.attribute.rend,
  att.global.attribute.n,
  empty
taxonomy =
  
  ## (taxonomy) defines a typology used to classify texts either implicitly, by
  ## means of a bibliographic citation, or explicitly by a structured
  ## taxonomy.
  element taxonomy { taxonomy.content, taxonomy.attributes }
taxonomy.content = category+ | (model.biblLike, category*)
taxonomy.attributes =
  att.global.attribute.id,
  att.global.attribute.rend,
  att.global.attribute.n,
  empty
category =
  
  ## (category) contains an individual descriptive category, possibly nested
  ## within a superordinate category, within a user-defined taxonomy.
  element category { category.content, category.attributes }
category.content = catDesc, category*
category.attributes =
  att.global.attribute.id,
  att.global.attribute.rend,
  att.global.attribute.n,
  empty
catDesc =
  
  ## (category description) describes some category within a taxonomy
  ## or text typology, either in the form of a brief prose description
  ## or in terms of the situational parameters used by the TEI
  ## formal textDesc.
  element catDesc { catDesc.content, catDesc.attributes }
catDesc.content = (text | model.phrase | model.catDescPart)*
catDesc.attributes =
  att.global.attribute.id,
  att.global.attribute.rend,
  att.global.attribute.n,
  empty
fsdDecl =
  
  ## (FSD (feature-system declaration) declaration) identifies the feature system declaration which contains
  ## definitions for a particular type of feature structure.
  element fsdDecl { fsdDecl.content, fsdDecl.attributes }
fsdDecl.content = empty
fsdDecl.attributes =
  att.global.attribute.id,
  att.global.attribute.rend,
  att.global.attribute.n,
  
  ## identifies the type of feature structure documented by the FSD;
  ## this will be the value of the type attribute on at least one
  ## feature structure.
  attribute type { data.enumerated },
  
  ## supplies a link to the entity containing the feature system
  ## declaration. 
  attribute url { data.pointer },
  empty
metDecl =
  
  ## documents the notation employed to represent a metrical
  ##   pattern when this is specified as the value of a met,
  ##   real, or rhyme attribute on any structural
  ##   element of a metrical text (e.g. lg, l, or
  ##   seg).
  element metDecl { metDecl.content, metDecl.attributes }
metDecl.content = macro.componentSeq | metSym+
metDecl.attributes =
  att.global.attribute.id,
  att.global.attribute.rend,
  att.global.attribute.n,
  att.declarable.attribute.default,
  
  ## indicates whether the notation conveys the abstract
  ##       metrical form, its actual prosodic realization, or the rhyme
  ##       scheme, or some combination thereof.
  [ a:defaultValue = "met real" ]
  attribute type {
    list { ("met" | "real" | "rhyme")+ }
  }?,
  
  ## specifies a regular expression defining any value that
  ##	is legal for this notation.
  attribute pattern { data.enumerated }?,
  empty
metSym =
  
  ## documents the intended significance of a particular character or
  ## character sequence within a metrical notation, either explicitly or in
  ## terms of other symbol elements in the same metDecl.
  element metSym { metSym.content, metSym.attributes }
metSym.content = macro.phraseSeq
metSym.attributes =
  att.global.attribute.id,
  att.global.attribute.rend,
  att.global.attribute.n,
  
  ## specifies the character or character sequence being documented.
  attribute value { data.words },
  
  ## specifies whether the symbol is defined in terms of other
  ## symbols (terminal is set to false) or in prose
  ## (terminal is set to true).
  [ a:defaultValue = "true" ]
  attribute terminal {
    
    ## (the element contains a prose definition of its meaning.) 
    "true"
    | 
      ## (the element contains a definition of its meaning given using
      ## symbols defined elsewhere in the same metDecl element.) 
      "false"
  }?,
  empty
variantEncoding =
  
  ## declares the method used to encode text-critical variants.
  element variantEncoding {
    variantEncoding.content, variantEncoding.attributes
  }
variantEncoding.content = empty
variantEncoding.attributes =
  att.global.attribute.id,
  att.global.attribute.rend,
  att.global.attribute.n,
  
  ## indicates which method is used to encode the apparatus of
  ## variants.
  attribute method {
    
    ## (apparatus uses line numbers or other canonical reference scheme
    ## referenced in a base text.) 
    "location-referenced"
    | 
      ## (apparatus indicates the precise locations of the beginning and
      ## ending of each lemma relative to a base text.) 
      "double-end-point"
    | 
      ## (alternate readings of a passage are given in parallel in the
      ## text; no notion of a base text is necessary.) 
      "parallel-segmentation"
  },
  
  ## indicates whether the apparatus appears within the running text
  ## or external to it.
  attribute location {
    
    ## (apparatus appears within the running text.) 
    "internal"
    | 
      ## (apparatus appears outside the base text.) 
      "external"
  },
  empty
profileDesc =
  
  ## (text-profile description) provides a detailed description of non-bibliographic aspects of a
  ## text, specifically the languages and sublanguages used, the situation in
  ## which it was produced, the participants and their setting.
  element profileDesc { profileDesc.content, profileDesc.attributes }
profileDesc.content = creation?, model.profileDescPart*
profileDesc.attributes =
  att.global.attribute.id,
  att.global.attribute.rend,
  att.global.attribute.n,
  empty
creation =
  
  ## contains information about the creation of a text.
  element creation { creation.content, creation.attributes }
creation.content = macro.phraseSeq
creation.attributes =
  att.global.attribute.id,
  att.global.attribute.rend,
  att.global.attribute.n,
  empty
langUsage =
  
  ## (language usage) describes the languages, sublanguages, registers, dialects etc.
  ## represented within a text.
  element langUsage { langUsage.content, langUsage.attributes }
langUsage.content = (language)+
langUsage.attributes =
  att.global.attribute.id,
  att.global.attribute.rend,
  att.global.attribute.n,
  att.declarable.attribute.default,
  empty
language =
  
  ## characterizes a single language or sublanguage used within a
  ##   text.
  element language { language.content, language.attributes }
language.content = macro.phraseSeq
language.attributes =
  att.global.attribute.id,
  att.global.attribute.rend,
  att.global.attribute.n,
  
  ## Supplies a language code constructed as defined in RFC 3066 (or
  ##       its successor) which is used to identify the language documented
  ##       by this element, and which is referenced by the global xml:lang attribute.
  attribute ident { data.language },
  
  ## specifies the approximate percentage (by volume) of the
  ##       text which uses this language.
  ##       
  attribute usage {
    xsd:nonNegativeInteger { maxInclusive = "100" }
  }?,
  empty
textClass =
  
  ## (text classification) groups information which describes the nature or topic of a text
  ## in terms of a standard classification scheme, thesaurus, etc.
  element textClass { textClass.content, textClass.attributes }
textClass.content = (classCode | catRef | keywords)*
textClass.attributes =
  att.global.attribute.id,
  att.global.attribute.rend,
  att.global.attribute.n,
  att.declarable.attribute.default,
  empty
keywords =
  
  ## (Keywords) contains a list of keywords or phrases identifying the topic or
  ## nature of a text.
  element keywords { keywords.content, keywords.attributes }
keywords.content = term+ | \list
keywords.attributes =
  att.global.attribute.id,
  att.global.attribute.rend,
  att.global.attribute.n,
  
  ## identifies the controlled vocabulary within which the set of
  ##   keywords concerned is defined.
  ##    
  attribute scheme { data.pointer },
  empty
classCode =
  
  ## (classCode) contains the classification code used for this text in some
  ## standard classification system.
  element classCode { classCode.content, classCode.attributes }
classCode.content = macro.phraseSeq
classCode.attributes =
  att.global.attribute.id,
  att.global.attribute.rend,
  att.global.attribute.n,
  
  ## identifies the classification system or taxonomy in use.
  attribute scheme { data.pointer },
  empty
catRef =
  
  ## (category reference) specifies one or more defined categories
  ## within some taxonomy or text typology.
  element catRef { catRef.content, catRef.attributes }
catRef.content = empty
catRef.attributes =
  att.global.attribute.id,
  att.global.attribute.rend,
  att.global.attribute.n,
  
  ## identifies the categories concerned
  ##    
  attribute target { data.pointers },
  
  ## identifies the classification scheme within which the set of
  ##     categories concerned is defined
  ##    
  attribute scheme { data.pointer }?,
  empty
revisionDesc =
  
  ## (revision description) summarizes the revision history for a file.
  element revisionDesc { revisionDesc.content, revisionDesc.attributes }
revisionDesc.content = \list | change+
revisionDesc.attributes =
  att.global.attribute.id,
  att.global.attribute.rend,
  att.global.attribute.n,
  empty
change =
  
  ## summarizes a particular change or correction made
  ## to a particular version of an electronic text which is
  ## shared between several researchers.
  element change { change.content, change.attributes }
change.content = macro.specialPara
change.attributes =
  att.global.attribute.id,
  att.global.attribute.rend,
  att.global.attribute.n,
  att.ascribed.attribute.who,
  
  ## supplies the date of the change in standard form,  i.e. yyyy-mm-dd.
  attribute date { data.temporal }?,
  empty
model.headerPart = encodingDesc | profileDesc
model.sourceDescPart = scriptStmt | recordingStmt
model.encodingPart =
  projectDesc
  | samplingDecl
  | editorialDecl
  | tagsDecl
  | refsDecl
  | classDecl
  | fsdDecl
  | metDecl
  | variantEncoding
model.editorialDeclPart =
  correction
  | normalization
  | quotation
  | hyphenation
  | segmentation
  | stdVals
  | interpretation
model.profileDescPart = langUsage | textClass
TEI =
  
  ## (TEI document) contains a single TEI-conformant document,
  ## comprising a TEI header and a text, either in isolation or as part of a
  ## teiCorpus element.
  element TEI.2 { TEI.content, TEI.attributes }
TEI.content = teiHeader, \text
TEI.attributes =
  
  ## The version of the TEI scheme
  [ a:defaultValue = "5.0" ] attribute version { xsd:decimal }?,
  att.global.attribute.id,
  att.global.attribute.rend,
  att.global.attribute.n,
  empty
\text =
  
  ## contains a single text of any kind, whether unitary or
  ## composite, for example a poem or drama, a collection of essays, a novel,
  ## a dictionary, or a corpus sample.
  element text { text.content, text.attributes }
text.content =
  model.global*,
  (front, model.global*)?,
  (body),
  model.global*,
  (back, model.global*)?
text.attributes =
  att.global.attribute.id,
  att.global.attribute.rend,
  att.global.attribute.n,
  att.declaring.attribute.decls,
  empty
body =
  
  ## (text body) contains the whole body of a single unitary text, excluding any front or back matter.
  element body { body.content, body.attributes }
body.content =
  model.divWrapper*,
  macro.component*,
  (\div | divGen)*,
  model.divWrapper.bottom*
body.attributes =
  att.global.attribute.id,
  att.global.attribute.rend,
  att.global.attribute.n,
  att.declaring.attribute.decls,
  empty
\div =
  
  ## (text division) contains a subdivision of the front, body, or back of a
  ## text.
  element div { div.content, div.attributes }
div.content =
  (model.divWrapper | model.global)*,
  ((\div | divGen)+
   | ((macro.component, model.global?)+, (\div | divGen)*)),
  (model.divWrapper | model.divWrapper.bottom)*
div.attributes =
  att.global.attribute.id,
  att.global.attribute.rend,
  att.global.attribute.n,
  att.divLike.attribute.type,
  att.divLike.attribute.org,
  att.divLike.attribute.sample,
  att.divLike.attribute.part,
  att.declaring.attribute.decls,
  empty
trailer =
  
  ## (trailer) contains a closing title or footer appearing at the end of
  ## a division of a text. 
  element trailer { trailer.content, trailer.attributes }
trailer.content = macro.phraseSeq
trailer.attributes =
  att.global.attribute.id,
  att.global.attribute.rend,
  att.global.attribute.n,
  empty
titlePage =
  
  ## (title page) contains the title page of a text, appearing within the front
  ## or back matter. 
  element titlePage { titlePage.content, titlePage.attributes }
titlePage.content =
  model.global*,
  model.titlepagePart,
  (model.titlepagePart | model.global)*
titlePage.attributes =
  att.global.attribute.id,
  att.global.attribute.rend,
  att.global.attribute.n,
  
  ## classifies the title page according to any convenient typology.
  attribute type { data.enumerated }?,
  empty
docTitle =
  
  ## (document title) contains the title of a document, including all its
  ## constituents, as given on a title page.
  element docTitle { docTitle.content, docTitle.attributes }
docTitle.content = model.global*, (titlePart, model.global*)+
docTitle.attributes =
  att.global.attribute.id,
  att.global.attribute.rend,
  att.global.attribute.n,
  empty
titlePart =
  
  ## (title part) contains a subsection or division of the title of a work, as
  ## indicated on a title page.
  element titlePart { titlePart.content, titlePart.attributes }
titlePart.content = macro.paraContent
titlePart.attributes =
  att.global.attribute.id,
  att.global.attribute.rend,
  att.global.attribute.n,
  
  ## specifies the role of this subdivision of the title.
  [ a:defaultValue = "main" ] attribute type { data.enumerated }?,
  empty
docAuthor =
  
  ## (document author) contains the name of the author of the document, as given on the
  ## title page (often but not always contained in a byline).
  element docAuthor { docAuthor.content, docAuthor.attributes }
docAuthor.content = macro.phraseSeq
docAuthor.attributes =
  att.global.attribute.id,
  att.global.attribute.rend,
  att.global.attribute.n,
  empty
docEdition =
  
  ## (document edition) contains an edition statement as presented on a title page of a
  ## document.
  element docEdition { docEdition.content, docEdition.attributes }
docEdition.content = macro.paraContent
docEdition.attributes =
  att.global.attribute.id,
  att.global.attribute.rend,
  att.global.attribute.n,
  empty
docImprint =
  
  ## (document imprint) contains the imprint statement (place and date of publication,
  ## publisher name), as given
  ## (usually) at the foot of a title page.
  element docImprint { docImprint.content, docImprint.attributes }
docImprint.content =
  (text
   | model.gLike
   | model.phrase
   | pubPlace
   | docDate
   | publisher
   | model.global)*
docImprint.attributes =
  att.global.attribute.id,
  att.global.attribute.rend,
  att.global.attribute.n,
  empty
docDate =
  
  ## (document date) contains the date of a document, as given
  ## (usually) on a title page.
  element docDate { docDate.content, docDate.attributes }
docDate.content = macro.phraseSeq
docDate.attributes =
  att.global.attribute.id,
  att.global.attribute.rend,
  att.global.attribute.n,
  
  ## gives the value of the date in a standard form.
  attribute value { data.temporal }?,
  empty
front =
  
  ## (front matter) contains any prefatory matter (headers,
  ## title page, prefaces, dedications, etc.)
  ## found  at the start of a document, before the main body.
  element front { front.content, front.attributes }
front.content = model.pLike.front*, titlePage*, macro.component*, \div*
front.attributes =
  att.global.attribute.id,
  att.global.attribute.rend,
  att.global.attribute.n,
  att.declaring.attribute.decls,
  empty
back =
  
  ## (back matter) contains any appendixes, etc. following the main part of a
  ## text.
  element back { back.content, back.attributes }
back.content = macro.component*, \div*, (trailer)*
back.attributes =
  att.global.attribute.id,
  att.global.attribute.rend,
  att.global.attribute.n,
  att.declaring.attribute.decls,
  empty
ab =
  
  ## (anonymous block) contains any arbitrary component-level unit of text, acting as
  ## an anonymous container for phrase or inter level elements analogous to, but
  ## without the semantic baggage of, a paragraph.
  element ab { ab.content, ab.attributes }
ab.content = macro.specialPara
ab.attributes =
  
  ## specifies whether or not the block is complete. 
  [ a:defaultValue = "N" ]
  attribute part {
    
    ## (the block is incomplete) 
    "Y"
    | 
      ## (either the block is complete, or no claim is made as to its
      ## completeness) 
      "N"
    | 
      ## (the initial part of an incomplete block) 
      "I"
    | 
      ## (a medial part of an incomplete block) 
      "M"
    | 
      ## (the final part of an incomplete block) 
      "F"
  }?,
  att.global.attribute.id,
  att.global.attribute.rend,
  att.global.attribute.n,
  att.typed.attribute.type,
  att.typed.attribute.subtype,
  empty
anchor =
  
  ## (anchor point) attaches an identifier to a
  ## point within a text, whether or not it corresponds with a textual
  ## element.
  element anchor { anchor.content, anchor.attributes }
anchor.content = empty
anchor.attributes =
  att.global.attribute.id,
  att.global.attribute.rend,
  att.global.attribute.n,
  att.typed.attribute.type,
  att.typed.attribute.subtype,
  empty
att.global.linking.attributes = notAllowed
att.pointing.attributes =
  att.pointing.attribute.type, att.pointing.attribute.evaluate
att.pointing.attribute.type =
  
  ## categorizes the pointer in some respect, using any
  ##       convenient set of categories.
  attribute type { data.word }?
att.pointing.attribute.evaluate =
  
  ## specifies the intended meaning when the target of a
  ##       pointer is itself a pointer.
  attribute evaluate {
    
    ## (if the element pointed to is itself a pointer, then
    ##	  the target of that pointer will be taken, and so on, until
    ##	  an element is found which is not a pointer.) 
    "all"
    | 
      ## (if the element pointed to is itself a pointer, then
      ##	  its target (whether a pointer or not) is taken as the target
      ##	  of this pointer.) 
      "one"
    | 
      ## (no further evaluation of targets is carried out
      ##	  beyond that needed to find the element specified in the
      ##	  pointer's target.) 
      "none"
  }?
att.pointing.group.attributes =
  att.pointing.group.attribute.domains,
  att.pointing.group.attribute.targFunc
att.pointing.group.attribute.domains =
  
  ## optionally specifies the identifiers of the elements
  ##       within which all elements indicated by the contents of this
  ##       element lie.
  attribute domains {
    list { data.name, data.name+ }
  }?
att.pointing.group.attribute.targFunc =
  
  ## describes the function of each of the values of the
  ##       targets attribute of the enclosed link,
  ##       join or alt tags.
  attribute targFunc {
    list { data.word, data.word+ }
  }?
table =
  
  ## contains text displayed in tabular form, in
  ## rows and columns.
  element table { table.content, table.attributes }
table.content = (head | model.global)*, (row, model.global*)+
table.attributes =
  
  ##
  attribute align { text }?,
  
  ##
  attribute summary { text }?,
  
  ##
  attribute width { text }?,
  
  ##
  attribute border { text }?,
  
  ##
  attribute frame { text }?,
  
  ##
  attribute rules { text }?,
  
  ##
  attribute cellspacing { text }?,
  
  ##
  attribute cellpadding { text }?,
  
  ## indicates the number of rows in the table.
  attribute rows { data.count }?,
  
  ## indicates the number of columns in each row of the table.
  attribute cols { data.count }?,
  att.global.attribute.id,
  att.global.attribute.rend,
  att.global.attribute.n,
  empty
row =
  
  ## contains one row of a table. 
  element row { row.content, row.attributes }
row.content = ((cell | table), model.global*)+
row.attributes =
  att.global.attribute.id,
  att.global.attribute.rend,
  att.global.attribute.n,
  
  ## indicates the kind of information held in the cells of this row.
  [ a:defaultValue = "data" ] attribute role { data.enumerated }?,
  empty
cell =
  
  ## contains one cell of a table. 
  element cell { cell.content, cell.attributes }
cell.content = macro.paraContent
cell.attributes =
  
  ##
  attribute align { text }?,
  
  ## indicates the kind of information held in the cell.
  [ a:defaultValue = "data" ] attribute role { data.enumerated }?,
  
  ## indicates the number of rows occupied by this cell.
  [ a:defaultValue = "1" ] attribute rows { data.count }?,
  
  ## indicates the number of columns occupied by this cell.
  [ a:defaultValue = "1" ] attribute cols { data.count }?,
  att.global.attribute.id,
  att.global.attribute.rend,
  att.global.attribute.n,
  empty
figure =
  
  ## contains a block containing graphics, illustrations, or figures.
  element figure { figure.content, figure.attributes }
figure.content =
  (model.pLike
   | model.global
   | figure
   | figDesc
   | graphic
   | binaryObject
   | head)*
figure.attributes =
  att.global.attribute.id,
  att.global.attribute.rend,
  att.global.attribute.n,
  empty
figDesc =
  
  ## (Description of Figure) contains a brief prose description of the appearance or content
  ## of a graphic figure, for use when documenting an image without
  ## displaying it.
  element figDesc { figDesc.content, figDesc.attributes }
figDesc.content = macro.paraContent
figDesc.attributes =
  att.global.attribute.id,
  att.global.attribute.rend,
  att.global.attribute.n,
  empty
Button =
  
  ##
  element Button { Button.content, Button.attributes }
Button.content = macro.paraContent
Button.attributes =
  att.global.attribute.id,
  att.global.attribute.rend,
  att.global.attribute.n,
  empty
Code =
  
  ##
  element Code { Code.content, Code.attributes }
Code.content = text
Code.attributes =
  att.global.attribute.id,
  att.global.attribute.rend,
  att.global.attribute.n,
  empty
Command =
  
  ##
  element Command { Command.content, Command.attributes }
Command.content = text
Command.attributes =
  att.global.attribute.id,
  att.global.attribute.rend,
  att.global.attribute.n,
  empty
Exercise =
  
  ##
  element Exercise { Exercise.content, Exercise.attributes }
Exercise.content = text
Exercise.attributes =
  att.global.attribute.id,
  att.global.attribute.rend,
  att.global.attribute.n,
  empty
Field =
  
  ##
  element Field { Field.content, Field.attributes }
Field.content = text
Field.attributes =
  att.global.attribute.id,
  att.global.attribute.rend,
  att.global.attribute.n,
  empty
Filespec =
  
  ##
  element Filespec { Filespec.content, Filespec.attributes }
Filespec.content = text
Filespec.attributes =
  att.global.attribute.id,
  att.global.attribute.rend,
  att.global.attribute.n,
  empty
Icon =
  
  ##
  element Icon { Icon.content, Icon.attributes }
Icon.content = text
Icon.attributes =
  att.global.attribute.id,
  att.global.attribute.rend,
  att.global.attribute.n,
  empty
Input =
  
  ##
  element Input { Input.content, Input.attributes }
Input.content = text
Input.attributes =
  att.global.attribute.id,
  att.global.attribute.rend,
  att.global.attribute.n,
  empty
Keyword =
  
  ##
  element Keyword { Keyword.content, Keyword.attributes }
Keyword.content = text
Keyword.attributes =
  att.global.attribute.id,
  att.global.attribute.rend,
  att.global.attribute.n,
  empty
Key =
  
  ##
  element Key { Key.content, Key.attributes }
Key.content = text
Key.attributes =
  att.global.attribute.id,
  att.global.attribute.rend,
  att.global.attribute.n,
  empty
Label =
  
  ##
  element Label { Label.content, Label.attributes }
Label.content = text
Label.attributes =
  att.global.attribute.id,
  att.global.attribute.rend,
  att.global.attribute.n,
  empty
Link =
  
  ##
  element Link { Link.content, Link.attributes }
Link.content = text
Link.attributes =
  att.global.attribute.id,
  att.global.attribute.rend,
  att.global.attribute.n,
  empty
Menu =
  
  ##
  element Menu { Menu.content, Menu.attributes }
Menu.content = text
Menu.attributes =
  att.global.attribute.id,
  att.global.attribute.rend,
  att.global.attribute.n,
  empty
Name =
  
  ##
  element Name { Name.content, Name.attributes }
Name.content = text
Name.attributes =
  att.global.attribute.id,
  att.global.attribute.rend,
  att.global.attribute.n,
  empty
Output =
  
  ##
  element Output { Output.content, Output.attributes }
Output.content = text
Output.attributes =
  att.global.attribute.id,
  att.global.attribute.rend,
  att.global.attribute.n,
  empty
Program =
  
  ##
  element Program { Program.content, Program.attributes }
Program.content = text
Program.attributes =
  att.global.attribute.id,
  att.global.attribute.rend,
  att.global.attribute.n,
  empty
Prompt =
  
  ##
  element Prompt { Prompt.content, Prompt.attributes }
Prompt.content = text
Prompt.attributes =
  att.global.attribute.id,
  att.global.attribute.rend,
  att.global.attribute.n,
  empty
Screen =
  
  ##
  element Screen { Screen.content, Screen.attributes }
Screen.content = text
Screen.attributes =
  att.global.attribute.id,
  att.global.attribute.rend,
  att.global.attribute.n,
  empty
Software =
  
  ##
  element Software { Software.content, Software.attributes }
Software.content = text
Software.attributes =
  att.global.attribute.id,
  att.global.attribute.rend,
  att.global.attribute.n,
  empty
Value =
  
  ##
  element Value { Value.content, Value.attributes }
Value.content = text
Value.attributes =
  att.global.attribute.id,
  att.global.attribute.rend,
  att.global.attribute.n,
  empty
email =
  
  ##
  element email { email.content, email.attributes }
email.content = text
email.attributes =
  att.global.attribute.id,
  att.global.attribute.rend,
  att.global.attribute.n,
  empty
xptr =
  
  ##
  element xptr { xptr.content, xptr.attributes }
xptr.content = empty
xptr.attributes =
  att.global.attribute.id,
  att.global.attribute.rend,
  att.global.attribute.n,
  att.pointing.attribute.type,
  att.pointing.attribute.evaluate,
  att.declaring.attribute.decls,
  
  ##
  attribute url { xsd:anyURI }?,
  
  ##
  attribute doc { xsd:ENTITY }?,
  empty
xref =
  
  ##
  element xref { xref.content, xref.attributes }
xref.content = macro.paraContent
xref.attributes =
  att.global.attribute.id,
  att.global.attribute.rend,
  att.global.attribute.n,
  att.pointing.attribute.type,
  att.pointing.attribute.evaluate,
  att.declaring.attribute.decls,
  
  ##
  attribute url { xsd:anyURI }?,
  
  ##
  attribute doc { xsd:ENTITY }?,
  empty
start = TEI
