TEI for writing ODDs

anyISOSchematron =
   element sch:* { ( attribute * { text } | anyISOSchematron | text )* }

anySchematron =
   element d1176e4a3528:* { ( attribute * { text } | anySchematron | text )* }

macro.anyXML =
   element 
                     * - (d31e1:* | d1191e7a3528:egXML)
   {
      attribute * { text }*,
      ( text | macro.anyXML )*
   }

macro.limitedContent = ( text | model.limitedPhrase | model.inter )*

macro.paraContent =
   ( text | model.gLike | model.phrase | model.inter | model.global )*

macro.phraseSeq = ( text | model.gLike | model.phrase | model.global )*

macro.phraseSeq.limited = ( text | model.limitedPhrase | model.global )*

macro.schemaPattern = text | ( pattern | define )+

macro.specialPara =
   (
      text
    | model.gLike
    | model.phrase
    | model.inter
    | model.divPart
    | model.global
   )*

macro.xtext = ( text | model.gLike )*

                     element 
                     TEI
{
   att.global.attributes,
   attribute version { token { pattern = "[\d]+(\.[\d]+){0,2}" } }?,
   ( teiHeader, ( ( model.resourceLike+, text? ) | text ) )
}

                     element 
                     abbr
{
   att.global.attributes,
   att.responsibility.attributes,
   attribute type { xsd:Name }?,
   macro.phraseSeq
}

element addrLine { att.global.attributes, macro.phraseSeq }

                     element 
                     address
{
   att.global.attributes,
   ( model.global*, ( ( model.addrPart ), model.global* )+ )
}

element altIdent { att.global.attributes, att.typed.attributes, macro.xtext }

element att { att.global.attributes, attribute scheme { xsd:Name }?, text }

                     element 
                     attDef
{
   att.global.attributes,
   att.identified.attributes,
   attribute usage { "req" | "mwa" | "rec" | "rwa" | "opt" }?,
   attribute ns { xsd:anyURI }?,
   (
      model.glossLike*,
      datatype?,
      constraintSpec*,
      defaultVal?,
      ( valList | valDesc+ )?,
      exemplum*,
      remarks*
   )
}

                     element 
                     attList
{
   att.global.attributes,
   attribute org { "group" | "choice" }?,
   ( attRef | attDef | attList )+
}

                     element 
                     attRef
{
   att.global.attributes,
   attribute name { token { pattern = "(\p{L}|\p{N}|\p{P}|\p{S})+" } },
   empty
}

                     element 
                     author
{
   att.global.attributes,
   att.naming.attributes,
   macro.phraseSeq
}

element authority { att.global.attributes, macro.phraseSeq.limited }

                     element 
                     availability
{
   att.global.attributes,
   att.declarable.attributes,
   attribute status { "free" | "unknown" | "restricted" }?,
   model.pLike+
}

                     element 
                     back
{
   att.global.attributes,
   att.declaring.attributes,
   (
      ( model.frontPart | model.pLike.front | model.global )*,
      (
         (
            (
               ( model.div1Like ),
               ( model.frontPart | model.div1Like | model.global )*
            )
          | (
               ( model.divLike ),
               ( model.frontPart | model.divLike | model.global )*
            )
         )?
      ),
      ( ( ( model.divBottomPart ), ( model.divBottomPart | model.global )* )? )
   )
}

                     element 
                     bibl
{
   att.global.attributes,
   att.declarable.attributes,
   att.typed.attributes,
   (
      text
    | model.gLike
    | model.highlighted
    | model.pPart.data
    | model.pPart.edit
    | model.segLike
    | model.ptrLike
    | model.biblPart
    | model.global
   )*
}

                     element 
                     biblFull
{
   att.global.attributes,
   att.declarable.attributes,
   (
      (
         titleStmt,
         editionStmt?,
         extent?,
         publicationStmt,
         seriesStmt?,
         notesStmt?
      ),
      sourceDesc*
   )
}

                     element 
                     biblScope
{
   att.global.attributes,
   attribute 
                     type
   {
      "vol" | "issue" | "pp" | "ll" | "chap" | "part" | xsd:Name
   }?,
   attribute from { token { pattern = "(\p{L}|\p{N}|\p{P}|\p{S})+" } }?,
   attribute to { token { pattern = "(\p{L}|\p{N}|\p{P}|\p{S})+" } }?,
   macro.phraseSeq
}

                     element 
                     body
{
   att.global.attributes,
   att.declaring.attributes,
   (
      model.global*,
      ( ( model.divTop ), ( model.global | model.divTop )* )?,
      ( ( model.divGenLike ), ( model.global | model.divGenLike )* )?,
      (
         ( ( model.divLike ), ( model.global | model.divGenLike )* )+
       | ( ( model.div1Like ), ( model.global | model.divGenLike )* )+
       | (
            ( ( model.common ), model.global* )+,
            (
               ( ( model.divLike ), ( model.global | model.divGenLike )* )+
             | ( ( model.div1Like ), ( model.global | model.divGenLike )* )+
            )?
         )
      ),
      ( ( model.divBottom ), model.global* )*
   )
}

                     element 
                     cell
{
   att.global.attributes,
   att.tableDecoration.attributes,
   macro.paraContent
}

                     element 
                     change
{
   att.global.attributes,
   att.ascribed.attributes,
   att.datable.attributes,
   att.docStatus.attributes,
   ( text | model.limitedPhrase | model.inter | model.global )*
}

element choice { att.global.attributes, ( model.choicePart | choice )* }

An American encoding of Gulliver's Travels which retains the British spelling but also provides a version regularized to American spelling might be encoded as follows.

                     element 
                     cit
{
   att.global.attributes,
   att.typed.attributes,
   (
      model.qLike
    | model.egLike
    | model.biblLike
    | model.ptrLike
    | model.global
    | model.entryPart
   )+
}

                     element 
                     classRef
{
   att.global.attributes,
   att.readFrom.attributes,
   attribute key { xsd:NCName },
   empty
}

                     element 
                     classSpec
{
   att.global.attributes,
   att.identified.attributes,
   attribute type { "model" | "atts" },
   attribute 
                     generate
   {
      list
      {
         (
            "alternation"
          | "sequence"
          | "sequenceOptional"
          | "sequenceOptionalRepeatable"
          | "sequenceRepeatable"
         ),
         (
            "alternation"
          | "sequence"
          | "sequenceOptional"
          | "sequenceOptionalRepeatable"
          | "sequenceRepeatable"
         )?,
         (
            "alternation"
          | "sequence"
          | "sequenceOptional"
          | "sequenceOptionalRepeatable"
          | "sequenceRepeatable"
         )?,
         (
            "alternation"
          | "sequence"
          | "sequenceOptional"
          | "sequenceOptionalRepeatable"
          | "sequenceRepeatable"
         )?,
         (
            "alternation"
          | "sequence"
          | "sequenceOptional"
          | "sequenceOptionalRepeatable"
          | "sequenceRepeatable"
         )?
      }
   }?,
   (
      model.glossLike*,
      classes?,
      constraintSpec*,
      attList?,
      exemplum*,
      remarks*,
      listRef*
   )
}

                     element 
                     classes
{
   att.global.attributes,
   attribute mode { "change" | "replace" }?,
   ( memberOf* )
}

This classes element indicates that the element documented (which may be an element or a class) is a member of two distinct classes: model.qLike and att.declarable.

                     element 
                     code
{
   att.global.attributes,
   attribute lang { token { pattern = "(\p{L}|\p{N}|\p{P}|\p{S})+" } }?,
   text
}

                     element 
                     constraint
{
   att.global.attributes,
   ( anySchematron | anyISOSchematron )*
}

                     element 
                     constraintSpec
{
   att.global.attributes,
   att.identified.attributes,
   att.typed.attributes,
   attribute scheme { "schematron" | "isoschematron" | "xsl" | "private" },
   model.glossLike*,
   constraint?
}

This constraint uses Schematron to enforce the presence of the spanTo attribute (which comes from an attribute class) on the <addSpan> element:

This constraint uses a language which is not expressed in XML to check whether the title and author are identical:

                     element 
                     content
{
   att.global.attributes,
   attribute autoPrefix { "true" | "false" }?,
   macro.schemaPattern*
}

This content model allows either a sequence of paragraphs or a series of msItem elements optionally preceded by a summary:

                     element 
                     datatype
{
   att.global.attributes,
   attribute minOccurs { xsd:nonNegativeInteger }?,
   attribute maxOccurs { xsd:nonNegativeInteger | "unbounded" }?,
   macro.schemaPattern*
}

The encoding in the following example requires that the attribute being defined contain at least two URIs in its value, as is the case for the targets attribute of <join>.

                     element 
                     date
{
   att.global.attributes,
   att.datable.attributes,
   att.editLike.attributes,
   att.typed.attributes,
   attribute 
                     calendar
   {
      "Gregorian"
    | "Julian"
    | "Islamic"
    | "Hebrew"
    | "Revolutionary"
    | "Iranian"
    | "Coptic"
    | "Chinese"
    | xsd:Name
   }?,
   ( text | model.gLike | model.phrase | model.global )*
}

element defaultVal { att.global.attributes, text }