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

<!ELEMENT schema (key|child|override)* >
<!ATTLIST schema id             CDATA #REQUIRED
                 path           CDATA #IMPLIED
                 gettext-domain CDATA #IMPLIED
                 extends        CDATA #IMPLIED
                 list-of        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 >

<!ELEMENT override (#PCDATA) >
<!ATTLIST override name    CDATA #REQUIRED
                   l10n    CDATA #IMPLIED
                   context CDATA #IMPLIED >
