tei_minimal.rnc.svn-base

XML Copy Editor is free software released under the GNU General Public License. It is available in C

default namespace = "http://www.tei-c.org/ns/1.0"
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"
namespace xlink = "http://www.w3.org/1999/xlink"

# Schema generated from ODD source 2006-09-24T05:42:38+01:00.

#
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 = div0, (div0 | divGen | model.global)*
macro.bodyPart.div1 = div1, (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)
macro.component = model.common
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, empty
att.ascribed.attribute.who =
  
  ## indicates the person, or group of
  ##	people, to whom the element content is ascribed.
  attribute who { data.pointers }?
att.authorialIntervention.attributes =
  att.authorialIntervention.attribute.hand,
  att.authorialIntervention.attribute.status,
  att.authorialIntervention.attribute.type,
  empty
att.authorialIntervention.attribute.hand =
  
  ## signifies the hand of the agent which made the addition or
  ##       performed the deletion.
  attribute hand { data.pointer }?
att.authorialIntervention.attribute.status =
  
  ## may be used to indicate faulty deletions, e.g. strikeouts
  ##       which include too much or too little text, or erroneous
  ##       additions, e.g., an insertion which duplicates some of the text
  ##       already present.
  [ a:defaultValue = "unremarkable" ]
  attribute status { data.enumerated }?
att.authorialIntervention.attribute.type =
  
  ## classifies the type of addition or deletion using any convenient typology.
  attribute type { data.enumerated }?
att.datable.attributes =
  att.datable.attribute.notBefore, att.datable.attribute.notAfter, empty
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.datePart.attributes =
  att.datePart.attribute.value,
  att.datePart.attribute.type,
  att.datePart.attribute.full,
  empty
att.datePart.attribute.value =
  
  ## supplies the value of a date or time in a standard form.
  attribute value { data.temporal | data.duration }?
att.datePart.attribute.type =
  
  ## characterizes the element in some sense, using any convenient
  ##  classification scheme or typology.
  attribute type { data.word }?
att.datePart.attribute.full =
  
  ## indicates whether the date element is given in full, as
  ##		an abbreviation or simply as an initial
  [ a:defaultValue = "yes" ]
  attribute full {
    
    ## (the temporal expression is spelled out in full.) 
    "yes"
    | 
      ## (the temporal expression is given in an abbreviated form.) 
      "abb"
    | 
      ## (the temporal expression is abbreviated using the initial characters.) 
      "init"
  }?
att.declarable.attributes = att.declarable.attribute.default, empty
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, empty
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,
  empty
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,
  empty
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,
  empty
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.xmlspace,
  att.global.attribute.xmlid,
  att.global.attribute.n,
  att.global.attribute.xmllang,
  att.global.attribute.rend,
  att.global.attribute.xmlbase,
  empty
att.global.attribute.xmlspace =
  
  ## signals an intention that white space should be 
  ##       preserved by applications
  attribute xml:space {
    
    ##
    "default"
    | 
      ##
      "preserve"
  }?
att.global.attribute.xmlid =
  
  ## provides a unique identifier for the element bearing the
  ##       attribute.
  attribute xml:id { xsd:ID }?
att.global.attribute.n =
  
  ## gives a number (or other label) for an element, which is
  ##       not necessarily unique within the document.
  attribute n { data.words }?
att.global.attribute.xmllang =
  
  ## indicates the language of the element content using the
  ##       codes from RFC
  ##       3066
  attribute xml:lang { data.language }?
att.global.attribute.rend =
  
  ## indicates how the element in question was rendered or
  ##	presented in the source text.
  attribute rend { data.words }?
att.global.attribute.xmlbase =
  
  ## provides a base URI reference with which applications can
  ##       resolve relative URI references into absolute URI
  ##       references.
  attribute xml:base { data.pointer }?
att.measured.attributes =
  att.measured.attribute.unit, att.measured.attribute.scope, empty
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,
  empty
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, empty
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.code }?
att.placement.attributes = att.placement.attribute.place, empty
att.placement.attribute.place =
  
  ##
  attribute place { data.enumerated }?
att.segLike.attributes =
  att.segLike.attribute.type,
  att.segLike.attribute.function,
  att.segLike.attribute.part,
  empty
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, empty
att.spanning.attribute.spanTo =
  
  ## indicates the end of a span initiated by the element
  ##	bearing this attribute.
  attribute spanTo { data.pointer }?
att.tableDecoration.attributes =
  att.tableDecoration.attribute.role,
  att.tableDecoration.attribute.rows,
  att.tableDecoration.attribute.cols,