XML Schema Documentation

Table of Contents

top

Schema Document Properties

Target Namespace None
Element and Attribute Namespaces
  • Global element and attribute declarations belong to this schema's target namespace.
  • By default, local element declarations belong to this schema's target namespace.
  • By default, local attribute declarations have no namespace.

Declared Namespaces

Prefix Namespace
xml http://www.w3.org/XML/1998/namespace
xs http://www.w3.org/2001/XMLSchema
Schema Component Representation
<xs:schema elementFormDefault="qualified">
...
</xs:schema>
top

Global Declarations

Element: before

Name before
Type Locally-defined complex type
Nillable no
Abstract no
Documentation Indicates that a particular phonetic change must occur before another one. The change that must come after is specified by the word reference (@l + @v).
XML Instance Representation
<before
l="language-type [1]"
v="anySimpleType [1]">
<!-- Mixed content -->
<order-example> ... </order-example> [0..*]
</before>
Schema Component Representation
<xs:element name="before">
<xs:complexType mixed="true">
<xs:sequence>
<xs:element ref="order-example" minOccurs="0" maxOccurs="unbounded"/>
</xs:sequence>
<xs:attribute name="l" type="language-type" use="required"/>
<xs:attribute name="v" use="required"/>
</xs:complexType>
</xs:element>
top

Element: cat

Name cat
Type Locally-defined complex type
Nillable no
Abstract no
Documentation A semantic category, specified by its @id. An individual word element can be linked to a semantic category by its @cat attribute.
XML Instance Representation
<cat
id="xs:NMTOKEN [1]"
label="anySimpleType [1]"
num="xs:NMTOKEN [1]"/>
Schema Component Representation
<xs:element name="cat">
<xs:complexType>
<xs:attribute name="id" type="xs:NMTOKEN" use="required"/>
<xs:attribute name="label" use="required"/>
<xs:attribute name="num" type="xs:NMTOKEN" use="required"/>
</xs:complexType>
</xs:element>
top

Element: cat-group

Name cat-group
Type Locally-defined complex type
Nillable no
Abstract no
Documentation A group of semantic categories, for organization purposes.
XML Instance Representation
<cat-group
id="xs:ID [1]"
label="anySimpleType [1]"
num="xs:NMTOKEN [1]">
<cat> ... </cat> [1..*]
</cat-group>
Schema Component Representation
<xs:element name="cat-group">
<xs:complexType>
<xs:sequence>
<xs:element ref="cat" maxOccurs="unbounded"/>
</xs:sequence>
<xs:attribute name="id" type="xs:ID" use="required"/>
<xs:attribute name="label" use="required"/>
<xs:attribute name="num" type="xs:NMTOKEN" use="required"/>
</xs:complexType>
</xs:element>
top

Element: cats

Name cats
Type Locally-defined complex type
Nillable no
Abstract no
Documentation Parent element of all semantic categories.
XML Instance Representation
<cats>
<cat-group> ... </cat-group> [1..*]
</cats>
Schema Component Representation
<xs:element name="cats">
<xs:complexType>
<xs:sequence>
<xs:element ref="cat-group" maxOccurs="unbounded"/>
</xs:sequence>
</xs:complexType>
</xs:element>
top

Element: change

Name change
Type Locally-defined complex type
Nillable no
Abstract no
Documentation Indicate a change on the part of Tolkien from one form to another. The new form is linked by the source reference (@source). Intermediate forms may be indicated by @i1 attributes.
XML Instance Representation
<change
i1="xs:NMTOKEN [0..1]"
source="anySimpleType [1]"
v="anySimpleType [1]"/>
Schema Component Representation
<xs:element name="change">
<xs:complexType mixed="true">
<xs:attribute name="i1" type="xs:NMTOKEN"/>
<xs:attribute name="source" use="required"/>
<xs:attribute name="v" use="required"/>
</xs:complexType>
</xs:element>
top

Element: cite

Name cite
Type xs:string
Nillable no
Abstract no
Documentation Bibliographical citation for a specific reference.
XML Instance Representation
<cite> xs:string </cite>
Schema Component Representation
<xs:element name="cite" type="xs:string"/>
top

Element: class

Name class
Type Locally-defined complex type
Nillable no
Abstract no
Documentation Syntactical class for a word, such as a strong versus weak verb. The @form attribute specifies one or more space-delimited classes. The optional @variant attribute has special variations.
XML Instance Representation
<class
form="anySimpleType [1]"
variant="xs:token (value comes from list: { 'common' | 'feminine' | 'masculine' }) [0..1]"/>
Schema Component Representation
<xs:element name="class">
<xs:complexType>
<xs:attribute name="form" use="required"/>
<xs:attribute name="variant">
<xs:simpleType>
<xs:restriction base="xs:token">
<xs:enumeration value="common"/>
<xs:enumeration value="feminine"/>
<xs:enumeration value="masculine"/>
</xs:restriction>
</xs:simpleType>
</xs:attribute>
</xs:complexType>
</xs:element>
top

Element: cognate

Name cognate
Type Locally-defined complex type
Nillable no
Abstract no
Documentation Link to a cognate in another language. As a child of a word element, uses a word reference (@l + @v); as a child of a ref element, uses a source reference (@source).
XML Instance Representation
<cognate
l="language-type [0..1]"
mark="anySimpleType [0..1]"
source="anySimpleType [0..1]"
v="anySimpleType [1]"/>
Schema Component Representation
<xs:element name="cognate">
<xs:complexType mixed="true">
<xs:attribute name="l" type="language-type"/>
<xs:attribute name="mark"/>
<xs:attribute name="source"/>
<xs:attribute name="v" use="required"/>
</xs:complexType>
</xs:element>
top

Element: correction

Name correction
Type Locally-defined complex type
Nillable no
Abstract no
Documentation An editorial correction of an earlier published form. Uses a source reference (@source). Note that the reference value (ref/@v) of the correction reference is the original (uncorrected) form, while the reference value (ref/@v) of the linked/corrected reference is the corrected form. This is to ensure that the corrected form will appear in the relationship of its original references.
XML Instance Representation
<correction
source="anySimpleType [1]"
v="anySimpleType [1]"/>
Schema Component Representation
<xs:element name="correction">
<xs:complexType mixed="true">
<xs:attribute name="source" use="required"/>
<xs:attribute name="v" use="required"/>
</xs:complexType>
</xs:element>
top

Element: deriv

Name deriv
Type Locally-defined complex type
Nillable no
Abstract no
Documentation Indicates this form is derived etymologically from the linked form. As a child of a word element, uses a word reference (@l + @v); as a child of a ref element, uses a source reference (@source). Intermediate forms may be indicated by @i1, @i2 and @i3 attributes, in that chronological order (past to future). @@@ In the final form of the data model, a deriv element should be unique with a word/ref element, but there are some unfinished data corrections preventing enforcement of this rule. These unfinished data elements are indicated by @t="m" attribute values, which will be removed after the data is cleaned up.
XML Instance Representation
<deriv
form="xs:NMTOKEN [0..1]"
i1="anySimpleType [0..1]"
i2="anySimpleType [0..1]"
i3="anySimpleType [0..1]"
l="language-type [0..1]"
mark="anySimpleType [0..1]"
source="anySimpleType [0..1]"
t="xs:token (value comes from list: { 'm' }) [0..1]"
v="anySimpleType [1]">
<!-- Mixed content -->
Start Choice [0..*]
<rule-example> ... </rule-example> [1]
<rule-start> ... </rule-start> [1]
End Choice
</deriv>
Schema Component Representation
<xs:element name="deriv">
<xs:complexType mixed="true">
<xs:choice minOccurs="0" maxOccurs="unbounded">
<xs:element ref="rule-example"/>
<xs:element ref="rule-start"/>
</xs:choice>
<xs:attribute name="form" type="xs:NMTOKEN"/>
<xs:attribute name="i1"/>
<xs:attribute name="i2"/>
<xs:attribute name="i3"/>
<xs:attribute name="l" type="language-type"/>
<xs:attribute name="mark"/>
<xs:attribute name="source"/>
<xs:attribute name="t">
<xs:simpleType>
<xs:restriction base="xs:token">
<xs:enumeration value="m"/>
</xs:restriction>
</xs:simpleType>
</xs:attribute>
<xs:attribute name="v" use="required"/>
</xs:complexType>
</xs:element>
top

Element: derivatives

Name derivatives
Type Locally-defined complex type
Nillable no
Abstract no
Documentation An element controlling how derivative are displayed in the page for this word. If @no-root="true", the derivation trees of child roots are not expanded.
XML Instance Representation
<derivatives
no-roots="xs:NMTOKEN [1]"/>
Schema Component Representation
<xs:element name="derivatives">
<xs:complexType>
<xs:attribute name="no-roots" type="xs:NMTOKEN" use="required"/>
</xs:complexType>
</xs:element>
top

Element: element

Name element
Type Locally-defined complex type
Nillable no
Abstract no
Documentation Indicates the decomposition of a word or phrase into its elements. As a child of a word element, uses a word reference (@l + @v); as a child of a ref element, uses a source reference (@source). If the element is a non-standard form (e.g. a soft-mutation), this is indicated by the @form attribute. The @form attribute is omitted if the link reference already has its inflection indicated by a child inflect element.
XML Instance Representation
<element
form="anySimpleType [0..1]"
l="language-type [0..1]"
mark="anySimpleType [0..1]"
source="anySimpleType [0..1]"
v="anySimpleType [0..1]"
variant="xs:NMTOKEN [0..1]"/>
Schema Component Representation
<xs:element name="element">
<xs:complexType mixed="true">
<xs:attribute name="form"/>
<xs:attribute name="l" type="language-type"/>
<xs:attribute name="mark"/>
<xs:attribute name="source"/>
<xs:attribute name="v"/>
<xs:attribute name="variant" type="xs:NMTOKEN"/>
</xs:complexType>
</xs:element>
top

Element: example

Name example
Type Locally-defined complex type
Nillable no
Abstract no
Documentation Indicates examples of the topic under discussion, using a source reference (@source). If @t="deriv", it is an example a derivational rule. If @t="inflect", it is an example an inflectional rule.
XML Instance Representation
<example
source="anySimpleType [1]"
t="xs:token (value comes from list: { 'deriv' | 'inflect' }) [0..1]"
v="anySimpleType [1]"/>
Schema Component Representation
<xs:element name="example">
<xs:complexType>
<xs:attribute name="source" use="required"/>
<xs:attribute name="t">
<xs:simpleType>
<xs:restriction base="xs:token">
<xs:enumeration value="deriv"/>
<xs:enumeration value="inflect"/>
</xs:restriction>
</xs:simpleType>
</xs:attribute>
<xs:attribute name="v" use="required"/>
</xs:complexType>
</xs:element>
top

Element: form

Name form
Type Locally-defined complex type
Nillable no
Abstract no
Documentation Controls the subdivision of inflectional tables in the HTML version of the lexicon.
XML Instance Representation
<form
exclude="xs:token (value comes from list: { 'plural' | 'subjective' }) [0..1]"
exclude2="xs:token (value comes from list: { 'dual' }) [0..1]"
form="anySimpleType [1]"/>
Schema Component Representation
<xs:element name="form">
<xs:complexType>
<xs:attribute name="exclude">
<xs:simpleType>
<xs:restriction base="xs:token">
<xs:enumeration value="plural"/>
<xs:enumeration value="subjective"/>
</xs:restriction>
</xs:simpleType>
</xs:attribute>
<xs:attribute name="exclude2">
<xs:simpleType>
<xs:restriction base="xs:token">
<xs:enumeration value="dual"/>
</xs:restriction>
</xs:simpleType>
</xs:attribute>
<xs:attribute name="form" use="required"/>
</xs:complexType>
</xs:element>
top

Element: grammar

Name grammar
Type xs:string
Nillable no
Abstract no
Documentation Documentation appearing at the top of a language’s grammar page.
XML Instance Representation
<grammar> xs:string </grammar>
Schema Component Representation
<xs:element name="grammar" type="xs:string"/>
top

Element: inflect

Name inflect
Type Locally-defined complex type
Nillable no
Abstract no
Documentation Indicates this form is inflected grammatically from the base word. If this base form is attested, it is linked by a source reference (@source); if there is no @source attribute, then the base form is not attested. The @form attribute indicates the natures of the inflection, which may be a space-delimited list, such as form="soft-mutation plural". The @variant attribute indicates it is a nonstandard variation of the inflection.
XML Instance Representation
<inflect
form="anySimpleType [1]"
source="anySimpleType [0..1]"
v="anySimpleType [0..1]"
variant="anySimpleType [0..1]"/>
Schema Component Representation
<xs:element name="inflect">
<xs:complexType mixed="true">
<xs:attribute name="form" use="required"/>
<xs:attribute name="source"/>
<xs:attribute name="v"/>
<xs:attribute name="variant"/>
</xs:complexType>
</xs:element>
top

Element: inflect-table

Name inflect-table
Type Locally-defined complex type
Nillable no
Abstract no
Documentation Controls the generation of inflectional tables in the HTML version of the lexicon.
XML Instance Representation
<inflect-table
exclude="xs:NMTOKEN [0..1]"
form="anySimpleType [0..1]"
from="xs:token (value comes from list: { 'inflect' }) [0..1]"
hide="xs:token (value comes from list: { 'true' }) [0..1]"
key="xs:token (value comes from list: { 'class' | 'inflect-form-and-class-ref' | 'inflect-form-ref' }) [1]"
l="language-list-type [0..1]"
omit="anySimpleType [0..1]"
show-element-of="xs:token (value comes from list: { 'true' }) [0..1]"
show-form="xs:token (value comes from list: { 'class' }) [0..1]"
show-glosses="xs:token (value comes from list: { 'false' | 'true' }) [0..1]"
show-variants="xs:token (value comes from list: { 'true' }) [0..1]"
speech="speech-type [0..1]">
<form> ... </form> [0..*]
</inflect-table>
Schema Component Representation
<xs:element name="inflect-table">
<xs:complexType>
<xs:sequence>
<xs:element ref="form" minOccurs="0" maxOccurs="unbounded"/>
</xs:sequence>
<xs:attribute name="exclude" type="xs:NMTOKEN"/>
<xs:attribute name="form"/>
<xs:attribute name="from">
<xs:simpleType>
<xs:restriction base="xs:token">
<xs:enumeration value="inflect"/>
</xs:restriction>
</xs:simpleType>
</xs:attribute>
<xs:attribute name="hide">
<xs:simpleType>
<xs:restriction base="xs:token">
<xs:enumeration value="true"/>
</xs:restriction>
</xs:simpleType>
</xs:attribute>
<xs:attribute name="key" use="required">
<xs:simpleType>
<xs:restriction base="xs:token">
<xs:enumeration value="class"/>
<xs:enumeration value="inflect-form-and-class-ref"/>
<xs:enumeration value="inflect-form-ref"/>
</xs:restriction>
</xs:simpleType>
</xs:attribute>
<xs:attribute name="l" type="language-list-type"/>
<xs:attribute name="omit"/>
<xs:attribute name="show-element-of">
<xs:simpleType>
<xs:restriction base="xs:token">
<xs:enumeration value="true"/>
</xs:restriction>
</xs:simpleType>
</xs:attribute>
<xs:attribute name="show-form">
<xs:simpleType>
<xs:restriction base="xs:token">
<xs:enumeration value="class"/>
</xs:restriction>
</xs:simpleType>
</xs:attribute>
<xs:attribute name="show-glosses">
<xs:simpleType>
<xs:restriction base="xs:token">
<xs:enumeration value="false"/>
<xs:enumeration value="true"/>
</xs:restriction>
</xs:simpleType>
</xs:attribute>
<xs:attribute name="show-variants">
<xs:simpleType>
<xs:restriction base="xs:token">
<xs:enumeration value="true"/>
</xs:restriction>
</xs:simpleType>
</xs:attribute>
<xs:attribute name="speech" type="speech-type"/>
</xs:complexType>
</xs:element>
top

Element: language

Name language
Type Locally-defined complex type
Nillable no
Abstract no
Documentation Defines a language in the lexicon, identified by its @id attribute and labeled by its @name attribute. Child languages are historical descendants of the language. Other child elements provide documentation for the various index pages for the language.
XML Instance Representation
<language
id="xs:ID [1]"
name="anySimpleType [1]">
Start Choice [0..*]
<grammar> ... </grammar> [1]
<language> ... </language> [1]
<names> ... </names> [1]
<notes> ... </notes> [1]
<phonetics> ... </phonetics> [1]
<phrases> ... </phrases> [1]
<words> ... </words> [1]
End Choice
</language>
Schema Component Representation
<xs:element name="language">
<xs:complexType>
<xs:choice minOccurs="0" maxOccurs="unbounded">
<xs:element ref="grammar"/>
<xs:element ref="language"/>
<xs:element ref="names"/>
<xs:element ref="notes"/>
<xs:element ref="phonetics"/>
<xs:element ref="phrases"/>
<xs:element ref="words"/>
</xs:choice>
<xs:attribute name="id" type="xs:ID" use="required"/>
<xs:attribute name="name" use="required"/>
</xs:complexType>
</xs:element>
top

Element: language-cat

Name language-cat
Type Locally-defined complex type
Nillable no
Abstract no
Documentation A category of languages that is not itself a language, labeled by its @name.
XML Instance Representation
<language-cat
name="anySimpleType [1]">
Start Choice [0..*]
<language> ... </language> [1]
<language-cat> ... </language-cat> [1]
End Choice
</language-cat>
Schema Component Representation
<xs:element name="language-cat">
<xs:complexType>
<xs:choice minOccurs="0" maxOccurs="unbounded">
<xs:element ref="language"/>
<xs:element ref="language-cat"/>
</xs:choice>
<xs:attribute name="name" use="required"/>
</xs:complexType>
</xs:element>
top

Element: names

Name names
Type xs:string
Nillable no
Abstract no
Documentation Documentation appearing at the top of a language’s name page.
XML Instance Representation
<names> xs:string </names>
Schema Component Representation
<xs:element name="names" type="xs:string"/>
top

Element: notes

Name notes
Type xs:string
Nillable no
Abstract no
Documentation Notes for the parent item, which may contain (escaped) HTML markup.
XML Instance Representation
<notes> xs:string </notes>
Schema Component Representation
<xs:element name="notes" type="xs:string"/>
top

Element: order-example

Name order-example
Type Locally-defined complex type
Nillable no
Abstract no
Documentation An example supporting the ordering of phonetic rules indicated by the containing before element, linked using a source reference (@source).
XML Instance Representation
<order-example
source="anySimpleType [1]"
v="anySimpleType [1]"/>
Schema Component Representation
<xs:element name="order-example">
<xs:complexType>
<xs:attribute name="source" use="required"/>
<xs:attribute name="v" use="required"/>
</xs:complexType>
</xs:element>
top

Element: phonetics

Name phonetics
Type xs:string
Nillable no
Abstract no
Documentation Documentation appearing at the top of a language’s phonetics page.
XML Instance Representation
<phonetics> xs:string </phonetics>
Schema Component Representation
<xs:element name="phonetics" type="xs:string"/>
top

Element: phrases

Name phrases
Type xs:string
Nillable no
Abstract no
Documentation Documentation appearing at the top of a language’s phrases page.
XML Instance Representation
<phrases> xs:string </phrases>
Schema Component Representation
<xs:element name="phrases" type="xs:string"/>
top

Element: ref

Name ref
Type Locally-defined complex type
Nillable no
Abstract no
Documentation Reference to an attested form (@v) in Tolkien’s writing, identified by its @source attribute. Child elements indicate relationships to other attested forms. The @gloss attribute contains any attested glosses.The @mark attribute indicates the notation markers associated with the form. The @l attribute indicates its language if it is different from the language of the containing word. The @rl, @rule and @from attributes link to associated phonetic rules, if any.
XML Instance Representation
<ref
from="anySimpleType [0..1]"
gloss="anySimpleType [0..1]"
l="language-type [0..1]"
mark="anySimpleType [0..1]"
rl="anySimpleType [0..1]"
rule="anySimpleType [0..1]"
source="anySimpleType [1]"
v="anySimpleType [1]">
Start Choice [0..*]
<change> ... </change> [1]
<cognate> ... </cognate> [1]
<correction> ... </correction> [1]
<deriv> ... </deriv> [1]
<element> ... </element> [1]
<example> ... </example> [1]
<inflect> ... </inflect> [1]
<related> ... </related> [1]
End Choice
</ref>
Schema Component Representation
<xs:element name="ref">
<xs:complexType>
<xs:choice minOccurs="0" maxOccurs="unbounded">
<xs:element ref="change"/>
<xs:element ref="cognate"/>
<xs:element ref="correction"/>
<xs:element ref="deriv"/>
<xs:element ref="element"/>
<xs:element ref="example"/>
<xs:element ref="inflect"/>
<xs:element ref="related"/>
</xs:choice>
<xs:attribute name="from"/>
<xs:attribute name="gloss"/>
<xs:attribute name="l" type="language-type"/>
<xs:attribute name="mark"/>
<xs:attribute name="rl"/>
<xs:attribute name="rule"/>
<xs:attribute name="source" use="required"/>
<xs:attribute name="v" use="required"/>
</xs:complexType>
</xs:element>
top

Element: related

Name related
Type Locally-defined complex type
Nillable no
Abstract no
Documentation A generic relationship between forms. As a child of a word element, uses a word reference (@l + @v); as a child of a ref element, uses a source reference (@source).
XML Instance Representation
Schema Component Representation
top

Element: rule

Name rule
Type Locally-defined complex type
Nillable no
Abstract no
Documentation A phonetic rule, specifying the language (@l), the original phonetic form (@from) and the new form (@rule). This triplet (@l, @rule, @form) is used to link to examples of the phonetic rule.
XML Instance Representation
<rule
from="anySimpleType [1]"
l="language-type [1]"
rule="anySimpleType [1]"/>
Schema Component Representation
<xs:element name="rule">
<xs:complexType>
<xs:attribute name="from" use="required"/>
<xs:attribute name="l" type="language-type" use="required"/>
<xs:attribute name="rule" use="required"/>
</xs:complexType>
</xs:element>
top

Element: rule-example

Name rule-example
Type Locally-defined complex type
Nillable no
Abstract no
Documentation An example of phonetic rule within a derivation, linked by the triplet (@l, @rule, @form) = (language, new phonetic form, original phonetic form). The @to attribute indicates the resulting word form after this phonetic change, derived from the previous rule-example or rule-start.
XML Instance Representation
<rule-example
from="anySimpleType [0..1]"
l="language-type [1]"
rule="anySimpleType [1]"
to="xs:string [1]"/>
Schema Component Representation
<xs:element name="rule-example">
<xs:complexType>
<xs:attribute name="from"/>
<xs:attribute name="l" type="language-type" use="required"/>
<xs:attribute name="rule" use="required"/>
<xs:attribute name="to" type="xs:string" use="required"/>
</xs:complexType>
</xs:element>
top

Element: rule-start

Name rule-start
Type Locally-defined complex type
Nillable no
Abstract no
Documentation Starting point for a set of phonetic rule change, contained in its @to attribute. Phonetic changes are described by the following rule-example elements. If the @l attribute is present, it specifies which linguistic stage is the starting point for the phonetic changes.
XML Instance Representation
<rule-start
l="language-type [0..1]"
to="anySimpleType [1]"/>
Schema Component Representation
<xs:element name="rule-start">
<xs:complexType>
<xs:attribute name="l" type="language-type"/>
<xs:attribute name="to" use="required"/>
</xs:complexType>
</xs:element>
top

Element: see

Name see
Type Locally-defined complex type
Nillable no
Abstract no
Documentation Linked to another word discussing this form, using a word reference (@l + @v).
XML Instance Representation
<see
l="language-type [1]"
v="anySimpleType [1]"/>
Schema Component Representation
<xs:element name="see">
<xs:complexType>
<xs:attribute name="l" type="language-type" use="required"/>
<xs:attribute name="v" use="required"/>
</xs:complexType>
</xs:element>
top

Element: see-further

Name see-further
Type Locally-defined complex type
Nillable no
Abstract no
Documentation Linked to another word with further discussion of this word, using a word reference (@l + @v).
XML Instance Representation
<see-further
l="language-type [1]"
v="anySimpleType [1]"/>
Schema Component Representation
<xs:element name="see-further">
<xs:complexType>
<xs:attribute name="l" type="language-type" use="required"/>
<xs:attribute name="v" use="required"/>
</xs:complexType>
</xs:element>
top

Element: see-notes

Name see-notes
Type Locally-defined complex type
Nillable no
Abstract no
Documentation Linked to another word with notes discussing this word, using a word reference (@l + @v).
XML Instance Representation
<see-notes
l="language-type [1]"
v="anySimpleType [1]"/>
Schema Component Representation
<xs:element name="see-notes">
<xs:complexType>
<xs:attribute name="l" type="language-type" use="required"/>
<xs:attribute name="v" use="required"/>
</xs:complexType>
</xs:element>
top

Element: source

Name source
Type Locally-defined complex type
Nillable no
Abstract no
Documentation Identifies a particular bibliographical source, identified by its @prefix and labeled by its @name. The optional @type attribute is used to group similar references in the generated reference documentation.
XML Instance Representation
<source
name="anySimpleType [1]"
prefix="xs:ID [1]"
type="xs:token (value comes from list: { 'adunaic' | 'appendix' | 'index' | 'minor' | 'quenya' | 'secondary' | 'sindarin' | 'telerin' | 'work' }) [0..1]">
Start Choice [0..*]
<cite> ... </cite> [1]
<notes> ... </notes> [1]
End Choice
</source>
Schema Component Representation
<xs:element name="source">
<xs:complexType>
<xs:choice minOccurs="0" maxOccurs="unbounded">
<xs:element ref="cite"/>
<xs:element ref="notes"/>
</xs:choice>
<xs:attribute name="name" use="required"/>
<xs:attribute name="prefix" type="xs:ID" use="required"/>
<xs:attribute name="type">
<xs:simpleType>
<xs:restriction base="xs:token">
<xs:enumeration value="adunaic"/>
<xs:enumeration value="appendix"/>
<xs:enumeration value="index"/>
<xs:enumeration value="minor"/>
<xs:enumeration value="quenya"/>
<xs:enumeration value="secondary"/>
<xs:enumeration value="sindarin"/>
<xs:enumeration value="telerin"/>
<xs:enumeration value="work"/>
</xs:restriction>
</xs:simpleType>
</xs:attribute>
</xs:complexType>
</xs:element>
top

Element: word

Name word
Type Locally-defined complex type
Nillable no
Abstract no
Documentation An entry in the lexicon with its own word page. Uses the XML element-name "word" for historical reasons, but these elements also represent other lexicon entries such as phonetic rules or grammatical entries. Child elements indicate relationships to other words, while ref elements indicate attested forms of the word. Child words are generally conceptual predecessor’s of this word, though such relationships are often subjective. The @l attribute indicates the word’s language and the @v attribute the base word form. The @gloss attribute assembles the words glosses; this attribute may be omitted if the word has only one non-change, non-correction attested reference (ref). The @speech attribute is the (possibly space-delimited) part of speech for the word. The @mark attribute indicates the notation markers for the word. The @page-id is the numeric identifier of the generated HTML Lexicon, and can be used to link to the lexicon. Other attributes have specialized uses that will eventually be cleaned up and documented.
XML Instance Representation
<word
cat="anySimpleType [0..1]"
from="anySimpleType [0..1]"
gloss="anySimpleType [0..1]"
l="language-type [1]"
mark="anySimpleType [0..1]"
order="xs:NMTOKEN [0..1]"
orthography="anySimpleType [0..1]"
page-id="xs:NMTOKEN [1]"
phone-col="xs:token (value comes from list: { '0' | '1' | '2' | '3' | '4' | '5' }) [0..1]"
phone-row="xs:token (value comes from list: { '0' | '1' | '2' | '3' | '4' | '5' | '6' | '7' }) [0..1]"
rule="anySimpleType [0..1]"
speech="speech-list-type [1]"
stem="anySimpleType [0..1]"
tengwa="anySimpleType [0..1]"
tengwar="anySimpleType [0..1]"
v="anySimpleType [1]">
Start Choice [0..*]
<before> ... </before> [1]
<class> ... </class> [1]
<cognate> ... </cognate> [1]
<deriv> ... </deriv> [1]
<derivatives> ... </derivatives> [1]
<element> ... </element> [1]
<inflect> ... </inflect> [1]
<inflect-table> ... </inflect-table> [1]
<notes> ... </notes> [1]
<ref> ... </ref> [1]
<related> ... </related> [1]
<rule> ... </rule> [1]
<see> ... </see> [1]
<see-further> ... </see-further> [1]
<see-notes> ... </see-notes> [1]
<word> ... </word> [1]
End Choice
</word>
Schema Component Representation
<xs:element name="word">
<xs:complexType>
<xs:choice minOccurs="0" maxOccurs="unbounded">
<xs:element ref="before"/>
<xs:element ref="class"/>
<xs:element ref="cognate"/>
<xs:element ref="deriv"/>
<xs:element ref="derivatives"/>
<xs:element ref="element"/>
<xs:element ref="inflect"/>
<xs:element ref="inflect-table"/>
<xs:element ref="notes"/>
<xs:element ref="ref"/>
<xs:element ref="related"/>
<xs:element ref="rule"/>
<xs:element ref="see"/>
<xs:element ref="see-further"/>
<xs:element ref="see-notes"/>
<xs:element ref="word"/>
</xs:choice>
<xs:attribute name="cat"/>
<xs:attribute name="from"/>
<xs:attribute name="gloss"/>
<xs:attribute name="l" type="language-type" use="required"/>
<xs:attribute name="mark"/>
<xs:attribute name="order" type="xs:NMTOKEN"/>
<xs:attribute name="orthography"/>
<xs:attribute name="page-id" type="xs:NMTOKEN" use="required"/>
<xs:attribute name="phone-col">
<xs:simpleType>
<xs:restriction base="xs:token">
<xs:enumeration value="0"/>
<xs:enumeration value="1"/>
<xs:enumeration value="2"/>
<xs:enumeration value="3"/>
<xs:enumeration value="4"/>
<xs:enumeration value="5"/>
</xs:restriction>
</xs:simpleType>
</xs:attribute>
<xs:attribute name="phone-row">
<xs:simpleType>
<xs:restriction base="xs:token">
<xs:enumeration value="0"/>
<xs:enumeration value="1"/>
<xs:enumeration value="2"/>
<xs:enumeration value="3"/>
<xs:enumeration value="4"/>
<xs:enumeration value="5"/>
<xs:enumeration value="6"/>
<xs:enumeration value="7"/>
</xs:restriction>
</xs:simpleType>
</xs:attribute>
<xs:attribute name="rule"/>
<xs:attribute name="speech" type="speech-list-type" use="required"/>
<xs:attribute name="stem"/>
<xs:attribute name="tengwa"/>
<xs:attribute name="tengwar"/>
<xs:attribute name="v" use="required"/>
</xs:complexType>
</xs:element>
top

Element: word-data

Name word-data
Type Locally-defined complex type
Nillable no
Abstract no
Documentation The root element of the XML data, with a @version attribute indicating the current version of the lexicon data.
XML Instance Representation
<word-data
version="xs:NMTOKEN [1]">
<language-cat> ... </language-cat> [1..*]
<source> ... </source> [1..*]
<cats> ... </cats> [1]
<word> ... </word> [1..*]
</word-data>
Schema Component Representation
<xs:element name="word-data">
<xs:complexType>
<xs:sequence>
<xs:element ref="language-cat" maxOccurs="unbounded"/>
<xs:element ref="source" maxOccurs="unbounded"/>
<xs:element ref="cats"/>
<xs:element ref="word" maxOccurs="unbounded"/>
</xs:sequence>
<xs:attribute name="version" type="xs:NMTOKEN" use="required"/>
</xs:complexType>
<-- XSD key processing is too slow <xs:key name="word-key"> <xs:selector xpath=".//word"/> <xs:field xpath="@l"/> <xs:field xpath="@v"/> </xs:key> <xs:key name="ref-key"> <xs:selector xpath=".//ref"/> <xs:field xpath="@source"/> </xs:key> -->
</xs:element>
top

Element: words

Name words
Type xs:string
Nillable no
Abstract no
Documentation Documentation appearing at the top of a language’s words list page.
XML Instance Representation
<words> xs:string </words>
Schema Component Representation
<xs:element name="words" type="xs:string"/>
top

Global Definitions

Simple Type: language-list-type

Super-types: None
Sub-types: None
Name language-list-type
Content
Schema Component Representation
<xs:simpleType name="language-list-type">
<xs:list itemType="language-type"/>
</xs:simpleType>
top

Simple Type: language-type

Super-types: xs:string < language-type (by restriction)
Sub-types: None
Name language-type
Content
  • Base XSD Type: string
  • value comes from list: { 'ad' | 'aq' | 'at' | 'av' | 'bel' | 'bs' | 'cir' | 'dan' | 'dun' | 'dor' | 'eas' | 'ed' | 'edan' | 'eilk' | 'en' | 'ent' | 'eon' | 'ep' | 'eq' | 'et' | 'fal' | 'g' | 'ilk' | 'kh' | 'khx' | 'lem' | 'ln' | 'lon' | 'mp' | 'mq' | 'mt' | 'n' | 'oss' | 'p' | 'pad' | 'nan' | 'ns' | 'on' | 'os' | 'q' | 'roh' | 's' | 'sar' | 'sol' | 't' | 'tal' | 'teng' | 'un' | 'val' | 'van' | 'wes' | 'wos' }
Schema Component Representation
<xs:simpleType name="language-type">
<xs:restriction base="xs:string">
<xs:enumeration value="ad"/>
<-- Adunaic -->
<xs:enumeration value="aq"/>
<-- Ancient Quenya -->
<xs:enumeration value="at"/>
<-- Ancient Telerin -->
<xs:enumeration value="av"/>
<-- Avari -->
<xs:enumeration value="bel"/>
<-- Beleriandric -->
<xs:enumeration value="bs"/>
<-- Black Speech -->
<xs:enumeration value="cir"/>
<-- Cirth -->
<xs:enumeration value="dan"/>
<-- Danian -->
<xs:enumeration value="dun"/>
<-- Dunlending -->
<xs:enumeration value="dor"/>
<-- Doriathrin -->
<xs:enumeration value="eas"/>
<-- Easterling -->
<xs:enumeration value="ed"/>
<-- Easterling -->
<xs:enumeration value="edan"/>
<-- East Danian -->
<xs:enumeration value="eilk"/>
<-- Early Ilkorin -->
<xs:enumeration value="en"/>
<-- Early Noldorin -->
<xs:enumeration value="ent"/>
<-- Entish -->
<xs:enumeration value="eon"/>
<-- Early Old Noldorin -->
<xs:enumeration value="ep"/>
<-- Early Primitive Elvish -->
<xs:enumeration value="eq"/>
<-- Early Quenya -->
<xs:enumeration value="et"/>
<-- Early Telerin -->
<xs:enumeration value="fal"/>
<-- Falathrin -->
<xs:enumeration value="g"/>
<-- Gnomish -->
<xs:enumeration value="ilk"/>
<-- Ilkorin -->
<xs:enumeration value="kh"/>
<-- Khuzdul -->
<xs:enumeration value="khx"/>
<-- Khuzdhul, External -->
<xs:enumeration value="lem"/>
<-- Lemberin -->
<xs:enumeration value="ln"/>
<-- Late Noldorin -->
<xs:enumeration value="lon"/>
<-- Late Old Noldorin -->
<xs:enumeration value="mp"/>
<-- Middle Primitive Elvish -->
<xs:enumeration value="mq"/>
<-- Middle Quenya -->
<xs:enumeration value="mt"/>
<-- Middle Telerin -->
<xs:enumeration value="n"/>
<-- Noldorin -->
<xs:enumeration value="oss"/>
<-- Ossriandric -->
<xs:enumeration value="p"/>
<-- Primitive Elvish -->
<xs:enumeration value="pad"/>
<-- Primitive Adunaic -->
<xs:enumeration value="nan"/>
<-- Nandorin -->
<xs:enumeration value="ns"/>
<-- North Sindarin -->
<xs:enumeration value="on"/>
<-- Old Noldorin -->
<xs:enumeration value="os"/>
<-- Old Sindarin -->
<xs:enumeration value="q"/>
<-- Quenya -->
<xs:enumeration value="roh"/>
<-- Rohirric -->
<xs:enumeration value="s"/>
<-- Sindarin -->
<xs:enumeration value="sar"/>
<-- Sarati -->
<xs:enumeration value="sol"/>
<-- Solosimpi -->
<xs:enumeration value="t"/>
<-- Telerin -->
<xs:enumeration value="tal"/>
<-- Talaski -->
<xs:enumeration value="teng"/>
<-- Tengwar -->
<xs:enumeration value="un"/>
<-- Unknown -->
<xs:enumeration value="val"/>
<-- Valarin -->
<xs:enumeration value="van"/>
<-- Vanyarin -->
<xs:enumeration value="wes"/>
<-- Westron -->
<xs:enumeration value="wos"/>
<-- Wose -->
</xs:restriction>
</xs:simpleType>
top

Simple Type: speech-list-type

Super-types: None
Sub-types: None
Name speech-list-type
Content
Schema Component Representation
<xs:simpleType name="speech-list-type">
<xs:list itemType="speech-type"/>
</xs:simpleType>
top

Simple Type: speech-type

Super-types: xs:string < speech-type (by restriction)
Sub-types: None
Name speech-type
Content
  • Base XSD Type: string
  • value comes from list: { '?' | 'adj' | 'adv' | 'affix' | 'article' | 'cardinal' | 'conj' | 'collective-name' | 'collective-noun' | 'family-name' | 'fem-name' | 'fraction' | 'grammar' | 'infix' | 'interj' | 'masc-name' | 'n' | 'ordinal' | 'particle' | 'phoneme' | 'phonetics' | 'phonetic-group' | 'phonetic-rule' | 'phrase' | 'place-name' | 'pref' | 'prep' | 'pron' | 'proper-name' | 'radical' | 'rel-pron' | 'root' | 'text' | 'suf' | 'vb' }
Schema Component Representation
<xs:simpleType name="speech-type">
<xs:restriction base="xs:string">
<xs:enumeration value="?"/>
<-- Unknown -->
<xs:enumeration value="adj"/>
<-- Adjective -->
<xs:enumeration value="adv"/>
<-- Adverb -->
<xs:enumeration value="affix"/>
<-- Affix -->
<xs:enumeration value="article"/>
<-- Definite Article -->
<xs:enumeration value="cardinal"/>
<-- Cardinal -->
<xs:enumeration value="conj"/>
<-- Conjugation -->
<xs:enumeration value="collective-name"/>
<-- Collective Name -->
<xs:enumeration value="collective-noun"/>
<-- Collective Noun -->
<xs:enumeration value="family-name"/>
<-- Family Name -->
<xs:enumeration value="fem-name"/>
<-- Feminine Name -->
<xs:enumeration value="fraction"/>
<-- Fraction -->
<xs:enumeration value="grammar"/>
<-- Grammatical Information -->
<xs:enumeration value="infix"/>
<-- Infix -->
<xs:enumeration value="interj"/>
<-- Interjection -->
<xs:enumeration value="masc-name"/>
<-- Masculine Name -->
<xs:enumeration value="n"/>
<-- Noun -->
<xs:enumeration value="ordinal"/>
<-- Ordinal -->
<xs:enumeration value="particle"/>
<-- Particle -->
<xs:enumeration value="phoneme"/>
<-- Phoneme -->
<xs:enumeration value="phonetics"/>
<-- Phonetic Information -->
<xs:enumeration value="phonetic-group"/>
<-- Phonetic Group -->
<xs:enumeration value="phonetic-rule"/>
<-- Phonetic Rule -->
<xs:enumeration value="phrase"/>
<-- Phrase -->
<xs:enumeration value="place-name"/>
<-- Prefix -->
<xs:enumeration value="pref"/>
<-- Prefix -->
<xs:enumeration value="prep"/>
<-- Preposition -->
<xs:enumeration value="pron"/>
<-- Pronoun -->
<xs:enumeration value="proper-name"/>
<-- Prefix -->
<xs:enumeration value="radical"/>
<-- Radical -->
<xs:enumeration value="rel-pron"/>
<-- Relative Pronoun -->
<xs:enumeration value="root"/>
<-- Root -->
<xs:enumeration value="text"/>
<-- Text (collection of phrases) -->
<xs:enumeration value="suf"/>
<-- Suffix -->
<xs:enumeration value="vb"/>
<-- Verb -->
</xs:restriction>
</xs:simpleType>
top

Legend

Complex Type:

Schema Component Type

AusAddress

Schema Component Name
Super-types: Address < AusAddress (by extension)
Sub-types:
  • QLDAddress (by restriction)
If this schema component is a type definition, its type hierarchy is shown in a gray-bordered box.
Name AusAddress
Abstract no
The table above displays the properties of this schema component.
XML Instance Representation
<... country="Australia">
<unitNo> string </unitNo> [0..1]
<houseNo> string </houseNo> [1]
<street> string </street> [1]
Start Choice[1]
<city> string </city> [1]
<town> string </town> [1]
End Choice
<state> AusStates </state> [1]
<postcode> string <<pattern = [1-9][0-9]{3}>> </postcode> [1]?
</...>

The XML Instance Representation table above shows the schema component's content as an XML instance.

Schema Component Representation
<complexTypename="AusAddress">
<complexContent>
<extensionbase="Address">
<sequence>
<elementname="state" type="AusStates"/>
<elementname="postcode">
<simpleType>
<restrictionbase="string">
<patternvalue="[1-9][0-9]{3}"/>
</restriction>
</simpleType>
</element>
</sequence>
<attributename="country" type="string" fixed="Australia"/>
</extension>
</complexContent>
</complexType>
The Schema Component Representation table above displays the underlying XML representation of the schema component. (Annotations are not shown.)
top

Glossary

Abstract (Applies to complex type definitions and element declarations). An abstract element or complex type cannot used to validate an element instance. If there is a reference to an abstract element, only element declarations that can substitute the abstract element can be used to validate the instance. For references to abstract type definitions, only derived types can be used.

All Model Group Child elements can be provided in any order in instances. See: http://www.w3.org/TR/xmlschema-1/#element-all.

Choice Model Group Only one from the list of child elements and model groups can be provided in instances. See: http://www.w3.org/TR/xmlschema-1/#element-choice.

Collapse Whitespace Policy Replace tab, line feed, and carriage return characters with space character (Unicode character 32). Then, collapse contiguous sequences of space characters into single space character, and remove leading and trailing space characters.

Disallowed Substitutions (Applies to element declarations). If substitution is specified, then substitution group members cannot be used in place of the given element declaration to validate element instances. If derivation methods, e.g. extension, restriction, are specified, then the given element declaration will not validate element instances that have types derived from the element declaration's type using the specified derivation methods. Normally, element instances can override their declaration's type by specifying an xsi:type attribute.

Key Constraint Like Uniqueness Constraint, but additionally requires that the specified value(s) must be provided. See: http://www.w3.org/TR/xmlschema-1/#cIdentity-constraint_Definitions.

Key Reference Constraint Ensures that the specified value(s) must match value(s) from a Key Constraint or Uniqueness Constraint. See: http://www.w3.org/TR/xmlschema-1/#cIdentity-constraint_Definitions.

Model Group Groups together element content, specifying the order in which the element content can occur and the number of times the group of element content may be repeated. See: http://www.w3.org/TR/xmlschema-1/#Model_Groups.

Nillable (Applies to element declarations). If an element declaration is nillable, instances can use the xsi:nil attribute. The xsi:nil attribute is the boolean attribute, nil, from the http://www.w3.org/2001/XMLSchema-instance namespace. If an element instance has an xsi:nil attribute set to true, it can be left empty, even though its element declaration may have required content.

Notation A notation is used to identify the format of a piece of data. Values of elements and attributes that are of type, NOTATION, must come from the names of declared notations. See: http://www.w3.org/TR/xmlschema-1/#cNotation_Declarations.

Preserve Whitespace Policy Preserve whitespaces exactly as they appear in instances.

Prohibited Derivations (Applies to type definitions). Derivation methods that cannot be used to create sub-types from a given type definition.

Prohibited Substitutions (Applies to complex type definitions). Prevents sub-types that have been derived using the specified derivation methods from validating element instances in place of the given type definition.

Replace Whitespace Policy Replace tab, line feed, and carriage return characters with space character (Unicode character 32).

Sequence Model Group Child elements and model groups must be provided in the specified order in instances. See: http://www.w3.org/TR/xmlschema-1/#element-sequence.

Substitution Group Elements that are members of a substitution group can be used wherever the head element of the substitution group is referenced.

Substitution Group Exclusions (Applies to element declarations). Prohibits element declarations from nominating themselves as being able to substitute a given element declaration, if they have types that are derived from the original element's type using the specified derivation methods.

Target Namespace The target namespace identifies the namespace that components in this schema belongs to. If no target namespace is provided, then the schema components do not belong to any namespace.

Uniqueness Constraint Ensures uniqueness of an element/attribute value, or a combination of values, within a specified scope. See: http://www.w3.org/TR/xmlschema-1/#cIdentity-constraint_Definitions.

top