<!ELEMENT schemalist (schema|enum)* >
<!ATTLIST schemalist gettext-domain #IMPLIED >

<!ELEMENT schema (key|child)* >
<!ATTLIST schema id             CDATA #REQUIRED
                 path           CDATA #IMPLIED
                 gettext-domain CDATA #IMPLIED >

<!-- enumerated and flags types -->
<!-- each value element maps a nick to a numeric value -->
<!ELEMENT enum (value*) >
<!ATTLIST enum id CDATA #REQUIRED >

<!ELEMENT flags (value*) >
<!ATTLIST flags id CDATA #REQUIRED >

<!ELEMENT value EMPTY >
<!-- nick must be at least 2 characters long -->
<!-- value must be parsable as a 32-bit integer -->
<!ELEMENT value nick  #REQUIRED
                value #REQUIRED >

<!ELEMENT key (default|summary?|description?|range?|choices?|aliases?) >
<!-- name can only contain lowercase letters, numbers and '-' -->
<!-- type must be a GVariant type string -->
<!-- enum must be the id of an enum type that has been defined earlier -->
<!-- flags must be the id of a flags type that has been defined earlier -->
<!-- exactly one of type, enum or flags must be given -->
<!ATTLIST key name  CDATA #REQUIRED
              type  CDATA #IMPLIED
              enum  CDATA #IMPLIED
              flags CDATA #IMPLIED >

<!-- the default value is specified a a serialized GVariant,
     i.e. you have to include the quotes when specifying a string -->
<!ELEMENT default (#PCDATA) >
<!-- the presence of the l10n attribute marks a default value for
     translation, its value is the gettext category to use -->
<!-- if context is present, it specifies msgctxt to use -->
<!ATTLIST default l10n    (messages|time) #IMPLIED
                  context CDATA           #IMPLIED >

<!ELEMENT summary (#PCDATA) >
<!ELEMENT description (#PCDATA) >

<!-- range is only allowed for keys with numeric type -->
<!ELEMENT range EMPTY >
<!-- min and max must be parseable as values of the key type and min < max -->
<!ATTLIST range min CDATA #REQUIRED
                max CDATA #REQUIRED >

<!-- choices is only allowed for keys with string or string array type -->
<!ELEMENT choices (choice+) >
<!-- each choice element specifies one possible value -->
<!ELEMENT choice EMPTY >
<!ATTLIST choice value CDATA #REQUIRED >

<!-- aliases is only allowed for keys with enumerated type or with choices -->
<!ELEMENT aliases (alias+) >
<!-- each alias element specifies an alias for one of the possible values -->
<!ELEMENT alias EMPTY >
<!ATTLIST alias value CDATA #REQUIRED >

<!ELEMENT child EMPTY >
<!ATTLIST child name   CDATA #REQUIRED
                schema CDATA #REQUIRED >
