home *** CD-ROM | disk | FTP | other *** search
/ MacFormat UK 160 - Disc 2 / MF_UK_160_2.iso / pc / DiscContent / Trials / oxygen / lib / oxygen.jar / builtin / XSL1.0Schema.xsd < prev    next >
Encoding:
Extensible Markup Language  |  2005-07-21  |  85.1 KB  |  1,398 lines
  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <xs:schema elementFormDefault="qualified" targetNamespace="http://www.w3.org/1999/XSL/Transform"
  3.     xmlns="http://www.w3.org/1999/XSL/Transform" xmlns:xs="http://www.w3.org/2001/XMLSchema" xmlns:xsl="http://www.w3.org/1999/XSL/Transform">
  4.     <xs:annotation>
  5.         <xs:documentation> 2004-07-28, George Bina, SyncRO Soft Ltd. (oXygen XML Editor) added annotations for elements
  6.             and attributes. Copyright ¬© 2002-2004 SyncRO Soft Ltd. All rights reserved. </xs:documentation>
  7.     </xs:annotation>
  8.     
  9.     <xs:import namespace="http://www.w3.org/XML/1998/namespace" schemaLocation="xml.xsd"/>
  10.     <xs:element name="apply-imports">
  11.         <xs:annotation>
  12.             <xs:documentation> The xsl:apply-imports element is used in conjunction with imported stylesheets. At
  13.                 run-time, there must be a current template. A current template is established when a template is
  14.                 activated as a result of a call on xsl:apply-templates. Calling xsl:call-template does not change the
  15.                 current template. Calling xsl:for-each does not cause the current template to become null. The effect is
  16.                 to search for a template that matches the current node and that is defined in a stylesheet that was
  17.                 imported (directly or indirectly, possibly via xsl:include) from the stylesheet containing the current
  18.                 template, and whose mode matches the current mode. If there is such a template, it is activated using
  19.                 the current node. If not, the call on xsl:apply-imports has no effect. </xs:documentation>
  20.         </xs:annotation>
  21.         <xs:complexType>
  22.             <xs:attributeGroup ref="xml:specialAttrs"/>
  23.         </xs:complexType>
  24.     </xs:element>
  25.     <xs:element name="apply-templates">
  26.         <xs:annotation>
  27.             <xs:documentation> The xsl:apply-templates element causes navigation from the current element, usually but
  28.                 not necessarily to process its children. Each selected node is processed using the best-match
  29.                 xsl:template defined for that node. In the absence of a select attribute, the xsl:apply-templates
  30.                 instruction processes all of the children of the current node, including text nodes. However, text nodes
  31.                 that have been stripped will not be processed. If stripping of whitespace nodes has not been enabled for
  32.                 an element, then all whitespace in the content of the element will be processed as text, and thus
  33.                 whitespace between child elements will count in determining the position of a child element as returned
  34.                 by the position function. A select attribute can be used to process nodes selected by an expression
  35.                 instead of processing all children. The value of the select attribute is an expression. The expression
  36.                 must evaluate to a node-set. The selected set of nodes is processed in document order, unless a sorting
  37.                 specification is present </xs:documentation>
  38.         </xs:annotation>
  39.         <xs:complexType>
  40.             <xs:choice maxOccurs="unbounded" minOccurs="0">
  41.                 <xs:element ref="sort"/>
  42.                 <xs:element ref="with-param"/>
  43.             </xs:choice>
  44.             <xs:attribute default="node()" name="select" type="xs:string">
  45.                 <xs:annotation>
  46.                     <xs:documentation>A select attribute can be used to process nodes selected by an expression instead
  47.                         of processing all children. The value of the select attribute must be a node-set expression.</xs:documentation>
  48.                 </xs:annotation>
  49.             </xs:attribute>
  50.             <xs:attribute name="mode" type="xs:QName">
  51.                 <xs:annotation>
  52.                     <xs:documentation> The optional mode attribute identifies the processing mode. If this attribute is
  53.                         present, only templates with a matching mode parameter will be considered when searching for the
  54.                         rule to apply to the selected elements. </xs:documentation>
  55.                 </xs:annotation>
  56.             </xs:attribute>
  57.             <xs:attributeGroup ref="xml:specialAttrs"/>
  58.         </xs:complexType>
  59.     </xs:element>
  60.     <xs:element name="attribute">
  61.         <xs:annotation>
  62.             <xs:documentation> The xsl:attribute element is used to add an attribute value to an xsl:element element or
  63.                 general formatting element, or to an element created using xsl:copy. The attribute must be output
  64.                 immediately after the element, with no intervening character data. The name of the attribute is
  65.                 indicated by the name attribute and the value by the content of the xsl:attribute element. </xs:documentation>
  66.         </xs:annotation>
  67.         <xs:complexType mixed="true">
  68.             <xs:choice maxOccurs="unbounded" minOccurs="0">
  69.                 <xs:element ref="apply-templates"/>
  70.                 <xs:element ref="call-template"/>
  71.                 <xs:element ref="apply-imports"/>
  72.                 <xs:element ref="for-each"/>
  73.                 <xs:element ref="value-of"/>
  74.                 <xs:element ref="copy-of"/>
  75.                 <xs:element ref="number"/>
  76.                 <xs:element ref="choose"/>
  77.                 <xs:element ref="if"/>
  78.                 <xs:element ref="text"/>
  79.                 <xs:element ref="copy"/>
  80.                 <xs:element ref="variable"/>
  81.                 <xs:element ref="message"/>
  82.                 <xs:element ref="fallback"/>
  83.             </xs:choice>
  84.             <xs:attribute name="name" type="xs:string" use="required">
  85.                 <xs:annotation>
  86.                     <xs:documentation>The name attribute is interpreted as an attribute value template, so it may
  87.                         contain string expressions within curly braces. It is an error if the string that results from
  88.                         instantiating the attribute value template is not a QName or is the string xmlns. If the
  89.                         namespace attribute is not present, then the QName is expanded into an expanded-name using the
  90.                         namespace declarations in effect for the xsl:attribute element, not including any default
  91.                         namespace declaration. </xs:documentation>
  92.                 </xs:annotation>
  93.             </xs:attribute>
  94.             <xs:attribute name="namespace" type="xs:string">
  95.                 <xs:annotation>
  96.                     <xs:documentation>If the namespace attribute is present, then it also is interpreted as an attribute
  97.                         value template. The string that results from instantiating it should be a URI reference. It is
  98.                         not an error if the string is not a syntactically legal URI reference. If the string is empty,
  99.                         then the expanded-name of the attribute has a null namespace URI. Otherwise, the string is used
  100.                         as the namespace URI of the expanded-name of the attribute to be created. The local part of the
  101.                         QName specified by the name attribute is used as the local part of the expanded-name of the
  102.                         attribute to be created. </xs:documentation>
  103.                 </xs:annotation>
  104.             </xs:attribute>
  105.             <xs:attributeGroup ref="xml:specialAttrs"/>
  106.         </xs:complexType>
  107.     </xs:element>
  108.     <xs:element name="attribute-set">
  109.         <xs:annotation>
  110.             <xs:documentation>The xsl:attribute-set element is used to declare a named collection of attributes, which
  111.                 will often be used together to define an output style. The attributes in an attribute-set can be used in
  112.                 several ways: they can be added to a literal result element, they can be added to an element created
  113.                 using xsl:element or xsl:copy or to base an attribute set on another one.</xs:documentation>
  114.         </xs:annotation>
  115.         <xs:complexType>
  116.             <xs:sequence minOccurs="0" maxOccurs="unbounded">
  117.                 <xs:element ref="attribute"/>
  118.             </xs:sequence>
  119.             <xs:attribute name="name" type="xs:QName" use="required">
  120.                 <xs:annotation>
  121.                     <xs:documentation>The name attribute specifies the name of the attribute set. Each name is specified
  122.                         as a QName.</xs:documentation>
  123.                 </xs:annotation>
  124.             </xs:attribute>
  125.             <xs:attribute name="use-attribute-sets" type="xs:NMTOKENS">
  126.                 <xs:annotation>
  127.                     <xs:documentation> One attribute set can be based on another by specifying use-attribute-sets in the
  128.                         list of attributes for the xsl:attribute-set element. The value of the use-attribute-sets
  129.                         attribute is a whitespace-separated list of names of attribute sets. Attributes defined
  130.                         explicitly in the attribute set override any that are included implicitly from another attribute
  131.                         set. Attribute sets named in use-attribute-sets attribute are applied in the order given: if the
  132.                         same attribute is generated more than once, the later value always takes precedence. It is an
  133.                         error if use of use-attribute-sets attributes on xsl:attribute-set elements causes an attribute
  134.                         set to directly or indirectly use itself. </xs:documentation>
  135.                 </xs:annotation>
  136.             </xs:attribute>
  137.             <xs:attributeGroup ref="xml:specialAttrs"/>
  138.         </xs:complexType>
  139.     </xs:element>
  140.     <xs:element name="call-template">
  141.         <xs:annotation>
  142.             <xs:documentation>The xsl:call-template element is used to invoke a named template. Unlike
  143.                 xsl:apply-templates, xsl:call-template does not change the current node or the current node list.</xs:documentation>
  144.         </xs:annotation>
  145.         <xs:complexType>
  146.             <xs:sequence minOccurs="0" maxOccurs="unbounded">
  147.                 <xs:element ref="with-param"/>
  148.             </xs:sequence>
  149.             <xs:attribute name="name" type="xs:QName" use="required">
  150.                 <xs:annotation>
  151.                     <xs:documentation>The name of the invoked template. It's value must be a valid QName that identifies
  152.                         a named template somewhere in the stylesheet.</xs:documentation>
  153.                 </xs:annotation>
  154.             </xs:attribute>
  155.             <xs:attributeGroup ref="xml:specialAttrs"/>
  156.         </xs:complexType>
  157.     </xs:element>
  158.     <xs:element name="choose">
  159.         <xs:annotation>
  160.             <xs:documentation>The xsl:choose element is used to choose one of a number of alternative outputs. The
  161.                 element typically contains a number of xsl:when elements, each with a separate test condition. The first
  162.                 xsl:when element whose condition matches the current element in the source document is expanded, the
  163.                 others are ignored. If none of the conditions is satisfied, the xsl:otherwise child element, if any, is expanded.</xs:documentation>
  164.         </xs:annotation>
  165.         <xs:complexType>
  166.             <xs:sequence>
  167.                 <xs:element maxOccurs="unbounded" minOccurs="1" ref="when"/>
  168.                 <xs:element maxOccurs="1" minOccurs="0" ref="otherwise"/>
  169.             </xs:sequence>
  170.             <xs:attributeGroup ref="xml:specialAttrs"/>
  171.         </xs:complexType>
  172.     </xs:element>
  173.     <xs:element name="comment">
  174.         <xs:annotation>
  175.             <xs:documentation>The xsl:comment element indicates text that is to be output to the current output stream
  176.                 in the form of an XML or HTML comment. Note that special characters occurring within the comment text
  177.                 will not be escaped.</xs:documentation>
  178.         </xs:annotation>
  179.         <xs:complexType mixed="true">
  180.             <xs:choice maxOccurs="unbounded" minOccurs="0">
  181.                 <xs:element ref="apply-templates"/>
  182.                 <xs:element ref="call-template"/>
  183.                 <xs:element ref="apply-imports"/>
  184.                 <xs:element ref="for-each"/>
  185.                 <xs:element ref="value-of"/>
  186.                 <xs:element ref="copy-of"/>
  187.                 <xs:element ref="number"/>
  188.                 <xs:element ref="choose"/>
  189.                 <xs:element ref="if"/>
  190.                 <xs:element ref="text"/>
  191.                 <xs:element ref="copy"/>
  192.                 <xs:element ref="variable"/>
  193.                 <xs:element ref="message"/>
  194.                 <xs:element ref="fallback"/>
  195.             </xs:choice>
  196.             <xs:attributeGroup ref="xml:specialAttrs"/>
  197.         </xs:complexType>
  198.     </xs:element>
  199.     <xs:element name="copy">
  200.         <xs:annotation>
  201.             <xs:documentation> The xsl:copy element causes the current XML node in the source document to be copied to
  202.                 the output. The namespace nodes of the current node are automatically copied as well, but the attributes
  203.                 and children of the node are not automatically copied. </xs:documentation>
  204.         </xs:annotation>
  205.         <xs:complexType mixed="true">
  206.             <xs:choice maxOccurs="unbounded" minOccurs="0">
  207.                 <xs:element ref="apply-templates"/>
  208.                 <xs:element ref="call-template"/>
  209.                 <xs:element ref="apply-imports"/>
  210.                 <xs:element ref="for-each"/>
  211.                 <xs:element ref="value-of"/>
  212.                 <xs:element ref="copy-of"/>
  213.                 <xs:element ref="number"/>
  214.                 <xs:element ref="choose"/>
  215.                 <xs:element ref="if"/>
  216.                 <xs:element ref="text"/>
  217.                 <xs:element ref="copy"/>
  218.                 <xs:element ref="variable"/>
  219.                 <xs:element ref="message"/>
  220.                 <xs:element ref="fallback"/>
  221.                 <xs:element ref="processing-instruction"/>
  222.                 <xs:element ref="comment"/>
  223.                 <xs:element ref="element"/>
  224.                 <xs:element ref="attribute"/>
  225.             </xs:choice>
  226.             <xs:attribute name="use-attribute-sets" type="xs:NMTOKENS">
  227.                 <xs:annotation>
  228.                     <xs:documentation> Attributes of the generated element can be defined by reference to a named
  229.                         attribute set. The optional use-attribute-sets attribute contains a white-space-separated list
  230.                         of attribute set names. Each name is specified as a QName. They are applied in the order given:
  231.                         if the same attribute is generated more than once, the later value always takes precedence. </xs:documentation>
  232.                 </xs:annotation>
  233.             </xs:attribute>
  234.             <xs:attributeGroup ref="xml:specialAttrs"/>
  235.         </xs:complexType>
  236.     </xs:element>
  237.     <xs:element name="copy-of">
  238.         <xs:annotation>
  239.             <xs:documentation> The xsl:copy-of element copies of the value of the expression in the mandatory select
  240.                 attribute to the result tree If this expression is a string, a number, or a boolean, the effect is the
  241.                 same as using xsl:value-of. It is usually used where the value is a nodeset or a result tree fragment. </xs:documentation>
  242.         </xs:annotation>
  243.         <xs:complexType>
  244.             <xs:attribute name="select" type="xs:string" use="required">
  245.                 <xs:annotation>
  246.                     <xs:documentation> Defines the expression the xsl:copy-of is applied on. </xs:documentation>
  247.                 </xs:annotation>
  248.             </xs:attribute>
  249.             <xs:attributeGroup ref="xml:specialAttrs"/>
  250.         </xs:complexType>
  251.     </xs:element>
  252.     <xs:element name="decimal-format">
  253.         <xs:annotation>
  254.             <xs:documentation> The xsl:decimal-format element is used to indicate a set of localisation parameters. If
  255.                 the xsl:decimal-format element has a name attribute, it identifies a named format; if not, it identifies
  256.                 the default format. In practice decimal formats are used only for formatting numbers using the
  257.                 format-number() function in XSL expressions. It is an error to declare either the default decimal-format
  258.                 or a decimal-format with a given name more than once (even with different import precedence), unless it
  259.                 is declared every time with the same value for all attributes (taking into account any default values). </xs:documentation>
  260.         </xs:annotation>
  261.         <xs:complexType>
  262.             <xs:attribute name="name" type="xs:QName">
  263.                 <xs:annotation>
  264.                     <xs:documentation>The name attribute declares a named decimal-format. The value of the name
  265.                         attribute is a QName. </xs:documentation>
  266.                 </xs:annotation>
  267.             </xs:attribute>
  268.             <xs:attribute default="." name="decimal-separator" type="xs:string">
  269.                 <xs:annotation>
  270.                     <xs:documentation>The decimal-separator attribute specifies the character used for the decimal sign;
  271.                         the default value is the period character (.). </xs:documentation>
  272.                 </xs:annotation>
  273.             </xs:attribute>
  274.             <xs:attribute default="," name="grouping-separator" type="xs:string">
  275.                 <xs:annotation>
  276.                     <xs:documentation>The grouping-separator attribute specifies the character used as a grouping (e.g.
  277.                         thousands) separator; the default value is the comma character (,). </xs:documentation>
  278.                 </xs:annotation>
  279.             </xs:attribute>
  280.             <xs:attribute default="Infinity" name="infinity" type="xs:string">
  281.                 <xs:annotation>
  282.                     <xs:documentation>The infinity attribute specifies the string used to represent infinity; the
  283.                         default value is the string Infinity.</xs:documentation>
  284.                 </xs:annotation>
  285.             </xs:attribute>
  286.             <xs:attribute default="-" name="minus-sign" type="xs:string">
  287.                 <xs:annotation>
  288.                     <xs:documentation>The minus-sign attribute specifies the character used as the default minus sign;
  289.                         the default value is the hyphen-minus character (-, #x2D).</xs:documentation>
  290.                 </xs:annotation>
  291.             </xs:attribute>
  292.             <xs:attribute default="NaN" name="NaN" type="xs:string">
  293.                 <xs:annotation>
  294.                     <xs:documentation>The NaN attribute specifies the string used to represent the NaN value; the
  295.                         default value is the string NaN.</xs:documentation>
  296.                 </xs:annotation>
  297.             </xs:attribute>
  298.             <xs:attribute default="%" name="percent" type="xs:string">
  299.                 <xs:annotation>
  300.                     <xs:documentation>The percent attribute specifies the character used as a percent sign; the default
  301.                         value is the percent character (%).</xs:documentation>
  302.                 </xs:annotation>
  303.             </xs:attribute>
  304.             <xs:attribute default="‚Ä∞" name="per-mille" type="xs:string">
  305.                 <xs:annotation>
  306.                     <xs:documentation>The per-mille attribute specifies the character used as a per mille sign; the
  307.                         default value is the Unicode per-mille character (#x2030). </xs:documentation>
  308.                 </xs:annotation>
  309.             </xs:attribute>
  310.             <xs:attribute default="0" name="zero-digit" type="xs:string">
  311.                 <xs:annotation>
  312.                     <xs:documentation>The zero-digit attribute specifies the character used as the digit zero; the
  313.                         default value is the digit zero (0).</xs:documentation>
  314.                 </xs:annotation>
  315.             </xs:attribute>
  316.             <xs:attribute default="#" name="digit" type="xs:string">
  317.                 <xs:annotation>
  318.                     <xs:documentation>The digit attribute specifies the character used for a digit in the format
  319.                         pattern; the default value is the number sign character (#). </xs:documentation>
  320.                 </xs:annotation>
  321.             </xs:attribute>
  322.             <xs:attribute default=";" name="pattern-separator" type="xs:string">
  323.                 <xs:annotation>
  324.                     <xs:documentation>The pattern-separator attribute specifies the character used to separate positive
  325.                         and negative sub patterns in a pattern; the default value is the semi-colon character (;).</xs:documentation>
  326.                 </xs:annotation>
  327.             </xs:attribute>
  328.             <xs:attributeGroup ref="xml:specialAttrs"/>
  329.         </xs:complexType>
  330.     </xs:element>
  331.     <xs:element name="element">
  332.         <xs:annotation>
  333.             <xs:documentation> The xsl:element is used to create an output element whose name might be calculated at
  334.                 run-time. The expanded-name of the element to be created is specified by a required name attribute and
  335.                 an optional namespace attribute. The attributes of the generated element are defined by subsequent
  336.                 xsl:attribute elements. The content of the generated element is whatever is generated between the
  337.                 <xsl:element> and </xsl:element> tags.</xs:documentation>
  338.         </xs:annotation>
  339.         <xs:complexType mixed="true">
  340.             <xs:choice maxOccurs="unbounded" minOccurs="0">
  341.                 <xs:element ref="apply-templates"/>
  342.                 <xs:element ref="call-template"/>
  343.                 <xs:element ref="apply-imports"/>
  344.                 <xs:element ref="for-each"/>
  345.                 <xs:element ref="value-of"/>
  346.                 <xs:element ref="copy-of"/>
  347.                 <xs:element ref="number"/>
  348.                 <xs:element ref="choose"/>
  349.                 <xs:element ref="if"/>
  350.                 <xs:element ref="text"/>
  351.                 <xs:element ref="copy"/>
  352.                 <xs:element ref="variable"/>
  353.                 <xs:element ref="message"/>
  354.                 <xs:element ref="fallback"/>
  355.                 <xs:element ref="processing-instruction"/>
  356.                 <xs:element ref="comment"/>
  357.                 <xs:element ref="element"/>
  358.                 <xs:element ref="attribute"/>
  359.             </xs:choice>
  360.             <xs:attribute name="name" type="xs:string" use="required">
  361.                 <xs:annotation>
  362.                     <xs:documentation> The name attribute is the name of the generated element. The name attribute is an
  363.                         attribute value template, so it may contain string expressions inside curly braces. It is an
  364.                         error if the string that results from instantiating the attribute value template is not a QName. </xs:documentation>
  365.                 </xs:annotation>
  366.             </xs:attribute>
  367.             <xs:attribute name="namespace" type="xs:string">
  368.                 <xs:annotation>
  369.                     <xs:documentation>If the namespace attribute is present, then it is interpreted as an attribute
  370.                         value template. The string that results from instantiating the attribute value template should
  371.                         be a URI reference. It is not an error if the string is not a syntactically legal URI reference.
  372.                         If the string is empty, then the expanded-name of the element has a null namespace URI.
  373.                         Otherwise, the string is used as the namespace URI of the expanded-name of the element to be
  374.                         created. </xs:documentation>
  375.                 </xs:annotation>
  376.             </xs:attribute>
  377.             <xs:attribute name="use-attribute-sets" type="xs:NMTOKENS">
  378.                 <xs:annotation>
  379.                     <xs:documentation>Attributes of the generated element can be defined by reference to a named
  380.                         attribute set. The optional use-attribute-sets attribute contains a white-space-separated list
  381.                         of attribute set names. They are applied in the order given: if the same attribute is generated
  382.                         more than once, the later value always takes precedence.</xs:documentation>
  383.                 </xs:annotation>
  384.             </xs:attribute>
  385.             <xs:attributeGroup ref="xml:specialAttrs"/>
  386.         </xs:complexType>
  387.     </xs:element>
  388.     <xs:element name="fallback">
  389.         <xs:annotation>
  390.             <xs:documentation> The xsl:fallback element is used to define recovery action to be taken when an
  391.                 instruction element is used in the stylesheet and no implentation of that element is available. An
  392.                 element is an instruction element if its namespace URI is the standard URI for XSL elements or if its
  393.                 namespace is identified in the xsl:extension-element-prefixes attribute of a containing literal result
  394.                 element, or in the extension-element-prefixes attribute of the xsl:stylesheet element. If the
  395.                 xsl:fallback element appears in any other context, it is ignored, together with all its child and
  396.                 descendant elements. If the parent element can be instantiated and processed, the xsl:fallback element
  397.                 and its descendants are ignored. If the parent element is not recognised of if any failure occurs
  398.                 instantiating it, all its xsl:fallback children are processed in turn. If there are no xsl:fallback
  399.                 children, an error is reported. </xs:documentation>
  400.         </xs:annotation>
  401.         <xs:complexType mixed="true">
  402.             <xs:choice maxOccurs="unbounded" minOccurs="0">
  403.                 <xs:element ref="apply-templates"/>
  404.                 <xs:element ref="call-template"/>
  405.                 <xs:element ref="apply-imports"/>
  406.                 <xs:element ref="for-each"/>
  407.                 <xs:element ref="value-of"/>
  408.                 <xs:element ref="copy-of"/>
  409.                 <xs:element ref="number"/>
  410.                 <xs:element ref="choose"/>
  411.                 <xs:element ref="if"/>
  412.                 <xs:element ref="text"/>
  413.                 <xs:element ref="copy"/>
  414.                 <xs:element ref="variable"/>
  415.                 <xs:element ref="message"/>
  416.                 <xs:element ref="fallback"/>
  417.                 <xs:element ref="processing-instruction"/>
  418.                 <xs:element ref="comment"/>
  419.                 <xs:element ref="element"/>
  420.                 <xs:element ref="attribute"/>
  421.             </xs:choice>
  422.             <xs:attributeGroup ref="xml:specialAttrs"/>
  423.         </xs:complexType>
  424.     </xs:element>
  425.     <xs:element name="for-each">
  426.         <xs:annotation>
  427.             <xs:documentation> The xsl:for-each element causes iteration over the nodes selected by a node-set
  428.                 expression. It can be used as an alternative to xsl:apply-templates where the child nodes of the current
  429.                 node are known in advance. The xsl:for-each instruction contains a template, which is instantiated for
  430.                 each node selected by the expression specified by the select attribute. The template is instantiated
  431.                 with the selected node as the current node, and with a list of all of the selected nodes as the current
  432.                 node list. The nodes are processed in document order, unless a sorting specification is present </xs:documentation>
  433.         </xs:annotation>
  434.         <xs:complexType mixed="true">
  435.             <xs:choice maxOccurs="unbounded" minOccurs="0">
  436.                 <xs:element ref="apply-templates"/>
  437.                 <xs:element ref="call-template"/>
  438.                 <xs:element ref="apply-imports"/>
  439.                 <xs:element ref="for-each"/>
  440.                 <xs:element ref="value-of"/>
  441.                 <xs:element ref="copy-of"/>
  442.                 <xs:element ref="number"/>
  443.                 <xs:element ref="choose"/>
  444.                 <xs:element ref="if"/>
  445.                 <xs:element ref="text"/>
  446.                 <xs:element ref="copy"/>
  447.                 <xs:element ref="variable"/>
  448.                 <xs:element ref="message"/>
  449.                 <xs:element ref="fallback"/>
  450.                 <xs:element ref="processing-instruction"/>
  451.                 <xs:element ref="comment"/>
  452.                 <xs:element ref="element"/>
  453.                 <xs:element ref="attribute"/>
  454.                 <xs:element ref="sort"/>
  455.             </xs:choice>
  456.             <xs:attribute name="select" type="xs:string" use="required">
  457.                 <xs:annotation>
  458.                     <xs:documentation>The select attribute defines the node set the xsl:for-each applies on. The XSL
  459.                         statements subordinate to the xsl:for-each element are applied to each source node seleced by
  460.                         the node-set expression in turn.</xs:documentation>
  461.                 </xs:annotation>
  462.             </xs:attribute>
  463.             <xs:attributeGroup ref="xml:specialAttrs"/>
  464.         </xs:complexType>
  465.     </xs:element>
  466.     <xs:element name="if">
  467.         <xs:annotation>
  468.             <xs:documentation>The xsl:if element is used for conditional processing. It takes a mandatory test
  469.                 attribute, whose value is a boolean expression. The contents of the xsl:if element are expanded only of
  470.                 the expression is true.</xs:documentation>
  471.         </xs:annotation>
  472.         <xs:complexType mixed="true">
  473.             <xs:choice maxOccurs="unbounded" minOccurs="0">
  474.                 <xs:element ref="apply-templates"/>
  475.                 <xs:element ref="call-template"/>
  476.                 <xs:element ref="apply-imports"/>
  477.                 <xs:element ref="for-each"/>
  478.                 <xs:element ref="value-of"/>
  479.                 <xs:element ref="copy-of"/>
  480.                 <xs:element ref="number"/>
  481.                 <xs:element ref="choose"/>
  482.                 <xs:element ref="if"/>
  483.                 <xs:element ref="text"/>
  484.                 <xs:element ref="copy"/>
  485.                 <xs:element ref="variable"/>
  486.                 <xs:element ref="message"/>
  487.                 <xs:element ref="fallback"/>
  488.                 <xs:element ref="processing-instruction"/>
  489.                 <xs:element ref="comment"/>
  490.                 <xs:element ref="element"/>
  491.                 <xs:element ref="attribute"/>
  492.             </xs:choice>
  493.             <xs:attribute name="test" type="xs:string" use="required">
  494.                 <xs:annotation>
  495.                     <xs:documentation>Specifies the test boolean expression. The contents of the xsl:if element are
  496.                         expanded only of the expression is true.</xs:documentation>
  497.                 </xs:annotation>
  498.             </xs:attribute>
  499.             <xs:attributeGroup ref="xml:specialAttrs"/>
  500.         </xs:complexType>
  501.     </xs:element>
  502.     <xs:element name="import">
  503.         <xs:annotation>
  504.             <xs:documentation> The xsl:import element is always used at the top level of the stylesheet, and it must
  505.                 appear before all other elements at the top level. It has a mandatory href attribute, which is a URI
  506.                 (absolute or relative) of another stylesheet to be textually included within this one. The top-level
  507.                 elements of the included stylesheet effectively replace the xsl:import element. The elements in the
  508.                 imported stylesheet have lower precedence than the elements in the importing stylesheet. The main effect
  509.                 of this is on selection of a template when xsl:apply-templates is used: if there is a matching template
  510.                 with precedence X, all templates with precedence less than X are ignored, regardless of their priority.
  511.                 It is an error if a stylesheet directly or indirectly imports itself. </xs:documentation>
  512.         </xs:annotation>
  513.         <xs:complexType>
  514.             <xs:attribute name="href" type="xs:string" use="required">
  515.                 <xs:annotation>
  516.                     <xs:documentation>The href attribute value is a URI reference identifying the stylesheet to be
  517.                         imported. A relative URI is resolved relative to the base URI of the xsl:import element.</xs:documentation>
  518.                 </xs:annotation>
  519.             </xs:attribute>
  520.             <xs:attributeGroup ref="xml:specialAttrs"/>
  521.         </xs:complexType>
  522.     </xs:element>
  523.     <xs:element name="include">
  524.         <xs:annotation>
  525.             <xs:documentation>The xsl:include element is only allowed as a top-level element. The inclusion works at the
  526.                 XML tree level. The resource located by the href attribute value is parsed as an XML document, and the
  527.                 children of the xsl:stylesheet element in this document replace the xsl:include element in the including
  528.                 document. The fact that template rules or definitions are included does not affect the way they are
  529.                 processed. It is an error if a stylesheet directly or indirectly includes itself. </xs:documentation>
  530.         </xs:annotation>
  531.         <xs:complexType>
  532.             <xs:attribute name="href" type="xs:string" use="required">
  533.                 <xs:annotation>
  534.                     <xs:documentation>The href attribute value is a URI reference identifying the stylesheet to be
  535.                         included. A relative URI is resolved relative to the base URI of the xsl:import element.</xs:documentation>
  536.                 </xs:annotation>
  537.             </xs:attribute>
  538.             <xs:attributeGroup ref="xml:specialAttrs"/>
  539.         </xs:complexType>
  540.     </xs:element>
  541.     <xs:element name="key">
  542.         <xs:annotation>
  543.             <xs:documentation> The xsl:key element is used at the top level of the stylesheet to declare an attribute,
  544.                 or other value, that may be used as a key to identify nodes using the key() function within an
  545.                 expression. Each xsl:key definition declares a named key, which must match the name of the key used in
  546.                 the key() function. Keys are not unique: the same value may identify many different nodes. Keys are
  547.                 multi-valued: each matched node may have several (zero or more) values of the key, any one of which may
  548.                 be used to locate that node. Keys can only be used to identify nodes within a single XML document: the
  549.                 key() function will return nodes that are in the same document as the current node. </xs:documentation>
  550.         </xs:annotation>
  551.         <xs:complexType>
  552.             <xs:attribute name="name" type="xs:QName" use="required">
  553.                 <xs:annotation>
  554.                     <xs:documentation>The name attribute specifies the name of the key. The value of the name attribute
  555.                         is a QName. </xs:documentation>
  556.                 </xs:annotation>
  557.             </xs:attribute>
  558.             <xs:attribute name="match" type="xs:string" use="required">
  559.                 <xs:annotation>
  560.                     <xs:documentation>The set of nodes to which the key applies is defined by a pattern in the match attribute.</xs:documentation>
  561.                 </xs:annotation>
  562.             </xs:attribute>
  563.             <xs:attribute name="use" type="xs:string" use="required">
  564.                 <xs:annotation>
  565.                     <xs:documentation> The value of the key, for each of these matched elements, is determined by the
  566.                         use attribute. This is an expression, which is evaluated for each matched element. If the
  567.                         expression returns a node-set, the string value of each node in this node-set acts as a key
  568.                         value. If the expression returns any other value, the value is converted to a string and that
  569.                         string acts as the key. </xs:documentation>
  570.                 </xs:annotation>
  571.             </xs:attribute>
  572.             <xs:attributeGroup ref="xml:specialAttrs"/>
  573.         </xs:complexType>
  574.     </xs:element>
  575.     <xs:element name="message">
  576.         <xs:annotation>
  577.             <xs:documentation>The xsl:message element sends a message in a way that is dependent on the XSLT processor.
  578.                 The message is the contents of the xsl:message element.</xs:documentation>
  579.         </xs:annotation>
  580.         <xs:complexType mixed="true">
  581.             <xs:choice maxOccurs="unbounded" minOccurs="0">
  582.                 <xs:element ref="apply-templates"/>
  583.                 <xs:element ref="call-template"/>
  584.                 <xs:element ref="apply-imports"/>
  585.                 <xs:element ref="for-each"/>
  586.                 <xs:element ref="value-of"/>
  587.                 <xs:element ref="copy-of"/>
  588.                 <xs:element ref="number"/>
  589.                 <xs:element ref="choose"/>
  590.                 <xs:element ref="if"/>
  591.                 <xs:element ref="text"/>
  592.                 <xs:element ref="copy"/>
  593.                 <xs:element ref="variable"/>
  594.                 <xs:element ref="message"/>
  595.                 <xs:element ref="fallback"/>
  596.                 <xs:element ref="processing-instruction"/>
  597.                 <xs:element ref="comment"/>
  598.                 <xs:element ref="element"/>
  599.                 <xs:element ref="attribute"/>
  600.             </xs:choice>
  601.             <xs:attribute default="no" name="terminate">
  602.                 <xs:annotation>
  603.                     <xs:documentation>The terminate attribute has as permitted values yes and no. If the value is set to
  604.                         yes, processing of the stylesheet is terminated after issuing the message. The default value is no.</xs:documentation>
  605.                 </xs:annotation>
  606.                 <xs:simpleType>
  607.                     <xs:restriction base="xs:NMTOKEN">
  608.                         <xs:enumeration value="yes"/>
  609.                         <xs:enumeration value="no"/>
  610.                     </xs:restriction>
  611.                 </xs:simpleType>
  612.             </xs:attribute>
  613.             <xs:attributeGroup ref="xml:specialAttrs"/>
  614.         </xs:complexType>
  615.     </xs:element>
  616.     <xs:element name="namespace-alias">
  617.         <xs:annotation>
  618.             <xs:documentation> The xsl:namespace-alias element is a top-level element that is used to control the
  619.                 mapping between a namespace URI used in the stylesheet and the corresponding namespace URI used in the
  620.                 result document. Normally when a literal result element is encountered in a template, the namespace used
  621.                 for the element name and attribute names in the result document is the same as the namespace used in the
  622.                 stylesheet. If a different namespace is wanted (e.g. because the result document is a stylesheet using
  623.                 the XSLT namespace), then xsl:namespace-alias can be used to define the mapping. The xsl:namespace-alias
  624.                 element declares that the namespace URI bound to the prefix specified by the stylesheet-prefix attribute
  625.                 is an alias for the namespace URI bound to the prefix specified by the result-prefix attribute. Thus,
  626.                 the stylesheet-prefix attribute specifies the namespace URI that will appear in the stylesheet, and the
  627.                 result-prefix attribute specifies the corresponding namespace URI that will appear in the result tree.
  628.                 The default namespace (as declared by xmlns) may be specified by using #default instead of a prefix. If
  629.                 a namespace URI is declared to be an alias for multiple different namespace URIs, then the declaration
  630.                 with the highest import precedence is used.</xs:documentation>
  631.         </xs:annotation>
  632.         <xs:complexType>
  633.             <xs:attribute name="stylesheet-prefix" type="xs:string" use="required">
  634.                 <xs:annotation>
  635.                     <xs:documentation>The stylesheet-prefix attribute specifies the namespace URI that will appear in
  636.                         the stylesheet.</xs:documentation>
  637.                 </xs:annotation>
  638.             </xs:attribute>
  639.             <xs:attribute name="result-prefix" type="xs:string" use="required">
  640.                 <xs:annotation>
  641.                     <xs:documentation>The result-prefix attribute specifies the corresponding namespace URI that will
  642.                         appear in the result tree. </xs:documentation>
  643.                 </xs:annotation>
  644.             </xs:attribute>
  645.             <xs:attributeGroup ref="xml:specialAttrs"/>
  646.         </xs:complexType>
  647.     </xs:element>
  648.     <xs:element name="number">
  649.         <xs:annotation>
  650.             <xs:documentation>The xsl:number element is used to insert a formatted number into the result tree. The
  651.                 number to be inserted may be specified by an expression. The value attribute contains an expression. The
  652.                 expression is evaluated and the resulting object is converted to a number as if by a call to the number
  653.                 function. If no value attribute is specified, then the xsl:number element inserts a number based on the
  654.                 position of the current node in the source tree. </xs:documentation>
  655.         </xs:annotation>
  656.         <xs:complexType>
  657.             <xs:attribute default="single" name="level">
  658.                 <xs:annotation>
  659.                     <xs:documentation>The level attribute specifies what levels of the source tree should be considered
  660.                         for counting; it has the values single, multiple or any. The default is single. </xs:documentation>
  661.                 </xs:annotation>
  662.                 <xs:simpleType>
  663.                     <xs:restriction base="xs:NMTOKEN">
  664.                         <xs:enumeration value="single"/>
  665.                         <xs:enumeration value="multiple"/>
  666.                         <xs:enumeration value="any"/>
  667.                     </xs:restriction>
  668.                 </xs:simpleType>
  669.             </xs:attribute>
  670.             <xs:attribute name="count" type="xs:string">
  671.                 <xs:annotation>
  672.                     <xs:documentation>The count attribute value is a pattern indicating which nodes to count; the
  673.                         default is to match all nodes of the same type and name as the current node. </xs:documentation>
  674.                 </xs:annotation>
  675.             </xs:attribute>
  676.             <xs:attribute name="from" type="xs:string">
  677.                 <xs:annotation>
  678.                     <xs:documentation>The from attribute is a pattern that specifies where counting starts. </xs:documentation>
  679.                 </xs:annotation>
  680.             </xs:attribute>
  681.             <xs:attribute name="value" type="xs:string">
  682.                 <xs:annotation>
  683.                     <xs:documentation>The value attribute contains an expression. The expression is evaluated and the
  684.                         resulting object is converted to a number as if by a call to the number function. If this
  685.                         attribute is present, the other attributes are ignored. </xs:documentation>
  686.                 </xs:annotation>
  687.             </xs:attribute>
  688.             <xs:attribute default="1" name="format" type="xs:string">
  689.                 <xs:annotation>
  690.                     <xs:documentation> The format attribute controls the output format. This contains an alternating
  691.                         sequence of format-tokens and punctuation-tokens. A format-token is any sequence of alphanumeric
  692.                         characters, a punctuation-token is any other sequence. The default value for the format
  693.                         attribute is 1.</xs:documentation>
  694.                 </xs:annotation>
  695.             </xs:attribute>
  696.             <xs:attribute name="lang" type="xs:string">
  697.                 <xs:annotation>
  698.                     <xs:documentation>When numbering with an alphabetic sequence, the lang attribute specifies which
  699.                         language's alphabet is to be used; it has the same range of values as xml:lang; if no lang value
  700.                         is specified, the language should be determined from the system environment. </xs:documentation>
  701.                 </xs:annotation>
  702.             </xs:attribute>
  703.             <xs:attribute name="letter-value" type="xs:string">
  704.                 <xs:annotation>
  705.                     <xs:documentation>The letter-value attribute disambiguates between numbering sequences that use
  706.                         letters. In many languages there are two commonly used numbering sequences that use letters. One
  707.                         numbering sequence assigns numeric values to letters in alphabetic sequence, and the other
  708.                         assigns numeric values to each letter in some other manner traditional in that language. In
  709.                         English, these would correspond to the numbering sequences specified by the format tokens a and
  710.                         i. In some languages, the first member of each sequence is the same, and so the format token
  711.                         alone would be ambiguous. A value of alphabetic specifies the alphabetic sequence; a value of
  712.                         traditional specifies the other sequence. If the letter-value attribute is not specified, then
  713.                         it is implementation-dependent how any ambiguity is resolved. </xs:documentation>
  714.                 </xs:annotation>
  715.             </xs:attribute>
  716.             <xs:attribute name="grouping-separator" type="xs:string">
  717.                 <xs:annotation>
  718.                     <xs:documentation>The grouping-separator attribute gives the separator used as a grouping (e.g.
  719.                         thousands) separator in decimal numbering sequences, and the optional grouping-size specifies
  720.                         the size (normally 3) of the grouping. For example, grouping-separator="," and grouping-size="3"
  721.                         would produce numbers of the form 1,000,000. If only one of the grouping-separator and
  722.                         grouping-size attributes is specified, then it is ignored. </xs:documentation>
  723.                 </xs:annotation>
  724.             </xs:attribute>
  725.             <xs:attribute name="grouping-size" type="xs:string">
  726.                 <xs:annotation>
  727.                     <xs:documentation>The grouping-separator attribute gives the separator used as a grouping (e.g.
  728.                         thousands) separator in decimal numbering sequences, and the optional grouping-size specifies
  729.                         the size (normally 3) of the grouping. For example, grouping-separator="," and grouping-size="3"
  730.                         would produce numbers of the form 1,000,000. If only one of the grouping-separator and
  731.                         grouping-size attributes is specified, then it is ignored. </xs:documentation>
  732.                 </xs:annotation>
  733.             </xs:attribute>
  734.             <xs:attributeGroup ref="xml:specialAttrs"/>
  735.         </xs:complexType>
  736.     </xs:element>
  737.     <xs:element name="otherwise">
  738.         <xs:annotation>
  739.             <xs:documentation>The xsl:otherwise element is used within an xsl:choose element to indicate the default
  740.                 action to be taken if none of the other choices matches.</xs:documentation>
  741.         </xs:annotation>
  742.         <xs:complexType mixed="true">
  743.             <xs:choice maxOccurs="unbounded" minOccurs="0">
  744.                 <xs:element ref="apply-templates"/>
  745.                 <xs:element ref="call-template"/>
  746.                 <xs:element ref="apply-imports"/>
  747.                 <xs:element ref="for-each"/>
  748.                 <xs:element ref="value-of"/>
  749.                 <xs:element ref="copy-of"/>
  750.                 <xs:element ref="number"/>
  751.                 <xs:element ref="choose"/>
  752.                 <xs:element ref="if"/>
  753.                 <xs:element ref="text"/>
  754.                 <xs:element ref="copy"/>
  755.                 <xs:element ref="variable"/>
  756.                 <xs:element ref="message"/>
  757.                 <xs:element ref="fallback"/>
  758.                 <xs:element ref="processing-instruction"/>
  759.                 <xs:element ref="comment"/>
  760.                 <xs:element ref="element"/>
  761.                 <xs:element ref="attribute"/>
  762.             </xs:choice>
  763.             <xs:attributeGroup ref="xml:specialAttrs"/>
  764.         </xs:complexType>
  765.     </xs:element>
  766.     <xs:element name="output">
  767.         <xs:annotation>
  768.             <xs:documentation>An XSLT processor may output the result tree as a sequence of bytes, although it is not
  769.                 required to be able to do so. The xsl:output element allows stylesheet authors to specify how they wish
  770.                 the result tree to be output. If an XSLT processor outputs the result tree, it should do so as specified
  771.                 by the xsl:output element; however, it is not required to do so. A stylesheet may contain multiple
  772.                 xsl:output elements and may include or import stylesheets that also contain xsl:output elements. All the
  773.                 xsl:output elements occurring in a stylesheet are merged into a single effective xsl:output element. For
  774.                 the cdata-section-elements attribute, the effective value is the union of the specified values. For
  775.                 other attributes, the effective value is the specified value with the highest import precedence. The
  776.                 values of attributes are defaulted after the xsl:output elements have been merged; different output
  777.                 methods may have different default values for an attribute. </xs:documentation>
  778.         </xs:annotation>
  779.         <xs:complexType>
  780.             <xs:attribute name="method" type="xs:QName">
  781.                 <xs:annotation>
  782.                     <xs:documentation>The method attribute on xsl:output identifies the overall method that should be
  783.                         used for outputting the result tree. The value must be a QName. If the QName does not have a
  784.                         prefix, then it identifies a method specified in this document and must be one of xml, html or
  785.                         text. If the QName has a prefix, then the QName is expanded into an expanded-name; the
  786.                         expanded-name identifies the output method.</xs:documentation>
  787.                 </xs:annotation>
  788.             </xs:attribute>
  789.             <xs:attribute name="version" type="xs:NMTOKEN">
  790.                 <xs:annotation>
  791.                     <xs:documentation>The version attribute specifies the version of the output method.</xs:documentation>
  792.                 </xs:annotation>
  793.             </xs:attribute>
  794.             <xs:attribute name="encoding" type="xs:string">
  795.                 <xs:annotation>
  796.                     <xs:documentation> The encoding attribute specifies the preferred character encoding that the XSLT
  797.                         processor should use to encode sequences of characters as sequences of bytes; the value of the
  798.                         attribute should be treated case-insensitively; the value must contain only characters in the
  799.                         range #x21 to #x7E (i.e. printable ASCII characters); the value should either be a charset
  800.                         registered with the Internet Assigned Numbers Authority or start with X-. The default (and
  801.                         fallback) is UTF-8.</xs:documentation>
  802.                 </xs:annotation>
  803.             </xs:attribute>
  804.             <xs:attribute name="omit-xml-declaration">
  805.                 <xs:annotation>
  806.                     <xs:documentation>The omit-xml-declaration attribute specifies whether the XSLT processor should
  807.                         output an XML declaration; the value must be yes or no.</xs:documentation>
  808.                 </xs:annotation>
  809.                 <xs:simpleType>
  810.                     <xs:restriction base="xs:NMTOKEN">
  811.                         <xs:enumeration value="yes"/>
  812.                         <xs:enumeration value="no"/>
  813.                     </xs:restriction>
  814.                 </xs:simpleType>
  815.             </xs:attribute>
  816.             <xs:attribute name="standalone">
  817.                 <xs:annotation>
  818.                     <xs:documentation>This is used only for XML output: if it is present, a standalone attribute is
  819.                         included in the XML declaration, with the value yes or no.</xs:documentation>
  820.                 </xs:annotation>
  821.                 <xs:simpleType>
  822.                     <xs:restriction base="xs:NMTOKEN">
  823.                         <xs:enumeration value="yes"/>
  824.                         <xs:enumeration value="no"/>
  825.                     </xs:restriction>
  826.                 </xs:simpleType>
  827.             </xs:attribute>
  828.             <xs:attribute name="doctype-public" type="xs:string">
  829.                 <xs:annotation>
  830.                     <xs:documentation>This is used only for XML output: it is copied into the DOCTYPE declaration as the
  831.                         public identifier. It is ignored if there is no system identifier.</xs:documentation>
  832.                 </xs:annotation>
  833.             </xs:attribute>
  834.             <xs:attribute name="doctype-system" type="xs:string">
  835.                 <xs:annotation>
  836.                     <xs:documentation>This is used only for XML output: it is copied into the DOCTYPE declaration as the
  837.                         system identifier</xs:documentation>
  838.                 </xs:annotation>
  839.             </xs:attribute>
  840.             <xs:attribute name="cdata-section-elements" type="xs:NMTOKENS">
  841.                 <xs:annotation>
  842.                     <xs:documentation>This is used only for XML output. It is a whitespace-separated list of element
  843.                         names. Character data belonging to these output elements will be written within CDATA sections.</xs:documentation>
  844.                 </xs:annotation>
  845.             </xs:attribute>
  846.             <xs:attribute name="indent">
  847.                 <xs:annotation>
  848.                     <xs:documentation>The indent attribute specifies whether the XSLT processor may add additional
  849.                         whitespace when outputting the result tree; the value must be yes or no. </xs:documentation>
  850.                 </xs:annotation>
  851.                 <xs:simpleType>
  852.                     <xs:restriction base="xs:NMTOKEN">
  853.                         <xs:enumeration value="yes"/>
  854.                         <xs:enumeration value="no"/>
  855.                     </xs:restriction>
  856.                 </xs:simpleType>
  857.             </xs:attribute>
  858.             <xs:attribute name="media-type" type="xs:string">
  859.                 <xs:annotation>
  860.                     <xs:documentation>The media-type attribute specifies the media type (MIME content type) of the data
  861.                         that results from outputting the result tree; the charset parameter should not be specified
  862.                         explicitly; instead, when the top-level media type is text, a charset parameter should be added
  863.                         according to the character encoding actually used by the output method.</xs:documentation>
  864.                 </xs:annotation>
  865.             </xs:attribute>
  866.             <xs:attributeGroup ref="xml:specialAttrs"/>
  867.         </xs:complexType>
  868.     </xs:element>
  869.     <xs:element name="param">
  870.         <xs:annotation>
  871.             <xs:documentation>The xsl:param element is used to define a formal parameter to a template, or to the
  872.                 stylesheet. As a template parameter, it must be used as an immediate child of the xsl:template element.
  873.                 As a stylesheet parameter, it must be used as an immediate child of the xsl:stylesheet element. The
  874.                 default value of the parameter may be defined either by a select attribute, or by the contents of the
  875.                 xsl:param element, in the same way as for xsl:variable. The default value is ignored if an actual
  876.                 parameter is supplied with the same name. </xs:documentation>
  877.         </xs:annotation>
  878.         <xs:complexType mixed="true">
  879.             <xs:choice maxOccurs="unbounded" minOccurs="0">
  880.                 <xs:element ref="apply-templates"/>
  881.                 <xs:element ref="call-template"/>
  882.                 <xs:element ref="apply-imports"/>
  883.                 <xs:element ref="for-each"/>
  884.                 <xs:element ref="value-of"/>
  885.                 <xs:element ref="copy-of"/>
  886.                 <xs:element ref="number"/>
  887.                 <xs:element ref="choose"/>
  888.                 <xs:element ref="if"/>
  889.                 <xs:element ref="text"/>
  890.                 <xs:element ref="copy"/>
  891.                 <xs:element ref="variable"/>
  892.                 <xs:element ref="message"/>
  893.                 <xs:element ref="fallback"/>
  894.                 <xs:element ref="processing-instruction"/>
  895.                 <xs:element ref="comment"/>
  896.                 <xs:element ref="element"/>
  897.                 <xs:element ref="attribute"/>
  898.             </xs:choice>
  899.             <xs:attribute name="name" type="xs:QName" use="required">
  900.                 <xs:annotation>
  901.                     <xs:documentation>The name attribute defines the name of the parameter.</xs:documentation>
  902.                 </xs:annotation>
  903.             </xs:attribute>
  904.             <xs:attribute name="select" type="xs:string">
  905.                 <xs:annotation>
  906.                     <xs:documentation>Defines the default value of the parameter. In this case, the content must be
  907.                         empty. </xs:documentation>
  908.                 </xs:annotation>
  909.             </xs:attribute>
  910.             <xs:attributeGroup ref="xml:specialAttrs"/>
  911.         </xs:complexType>
  912.     </xs:element>
  913.     <xs:element name="preserve-space">
  914.         <xs:annotation>
  915.             <xs:documentation>The xsl:preserve-space element is used at the top level of the stylesheet to define
  916.                 elements in the source document for which white-space nodes are significant and should be retained. </xs:documentation>
  917.         </xs:annotation>
  918.         <xs:complexType>
  919.             <xs:attribute name="elements" type="xs:string" use="required">
  920.                 <xs:annotation>
  921.                     <xs:documentation>The elements attribute is mandatory, and defines a space-separated list of element
  922.                         names. The value "*" may be used to mean "all elements"; in this case any elements where
  923.                         whitespace is not to be preserved may be indicated by an xsl:strip-space element.</xs:documentation>
  924.                 </xs:annotation>
  925.             </xs:attribute>
  926.             <xs:attributeGroup ref="xml:specialAttrs"/>
  927.         </xs:complexType>
  928.     </xs:element>
  929.     <xs:element name="processing-instruction">
  930.         <xs:annotation>
  931.             <xs:documentation>The xsl:processing-instruction element can appear anywhere within an xsl:template. It
  932.                 causes an XML processing instruction to be output. There is a mandatory name attribute which gives the
  933.                 name of the PI. The content of the xsl:processing-instruction element is expanded to form the data part
  934.                 of the PI. Note that special characters occurring within the PI text will not be escaped.</xs:documentation>
  935.         </xs:annotation>
  936.         <xs:complexType mixed="true">
  937.             <xs:choice maxOccurs="unbounded" minOccurs="0">
  938.                 <xs:element ref="apply-templates"/>
  939.                 <xs:element ref="call-template"/>
  940.                 <xs:element ref="apply-imports"/>
  941.                 <xs:element ref="for-each"/>
  942.                 <xs:element ref="value-of"/>
  943.                 <xs:element ref="copy-of"/>
  944.                 <xs:element ref="number"/>
  945.                 <xs:element ref="choose"/>
  946.                 <xs:element ref="if"/>
  947.                 <xs:element ref="text"/>
  948.                 <xs:element ref="copy"/>
  949.                 <xs:element ref="variable"/>
  950.                 <xs:element ref="message"/>
  951.                 <xs:element ref="fallback"/>
  952.             </xs:choice>
  953.             <xs:attribute name="name" type="xs:string" use="required">
  954.                 <xs:annotation>
  955.                     <xs:documentation>Specifies the name of the processing instruction node. This attribute is
  956.                         interpreted as an attribute value template, so it may contain string expressions within curly braces.</xs:documentation>
  957.                 </xs:annotation>
  958.             </xs:attribute>
  959.             <xs:attributeGroup ref="xml:specialAttrs"/>
  960.         </xs:complexType>
  961.     </xs:element>
  962.     <xs:element name="sort">
  963.         <xs:annotation>
  964.             <xs:documentation> The xsl:sort element is used within an xsl:for-each or xsl:apply-templates element to
  965.                 indicate the order in which the selected elements are processed. The first xsl:sort child specifies the
  966.                 primary sort key, the second xsl:sort child specifies the secondary sort key and so on. When an
  967.                 xsl:apply-templates or xsl:for-each element has one or more xsl:sort children, then instead of
  968.                 processing the selected nodes in document order, it sorts the nodes according to the specified sort keys
  969.                 and then processes them in sorted order. </xs:documentation>
  970.         </xs:annotation>
  971.         <xs:complexType>
  972.             <xs:attribute default="." name="select" type="xs:string">
  973.                 <xs:annotation>
  974.                     <xs:documentation> The select attribute (default value ".") is a string expression that calculates
  975.                         the sort key. </xs:documentation>
  976.                 </xs:annotation>
  977.             </xs:attribute>
  978.             <xs:attribute name="lang" type="xs:string">
  979.                 <xs:annotation>
  980.                     <xs:documentation> The value of the lang attribute can be an ISO language code such as "en"
  981.                         (English) or "de" (German). It determines the algorithm used for alphabetic collating. The value
  982.                         of lang does not have to be a recognized language code, it is also possible to use values such
  983.                         as "month" to select a data-type-specific collating algorithm. </xs:documentation>
  984.                 </xs:annotation>
  985.             </xs:attribute>
  986.             <xs:attribute default="text" name="data-type">
  987.                 <xs:annotation>
  988.                     <xs:documentation>The data-type attribute (values "text" or "number") determines whether collating
  989.                         is based on alphabetic sequence or numeric sequence. The default value is text. </xs:documentation>
  990.                 </xs:annotation>
  991.                 <xs:simpleType>
  992.                     <xs:restriction base="xs:string">
  993.                         <xs:enumeration value="text"/>
  994.                         <xs:enumeration value="number"/>
  995.                     </xs:restriction>
  996.                 </xs:simpleType>
  997.             </xs:attribute>
  998.             <xs:attribute default="ascending" name="order">
  999.                 <xs:annotation>
  1000.                     <xs:documentation>The order attribute specifies whether the strings should be sorted in ascending or
  1001.                         descending order; the default is ascending </xs:documentation>
  1002.                 </xs:annotation>
  1003.                 <xs:simpleType>
  1004.                     <xs:restriction base="xs:string">
  1005.                         <xs:enumeration value="ascending"/>
  1006.                         <xs:enumeration value="descending"/>
  1007.                     </xs:restriction>
  1008.                 </xs:simpleType>
  1009.             </xs:attribute>
  1010.             <xs:attribute name="case-order">
  1011.                 <xs:annotation>
  1012.                     <xs:documentation>The case-order attribute has the value upper-first or lower-first; this applies
  1013.                         when data-type="text", and specifies that upper-case letters should sort before lower-case
  1014.                         letters or vice-versa respectively. For example, if lang="en", then A a B b are sorted with
  1015.                         case-order="upper-first" and a A b B are sorted with case-order="lower-first". The default value
  1016.                         is language dependent. </xs:documentation>
  1017.                 </xs:annotation>
  1018.                 <xs:simpleType>
  1019.                     <xs:restriction base="xs:string">
  1020.                         <xs:enumeration value="upper-first"/>
  1021.                         <xs:enumeration value="lower-first"/>
  1022.                     </xs:restriction>
  1023.                 </xs:simpleType>
  1024.             </xs:attribute>
  1025.             <xs:attributeGroup ref="xml:specialAttrs"/>
  1026.         </xs:complexType>
  1027.     </xs:element>
  1028.     <xs:element name="strip-space">
  1029.         <xs:annotation>
  1030.             <xs:documentation>The element is used at the top level of the stylesheet to define elements in the source
  1031.                 document for which white-space nodes are insignificant and should be removed from the tree before
  1032.                 processing. </xs:documentation>
  1033.         </xs:annotation>
  1034.         <xs:complexType>
  1035.             <xs:attribute name="elements" type="xs:string" use="required">
  1036.                 <xs:annotation>
  1037.                     <xs:documentation>The elements attribute is mandatory, and defines a space-separated list of element
  1038.                         names. The value "*" may be used to mean "all elements"; in this case any elements where
  1039.                         whitespace is not to be stripped may be indicated by an xsl:preserve-space element.</xs:documentation>
  1040.                 </xs:annotation>
  1041.             </xs:attribute>
  1042.             <xs:attributeGroup ref="xml:specialAttrs"/>
  1043.         </xs:complexType>
  1044.     </xs:element>
  1045.     <xs:element name="stylesheet">
  1046.         <xs:annotation>
  1047.             <xs:documentation> The xsl:stylesheet element is always the top-level element of an XSL stylesheet. The name
  1048.                 xsl:transform may be used as a synonym. </xs:documentation>
  1049.         </xs:annotation>
  1050.         <xs:complexType>
  1051.             <xs:sequence>
  1052.                 <xs:element maxOccurs="unbounded" minOccurs="0" ref="import"/>
  1053.                 <xs:choice maxOccurs="unbounded" minOccurs="0">
  1054.                     <xs:element ref="include"/>
  1055.                     <xs:element ref="strip-space"/>
  1056.                     <xs:element ref="preserve-space"/>
  1057.                     <xs:element ref="output"/>
  1058.                     <xs:element ref="key"/>
  1059.                     <xs:element ref="decimal-format"/>
  1060.                     <xs:element ref="attribute-set"/>
  1061.                     <xs:element ref="variable"/>
  1062.                     <xs:element ref="param"/>
  1063.                     <xs:element ref="template"/>
  1064.                     <xs:element ref="namespace-alias"/>
  1065.                     <xs:any namespace="##other" processContents="lax"/>
  1066.                 </xs:choice>
  1067.             </xs:sequence>
  1068.             <xs:attribute name="extension-element-prefixes" type="xs:string">
  1069.                 <xs:annotation>
  1070.                     <xs:documentation>A namespace can be designated as an extension namespace by using an
  1071.                         extension-element-prefixes attribute. The value is a whitespace-separated list of namespace
  1072.                         prefixes. The namespace bound to each of the prefixes is designated as an extension namespace.
  1073.                         The default namespace (as declared by xmlns) may be designated as an extension namespace by
  1074.                         including #default in the list of namespace prefixes. </xs:documentation>
  1075.                 </xs:annotation>
  1076.             </xs:attribute>
  1077.             <xs:attribute name="exclude-result-prefixes" type="xs:string">
  1078.                 <xs:annotation>
  1079.                     <xs:documentation>A namespace URI is designated as an excluded namespace by using an
  1080.                         exclude-result-prefixes attribute. The value is a whitespace-separated list of namespace
  1081.                         prefixes. The namespace bound to each of the prefixes is designated as an excluded namespace.
  1082.                         The default namespace (as declared by xmlns) may be designated as an excluded namespace by
  1083.                         including #default in the list of namespace prefixes. </xs:documentation>
  1084.                 </xs:annotation>
  1085.             </xs:attribute>
  1086.             <xs:attribute name="id" type="xs:ID">
  1087.                 <xs:annotation>
  1088.                     <xs:documentation/>
  1089.                 </xs:annotation>
  1090.             </xs:attribute>
  1091.             <xs:attribute name="version" type="xs:NMTOKEN" use="required">
  1092.                 <xs:annotation>
  1093.                     <xs:documentation>An xsl:stylesheet element must have a version attribute, indicating the version of
  1094.                         XSLT that the stylesheet requires. For this version of XSLT, the value should be 1.0. When the
  1095.                         value is not equal to 1.0, forwards-compatible processing mode is enabled.</xs:documentation>
  1096.                 </xs:annotation>
  1097.             </xs:attribute>
  1098.             <xs:attributeGroup ref="xml:specialAttrs"/>
  1099.         </xs:complexType>
  1100.     </xs:element>
  1101.     <xs:element name="template">
  1102.         <xs:annotation>
  1103.             <xs:documentation>The xsl:template element defines a processing rule for source elements or other nodes of a
  1104.                 particular type.</xs:documentation>
  1105.         </xs:annotation>
  1106.         <xs:complexType mixed="true">
  1107.             <xs:choice maxOccurs="unbounded" minOccurs="0">
  1108.                 <xs:element ref="apply-templates"/>
  1109.                 <xs:element ref="call-template"/>
  1110.                 <xs:element ref="apply-imports"/>
  1111.                 <xs:element ref="for-each"/>
  1112.                 <xs:element ref="value-of"/>
  1113.                 <xs:element ref="copy-of"/>
  1114.                 <xs:element ref="number"/>
  1115.                 <xs:element ref="choose"/>
  1116.                 <xs:element ref="if"/>
  1117.                 <xs:element ref="text"/>
  1118.                 <xs:element ref="copy"/>
  1119.                 <xs:element ref="variable"/>
  1120.                 <xs:element ref="message"/>
  1121.                 <xs:element ref="fallback"/>
  1122.                 <xs:element ref="processing-instruction"/>
  1123.                 <xs:element ref="comment"/>
  1124.                 <xs:element ref="element"/>
  1125.                 <xs:element ref="attribute"/>
  1126.                 <xs:element ref="param"/>
  1127.             </xs:choice>
  1128.             <xs:attribute name="match" type="xs:string">
  1129.                 <xs:annotation>
  1130.                     <xs:documentation>The match attribute is a pattern that identifies the source node or nodes to which
  1131.                         the rule applies. The match attribute is required unless the xsl:template element has a name
  1132.                         attribute. </xs:documentation>
  1133.                 </xs:annotation>
  1134.             </xs:attribute>
  1135.             <xs:attribute name="name" type="xs:QName">
  1136.                 <xs:annotation>
  1137.                     <xs:documentation>An xsl:template element with a name attribute specifies a named template and may
  1138.                         be invoked directly using xsl:call-template. If an xsl:template element has a name attribute, it
  1139.                         may, but need not, also have a match attribute. </xs:documentation>
  1140.                 </xs:annotation>
  1141.             </xs:attribute>
  1142.             <xs:attribute name="priority" type="xs:decimal">
  1143.                 <xs:annotation>
  1144.                     <xs:documentation>The priority of a template rule is specified by the priority attribute. The value
  1145.                         of this must be a real number (positive or negative), the dafault priority is 1. </xs:documentation>
  1146.                 </xs:annotation>
  1147.             </xs:attribute>
  1148.             <xs:attribute name="mode" type="xs:NMTOKEN">
  1149.                 <xs:annotation>
  1150.                     <xs:documentation>The xsl:template element has an optional mode attribute. If this is present, the
  1151.                         template will only be matched when the same mode is used in the invoking xsl:apply-templates element.</xs:documentation>
  1152.                 </xs:annotation>
  1153.             </xs:attribute>
  1154.             <xs:attributeGroup ref="xml:specialAttrs"/>
  1155.         </xs:complexType>
  1156.     </xs:element>
  1157.     <xs:element name="text">
  1158.         <xs:annotation>
  1159.             <xs:documentation>The xsl:text element causes its content to be output. The main reasons for enclosing text
  1160.                 within an xsl:text element is to allow white space to be output. White space nodes in the stylesheet are
  1161.                 ignored unless they appear immediately within an xsl:text element.</xs:documentation>
  1162.         </xs:annotation>
  1163.         <xs:complexType>
  1164.             <xs:simpleContent>
  1165.                 <xs:extension base="xs:string">
  1166.                     <xs:attribute default="no" name="disable-output-escaping">
  1167.                         <xs:annotation>
  1168.                             <xs:documentation>The optional disable-output-escaping attribute may be set to yes or no;
  1169.                                 the default is no. If set to yes, special characters such as "<" and "&"
  1170.                                 will be output as themselves, not as entities. Be aware that in general this can produce
  1171.                                 non-well-formed XML or HTML. It is useful, however, when generating things such as ASP
  1172.                                 or JSP pages. Escaping may not be disabled when writing to a result tree fragment. </xs:documentation>
  1173.                         </xs:annotation>
  1174.                         <xs:simpleType>
  1175.                             <xs:restriction base="xs:NMTOKEN">
  1176.                                 <xs:enumeration value="yes"/>
  1177.                                 <xs:enumeration value="no"/>
  1178.                             </xs:restriction>
  1179.                         </xs:simpleType>
  1180.                     </xs:attribute>
  1181.                     <xs:attributeGroup ref="xml:specialAttrs"/>
  1182.                 </xs:extension>
  1183.             </xs:simpleContent>
  1184.         </xs:complexType>
  1185.     </xs:element>
  1186.     <xs:element name="transform">
  1187.         <xs:annotation>
  1188.             <xs:documentation>The xsl:transform element is always the top-level element of an XSL stylesheet. It is a
  1189.                 synonym with the generally used xsl:stylesheet element.</xs:documentation>
  1190.         </xs:annotation>
  1191.         <xs:complexType>
  1192.             <xs:sequence>
  1193.                 <xs:element maxOccurs="unbounded" minOccurs="0" ref="import"/>
  1194.                 <xs:choice maxOccurs="unbounded" minOccurs="0">
  1195.                     <xs:element ref="include"/>
  1196.                     <xs:element ref="strip-space"/>
  1197.                     <xs:element ref="preserve-space"/>
  1198.                     <xs:element ref="output"/>
  1199.                     <xs:element ref="key"/>
  1200.                     <xs:element ref="decimal-format"/>
  1201.                     <xs:element ref="attribute-set"/>
  1202.                     <xs:element ref="variable"/>
  1203.                     <xs:element ref="param"/>
  1204.                     <xs:element ref="template"/>
  1205.                     <xs:element ref="namespace-alias"/>
  1206.                     <xs:any namespace="##other" processContents="lax"/>
  1207.                 </xs:choice>
  1208.             </xs:sequence>
  1209.             <xs:attribute name="extension-element-prefixes" type="xs:string">
  1210.                 <xs:annotation>
  1211.                     <xs:documentation>A namespace can be designated as an extension namespace by using an
  1212.                         extension-element-prefixes attribute. The value is a whitespace-separated list of namespace
  1213.                         prefixes. The namespace bound to each of the prefixes is designated as an extension namespace.
  1214.                         The default namespace (as declared by xmlns) may be designated as an extension namespace by
  1215.                         including #default in the list of namespace prefixes. </xs:documentation>
  1216.                 </xs:annotation>
  1217.             </xs:attribute>
  1218.             <xs:attribute name="exclude-result-prefixes" type="xs:string">
  1219.                 <xs:annotation>
  1220.                     <xs:documentation>A namespace URI is designated as an excluded namespace by using an
  1221.                         exclude-result-prefixes attribute. The value is a whitespace-separated list of namespace
  1222.                         prefixes. The namespace bound to each of the prefixes is designated as an excluded namespace.
  1223.                         The default namespace (as declared by xmlns) may be designated as an excluded namespace by
  1224.                         including #default in the list of namespace prefixes. </xs:documentation>
  1225.                 </xs:annotation>
  1226.             </xs:attribute>
  1227.             <xs:attribute name="id" type="xs:ID">
  1228.                 <xs:annotation>
  1229.                     <xs:documentation/>
  1230.                 </xs:annotation>
  1231.             </xs:attribute>
  1232.             <xs:attribute name="version" type="xs:NMTOKEN" use="required">
  1233.                 <xs:annotation>
  1234.                     <xs:documentation>An xsl:transform element must have a version attribute, indicating the version of
  1235.                         XSLT that the stylesheet requires. For this version of XSLT, the value should be 1.0. When the
  1236.                         value is not equal to 1.0, forwards-compatible processing mode is enabled.</xs:documentation>
  1237.                 </xs:annotation>
  1238.             </xs:attribute>
  1239.             <xs:attributeGroup ref="xml:specialAttrs"/>
  1240.         </xs:complexType>
  1241.     </xs:element>
  1242.     <xs:element name="value-of">
  1243.         <xs:annotation>
  1244.             <xs:documentation>The xsl:value-of element evaluates an expression as a string, and outputs its value to the
  1245.                 current output stream.</xs:documentation>
  1246.         </xs:annotation>
  1247.         <xs:complexType>
  1248.             <xs:attribute name="select" type="xs:string" use="required">
  1249.                 <xs:annotation>
  1250.                     <xs:documentation>The select attribute identifes the expression, and is mandatory. If the select
  1251.                         expression is a node-set expression that selects more than one node, only the first is
  1252.                         considered. If it selects no node, the result is an empty string.</xs:documentation>
  1253.                 </xs:annotation>
  1254.             </xs:attribute>
  1255.             <xs:attribute default="no" name="disable-output-escaping">
  1256.                 <xs:annotation>
  1257.                     <xs:documentation>The optional disable-output-escaping attribute may be set to yes or no; the
  1258.                         default is no. If set to yes, special characters such as "<" and "&" will be
  1259.                         output as themselves, not as entities. Be aware that in general this can produce non-well-formed
  1260.                         XML or HTML. It is useful, however, when generating things such as ASP or JSP pages. Escaping
  1261.                         may not be disabled when writing to a result tree fragment. </xs:documentation>
  1262.                 </xs:annotation>
  1263.                 <xs:simpleType>
  1264.                     <xs:restriction base="xs:NMTOKEN">
  1265.                         <xs:enumeration value="yes"/>
  1266.                         <xs:enumeration value="no"/>
  1267.                     </xs:restriction>
  1268.                 </xs:simpleType>
  1269.             </xs:attribute>
  1270.             <xs:attributeGroup ref="xml:specialAttrs"/>
  1271.         </xs:complexType>
  1272.     </xs:element>
  1273.     <xs:element name="variable">
  1274.         <xs:annotation>
  1275.             <xs:documentation>The xsl:variable element is used to declare a variable and give it a value. If it appears
  1276.                 at the top level (immediately within xsl:stylesheet) it declares a global variable, otherwise it
  1277.                 declares a local variable that is visible only within the stylesheet element containing the xsl:variable
  1278.                 declaration. The value of the variable may be defined either by an expression within the optional select
  1279.                 attribute, or by the contents of the xsl:variable element. In the latter case the result is technically
  1280.                 a value of type Result Tree Fragment. Variables once declared cannot be updated. </xs:documentation>
  1281.         </xs:annotation>
  1282.         <xs:complexType mixed="true">
  1283.             <xs:choice maxOccurs="unbounded" minOccurs="0">
  1284.                 <xs:element ref="apply-templates"/>
  1285.                 <xs:element ref="call-template"/>
  1286.                 <xs:element ref="apply-imports"/>
  1287.                 <xs:element ref="for-each"/>
  1288.                 <xs:element ref="value-of"/>
  1289.                 <xs:element ref="copy-of"/>
  1290.                 <xs:element ref="number"/>
  1291.                 <xs:element ref="choose"/>
  1292.                 <xs:element ref="if"/>
  1293.                 <xs:element ref="text"/>
  1294.                 <xs:element ref="copy"/>
  1295.                 <xs:element ref="variable"/>
  1296.                 <xs:element ref="message"/>
  1297.                 <xs:element ref="fallback"/>
  1298.                 <xs:element ref="processing-instruction"/>
  1299.                 <xs:element ref="comment"/>
  1300.                 <xs:element ref="element"/>
  1301.                 <xs:element ref="attribute"/>
  1302.             </xs:choice>
  1303.             <xs:attribute name="name" type="xs:QName" use="required">
  1304.                 <xs:annotation>
  1305.                     <xs:documentation>The mandatory name attribute defines the name of the variable.</xs:documentation>
  1306.                 </xs:annotation>
  1307.             </xs:attribute>
  1308.             <xs:attribute name="select" type="xs:string">
  1309.                 <xs:annotation>
  1310.                     <xs:documentation>If the xsl:variable element has a select attribute, then the value of the
  1311.                         attribute must be an expression and the value of the variable is the object that results from
  1312.                         evaluating the expression. In this case, the content must be empty. </xs:documentation>
  1313.                 </xs:annotation>
  1314.             </xs:attribute>
  1315.             <xs:attributeGroup ref="xml:specialAttrs"/>
  1316.         </xs:complexType>
  1317.     </xs:element>
  1318.     <xs:element name="when">
  1319.         <xs:annotation>
  1320.             <xs:documentation>The xsl:when element is used within an xsl:choose element to indicate one of a number of
  1321.                 choices. It takes a mandatory parameter, test, whose value is a match pattern. If this is the first
  1322.                 xsl:when element within the enclosing xsl:choose whose test condition matches the current element, the
  1323.                 content of the xsl:when element is expanded, otherwise it is ignored.</xs:documentation>
  1324.         </xs:annotation>
  1325.         <xs:complexType mixed="true">
  1326.             <xs:choice maxOccurs="unbounded" minOccurs="0">
  1327.                 <xs:element ref="apply-templates"/>
  1328.                 <xs:element ref="call-template"/>
  1329.                 <xs:element ref="apply-imports"/>
  1330.                 <xs:element ref="for-each"/>
  1331.                 <xs:element ref="value-of"/>
  1332.                 <xs:element ref="copy-of"/>
  1333.                 <xs:element ref="number"/>
  1334.                 <xs:element ref="choose"/>
  1335.                 <xs:element ref="if"/>
  1336.                 <xs:element ref="text"/>
  1337.                 <xs:element ref="copy"/>
  1338.                 <xs:element ref="variable"/>
  1339.                 <xs:element ref="message"/>
  1340.                 <xs:element ref="fallback"/>
  1341.                 <xs:element ref="processing-instruction"/>
  1342.                 <xs:element ref="comment"/>
  1343.                 <xs:element ref="element"/>
  1344.                 <xs:element ref="attribute"/>
  1345.             </xs:choice>
  1346.             <xs:attribute name="test" type="xs:string" use="required">
  1347.                 <xs:annotation>
  1348.                     <xs:documentation>Each xsl:when element has a single attribute, test, which specifies an expression.</xs:documentation>
  1349.                 </xs:annotation>
  1350.             </xs:attribute>
  1351.             <xs:attributeGroup ref="xml:specialAttrs"/>
  1352.         </xs:complexType>
  1353.     </xs:element>
  1354.     <xs:element name="with-param">
  1355.         <xs:annotation>
  1356.             <xs:documentation>The xsl:with-param element is used to define an actual parameter to a template. There is a
  1357.                 mandatory attribute, name, to define the name of the parameter. The value of the parameter may be
  1358.                 defined either by a select attribute, or by the contents of the xsl:param element. It is not an error to
  1359.                 pass a parameter x to a template that does not have an xsl:param element for x; the parameter is simply ignored.</xs:documentation>
  1360.         </xs:annotation>
  1361.         <xs:complexType mixed="true">
  1362.             <xs:choice maxOccurs="unbounded" minOccurs="0">
  1363.                 <xs:element ref="apply-templates"/>
  1364.                 <xs:element ref="call-template"/>
  1365.                 <xs:element ref="apply-imports"/>
  1366.                 <xs:element ref="for-each"/>
  1367.                 <xs:element ref="value-of"/>
  1368.                 <xs:element ref="copy-of"/>
  1369.                 <xs:element ref="number"/>
  1370.                 <xs:element ref="choose"/>
  1371.                 <xs:element ref="if"/>
  1372.                 <xs:element ref="text"/>
  1373.                 <xs:element ref="copy"/>
  1374.                 <xs:element ref="variable"/>
  1375.                 <xs:element ref="message"/>
  1376.                 <xs:element ref="fallback"/>
  1377.                 <xs:element ref="processing-instruction"/>
  1378.                 <xs:element ref="comment"/>
  1379.                 <xs:element ref="element"/>
  1380.                 <xs:element ref="attribute"/>
  1381.             </xs:choice>
  1382.             <xs:attribute name="name" type="xs:NMTOKEN" use="required">
  1383.                 <xs:annotation>
  1384.                     <xs:documentation>The required name attribute defines the name of the parameter.</xs:documentation>
  1385.                 </xs:annotation>
  1386.             </xs:attribute>
  1387.             <xs:attribute name="select" type="xs:string">
  1388.                 <xs:annotation>
  1389.                     <xs:documentation>If the xsl:param element has a select attribute, then the value of the attribute
  1390.                         must be an expression and the value of the parameter is the object that results from evaluating
  1391.                         the expression. In this case, the content must be empty. </xs:documentation>
  1392.                 </xs:annotation>
  1393.             </xs:attribute>
  1394.             <xs:attributeGroup ref="xml:specialAttrs"/>
  1395.         </xs:complexType>
  1396.     </xs:element>
  1397. </xs:schema>
  1398.