home *** CD-ROM | disk | FTP | other *** search
<?xml version="1.0" ?> <xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema" targetNamespace="http://www.w3.org/1999/XSL/Transform" elementFormDefault="qualified" xmlns:xsl="http://www.w3.org/1999/XSL/Transform"> <!-- ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ --> <xs:annotation> <xs:documentation> This is a schema for XSLT 2.0 stylesheets. It defines all the elements that appear in the XSLT namespace; it also provides hooks that allow the inclusion of user-defined literal result elements, extension instructions, and top-level data elements. The schema is derived (with kind permission) from a schema for XSLT 1.0 stylesheets produced by Asir S Vedamuthu of WebMethods Inc. This schema is available for use under the conditions of the W3C Software License published at http://www.w3.org/Consortium/Legal/copyright-software-19980720 The schema is organized as follows: PART A: definitions of complex types and model groups used as the basis for element definitions PART B: definitions of individual XSLT elements PART C: definitions for literal result elements PART D: definitions of simple types used in attribute definitions This schema does not attempt to define all the constraints that apply to a valid XSLT 2.0 stylesheet module. It is the intention that all valid stylesheet modules should conform to this schema; however, the schema is non-normative and in the event of any conflict, the text of the Recommendation takes precedence. This schema does not implement the special rules that apply when a stylesheet has sections that use forwards-compatible-mode. In this mode, setting version="3.0" allows elements from the XSLT namespace to be used that are not defined in XSLT 2.0. Simplified stylesheets (those with a literal result element as the outermost element) will validate against this schema only if validation starts in lax mode. This version is dated 2005-02-11 Authors: Michael H Kay, Saxonica Limited Jeni Tennison, Jeni Tennison Consulting Ltd. </xs:documentation> <xs:documentation> 2004-07-28, George Bina, SyncRO Soft Ltd. (oXygen XML Editor) added annotations for elements and attributes. Copyright ¬© 2002-2004 SyncRO Soft Ltd. All rights reserved. </xs:documentation> </xs:annotation> <!-- ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ --> <!-- The declaration of xml:space and xml:lang may need to be commented out because of problems processing the schema using various tools --> <xs:import namespace="http://www.w3.org/XML/1998/namespace" schemaLocation="xml.xsd"/> <!-- An XSLT stylesheet may contain an in-line schema within an xsl:import-schema element, so the Schema for schemas needs to be imported --> <xs:import namespace="http://www.w3.org/2001/XMLSchema" schemaLocation="XMLSchema.xsd"/> <!-- ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ --> <xs:annotation> <xs:documentation> PART A: definitions of complex types and model groups used as the basis for element definitions </xs:documentation> </xs:annotation> <!-- ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ --> <xs:complexType name="generic-element-type" mixed="true"> <xs:attribute name="default-collation" type="xsl:uri-list"> <xs:annotation> <xs:documentation> The default-collation attribute is a standard attribute that may appear on any element in the XSLT namespace, or (as xsl:default-collation) on a literal result element. The attribute is used to specify the default collation used by all XPath expressions appearing in the attributes of this element, or attributes of descendant elements, unless overridden by another default-collation attribute on an inner element. It also determines the collation used by certain XSLT constructs (such as xsl:key and xsl:for-each-group) within its scope. The value of the attribute is a whitespace-separated list of collation URIs. If the implementation recognizes one or more of these collation URIs, then it uses the first one that it recognizes as the default collation. <br/> See more info at http://www.w3.org/TR/xslt20/#default-collation-attribute </xs:documentation> </xs:annotation> </xs:attribute> <xs:attribute name="exclude-result-prefixes" type="xsl:prefix-list-or-all"> <xs:annotation> <xs:documentation>The created element node will also have a copy of the namespace nodes that were present on the element node in the stylesheet tree with the exception of any namespace node whose string value is designated as an excluded namespace. A namespace URIs designated by using an [xsl:]exclude-result-prefixes attribute either on the literal result element itself or on an ancestor element are designated as excluded namespace. The attribute must be in the XSLT namespace only if its parent element is not in the XSLT namespace. The value of the attribute is either #all, or a whitespace-separated list of tokens, each of which is either a namespace prefix or #default. The namespace bound to each of the prefixes is designated as an excluded namespace. <br/> See more info at http://www.w3.org/TR/xslt20/#lre-namespaces</xs:documentation> </xs:annotation> </xs:attribute> <xs:attribute name="extension-element-prefixes" type="xsl:prefix-list"> <xs:annotation> <xs:documentation> A namespace is designated as an extension namespace by using an [xsl:]extension-element-prefixes attribute on an element in the stylesheet. The attribute must be in the XSLT namespace only if its parent element is not in the XSLT namespace. The default namespace (as declared by xmlns) may be designated as an extension namespace by including #default in the list of namespace prefixes. The designation of a namespace as an extension namespace is effective for the element bearing the [xsl:]extension-element-prefixes attribute and for all descendants of that element within the same stylesheet module. <br/> See more info at http://www.w3.org/TR/xslt20/#extension-instruction</xs:documentation> </xs:annotation> </xs:attribute> <xs:attribute name="use-when" type="xsl:expression"> <xs:annotation> <xs:documentation> Any element in the XSLT namespace may have a use-when attribute whose value is an XPath expression that can be evaluated statically. If the attribute is present and the effective boolean valueXP of the expression is false, then the element, together with all the nodes having that element as an ancestor, is effectively excluded from the stylesheet module. When a node is effectively excluded from a stylesheet module the stylesheet module has the same effect as if the node were not there. Among other things this means that no static or dynamic errors will be reported in respect of the element and its contents, other than errors in the use-when attribute itself. </xs:documentation> </xs:annotation> </xs:attribute> <xs:attribute name="xpath-default-namespace" type="xs:anyURI"> <xs:annotation> <xs:documentation>The attribute [xsl:]xpath-default-namespace may be used on an element in the stylesheet to define the namespace that will be used for an unprefixed element name or type name. The attribute must be in the XSLT namespace only if its parent element is not in the XSLT namespace. If the effective value of the attribute is a zero-length string, which will be the case if it is explicitly set to a zero-length string or if it is not specified at all, then an unprefixed element name or type name refers to a name that is in no namespace. <br/> See more info at http://www.w3.org/TR/xslt20/#unprefixed-qnames</xs:documentation> </xs:annotation> </xs:attribute> <xs:anyAttribute namespace="##other" processContents="lax"/> </xs:complexType> <xs:complexType name="versioned-element-type" mixed="true"> <xs:complexContent> <xs:extension base="xsl:generic-element-type"> <xs:attribute name="version" type="xs:decimal" use="optional"> <xs:annotation> <xs:documentation> An element enables backwards-compatible behavior for itself, its attributes, its descendants and their attributes if it has an [xsl:]version attribute whose value is less than 2.0. An element enables forwards-compatible behavior for itself, its attributes, its descendants and their attributes if it has an [xsl:]version attribute whose value is greater than 2.0. The compatibility behavior established by an element overrides any compatibility behavior established by an ancestor element. The attribute must be in the XSLT namespace only if its parent element is not in the XSLT namespace. <br/> See more info at http://www.w3.org/TR/xslt20/#backwards and http://www.w3.org/TR/xslt20/#forwards </xs:documentation> </xs:annotation> </xs:attribute> </xs:extension> </xs:complexContent> </xs:complexType> <xs:complexType name="element-only-versioned-element-type" mixed="false"> <xs:complexContent> <xs:restriction base="xsl:versioned-element-type"> <xs:anyAttribute namespace="##other" processContents="lax"/> </xs:restriction> </xs:complexContent> </xs:complexType> <xs:complexType name="sequence-constructor"> <xs:complexContent mixed="true"> <xs:extension base="xsl:versioned-element-type"> <xs:group ref="xsl:sequence-constructor-group" minOccurs="0" maxOccurs="unbounded"/> </xs:extension> </xs:complexContent> </xs:complexType> <xs:group name="sequence-constructor-group"> <xs:choice> <xs:element ref="xsl:variable"/> <xs:element ref="xsl:instruction"/> <xs:group ref="xsl:result-elements"/> </xs:choice> </xs:group> <xs:element name="declaration" type="xsl:generic-element-type" abstract="true"/> <xs:element name="instruction" type="xsl:versioned-element-type" abstract="true"/> <!-- ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ --> <xs:annotation> <xs:documentation> PART B: definitions of individual XSLT elements Elements are listed in alphabetical order. </xs:documentation> </xs:annotation> <!-- ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ --> <xs:element name="analyze-string" substitutionGroup="xsl:instruction"> <xs:annotation> <xs:documentation>This instruction is designed to process all the non-overlapping substrings of the input string that match the regular expression supplied. The input string is partitioned into a sequence of substrings, some of which match the regular expression, others which do not match it. Each substring will contain at least one character. This sequence of substrings is processed using the xsl:matching-substring and xsl:non-matching-substring child instructions. <br/> See more info at http://www.w3.org/TR/xslt20/#element-analyze-string</xs:documentation> </xs:annotation> <xs:complexType> <xs:complexContent> <xs:extension base="xsl:element-only-versioned-element-type"> <xs:sequence> <xs:element ref="xsl:matching-substring" minOccurs="0"/> <xs:element ref="xsl:non-matching-substring" minOccurs="0"/> <xs:element ref="xsl:fallback" minOccurs="0" maxOccurs="unbounded"/> </xs:sequence> <xs:attribute name="select" type="xsl:expression" use="required"> <xs:annotation> <xs:documentation>Specifies the string input for the xsl:analyze-string instruction as the result of evaluating the expression in this attribute.</xs:documentation> </xs:annotation> </xs:attribute> <xs:attribute name="regex" type="xsl:avt" use="required"> <xs:annotation> <xs:documentation> Specifies the regular expression input for the xsl:analyze-string instruction as the effective value of the this attribute. Because the regex attribute is an attribute value template, curly brackets within the regular expression must be doubled.</xs:documentation> </xs:annotation> </xs:attribute> <xs:attribute name="flags" type="xsl:avt" default=""> <xs:annotation> <xs:documentation> The flags attribute may be used to control the interpretation of the regular expression. <br/> See more info at http://www.w3.org/TR/xpath-functions/#flags </xs:documentation> </xs:annotation> </xs:attribute> </xs:extension> </xs:complexContent> </xs:complexType> </xs:element> <xs:element name="apply-imports" substitutionGroup="xsl:instruction"> <xs:annotation> <xs:documentation>A template rule that is being used to override another template rule can use the xsl:apply-imports instruction to invoke the overridden template rule. The xsl:apply-imports instruction only considers template rules in imported stylesheet modules. It will invoke the built-in template rule for the node if no other template rule is found. <br/> See more info at http://www.w3.org/TR/xslt20/#element-apply-imports</xs:documentation> </xs:annotation> <xs:complexType> <xs:complexContent> <xs:extension base="xsl:element-only-versioned-element-type"> <xs:sequence> <xs:element ref="xsl:with-param" minOccurs="0" maxOccurs="unbounded"/> </xs:sequence> </xs:extension> </xs:complexContent> </xs:complexType> </xs:element> <xs:element name="apply-templates" substitutionGroup="xsl:instruction"> <xs:annotation> <xs:documentation> The xsl:apply-templates instruction takes as input a sequence of nodes in the source tree, and produces as output a sequence of items; these will often be nodes to be added to the result tree. If the instruction has one or more xsl:sort children, then the input sequence is sorted. Each node in the input sequence is processed by finding a template rule whose pattern matches that node.<br/> See more info at http://www.w3.org/TR/xslt20/#element-apply-templates</xs:documentation> </xs:annotation> <xs:complexType> <xs:complexContent> <xs:extension base="xsl:element-only-versioned-element-type"> <xs:choice minOccurs="0" maxOccurs="unbounded"> <xs:element ref="xsl:sort"/> <xs:element ref="xsl:with-param"/> </xs:choice> <xs:attribute name="select" type="xsl:expression" default="child::node()"> <xs:annotation> <xs:documentation>A select attribute can be used to process nodes selected by an expression instead of processing all children. The value of the select attribute is an expression. The expression must evaluate to a sequence of nodes (it can contain zero, one, or more nodes).</xs:documentation> </xs:annotation> </xs:attribute> <xs:attribute name="mode" type="xsl:mode"> <xs:annotation> <xs:documentation>The xsl:apply-templates element has an optional mode attribute that identifies the processing mode. The value of this attribute must either be a QName to define the name of a mode, or the token #default, to indicate that the default mode is to be used, or the token #current, to indicate that the current mode is to be used. If the attribute is omitted, the default mode is used. When searching for a template rule to process each node selected by the xsl:apply-templates instruction, only those template rules that are applicable to the selected mode are considered. <br/> See more info at http://www.w3.org/TR/xslt20/#modes</xs:documentation> </xs:annotation> </xs:attribute> </xs:extension> </xs:complexContent> </xs:complexType> </xs:element> <xs:element name="attribute" substitutionGroup="xsl:instruction"> <xs:annotation> <xs:documentation>The xsl:attribute element can be used to add attributes to result elements whether created by literal result elements in the stylesheet or by instructions such as xsl:element or xsl:copy. The expanded-QName of the attribute to be created is specified by a required name attribute and an optional namespace attribute. Except in error cases, the result of evaluating an xsl:attribute instruction is the newly constructed attribute node. <br/> See more info at http://www.w3.org/TR/xslt20/#element-attribute</xs:documentation> </xs:annotation> <xs:complexType> <xs:complexContent mixed="true"> <xs:extension base="xsl:sequence-constructor"> <xs:attribute name="name" type="xsl:avt" use="required"> <xs:annotation> <xs:documentation>The name attribute, together with the optional namespace attribute, specifies the expanded-QName of the attribute to be created. The name attribute is interpreted as an attribute value template, whose effective value must be a lexical QName.</xs:documentation> </xs:annotation> </xs:attribute> <xs:attribute name="namespace" type="xsl:avt"> <xs:annotation> <xs:documentation> The namespace attribute, together with the required name attribute, specifies the expanded-QName of the attribute to be created. If the namespace attribute is not present, then the lexical QName is expanded into an expanded-QName using the namespace declarations in effect for the xsl:attribute element, not including any default namespace declaration. If the namespace attribute is present, then it is interpreted as an attribute value template. The effective value should be a URI reference.</xs:documentation> </xs:annotation> </xs:attribute> <xs:attribute name="select" type="xsl:expression"> <xs:annotation> <xs:documentation>The string value of the new attribute node may be defined by using the select attribute.</xs:documentation> </xs:annotation> </xs:attribute> <xs:attribute name="separator" type="xsl:avt"> <xs:annotation> <xs:documentation>If the separator attribute is present, then the effective value of this attribute is used to separate adjacent items in the result sequence. In the absence of this attribute, the default separator is a single space (#x20) when the content is specified using the select attribute, or a zero-length string when the content is specified using a sequence constructor.</xs:documentation> </xs:annotation> </xs:attribute> <xs:attribute name="type" type="xsl:QName"> <xs:annotation> <xs:documentation> The optional type attribute may be used on the xsl:attribute instruction to invoke validation of the contents of the attribute against a type definition in a schema, and to determine the type annotation that the new attribute node will carry. If the type attribute is present, then the newly constructed attribute is validated against the type definition identified by this attribute. The type and validation attributes are mutually exclusive.<br/> See more info at http://www.w3.org/TR/xslt20/#validation </xs:documentation> </xs:annotation> </xs:attribute> <xs:attribute name="validation" type="xsl:validation-type"> <xs:annotation> <xs:documentation> The optional validation attribute may be used on the xsl:attribute instruction to invoke validation of the contents of the attribute against attribute declaration in a schema, and to determine the type annotation that the new attribute node will carry. Possible values are strip, preserve, strict and lax. The type and validation attributes are mutually exclusive.<br/> See more info at http://www.w3.org/TR/xslt20/#validation </xs:documentation> </xs:annotation> </xs:attribute> </xs:extension> </xs:complexContent> </xs:complexType> </xs:element> <xs:element name="attribute-set" substitutionGroup="xsl:declaration"> <xs:annotation> <xs:documentation>The xsl:attribute-set element defines a named attribute set: that is, a collection of attribute definitions that can be used repeatedly on different elements in the result tree. <br/> See more info at http://www.w3.org/TR/xslt20/#element-attribute-set</xs:documentation> </xs:annotation> <xs:complexType> <xs:complexContent> <xs:extension base="xsl:element-only-versioned-element-type"> <xs:sequence minOccurs="0" maxOccurs="unbounded"> <xs:element ref="xsl:attribute"/> </xs:sequence> <xs:attribute name="name" type="xsl:QName" use="required"> <xs:annotation> <xs:documentation>The required name attribute specifies the name of the attribute set. The value of the name attribute is a QName. </xs:documentation> </xs:annotation> </xs:attribute> <xs:attribute name="use-attribute-sets" type="xsl:QNames" default=""> <xs:annotation> <xs:documentation>Specifying a use-attribute-sets attribute is broadly equivalent to adding xsl:attribute instructions for each of the attributes in each of the named attribute sets to the beginning of the content of the instruction with the use-attribute-sets attribute, in the same order in which the names of the attribute sets are specified in the use-attribute-sets attribute.</xs:documentation> </xs:annotation> </xs:attribute> </xs:extension> </xs:complexContent> </xs:complexType> </xs:element> <xs:element name="call-template" substitutionGroup="xsl:instruction"> <xs:annotation> <xs:documentation>This instruction is used to invoke a template by name. An xsl:template element with a name attribute defines a named template. Unlike xsl:apply-templates, the xsl:call-template instruction does not change the focus.<br/> See more info at http://www.w3.org/TR/xslt20/#element-call-template </xs:documentation> </xs:annotation> <xs:complexType> <xs:complexContent> <xs:extension base="xsl:element-only-versioned-element-type"> <xs:sequence> <xs:element ref="xsl:with-param" minOccurs="0" maxOccurs="unbounded"/> </xs:sequence> <xs:attribute name="name" type="xsl:QName" use="required"> <xs:annotation> <xs:documentation>The name attribute identifies the template to be invoked.</xs:documentation> </xs:annotation> </xs:attribute> </xs:extension> </xs:complexContent> </xs:complexType> </xs:element> <xs:element name="character-map" substitutionGroup="xsl:declaration"> <xs:annotation> <xs:documentation> The xsl:character-map declaration declares a character map with a name and a set of character mappings. The character mappings are specified by means of xsl:output-character elements contained either directly within the xsl:character-map element, or in further character maps referenced in the use-character-maps attribute. <br/> See more info at http://www.w3.org/TR/xslt20/#element-character-map</xs:documentation> </xs:annotation> <xs:complexType> <xs:complexContent> <xs:extension base="xsl:element-only-versioned-element-type"> <xs:sequence> <xs:element ref="xsl:output-character" minOccurs="0" maxOccurs="unbounded"/> </xs:sequence> <xs:attribute name="name" type="xsl:QName" use="required"> <xs:annotation> <xs:documentation>The required name attribute provides a name for the character map. </xs:documentation> </xs:annotation> </xs:attribute> <xs:attribute name="use-character-maps" type="xsl:QNames" default=""> <xs:annotation> <xs:documentation>Specifies further character maps references. The character maps referenced in a single use-character-maps attribute are considered in the order in which they are listed. The expansion is depth-first: each referenced character map is fully expanded before the next one is considered. </xs:documentation> </xs:annotation> </xs:attribute> </xs:extension> </xs:complexContent> </xs:complexType> </xs:element> <xs:element name="choose" substitutionGroup="xsl:instruction"> <xs:annotation> <xs:documentation>The xsl:choose element selects one among a number of possible alternatives. It consists of a sequence of xsl:when elements followed by an optional xsl:otherwise element. When an xsl:choose element is processed, each of the xsl:when elements is tested in turn (that is, in the order that the elements appear in the stylesheet), until one of the xsl:when elements is satisfied. If none of the xsl:when elements is satisfied, then the xsl:otherwise element is considered. <br/> See more info at http://www.w3.org/TR/xslt20/#element-choose </xs:documentation> </xs:annotation> <xs:complexType> <xs:complexContent> <xs:extension base="xsl:element-only-versioned-element-type"> <xs:sequence> <xs:element ref="xsl:when" maxOccurs="unbounded"/> <xs:element ref="xsl:otherwise" minOccurs="0"/> </xs:sequence> </xs:extension> </xs:complexContent> </xs:complexType> </xs:element> <xs:element name="comment" substitutionGroup="xsl:instruction"> <xs:annotation> <xs:documentation> The xsl:comment element is evaluated to contruct a new comment node. Except in error cases, the result of evaluating the xsl:comment instruction is a single node, the newly constructed comment node. <br/> See more info at http://www.w3.org/TR/xslt20/#element-comment </xs:documentation> </xs:annotation> <xs:complexType> <xs:complexContent mixed="true"> <xs:extension base="xsl:sequence-constructor"> <xs:attribute name="select" type="xsl:expression"> <xs:annotation> <xs:documentation>Specifies the string value of the new comment node.</xs:documentation> </xs:annotation> </xs:attribute> </xs:extension> </xs:complexContent> </xs:complexType> </xs:element> <xs:element name="copy" substitutionGroup="xsl:instruction"> <xs:annotation> <xs:documentation>The xsl:copy instruction provides a way of copying the context item. If the context item is a node, evaluating the xsl:copy instruction constructs a copy of the context node, and the result of the xsl:copy instruction is this newly constructed node. By default, the namespace nodes of the context node are automatically copied as well, but the attributes and children of the node are not automatically copied. <br/> See more info at http://www.w3.org/TR/xslt20/#element-copy </xs:documentation> </xs:annotation> <xs:complexType> <xs:complexContent mixed="true"> <xs:extension base="xsl:sequence-constructor"> <xs:attribute name="copy-namespaces" type="xsl:yes-or-no" default="yes"> <xs:annotation> <xs:documentation>The xsl:copy instruction has an optional copy-namespaces attribute, with the value yes or no. The default value is yes. The attribute is used only when copying element nodes. If the value is set to yes, or is omitted, then all the namespace nodes of the source element are copied as namespace nodes for the result element. If the value is set to no, then the namespace nodes are not copied. However, namespace nodes will still be added to the result element as required by the namespace fixup process.</xs:documentation> </xs:annotation> </xs:attribute> <xs:attribute name="inherit-namespaces" type="xsl:yes-or-no" default="yes"> <xs:annotation> <xs:documentation>The default value is yes. The attribute is used only when copying element nodes. If the value is set to yes, or is omitted, then the namespace nodes created for the newly constructed element (whether these were copied from those of the source node, or generated as a result of namespace fixup) are copied to the children and descendants of the newly constructed element. If the value is set to no, then these namespace nodes are not automatically copied to the children. This may result in namespace undeclarations (such as xmlns="" or, in the case of XML Namespaces 1.1, xmlns:p="") appearing on the child elements when a final result tree is serialized. </xs:documentation> </xs:annotation> </xs:attribute> <xs:attribute name="use-attribute-sets" type="xsl:QNames" default=""> <xs:annotation> <xs:documentation> The xsl:copy instruction has an optional use-attribute-sets attribute, whose value is a space-separated list of QNames that identify xsl:attribute-set declarations. This attribute is used only when copying element nodes. This list is expanded to produce a sequence of attribute nodes. </xs:documentation> </xs:annotation> </xs:attribute> <xs:attribute name="type" type="xsl:QName"> <xs:annotation> <xs:documentation> The optional attributes type and validation may be used on the xsl:copy instruction to validate the contents of an element, attribute or document node against a type definition, element declaration, or attribute declaration in a schema, and thus to determine the type annotation that the new copy of an element or attribute node will carry. These attributes are ignored when copying an item that is not an element, attribute or document node. When the node being copied is an element or document node, these attributes also affect the type annotation carried by any elements and attributes that have the copied element or document node as an ancestor. These two attributes are both optional, and if one is specified then the other must be omitted. <br/> See more info at http://www.w3.org/TR/xslt20/#validation </xs:documentation> </xs:annotation> </xs:attribute> <xs:attribute name="validation" type="xsl:validation-type"> <xs:annotation> <xs:documentation> The optional attributes type and validation may be used on the xsl:copy instruction to validate the contents of an element, attribute or document node against a type definition, element declaration, or attribute declaration in a schema, and thus to determine the type annotation that the new copy of an element or attribute node will carry. These attributes are ignored when copying an item that is not an element, attribute or document node. When the node being copied is an element or document node, these attributes also affect the type annotation carried by any elements and attributes that have the copied element or document node as an ancestor. These two attributes are both optional, and if one is specified then the other must be omitted. <br/> See more info at http://www.w3.org/TR/xslt20/#validation</xs:documentation> </xs:annotation> </xs:attribute> </xs:extension> </xs:complexContent> </xs:complexType> </xs:element> <xs:element name="copy-of" substitutionGroup="xsl:instruction"> <xs:annotation> <xs:documentation> The xsl:copy-of instruction can be used to construct a copy of a sequence of nodes and/or atomic values, with each new node containing copies of all the children, attributes, and (by default) namespaces of the original node, recursively. The result of evaluating the instruction is a sequence of items corresponding one-to-one with the supplied sequence, and retaining its order. <br/>See more info at http://www.w3.org/TR/xslt20/#element-copy-of </xs:documentation> </xs:annotation> <xs:complexType> <xs:complexContent mixed="true"> <xs:extension base="xsl:versioned-element-type"> <xs:attribute name="select" type="xsl:expression" use="required"> <xs:annotation> <xs:documentation>The required select attribute contains an expression, whose value may be any sequence of nodes and atomic values.</xs:documentation> </xs:annotation> </xs:attribute> <xs:attribute name="copy-namespaces" type="xsl:yes-or-no" default="yes"> <xs:annotation> <xs:documentation> When using xsl:copy-of the new elements will also have namespace nodes copied from the original element node, unless they are excluded by specifying copy-namespaces="no". If this attribute is omitted, or takes the value yes, then all the namespace nodes of the original element are copied to the new element. If it takes the value no, then none of the namespace nodes are copied: however, namespace nodes will still be created in the result tree as required by the namespace fixup process. </xs:documentation> </xs:annotation> </xs:attribute> <xs:attribute name="type" type="xsl:QName"> <xs:annotation> <xs:documentation> The optional attributes type and validation may be used on the xsl:copy-of instruction to validate the contents of an element, attribute or document node against a type definition, element declaration, or attribute declaration in a schema and thus to determine the type annotation that the new copy of an element or attribute node will carry. These attributes are applied individually to each element, attribute, and document node that is selected by the expression in the select attribute. These attributes are ignored when copying an item that is not an element, attribute or document node. The specified type and validation apply directly only to elements, attributes and document nodes created as copies of nodes actually selected by the select expression, they do not apply to nodes that are implicitly copied because they have selected nodes as an ancestor. However, these attributes do indirectly affect the type annotation carried by such implicitly copied nodes, as a consequence of the validation process. These two attributes are both optional, and if one is specified then the other must be omitted. <br/> See more info at http://www.w3.org/TR/xslt20/#validation </xs:documentation> </xs:annotation> </xs:attribute> <xs:attribute name="validation" type="xsl:validation-type"> <xs:annotation> <xs:documentation> The optional attributes type and validation may be used on the xsl:copy-of instruction to validate the contents of an element, attribute or document node against a type definition, element declaration, or attribute declaration in a schema and thus to determine the type annotation that the new copy of an element or attribute node will carry. These attributes are applied individually to each element, attribute, and document node that is selected by the expression in the select attribute. These attributes are ignored when copying an item that is not an element, attribute or document node. The specified type and validation apply directly only to elements, attributes and document nodes created as copies of nodes actually selected by the select expression, they do not apply to nodes that are implicitly copied because they have selected nodes as an ancestor. However, these attributes do indirectly affect the type annotation carried by such implicitly copied nodes, as a consequence of the validation process. These two attributes are both optional, and if one is specified then the other must be omitted. <br/> See more info at http://www.w3.org/TR/xslt20/#validation </xs:documentation> </xs:annotation> </xs:attribute> </xs:extension> </xs:complexContent> </xs:complexType> </xs:element> <xs:element name="decimal-format" substitutionGroup="xsl:declaration"> <xs:annotation> <xs:documentation> The xsl:decimal-format element declares a decimal-format, which controls the interpretation of a picture string used by the format-number function. <br/> See more info at http://www.w3.org/TR/xslt20/#element-decimal-format </xs:documentation> </xs:annotation> <xs:complexType> <xs:complexContent> <xs:extension base="xsl:element-only-versioned-element-type"> <xs:attribute name="name" type="xsl:QName"> <xs:annotation> <xs:documentation> If there is a name attribute, then the element declares a named decimal-format; otherwise, it declares the default decimal-format. The value of the name attribute is a QName. </xs:documentation> </xs:annotation> </xs:attribute> <xs:attribute name="decimal-separator" type="xsl:char" default="."> <xs:annotation> <xs:documentation> The decimal-separator attribute specifies the character used for the decimal-separator-sign; the default value is the period character (.). </xs:documentation> </xs:annotation> </xs:attribute> <xs:attribute name="grouping-separator" type="xsl:char" default=","> <xs:annotation> <xs:documentation> The grouping-separator attribute specifies the character used for the grouping-sign, which is typically used as a thousands separator; the default value is the comma character (,). </xs:documentation> </xs:annotation> </xs:attribute> <xs:attribute name="infinity" type="xs:string" default="Infinity"> <xs:annotation> <xs:documentation> The infinity attribute specifies the string used for the infinity-symbol; the default value is the string Infinity. </xs:documentation> </xs:annotation> </xs:attribute> <xs:attribute name="minus-sign" type="xsl:char" default="-"> <xs:annotation> <xs:documentation> The minus-sign attribute specifies the character used for the minus-symbol; the default value is the hyphen-minus character (-, #x2D). The value must be a single character. </xs:documentation> </xs:annotation> </xs:attribute> <xs:attribute name="NaN" type="xs:string" default="NaN"> <xs:annotation> <xs:documentation> The NaN attribute specifies the string used for the NaN-symbol, which is used to represent the value NaN (not-a-number); the default value is the string NaN. </xs:documentation> </xs:annotation> </xs:attribute> <xs:attribute name="percent" type="xsl:char" default="%"> <xs:annotation> <xs:documentation> The percent attribyte specifies the character used for the percent-sign; the default value is the percent character (%). </xs:documentation> </xs:annotation> </xs:attribute> <xs:attribute name="per-mille" type="xsl:char" default="‰"> <xs:annotation> <xs:documentation>The per-mille attribute specifies the character used for the per-mille-sign; the default value is the Unicode per-mille character (#x2030).</xs:documentation> </xs:annotation> </xs:attribute> <xs:attribute name="zero-digit" type="xsl:char" default="0"> <xs:annotation> <xs:documentation>The zero-digit attribute specifies the character used for the digit-zero-sign; the default value is the digit zero (0). This character must be a digit (category Nd in the Unicode property database), and it must have the numeric value zero. This attribute implicitly defines the Unicode character that is used to represent each of the values 0 to 9 in the final result string: Unicode is organized so that each set of decimal digits forms a contiguous block of characters in numerical sequence.</xs:documentation> </xs:annotation> </xs:attribute> <xs:attribute name="digit" type="xsl:char" default="#"> <xs:annotation> <xs:documentation> The digit attribute specifies the character used for the digit-sign in the picture string; the default value is the number sign character (#). </xs:documentation> </xs:annotation> </xs:attribute> <xs:attribute name="pattern-separator" type="xsl:char" default=";"> <xs:annotation> <xs:documentation> The pattern-separator attribute specifies the character used for the pattern-separator-sign, which separates positive and negative sub-pictures in a picture string; the default value is the semi-colon character (;). </xs:documentation> </xs:annotation> </xs:attribute> </xs:extension> </xs:complexContent> </xs:complexType> </xs:element> <xs:element name="element" substitutionGroup="xsl:instruction"> <xs:annotation> <xs:documentation> The xsl:element instruction allows an element to be created with a computed name. The expanded-QName of the element to be created is specified by a required name attribute and an optional namespace attribute. The result of evaluating the xsl:element instruction, except in error cases, is the newly constructed element node. <br/> See more info at http://www.w3.org/TR/xslt20/#element-element </xs:documentation> </xs:annotation> <xs:complexType mixed="true"> <xs:complexContent> <xs:extension base="xsl:sequence-constructor"> <xs:attribute name="name" type="xsl:avt" use="required"> <xs:annotation> <xs:documentation>The name attribute, together with the optional namespace attribute, specifies the expanded-QName of the element to be created. The name attribute is interpreted as an attribute value template, whose effective value must be a lexical QName.</xs:documentation> </xs:annotation> </xs:attribute> <xs:attribute name="namespace" type="xsl:avt"> <xs:annotation> <xs:documentation> The namespace attribute, together with the required name attribute, specifies the expanded-QName of the element to be created. If the namespace attribute is not present then the QName is expanded into an expanded-QName using the namespace declarations in effect for the xsl:element element, including any default namespace declaration. If the namespace attribute is present, then it is interpreted as an attribute value template. The effective value should be a URI reference.</xs:documentation> </xs:annotation> </xs:attribute> <xs:attribute name="inherit-namespaces" type="xsl:yes-or-no" default="yes"> <xs:annotation> <xs:documentation> The xsl:element instruction has an optional inherit-namespaces attribute, with the value yes or no. The default value is yes. If the value is set to yes, or is omitted, then the namespace nodes created for the newly constructed element (whether these were copied from those of the source node, or generated as a result of namespace fixup) are copied to the children and descendants of the newly constructed element. If the value is set to no, then these namespace nodes are not automatically copied to the children. This may result in namespace undeclarations (such as xmlns="" or, in the case of XML Namespaces 1.1, xmlns:p="") appearing on the child elements when a final result tree is serialized. </xs:documentation> </xs:annotation> </xs:attribute> <xs:attribute name="use-attribute-sets" type="xsl:QNames" default=""> <xs:annotation> <xs:documentation> The xsl:element element may have a use-attribute-sets attribute, whose value is a space-separated list of QNames that identify xsl:attribute-set declarations. If this attribute is present, it is expanded to produce a sequence of attribute nodes. </xs:documentation> </xs:annotation> </xs:attribute> <xs:attribute name="type" type="xsl:QName"> <xs:annotation> <xs:documentation> The optional attributes type and validation may be used on the xsl:element instruction to invoke validation of the contents of the element against a type definition or element declaration in a schema, and to determine the type annotation that the new element node will carry. These attributes also affect the type annotation carried by any elements and attributes that have the new element node as an ancestor. These two attributes are both optional, and if one is specified then the other must be omitted. <br/> See more info at http://www.w3.org/TR/xslt20/#validation </xs:documentation> </xs:annotation> </xs:attribute> <xs:attribute name="validation" type="xsl:validation-type"> <xs:annotation> <xs:documentation> The optional attributes type and validation may be used on the xsl:element instruction to invoke validation of the contents of the element against a type definition or element declaration in a schema, and to determine the type annotation that the new element node will carry. These attributes also affect the type annotation carried by any elements and attributes that have the new element node as an ancestor. These two attributes are both optional, and if one is specified then the other must be omitted. <br/> See more info at http://www.w3.org/TR/xslt20/#validation </xs:documentation> </xs:annotation> </xs:attribute> </xs:extension> </xs:complexContent> </xs:complexType> </xs:element> <xs:element name="fallback" substitutionGroup="xsl:instruction" type="xsl:sequence-constructor"> <xs:annotation> <xs:documentation> There are two situations where a processor performs fallback: when an extension instruction that is not available is evaluated, and when an instruction in the XSLT namespace, that is not defined in XSLT 2.0, is evaluated within a region of the stylesheet for which forwards compatible behavior is enabled. <br/> See more info at http://www.w3.org/TR/xslt20/#element-fallback</xs:documentation> </xs:annotation> </xs:element> <xs:element name="for-each" substitutionGroup="xsl:instruction"> <xs:annotation> <xs:documentation> The xsl:for-each instruction processes each item in a sequence of items. <br/> See more info at http://www.w3.org/TR/xslt20/#element-for-each </xs:documentation> </xs:annotation> <xs:complexType> <xs:complexContent mixed="true"> <xs:extension base="xsl:versioned-element-type"> <xs:sequence> <xs:element ref="xsl:sort" minOccurs="0" maxOccurs="unbounded"/> <xs:group ref="xsl:sequence-constructor-group" minOccurs="0" maxOccurs="unbounded"/> </xs:sequence> <xs:attribute name="select" type="xsl:expression" use="required"> <xs:annotation> <xs:documentation>The select attribute is required, and the expression must evaluate to a sequence, called the input sequence. If there is an xsl:sort element present the input sequence is sorted to produce a sorted sequence.</xs:documentation> </xs:annotation> </xs:attribute> </xs:extension> </xs:complexContent> </xs:complexType> </xs:element> <xs:element name="for-each-group" substitutionGroup="xsl:instruction"> <xs:annotation> <xs:documentation> The xsl:for-each-group instruction allocates the items in an input sequence into groups of items (that is, it establishes a collection of sequences) based either on common values of a grouping key, or on a pattern that the initial or final node in a group must match. <br/> See more info at http://www.w3.org/TR/xslt20/#element-for-each-group </xs:documentation> </xs:annotation> <xs:complexType> <xs:complexContent mixed="true"> <xs:extension base="xsl:versioned-element-type"> <xs:sequence> <xs:element ref="xsl:sort" minOccurs="0" maxOccurs="unbounded"/> <xs:group ref="xsl:sequence-constructor-group" minOccurs="0" maxOccurs="unbounded"/> </xs:sequence> <xs:attribute name="select" type="xsl:expression" use="required"> <xs:annotation> <xs:documentation> The sequence of items to be grouped, which is referred to as the population, is determined by evaluating the XPath expression contained in the select attribute. </xs:documentation> </xs:annotation> </xs:attribute> <xs:attribute name="group-by" type="xsl:expression"> <xs:annotation> <xs:documentation> Specifies the assignment of items to groups. If the group-by attribute is present, the items in the population are examined, in population order. For each item J, the expression in the group-by attribute is evaluated to produce a sequence of zero or more grouping key values. For each one of these grouping keys, if there is already a group created to hold items having that grouping key value, J is added to that group; otherwise a new group is created for items with that grouping key value, and J becomes its first member. An item in the population may thus be assigned to zero, one, or many groups. An item will never be assigned more than once to the same group; if two or more grouping keys for the same item are equal, then the duplicates are ignored. An item here means the item at a particular position within the population - if the population contains the same node at several different positions in the sequence then a group may indeed contain duplicate nodes. The number of groups will be the same as the number of distinct grouping key values present in the population. </xs:documentation> </xs:annotation> </xs:attribute> <xs:attribute name="group-adjacent" type="xsl:expression"> <xs:annotation> <xs:documentation> Specifies the assignment of items to groups. If the group-adjacent attribute is present, the items in the population are examined, in population order. If an item has the same value for the grouping key as its preceding item within the population (in population order), then it is assigned to the same group as its preceding item; otherwise a new group is created and the item becomes its first member. </xs:documentation> </xs:annotation> </xs:attribute> <xs:attribute name="group-starting-with" type="xsl:pattern"> <xs:annotation> <xs:documentation> Specifies the assignment of items to groups. If the group-starting-with attribute is present, then its value must be a pattern. In this case, the items in the population must all be nodes. The nodes in the population are examined in population order. If a node matches the pattern, or is the first node in the population, then a new group is created and the node becomes its first member. Otherwise, the node is assigned to the same group as its preceding node within the population. </xs:documentation> </xs:annotation> </xs:attribute> <xs:attribute name="group-ending-with" type="xsl:pattern"> <xs:annotation> <xs:documentation> Specifies the assignment of items to groups. If the group-ending-with attribute is present, then its value must be a pattern. In this case, the items in the population must all be nodes. The nodes in the population are examined in population order. If a node is the first node in the population, or if the previous node in the population matches the pattern, then a new group is created and the node becomes its first member. Otherwise, the node is assigned to the same group as its preceding node within the population. </xs:documentation> </xs:annotation> </xs:attribute> <xs:attribute name="collation" type="xs:anyURI"> <xs:annotation> <xs:documentation> If the grouping keys values are strings, or untyped atomic values, they are compared using the collation specified in the collation attribute if present, or the default collation otherwise. </xs:documentation> </xs:annotation> </xs:attribute> </xs:extension> </xs:complexContent> </xs:complexType> </xs:element> <xs:element name="function" substitutionGroup="xsl:declaration"> <xs:annotation> <xs:documentation> The xsl:function declaration defines a stylesheet function that can be called from any XPath expression used in the stylesheet (including an XPath expression used within a predicate in a pattern). The arity of a stylesheet function is the number of xsl:param elements in the function definition. Optional arguments are not allowed.<br/> See more info at http://www.w3.org/TR/xslt20/#element-function </xs:documentation> </xs:annotation> <xs:complexType> <xs:complexContent mixed="true"> <xs:extension base="xsl:versioned-element-type"> <xs:sequence> <xs:element ref="xsl:param" minOccurs="0" maxOccurs="unbounded"/> <xs:group ref="xsl:sequence-constructor-group" minOccurs="0" maxOccurs="unbounded"/> </xs:sequence> <xs:attribute name="name" type="xsl:QName" use="required"> <xs:annotation> <xs:documentation> The name attribute specifies the name of the function. The value of the name attribute is a QName. </xs:documentation> </xs:annotation> </xs:attribute> <xs:attribute name="override" type="xsl:yes-or-no" default="yes"> <xs:annotation> <xs:documentation> The optional override attribute defines what happens if this function has the same name and arity as a function provided by the implementer or made available in the static context using an implementation-defined mechanism. If the override attribute has the value yes, then this function is used in preference; if it has the value no, then the other function is used in preference. The default value is yes. Specifying override="yes" ensures interoperable behavior: the same code will execute with all processors. Specifying override="no" is useful when writing a fallback implementation of a function that is available with some processors but not others: it allows the vendor's implementation of the function to be used in preference to the stylesheet implementation, which is useful when the vendor's implementation is more efficient. </xs:documentation> </xs:annotation> </xs:attribute> <xs:attribute name="as" type="xsl:sequence-type" default="item()*"> <xs:annotation> <xs:documentation> The optional as attribute indicates the required type of the result of the function. If the as attribute is specified, then the result is converted to the required type, using the function conversion rules. It is a type error if this conversion fails. If the as attribute is omitted, the calculated result is used as supplied, and no conversion takes place. </xs:documentation> </xs:annotation> </xs:attribute> </xs:extension> </xs:complexContent> </xs:complexType> </xs:element> <xs:element name="if" substitutionGroup="xsl:instruction"> <xs:annotation> <xs:documentation> The xsl:if instruction is used for conditional processing. If the effective boolean value of the test expression is true, then the sequence constructor is evaluated, and the resulting node sequence is returned as the result of the xsl:if instruction; otherwise, the sequence constructor is not evaluated, and the empty sequence is returned. <br/> See more info at http://www.w3.org/TR/xslt20/#element-if </xs:documentation> </xs:annotation> <xs:complexType> <xs:complexContent mixed="true"> <xs:extension base="xsl:sequence-constructor"> <xs:attribute name="test" type="xsl:expression" use="required"> <xs:annotation> <xs:documentation> The test attribute specifies the test expression. </xs:documentation> </xs:annotation> </xs:attribute> </xs:extension> </xs:complexContent> </xs:complexType> </xs:element> <xs:element name="import"> <xs:annotation> <xs:documentation> A stylesheet module may import another stylesheet module using an xsl:import declaration. Importing a stylesheet module is the same as including it except that template rules and other declarations in the importing module take precedence over template rules and declarations in the imported module. <br/> See more info at http://www.w3.org/TR/xslt20/#element-import </xs:documentation> </xs:annotation> <xs:complexType> <xs:complexContent> <xs:extension base="xsl:element-only-versioned-element-type"> <xs:attribute name="href" type="xs:anyURI" use="required"> <xs:annotation> <xs:documentation> The xsl:import declaration has a required href attribute whose value is a URI reference identifying the stylesheet module to be included. </xs:documentation> </xs:annotation> </xs:attribute> </xs:extension> </xs:complexContent> </xs:complexType> </xs:element> <xs:element name="import-schema" substitutionGroup="xsl:declaration"> <xs:annotation> <xs:documentation> The xsl:import-schema declaration is used to identify schema components (that is, top-level type definitions and top-level element and attribute declarations) that need to be available statically, that is, before any source document is available. <br/> See more info at http://www.w3.org/TR/xslt20/#element-import-schema </xs:documentation> </xs:annotation> <xs:complexType> <xs:complexContent> <xs:extension base="xsl:element-only-versioned-element-type"> <xs:sequence> <xs:element ref="xs:schema" minOccurs="0" maxOccurs="1"/> </xs:sequence> <xs:attribute name="namespace" type="xs:anyURI"> <xs:annotation> <xs:documentation> The namespace attribute indicates that a schema for the given namespace is required by the stylesheet. This information may be enough on its own to enable an implementation to locate the required schema components. The namespace attribute may be omitted to indicate that a schema for names in no namespace is being imported. The zero-length string is not a valid namespace URI, and is therefore not a valid value for the namespace attribute. </xs:documentation> </xs:annotation> </xs:attribute> <xs:attribute name="schema-location" type="xs:anyURI"> <xs:annotation> <xs:documentation> The schema-location attribute gives a hint indicating where a schema document or other resource containing the required definitions may be found. It is likely that a schema-aware XSLT processor will be able to process a schema document found at this location. </xs:documentation> </xs:annotation> </xs:attribute> </xs:extension> </xs:complexContent> </xs:complexType> </xs:element> <xs:element name="include" substitutionGroup="xsl:declaration"> <xs:annotation> <xs:documentation> A stylesheet module may include another stylesheet module using an xsl:include declaration. <br/> See more info at http://www.w3.org/TR/xslt20/#element-include </xs:documentation> </xs:annotation> <xs:complexType> <xs:complexContent> <xs:extension base="xsl:element-only-versioned-element-type"> <xs:attribute name="href" type="xs:anyURI" use="required"> <xs:annotation> <xs:documentation> The xsl:include declaration has a required href attribute whose value is a URI reference identifying the stylesheet module to be included. </xs:documentation> </xs:annotation> </xs:attribute> </xs:extension> </xs:complexContent> </xs:complexType> </xs:element> <xs:element name="key" substitutionGroup="xsl:declaration"> <xs:annotation> <xs:documentation> The xsl:key declaration is used to declare keys. The presence of an xsl:key declaration makes it easy to find a node that matches the match pattern if any of the values of the key specifier (when applied to that node) are known. It also provides a hint to the implementation that access to the nodes by means of these values needs to be efficient (many implementations are likely to construct an index or hash table to achieve this). Note that the key specifier in general returns a sequence of values, and any one of these may be used to locate the node. <br/> See more info at http://www.w3.org/TR/xslt20/#element-key </xs:documentation> </xs:annotation> <xs:complexType> <xs:complexContent mixed="true"> <xs:extension base="xsl:sequence-constructor"> <xs:attribute name="name" type="xsl:QName" use="required"> <xs:annotation> <xs:documentation> The name attribute specifies the name of the key. The value of the name attribute is a QName. </xs:documentation> </xs:annotation> </xs:attribute> <xs:attribute name="match" type="xsl:pattern" use="required"> <xs:annotation> <xs:documentation> The match attribute is a Pattern; an xsl:key element applies to all nodes that match the pattern specified in the match attribute. </xs:documentation> </xs:annotation> </xs:attribute> <xs:attribute name="use" type="xsl:expression"> <xs:annotation> <xs:documentation> The value of the key may be specified either using the use attribute or by means of the contained sequence constructor. </xs:documentation> </xs:annotation> </xs:attribute> <xs:attribute name="collation" type="xs:anyURI"> <xs:annotation> <xs:documentation> The optional collation attribute is used only when deciding whether two strings are equal for the purposes of key matching. If an xsl:key declaration specifies a collation attribute, then every other xsl:key declaration with the same value for its name attribute must either specify the same collation, or specify no collation; this collation is used for all xsl:key declarations with the given name. In the absence of a collation attribute, the default collation is used. </xs:documentation> </xs:annotation> </xs:attribute> </xs:extension> </xs:complexContent> </xs:complexType> </xs:element> <xs:element name="matching-substring" type="xsl:sequence-constructor"> <xs:annotation> <xs:documentation> A matching substring inside an xsl:analyze-string element is processed using the xsl:matching-substring element. If the element is absent, the effect is the same as if it were present with empty content. <br/> See more info at http://www.w3.org/TR/xslt20/#element-matching-substring </xs:documentation> </xs:annotation> </xs:element> <xs:element name="message" substitutionGroup="xsl:instruction"> <xs:annotation> <xs:documentation> The xsl:message instruction sends a message in an implementation-defined way. The xsl:message instruction causes the creation of a new document, which is typically serialized and output to an implementation-defined destination. The result of the xsl:message instruction is an empty sequence. <br/> See more info at http://www.w3.org/TR/xslt20/#element-message </xs:documentation> </xs:annotation> <xs:complexType> <xs:complexContent mixed="true"> <xs:extension base="xsl:sequence-constructor"> <xs:attribute name="select" type="xsl:expression"> <xs:annotation> <xs:documentation> If the xsl:message instruction has a select attribute, then the value of the attribute must be an XPath expression. The content of the message may be specified by using either or both of the optional select attribute and the sequence constructor that forms the content of the xsl:message instruction. </xs:documentation> </xs:annotation> </xs:attribute> <xs:attribute name="terminate" type="xsl:avt" default="no"> <xs:annotation> <xs:documentation> The terminate attribute is interpreted as an attribute value template. If the effective value of the terminate attribute is yes, then the processor must terminate processing after sending the message. The default value is no. Note that because the order of evaluation of instructions is implementation-dependent, this gives no guarantee that any particular instruction will or will not be evaluated before processing terminates. </xs:documentation> </xs:annotation> </xs:attribute> </xs:extension> </xs:complexContent> </xs:complexType> </xs:element> <xs:element name="namespace" substitutionGroup="xsl:instruction"> <xs:annotation> <xs:documentation> The xsl:namespace element is evaluated to create a namespace node. Except in error situations, the result of evaluating the xsl:namespace instruction is a single node, the newly constructed namespace node. <br/> See more info at http://www.w3.org/TR/xslt20/#element-namespace </xs:documentation> </xs:annotation> <xs:complexType> <xs:complexContent mixed="true"> <xs:extension base="xsl:sequence-constructor"> <xs:attribute name="name" type="xsl:avt" use="required"> <xs:annotation> <xs:documentation> The xsl:namespace element has a required name attribute that specifies the name of the namespace node (that is, the namespace prefix). The value of the name attribute is interpreted as an attribute value template. If the effective value of the name attribute is a zero-length string, a namespace node is added for the default namespace. </xs:documentation> </xs:annotation> </xs:attribute> <xs:attribute name="select" type="xsl:expression"> <xs:annotation> <xs:documentation>The string value of the new namespace node (that is, the namespace URI) may be defined either by using the select attribute, or by the sequence constructor that forms the content of the xsl:namespace element. These are mutually exclusive. </xs:documentation> </xs:annotation> </xs:attribute> </xs:extension> </xs:complexContent> </xs:complexType> </xs:element> <xs:element name="namespace-alias" substitutionGroup="xsl:declaration"> <xs:annotation> <xs:documentation> A stylesheet can use the xsl:namespace-alias element to declare that a literal namespace URI is being used as an alias for a target namespace URI The effect is that when names in the namespace identified by the literal namespace URI are copied to the result tree, the namespace URI in the result tree will be the target namespace URI, instead of the literal namespace URI. The default namespace (as declared by xmlns) may be specified by using #default instead of a prefix. <br/> See more info at http://www.w3.org/TR/xslt20/#element-namespace-alias </xs:documentation> </xs:annotation> <xs:complexType> <xs:complexContent> <xs:extension base="xsl:element-only-versioned-element-type"> <xs:attribute name="stylesheet-prefix" type="xsl:prefix-or-default" use="required"> <xs:annotation> <xs:documentation> The stylesheet-prefix attribute specifies the namespace URI that will appear in the stylesheet. </xs:documentation> </xs:annotation> </xs:attribute> <xs:attribute name="result-prefix" type="xsl:prefix-or-default" use="required"> <xs:annotation> <xs:documentation> The result-prefix attribute specifies the corresponding namespace URI that will appear in the result tree. </xs:documentation> </xs:annotation> </xs:attribute> </xs:extension> </xs:complexContent> </xs:complexType> </xs:element> <xs:element name="next-match" substitutionGroup="xsl:instruction"> <xs:annotation> <xs:documentation> A template rule that is being used to override another template rule can use the xsl:next-match instruction to invoke the overridden template rule. The xsl:next-match instruction considers all other template rules of lower import precedence and/or priority. It will invoke the built-in template rule for the node if no other template rule is found. <br/> See more info at http://www.w3.org/TR/xslt20/#element-next-match </xs:documentation> </xs:annotation> <xs:complexType> <xs:complexContent> <xs:extension base="xsl:element-only-versioned-element-type"> <xs:choice minOccurs="0" maxOccurs="unbounded"> <xs:element ref="xsl:with-param"/> <xs:element ref="xsl:fallback"/> </xs:choice> </xs:extension> </xs:complexContent> </xs:complexType> </xs:element> <xs:element name="non-matching-substring" type="xsl:sequence-constructor"> <xs:annotation> <xs:documentation> A non matching substring inside an xsl:analyze-string element is processed using the xsl:non-matching-substring element. If the element is absent, the effect is the same as if it were present with empty content. <br/> See more info at http://www.w3.org/TR/xslt20/#element-non-matching-substring </xs:documentation> </xs:annotation> </xs:element> <xs:element name="number" substitutionGroup="xsl:instruction"> <xs:annotation> <xs:documentation> The xsl:number instruction is used to create a formatted number. The result of the instruction is a newly constructed text node containing the formatted number as its string value. But if the formatted number is a zero-length string, the result of the instruction is an empty sequence. The xsl:number instruction performs two tasks: firstly, determining a place marker (this is a sequence of integers, to allow for hierarchic numbering schemes such as 1.12.2 or 3(c)ii), and secondly, formatting the place marker for output as a text node in the result sequence. The place marker to be formatted can either be supplied directly, in the value attribute, or it can be computed based on the position of a selected node within the tree that contains it.<br/> See more info at http://www.w3.org/TR/xslt20/#element-number </xs:documentation> </xs:annotation> <xs:complexType> <xs:complexContent mixed="true"> <xs:extension base="xsl:versioned-element-type"> <xs:attribute name="value" type="xsl:expression"> <xs:annotation> <xs:documentation> The place marker to be formatted may be specified by an expression contained in the value attribute. If no value attribute is specified, then the xsl:number instruction returns a new text node containing a formatted place marker that is based on the position of a selected node within its containing document. </xs:documentation> </xs:annotation> </xs:attribute> <xs:attribute name="select" type="xsl:expression"> <xs:annotation> <xs:documentation> If the select attribute is present, then the expression contained in the select attribute is evaluated to determine the selected node. If the select attribute is omitted, then the selected node is the context node. </xs:documentation> </xs:annotation> </xs:attribute> <xs:attribute name="level" type="xsl:level" default="single"> <xs:annotation> <xs:documentation> The level attribute specifies rules for selecting the nodes that are taken into account in allocating a number; it has the values single, multiple or any. The default is single. </xs:documentation> </xs:annotation> </xs:attribute> <xs:attribute name="count" type="xsl:pattern"> <xs:annotation> <xs:documentation> The count attribute is a pattern that specifies which nodes are to be counted at those levels. If count attribute is not specified, then it defaults to the pattern that matches any node with the same node kind as the selected node and, if the selected node has an expanded-QName, with the same expanded-QName as the selected node. </xs:documentation> </xs:annotation> </xs:attribute> <xs:attribute name="from" type="xsl:pattern"> <xs:annotation> <xs:documentation> The from attribute is a pattern that specifies where counting starts. </xs:documentation> </xs:annotation> </xs:attribute> <xs:attribute name="format" type="xsl:avt" default="1"> <xs:annotation> <xs:documentation> The format attribute controls conversion of a sequence of numbers into a string. The numbers are integers greater than 0. The default value for the format attribute is 1. The format attribute is split into a sequence of tokens where each token is a maximal sequence of alphanumeric characters or a maximal sequence of non-alphanumeric characters. The alphanumeric tokens (format tokens) indicate the format to be used for each number in the sequence; in most cases the format token is the same as the required representation of the number 1 (one). If the first token is a non-alphanumeric token, then the constructed string will start with that token; if the last token is non-alphanumeric token, then the constructed string will end with that token. Non-alphanumeric tokens that occur between two format tokens are separator tokens that are used to join numbers in the sequence. <br/> See more info at http://www.w3.org/TR/xslt20/#convert </xs:documentation> </xs:annotation> </xs:attribute> <xs:attribute name="lang" type="xsl:avt"> <xs:annotation> <xs:documentation> Many numbering sequences are language-sensitive. In such cases, the lang attribute specifies which language's conventions are to be used; it has the same range of values as xml:lang. If no lang value is specified, the language that is used is implementation-defined. The set of languages for which numbering is supported is implementation-defined. If a language is requested that is not supported, the processor uses the language that it would use if the lang attribute were omitted. </xs:documentation> </xs:annotation> </xs:attribute> <xs:attribute name="letter-value" type="xsl:avt"> <xs:annotation> <xs:documentation> The letter-value attribute disambiguates between numbering sequences that use letters. In many languages there are two commonly used numbering sequences that use letters. One numbering sequence assigns numeric values to letters in alphabetic sequence, and the other assigns numeric values to each letter in some other manner traditional in that language. In English, these would correspond to the numbering sequences specified by the format tokens a and i. In some languages, the first member of each sequence is the same, and so the format token alone would be ambiguous. A value of alphabetic specifies the alphabetic sequence; a value of traditional specifies the other sequence. If the letter-value attribute is not specified, then it is implementation-dependent how any ambiguity is resolved. </xs:documentation> </xs:annotation> </xs:attribute> <xs:attribute name="ordinal" type="xsl:avt"> <xs:annotation> <xs:documentation> If the optional ordinal attribute is present, and if its value is not a zero-length string, this indicates a request to output ordinal numbers rather than cardinal numbers. </xs:documentation> </xs:annotation> </xs:attribute> <xs:attribute name="grouping-separator" type="xsl:avt"> <xs:annotation> <xs:documentation>The grouping-separator attribute gives the separator used as a grouping (for example, thousands) separator in decimal numbering sequence. </xs:documentation> </xs:annotation> </xs:attribute> <xs:attribute name="grouping-size" type="xsl:avt"> <xs:annotation> <xs:documentation>The optional grouping-size specifies the size (normally 3) of the grouping. </xs:documentation> </xs:annotation> </xs:attribute> </xs:extension> </xs:complexContent> </xs:complexType> </xs:element> <xs:element name="otherwise" type="xsl:sequence-constructor"> <xs:annotation> <xs:documentation> If no xsl:when element inside an xsl:choose is satisfied, the content of the xsl:otherwise element is evaluated.<br/> See more info at http://www.w3.org/TR/xslt20/#element-otherwise </xs:documentation> </xs:annotation> </xs:element> <xs:element name="output" substitutionGroup="xsl:declaration"> <xs:annotation> <xs:documentation> Stylesheet authors can use the xsl:output declaration to specify how they wish result trees to be serialized. If a processor serializes the result tree, it should do so as specified by these elements; however, it is not required to do so. A stylesheet may contain multiple xsl:output declarations and may include or import stylesheet modules that also contain xsl:output declarations. The name of an xsl:output declaration is the value of its name attribute, if any. All the xsl:output declarations in a stylesheet that share the same name are grouped into a named output definition; those that have no name are grouped into a single unnamed output definition. All the xsl:output elements making up an output definition are effectively merged. <br/> See more info at http://www.w3.org/TR/xslt20/#element-output </xs:documentation> </xs:annotation> <xs:complexType> <xs:complexContent mixed="true"> <xs:extension base="xsl:generic-element-type"> <xs:attribute name="name" type="xsl:QName"> <xs:annotation> <xs:documentation> The name of an xsl:output declaration is the value of its name attribute, if any. </xs:documentation> </xs:annotation> </xs:attribute> <xs:attribute name="method" type="xsl:method"> <xs:annotation> <xs:documentation>The method attribute on the xsl:output element identifies the overall method that is to be used for outputting the result tree. The value must be a valid QName. If the QName does not have a prefix, then it identifies a method specified in XSLT and XQuery Serialization and must be one of xml, html, xhtml, or text. The default value is in general xml but depending on the first element in the result tree it can be also html or xhtml.</xs:documentation> </xs:annotation> </xs:attribute> <xs:attribute name="byte-order-mark" type="xsl:yes-or-no"> <xs:annotation> <xs:documentation> The byte-order-mark attribute defines whether a byte order mark is written at the start of the file. If the value yes is specified, a byte order mark is written; if no is specified, no byte order mark is written. The default value depends on the encoding used. If the encoding is UTF-16, the default is yes; for UTF-8 it is implementation-defined, and for all other encodings it is no. The value of the byte order mark indicates whether high order bytes are written before or after low order bytes; the actual byte order used is implementation-dependent, unless it is defined by the selected encoding. </xs:documentation> </xs:annotation> </xs:attribute> <xs:attribute name="cdata-section-elements" type="xsl:QNames"> <xs:annotation> <xs:documentation>The cdata-section-elements attribute is a space-separated list of QNames. After expansion of these names using the in-scope namespace declarations for the xsl:output declaration in which they appear, this list of names provides the value of the cdata-section-elements parameter to the serialization method. The default value is an empty list.</xs:documentation> </xs:annotation> </xs:attribute> <xs:attribute name="doctype-public" type="xs:string"> <xs:annotation> <xs:documentation>The value of the doctype-public attribute provides the value of the doctype-public parameter to the serialization method. By default, the parameter is not supplied.</xs:documentation> </xs:annotation> </xs:attribute> <xs:attribute name="doctype-system" type="xs:string"> <xs:annotation> <xs:documentation>The value of the doctype-system attribute provides the value of the doctype-system parameter to the serialization method. By default, the parameter is not supplied.</xs:documentation> </xs:annotation> </xs:attribute> <xs:attribute name="encoding" type="xs:string"> <xs:annotation> <xs:documentation>The value of the encoding attribute provides the value of the encoding parameter to the serialization method. The default value is implementation-defined, but in the case of the xml and xhtml methods it must be either UTF-8 or UTF-16.</xs:documentation> </xs:annotation> </xs:attribute> <xs:attribute name="escape-uri-attributes" type="xsl:yes-or-no"> <xs:annotation> <xs:documentation>The value of the escape-uri-attributes attribute provides the value of the escape-uri-attributes parameter to the serialization method. The default value is yes.</xs:documentation> </xs:annotation> </xs:attribute> <xs:attribute name="include-content-type" type="xsl:yes-or-no"> <xs:annotation> <xs:documentation>The value of the include-content-type attribute provides the value of the include-content-type parameter to the serialization method. The default value is yes.</xs:documentation> </xs:annotation> </xs:attribute> <xs:attribute name="indent" type="xsl:yes-or-no"> <xs:annotation> <xs:documentation>The value of the indent attribute provides the value of the indent parameter to the serialization method. The default value is yes in the case of the html and xhtml output methods, no in the case of the xml output method.</xs:documentation> </xs:annotation> </xs:attribute> <xs:attribute name="media-type" type="xs:string"> <xs:annotation> <xs:documentation>The value of the media-type attribute provides the value of the media-type parameter to the serialization method. The default value is text/xml in the case of the xml output method, text/html in the case of the html and xhtml output methods, and text/plain in the case of the text output method.</xs:documentation> </xs:annotation> </xs:attribute> <xs:attribute name="normalization-form" type="xs:NMTOKEN"> <xs:annotation> <xs:documentation> The value of the normalization-form attribute provides the value of the normalization-form parameter to the serialization method. A value that is an NMTOKEN other than one of those enumerated for the normalization-form attribute specifes an implementation-defined normalization form; the behavior in this case is not specified by this document. The default value is none. </xs:documentation> </xs:annotation> </xs:attribute> <xs:attribute name="omit-xml-declaration" type="xsl:yes-or-no"> <xs:annotation> <xs:documentation>The value of the omit-xml-declaration attribute provides the value of the omit-xml-declaration parameter to the serialization method. The default value is no.</xs:documentation> </xs:annotation> </xs:attribute> <xs:attribute name="standalone" type="xsl:yes-or-no"> <xs:annotation> <xs:documentation>The value of the standalone attribute provides the value of the standalone parameter to the serialization method. By default, the parameter is not supplied; this means that no standalone attribute is included in the XML declaration.</xs:documentation> </xs:annotation> </xs:attribute> <xs:attribute name="undeclare-prefixes" type="xsl:yes-or-no"> <xs:annotation> <xs:documentation> The undeclare-prefixes attribute is relevant only when producing output with method="xml" and version="1.1" (or later). It defines whether namespace undeclarations (of the form xmlns:foo="") should be output when a child element has no namespace node with the same name (that is, namespace prefix) as a namespace node of its parent element. The default value is no: this means that namespace undeclarations are not output, which has the effect that when the resulting XML is reparsed, the new tree may contain namespace nodes on the child element that were not there in the original tree before serialization. </xs:documentation> </xs:annotation> </xs:attribute> <xs:attribute name="use-character-maps" type="xsl:QNames"> <xs:annotation> <xs:documentation>The use-character-maps attribute provides a list of named character maps that are used in conjunction with this output definition. </xs:documentation> </xs:annotation> </xs:attribute> <xs:attribute name="version" type="xs:NMTOKEN"> <xs:annotation> <xs:documentation>The value of the version attribute provides the value of the version parameter to the serialization method. The default value depends on the output method: it is 1.0 for xml, 4.01 for html, and 1.0 for xhtml. The parameter is not used by the text output method.</xs:documentation> </xs:annotation> </xs:attribute> </xs:extension> </xs:complexContent> </xs:complexType> </xs:element> <xs:element name="output-character"> <xs:annotation> <xs:documentation> The character mappings are specified by means of xsl:output-character elements contained either directly within the xsl:character-map element. The character map that is passed as a parameter to the serializer contains a mapping for the character specified in the character attribute to the string specified in the string attribute. <br/> See more info at http://www.w3.org/TR/xslt20/#element-output-character </xs:documentation> </xs:annotation> <xs:complexType> <xs:complexContent> <xs:extension base="xsl:element-only-versioned-element-type"> <xs:attribute name="character" type="xsl:char" use="required"> <xs:annotation> <xs:documentation> Specifies the character to be mapped. </xs:documentation> </xs:annotation> </xs:attribute> <xs:attribute name="string" type="xs:string" use="required"> <xs:annotation> <xs:documentation> Specifies the string that will replace the mapped character. </xs:documentation> </xs:annotation> </xs:attribute> </xs:extension> </xs:complexContent> </xs:complexType> </xs:element> <xs:element name="param"> <xs:annotation> <xs:documentation> The xsl:param element may be used as a child of xsl:stylesheet, to define a parameter to the transformation; or as a child of xsl:template to define a parameter to a template, which may be supplied when the template is invoked using xsl:call-template, xsl:apply-templates, xsl:apply-imports or xsl:next-match; or as a child of xsl:function to define a parameter to a stylesheet function, which may be supplied when the function is called from an XPath expression. <br/> See more info at http://www.w3.org/TR/xslt20/#element-param </xs:documentation> </xs:annotation> <xs:complexType> <xs:complexContent mixed="true"> <xs:extension base="xsl:sequence-constructor"> <xs:attribute name="name" type="xsl:QName" use="required"> <xs:annotation> <xs:documentation>The xsl:param element has a required name attribute, which specifies the name of the parameter. The value of the name attribute is a QName.</xs:documentation> </xs:annotation> </xs:attribute> <xs:attribute name="select" type="xsl:expression"> <xs:annotation> <xs:documentation> The supplied value of the parameter is the value supplied by the caller. If no value was supplied by the caller, and if the parameter is not mandatory, then the supplied value is computed using the expression given in the select attribute or the contained sequence constructor. If the xsl:param element has a select attribute, then the sequence constructor must be empty. </xs:documentation> </xs:annotation> </xs:attribute> <xs:attribute name="as" type="xsl:sequence-type"> <xs:annotation> <xs:documentation> The xsl:param element has an optional as attribute, which specifies the required type of the parameter. If the as attribute is specified, then the supplied value of the parameter is converted to the required type, using the function conversion rules. If the as attribute is omitted, the supplied value of the parameter is used directly, and no conversion takes place. </xs:documentation> </xs:annotation> </xs:attribute> <xs:attribute name="required" type="xsl:yes-or-no"> <xs:annotation> <xs:documentation>The optional required attribute may be used to indicate that a parameter is mandatory. This attribute may be specified for stylesheet parameters and for template parameters; it must not be specified for function parameters, which are always mandatory. A parameter is mandatory if it is a function parameter or if the required attribute is present and has the value yes. Otherwise, the parameter is optional. If the parameter is mandatory, then the xsl:param element must be empty and must not have a select attribute.</xs:documentation> </xs:annotation> </xs:attribute> <xs:attribute name="tunnel" type="xsl:yes-or-no"> <xs:annotation> <xs:documentation>Tunnel parameters have the property that they are automatically passed on by the called template to any further templates that it calls, and so on recursively. The tunnel attribute may be used to indicate that a parameter is a tunnel parameter. The default is no; the value yes may be specified only for template parameters. </xs:documentation> </xs:annotation> </xs:attribute> </xs:extension> </xs:complexContent> </xs:complexType> </xs:element> <xs:element name="perform-sort" substitutionGroup="xsl:instruction"> <xs:annotation> <xs:documentation> The xsl:perform-sort instruction is used to return a sorted sequence. The result of the xsl:perform-sort instruction is the result of sorting its initial sequence using its contained sort key specification. <br/> See more info at http://www.w3.org/TR/xslt20/#element-perform-sort </xs:documentation> </xs:annotation> <xs:complexType> <xs:complexContent mixed="true"> <xs:extension base="xsl:versioned-element-type"> <xs:sequence> <xs:element ref="xsl:sort" minOccurs="1" maxOccurs="unbounded"/> <xs:group ref="xsl:sequence-constructor-group" minOccurs="0" maxOccurs="unbounded"/> </xs:sequence> <xs:attribute name="select" type="xsl:expression"> <xs:annotation> <xs:documentation>The initial sequence is obtained either by evaluating the select attribute or by evaluating the contained sequence constructor (but not both).</xs:documentation> </xs:annotation> </xs:attribute> </xs:extension> </xs:complexContent> </xs:complexType> </xs:element> <xs:element name="preserve-space" substitutionGroup="xsl:declaration"> <xs:annotation> <xs:documentation> The set of whitespace-preserving element names is specified by xsl:strip-space and xsl:preserve-space declarations. Whether an element name is included in the set of whitespace-preserving names is determined by the best match among all the xsl:strip-space or xsl:preserve-space declarations: it is included if and only if there is no match or the best match is an xsl:preserve-space element. <br/> See more info at http://www.w3.org/TR/xslt20/#element-preserve-space </xs:documentation> </xs:annotation> <xs:complexType> <xs:complexContent> <xs:extension base="xsl:element-only-versioned-element-type"> <xs:attribute name="elements" type="xsl:nametests" use="required"> <xs:annotation> <xs:documentation> Specifies the preserve space elements. Its value is a whitespace-separated list of NameTests.</xs:documentation> </xs:annotation> </xs:attribute> </xs:extension> </xs:complexContent> </xs:complexType> </xs:element> <xs:element name="processing-instruction" substitutionGroup="xsl:instruction"> <xs:annotation> <xs:documentation> The xsl:processing-instruction element is evaluated to create a processing instruction node. <br/> See more info at http://www.w3.org/TR/xslt20/#element-processing-instruction </xs:documentation> </xs:annotation> <xs:complexType> <xs:complexContent mixed="true"> <xs:extension base="xsl:sequence-constructor"> <xs:attribute name="name" type="xsl:avt" use="required"> <xs:annotation> <xs:documentation> The xsl:processing-instruction element has a required name attribute that specifies the name of the processing instruction node. The value of the name attribute is interpreted as an attribute value template. </xs:documentation> </xs:annotation> </xs:attribute> <xs:attribute name="select" type="xsl:expression"> <xs:annotation> <xs:documentation>The string value of the new processing-instruction node may be defined either by using the select attribute, or by the sequence constructor that forms the content of the xsl:processing-instruction element. These are mutually exclusive.</xs:documentation> </xs:annotation> </xs:attribute> </xs:extension> </xs:complexContent> </xs:complexType> </xs:element> <xs:element name="result-document" substitutionGroup="xsl:instruction"> <xs:annotation> <xs:documentation> The xsl:result-document instruction is used to create a result tree. The xsl:result-document instruction defines the URI of the result tree, and may optionally specify the output format to be used for serializing this tree. <br/> See more info at http://www.w3.org/TR/xslt20/#element-result-document </xs:documentation> </xs:annotation> <xs:complexType> <xs:complexContent mixed="true"> <xs:extension base="xsl:sequence-constructor"> <xs:attribute name="format" type="xsl:QName"> <xs:annotation> <xs:documentation>The format attribute identifies the xsl:output declaration that will control the serialization of the result tree (see 20 Serialization), if the result tree is serialized. If the format attribute is omitted, the unnamed output definition is used to control serialization of the result tree. </xs:documentation> </xs:annotation> </xs:attribute> <xs:attribute name="href" type="xsl:avt"> <xs:annotation> <xs:documentation> The href attribute is optional. The default value is the zero-length string. The effective value of the attribute must be a URI, which may be absolute or relative. If the effective value is a relative URI, then it is resolved relative to the base output URI. </xs:documentation> </xs:annotation> </xs:attribute> <xs:attribute name="type" type="xsl:QName"> <xs:annotation> <xs:documentation> The optional attributes type and validation may be used on the xsl:result-document instruction to validate the contents of the new document, and to determine the type annotation that elements and attributes within the result tree will carry. <br/> See more info at http://www.w3.org/TR/xslt20/#validating-document-nodes</xs:documentation> </xs:annotation> </xs:attribute> <xs:attribute name="validation" type="xsl:validation-type"> <xs:annotation> <xs:documentation>The optional attributes type and validation may be used on the xsl:result-document instruction to validate the contents of the new document, and to determine the type annotation that elements and attributes within the result tree will carry. <br/> See more info at http://www.w3.org/TR/xslt20/#validating-document-nodes</xs:documentation> </xs:annotation> </xs:attribute> <xs:attribute name="method" type="xsl:avt"> <xs:annotation> <xs:documentation> The method attribute on the xsl:result-document element identifies the overall method that is to be used for outputting the result tree. The value must be a valid QName. If the QName does not have a prefix, then it identifies a method specified in XSLT and XQuery Serialization and must be one of xml, html, xhtml, or text. May be used to override the attribute defined in the selected output definition. </xs:documentation> </xs:annotation> </xs:attribute> <xs:attribute name="byte-order-mark" type="xsl:avt"> <xs:annotation> <xs:documentation> The byte-order-mark attribute defines whether a byte order mark is written at the start of the file. If the value yes is specified, a byte order mark is written; if no is specified, no byte order mark is written. The value of the byte order mark indicates whether high order bytes are written before or after low order bytes; the actual byte order used is implementation-dependent, unless it is defined by the selected encoding. May be used to override the attribute defined in the selected output definition. </xs:documentation> </xs:annotation> </xs:attribute> <xs:attribute name="cdata-section-elements" type="xsl:avt"> <xs:annotation> <xs:documentation>The cdata-section-elements attribute is a space-separated list of QNames. After expansion of these names using the in-scope namespace declarations for the xsl:output declaration in which they appear, this list of names provides the value of the cdata-section-elements parameter to the serialization method. The default value is an empty list. May be used to override the attribute defined in the selected output definition.</xs:documentation> </xs:annotation> </xs:attribute> <xs:attribute name="doctype-public" type="xsl:avt"> <xs:annotation> <xs:documentation> The value of the doctype-public attribute provides the value of the doctype-public parameter to the serialization method. By default, the parameter is not supplied. May be used to override the attribute defined in the selected output definition. </xs:documentation> </xs:annotation> </xs:attribute> <xs:attribute name="doctype-system" type="xsl:avt"> <xs:annotation> <xs:documentation>The value of the doctype-system attribute provides the value of the doctype-system parameter to the serialization method. By default, the parameter is not supplied. May be used to override the attribute defined in the selected output definition. </xs:documentation> </xs:annotation> </xs:attribute> <xs:attribute name="encoding" type="xsl:avt"> <xs:annotation> <xs:documentation>The value of the encoding attribute provides the value of the encoding parameter to the serialization method. May be used to override the attribute defined in the selected output definition. </xs:documentation> </xs:annotation> </xs:attribute> <xs:attribute name="escape-uri-attributes" type="xsl:avt"> <xs:annotation> <xs:documentation>The value of the escape-uri-attributes attribute provides the value of the escape-uri-attributes parameter to the serialization method. May be used to override the attribute defined in the selected output definition.</xs:documentation> </xs:annotation> </xs:attribute> <xs:attribute name="include-content-type" type="xsl:avt"> <xs:annotation> <xs:documentation>The value of the include-content-type attribute provides the value of the include-content-type parameter to the serialization method. May be used to override the attribute defined in the selected output definition.</xs:documentation> </xs:annotation> </xs:attribute> <xs:attribute name="indent" type="xsl:avt"> <xs:annotation> <xs:documentation>The value of the indent attribute provides the value of the indent parameter to the serialization method. May be used to override the attribute defined in the selected output definition. </xs:documentation> </xs:annotation> </xs:attribute> <xs:attribute name="media-type" type="xsl:avt"> <xs:annotation> <xs:documentation>The value of the media-type attribute provides the value of the media-type parameter to the serialization method. May be used to override the attribute defined in the selected output definition. </xs:documentation> </xs:annotation> </xs:attribute> <xs:attribute name="normalization-form" type="xsl:avt"> <xs:annotation> <xs:documentation> The value of the normalization-form attribute provides the value of the normalization-form parameter to the serialization method. A value that is an NMTOKEN other than one of those enumerated for the normalization-form attribute specifes an implementation-defined normalization form; the behavior in this case is not specified by this document. May be used to override the attribute defined in the selected output definition. </xs:documentation> </xs:annotation> </xs:attribute> <xs:attribute name="omit-xml-declaration" type="xsl:avt"> <xs:annotation> <xs:documentation>The value of the omit-xml-declaration attribute provides the value of the omit-xml-declaration parameter to the serialization method. May be used to override the attribute defined in the selected output definition. </xs:documentation> </xs:annotation> </xs:attribute> <xs:attribute name="standalone" type="xsl:avt"> <xs:annotation> <xs:documentation>The value of the standalone attribute provides the value of the standalone parameter to the serialization method. May be used to override the attribute defined in the selected output definition. </xs:documentation> </xs:annotation> </xs:attribute> <xs:attribute name="undeclare-prefixes" type="xsl:avt"> <xs:annotation> <xs:documentation> The undeclare-prefixes attribute is relevant only when producing output with method="xml" and version="1.1" (or later). It defines whether namespace undeclarations (of the form xmlns:foo="") should be output when a child element has no namespace node with the same name (that is, namespace prefix) as a namespace node of its parent element. May be used to override the attribute defined in the selected output definition. </xs:documentation> </xs:annotation> </xs:attribute> <xs:attribute name="use-character-maps" type="xsl:QNames"> <xs:annotation> <xs:documentation>The use-character-maps attribute provides a list of named character maps that are used in conjunction with this output definition. May be used to override the attribute defined in the selected output definition. </xs:documentation> </xs:annotation> </xs:attribute> <xs:attribute name="output-version" type="xsl:avt"> <xs:annotation> <xs:documentation>The value of the version attribute provides the value of the version parameter to the serialization method. May be used to override the attribute defined in the selected output definition. </xs:documentation> </xs:annotation> </xs:attribute> </xs:extension> </xs:complexContent> </xs:complexType> </xs:element> <xs:element name="sequence" substitutionGroup="xsl:instruction"> <xs:annotation> <xs:documentation> The xsl:sequence instruction may be used within a sequence constructor to construct a sequence of nodes and/or atomic values. This sequence is returned as the result of the instruction. Unlike most other instructions, xsl:sequence can add existing nodes to a sequence, rather than constructing new nodes. When xsl:sequence is used to add atomic values to a sequence, the effect is very similar to the xsl:copy-of instruction. <br/> See more info at http://www.w3.org/TR/xslt20/#element-sequence </xs:documentation> </xs:annotation> <xs:complexType> <xs:complexContent mixed="true"> <xs:extension base="xsl:sequence-constructor"> <xs:attribute name="select" type="xsl:expression"> <xs:annotation> <xs:documentation> The items comprising the result sequence may be selected using the select attribute, or constructed using the contained sequence constructor (but not both). </xs:documentation> </xs:annotation> </xs:attribute> <xs:attribute name="as" type="xsl:sequence-type"> <xs:annotation> <xs:documentation> The as attribute, if present, defines the required type of the result sequence. The computed value of the result sequence will be converted to this type using the function conversion rules. The as attribute may be used to restrict the sequence to contain only atomic values, or only nodes, or it may allow a sequence containing both atomic values and nodes. If no as attribute is specified, the default value is item()*, which permits any value. No conversion then takes place.</xs:documentation> </xs:annotation> </xs:attribute> </xs:extension> </xs:complexContent> </xs:complexType> </xs:element> <xs:element name="sort"> <xs:annotation> <xs:documentation> The xsl:sort element defines a sort key component. A sort key component specifies how a sort key value is to be computed for each item in the sequence being sorted, and also how two sort key values are to be compared. <br/> See more info at http://www.w3.org/TR/xslt20/#element-sort </xs:documentation> </xs:annotation> <xs:complexType> <xs:complexContent mixed="true"> <xs:extension base="xsl:sequence-constructor"> <xs:attribute name="select" type="xsl:expression"> <xs:annotation> <xs:documentation>The value of a sort key component is determined either by its select attribute, or by the contained sequence constructor. If neither is present, the default is select=".", which has the effect of sorting on the actual value of the item if it is an atomic value, or on the typed-value of the item if it is a node. If a select attribute is present, its value must be an XPath expression.</xs:documentation> </xs:annotation> </xs:attribute> <xs:attribute name="lang" type="xsl:avt"> <xs:annotation> <xs:documentation>The lang attribute indicates that a collation suitable for a particular natural language should be used. The effective value of the attribute must be a value that would be valid for the xml:lang attribute.</xs:documentation> </xs:annotation> </xs:attribute> <xs:attribute name="data-type" type="xsl:avt" default="text"> <xs:annotation> <xs:documentation> For backwards compatibility with XSLT 1.0, the data-type attribute remains available. If this has the effective value text, the atomized sort key values are converted to strings before being compared. If it has the effective value number, the atomized sort key values are converted to doubles before being compared. The conversion is done by using the string FO or number FO function as appropriate. If the data-type attribute has any other effective value, then the value must be a lexical QName with a non-empty prefix, and the effect of the attribute is implementation-defined. </xs:documentation> </xs:annotation> </xs:attribute> <xs:attribute name="order" type="xsl:avt" default="ascending"> <xs:annotation> <xs:documentation> The order attribute controls the direction of sorting. Possible values are ascending and descending. </xs:documentation> </xs:annotation> </xs:attribute> <xs:attribute name="case-order" type="xsl:avt"> <xs:annotation> <xs:documentation>The case-order attribute indicates whether the desired collation should sort upper-case letters before lower-case or vice versa. The effective value of the attribute must be either lower-first (indicating that lower-case letters precede upper-case letters in the collating sequence) or upper-first (indicating that upper-case letters precede lower-case).</xs:documentation> </xs:annotation> </xs:attribute> <xs:attribute name="collation" type="xsl:avt"> <xs:annotation> <xs:documentation>If the xsl:sort element has a collation attribute, then the strings are compared according to the rules for the named collation: that is, they are compared using the XPath function call compare($a, $b, $collation). </xs:documentation> </xs:annotation> </xs:attribute> <xs:attribute name="stable" type="xsl:yes-or-no"> <xs:annotation> <xs:documentation> The stable attribute is permitted only on the first xsl:sort element within a sort key specification. It is a static error if an xsl:sort element other than the first in a sequence of sibling xsl:sort elements has a stable attribute. A sort key specification is said to be stable if its first xsl:sort element has no stable attribute, or has a stable attribute whose effective value is yes. </xs:documentation> </xs:annotation> </xs:attribute> </xs:extension> </xs:complexContent> </xs:complexType> </xs:element> <xs:element name="strip-space" substitutionGroup="xsl:declaration"> <xs:annotation> <xs:documentation> The set of whitespace-preserving element names is specified by xsl:strip-space and xsl:preserve-space declarations. Whether an element name is included in the set of whitespace-preserving names is determined by the best match among all the xsl:strip-space or xsl:preserve-space declarations: it is included if and only if there is no match or the best match is an xsl:preserve-space element. <br/> See more info at http://www.w3.org/TR/xslt20/#element-strip-space </xs:documentation> </xs:annotation> <xs:complexType> <xs:complexContent> <xs:extension base="xsl:element-only-versioned-element-type"> <xs:attribute name="elements" type="xsl:nametests" use="required"> <xs:annotation> <xs:documentation>Specifies the strip space elements. Its value is a whitespace-separated list of NameTests.</xs:documentation> </xs:annotation> </xs:attribute> </xs:extension> </xs:complexContent> </xs:complexType> </xs:element> <xs:element name="stylesheet" substitutionGroup="xsl:transform"> <xs:annotation> <xs:documentation> A stylesheet module is represented by an xsl:stylesheet element in an XML document. xsl:transform is allowed as a synonym for xsl:stylesheet; everything this specification says about the xsl:stylesheet element applies equally to xsl:transform. <br/> See more info at http://www.w3.org/TR/xslt20/#element-stylesheet </xs:documentation> </xs:annotation> </xs:element> <xs:element name="template" substitutionGroup="xsl:declaration"> <xs:annotation> <xs:documentation> An xsl:template declaration defines a template, which contains a sequence constructor for creating nodes and/or atomic values. A template can serve either as a template rule, invoked by matching nodes against a pattern, or as a named template, invoked explicitly by name. It is also possible for the same template to serve in both capacities. <br/> See more info at http://www.w3.org/TR/xslt20/#element-template </xs:documentation> </xs:annotation> <xs:complexType> <xs:complexContent mixed="true"> <xs:extension base="xsl:versioned-element-type"> <xs:sequence> <xs:element ref="xsl:param" minOccurs="0" maxOccurs="unbounded"/> <xs:group ref="xsl:sequence-constructor-group" minOccurs="0" maxOccurs="unbounded"/> </xs:sequence> <xs:attribute name="match" type="xsl:pattern"> <xs:annotation> <xs:documentation> A template rule is specified using the xsl:template element with a match attribute. The match attribute is a Pattern that identifies the node or nodes to which the rule applies. The result of applying the template rule is the result of evaluating the sequence constructor contained in the xsl:template element, with the matching node used as the context node. </xs:documentation> </xs:annotation> </xs:attribute> <xs:attribute name="priority" type="xs:decimal"> <xs:annotation> <xs:documentation>The priority of a template rule is specified by the priority attribute on the template rule.</xs:documentation> </xs:annotation> </xs:attribute> <xs:attribute name="mode" type="xsl:modes"> <xs:annotation> <xs:documentation> A template rule is applicable to one or more modes. The modes to which it is applicable are defined by the mode attribute of the xsl:template element. If the attribute is omitted, then the template rule is applicable to the default mode. If the attribute is present, then its value must be a space-separated list of tokens, each of which defines a mode to which the template rule is applicable. Each token must be one of the following:<ul> <li> a QName, to define the name of the mode</li> <li> the token #default, to indicate that the template rule is applicable to the default mode</li> <li> the token #all, to indicate that the template rule is applicable to all modes.</li> </ul> </xs:documentation> </xs:annotation> </xs:attribute> <xs:attribute name="name" type="xsl:QName"> <xs:annotation> <xs:documentation> Specifies a name for the template. If the template has a name attribute, then it is a named template. </xs:documentation> </xs:annotation> </xs:attribute> <xs:attribute name="as" type="xsl:sequence-type" default="item()*"> <xs:annotation> <xs:documentation> If an as attribute is present, the as attribute defines the required type of the result. The result of evaluating the sequence constructor is converted to the required type using the function conversion rules. If no as attribute is specified, the default value is item()*, which permits any value. No conversion then takes place. </xs:documentation> </xs:annotation> </xs:attribute> </xs:extension> </xs:complexContent> </xs:complexType> </xs:element> <xs:complexType name="text-element-base-type"> <xs:simpleContent> <xs:restriction base="xsl:versioned-element-type"> <xs:simpleType> <xs:restriction base="xs:string"/> </xs:simpleType> <xs:anyAttribute namespace="##other" processContents="lax"/> </xs:restriction> </xs:simpleContent> </xs:complexType> <xs:element name="text" substitutionGroup="xsl:instruction"> <xs:annotation> <xs:documentation> The xsl:text element is evaluated to contruct a new text node. The content of the xsl:text element is a single text node whose value forms the string value of the new text node. An xsl:text element may also be empty, in which case the result of evaluating the instruction is an empty sequence.<br/> See more info at http://www.w3.org/TR/xslt20/#element-text </xs:documentation> </xs:annotation> <xs:complexType> <xs:simpleContent> <xs:extension base="xsl:text-element-base-type"> <xs:attribute name="disable-output-escaping" type="xsl:yes-or-no" default="no"> <xs:annotation> <xs:documentation>Normally, when using the XML, HTML, or XHTML output method, the serializer will escape special characters such as & and < when outputting text nodes. This ensures that the output is well-formed. Specifying disable-output-escaping as yes will disable this. This attribute is marked as deprecated in XSLT 2.0. Since disabling output escaping might not work with all implementations and can result in XML that is not well-formed, it should be used only when there is no alternative. The facility to define character maps for use during serialization has been produced as an alternative mechanism that can be used in many situations where disabling of output escaping was previously necessary, without the same difficulties. </xs:documentation> </xs:annotation> </xs:attribute> </xs:extension> </xs:simpleContent> </xs:complexType> </xs:element> <xs:complexType name="transform-element-base-type"> <xs:complexContent> <xs:restriction base="xsl:element-only-versioned-element-type"> <xs:attribute name="version" type="xs:decimal" use="required"/> <xs:anyAttribute namespace="##other" processContents="lax"/> </xs:restriction> </xs:complexContent> </xs:complexType> <xs:element name="transform"> <xs:annotation> <xs:documentation> The xsl:transform is allowed as a synonym for xsl:stylesheet; everything this specification says about the xsl:stylesheet element applies equally to xsl:transform. <br/> See more info at http://www.w3.org/TR/xslt20/#element-transform </xs:documentation> </xs:annotation> <xs:complexType> <xs:complexContent> <xs:extension base="xsl:transform-element-base-type"> <xs:sequence> <xs:element ref="xsl:import" minOccurs="0" maxOccurs="unbounded"/> <xs:choice minOccurs="0" maxOccurs="unbounded"> <xs:element ref="xsl:declaration"/> <xs:element ref="xsl:variable"/> <xs:element ref="xsl:param"/> <xs:any namespace="##other" processContents="lax"/> <!-- weaker than XSLT 1.0 --> </xs:choice> </xs:sequence> <xs:attribute name="id" type="xs:ID"> <xs:annotation> <xs:documentation> A stylesheet module may be embedded in an XML document and the xsl:stylesheet element may occur in that XML document other than as the document element. To facilitate this form of embedding, the xsl:stylesheet element may have an ID attribute that specifies a unique identifier. </xs:documentation> </xs:annotation> </xs:attribute> <xs:attribute name="default-validation" type="xsl:validation-strip-or-preserve" default="strip"> <xs:annotation> <xs:documentation> The default-validation attribute defines the default value of the validation attribute of all xsl:element, xsl:attribute, xsl:copy, xsl:copy-of, and xsl:result-document instructions, and of the xsl:validation attribute of all literal result elements. It also determines the validation applied to the implicit result tree created in the absence of an xsl:result-document instruction. This default applies within the stylesheet module: it does not extend to included or imported stylesheet modules. If the attribute is omitted, the default is strip. </xs:documentation> </xs:annotation> </xs:attribute> <xs:attribute name="input-type-annotations" type="xsl:input-type-annotations-type" default="unspecified"> <xs:annotation> <xs:documentation> Describes how type annotations in source documents are handled. This attribute has three permitted values: strip, preserve, and unspecified. The default value is unspecified. Stripping of type annotations takes place if at least one stylesheet module in the stylesheet specifies input-type-annotations="strip". </xs:documentation> </xs:annotation> </xs:attribute> </xs:extension> </xs:complexContent> </xs:complexType> </xs:element> <xs:element name="value-of" substitutionGroup="xsl:instruction"> <xs:annotation> <xs:documentation> The xsl:value-of instruction is evaluated to construct a new text node; the result of the instruction is the newly constructed text node. <br/> See more info at http://www.w3.org/TR/xslt20/#element-value-of </xs:documentation> </xs:annotation> <xs:complexType> <xs:complexContent mixed="true"> <xs:extension base="xsl:sequence-constructor"> <xs:attribute name="select" type="xsl:expression"> <xs:annotation> <xs:documentation> The string value of the new text node may be defined either by using the select attribute, or by the sequence constructor that forms the content of the xsl:value-of element. These are mutually exclusive, and one of them must be present. </xs:documentation> </xs:annotation> </xs:attribute> <xs:attribute name="separator" type="xsl:avt"> <xs:annotation> <xs:documentation> If the separator attribute is present, then the effective value of this attribute is used to separate adjacent items in the result sequence. In the absence of this attribute, the default separator is a single space (#x20) when the content is specified using the select attribute, or a zero-length string when the content is specified using a sequence constructor.</xs:documentation> </xs:annotation> </xs:attribute> <xs:attribute name="disable-output-escaping" type="xsl:yes-or-no" default="no"> <xs:annotation> <xs:documentation> Normally, when using the XML, HTML, or XHTML output method, the serializer will escape special characters such as & and < when outputting text nodes. This ensures that the output is well-formed. Specifying disable-output-escaping as yes will disable this. This attribute is marked as deprecated in XSLT 2.0. Since disabling output escaping might not work with all implementations and can result in XML that is not well-formed, it should be used only when there is no alternative. The facility to define character maps for use during serialization has been produced as an alternative mechanism that can be used in many situations where disabling of output escaping was previously necessary, without the same difficulties. </xs:documentation> </xs:annotation> </xs:attribute> </xs:extension> </xs:complexContent> </xs:complexType> </xs:element> <xs:element name="variable"> <xs:annotation> <xs:documentation> The xsl:variable element declares a variable, which may be a global variable or a local variable. A variable is a binding between a name and a value. The value of a variable is any sequence (of nodes and/or atomic values). <br/> See more info at http://www.w3.org/TR/xslt20/#element-variable </xs:documentation> </xs:annotation> <xs:complexType> <xs:complexContent mixed="true"> <xs:extension base="xsl:sequence-constructor"> <xs:attribute name="name" type="xsl:QName" use="required"> <xs:annotation> <xs:documentation> The xsl:variable element has a required name attribute, which specifies the name of the variable. The value of the name attribute is a QName. </xs:documentation> </xs:annotation> </xs:attribute> <xs:attribute name="select" type="xsl:expression" use="optional"> <xs:annotation> <xs:documentation> The value of the variable is computed using the expression given in the select attribute or the contained sequence constructor. This value is referred to as the supplied value of the variable. If the xsl:variable element has a select attribute, then the sequence constructor must be empty. </xs:documentation> </xs:annotation> </xs:attribute> <xs:attribute name="as" type="xsl:sequence-type" use="optional"> <xs:annotation> <xs:documentation> If the as attribute is specified, then the supplied value of the variable is converted to the required type, using the function conversion rules. If the as attribute is omitted, the supplied value of the variable is used directly, and no conversion takes place.</xs:documentation> </xs:annotation> </xs:attribute> </xs:extension> </xs:complexContent> </xs:complexType> </xs:element> <xs:element name="when"> <xs:annotation> <xs:documentation> The xsl:when element defines a possible alternative inside an xsl:choose element. When an xsl:choose element is processed, each of the xsl:when elements is tested in turn (that is, in the order that the elements appear in the stylesheet), until one of the xsl:when elements is satisfied. An xsl:when element is satisfied if the effective boolean value of the expression in its test attribute is true. <br/> See more info at http://www.w3.org/TR/xslt20/#element-when </xs:documentation> </xs:annotation> <xs:complexType> <xs:complexContent mixed="true"> <xs:extension base="xsl:sequence-constructor"> <xs:attribute name="test" type="xsl:expression" use="required"> <xs:annotation> <xs:documentation> Specifies the test expression. </xs:documentation> </xs:annotation> </xs:attribute> </xs:extension> </xs:complexContent> </xs:complexType> </xs:element> <xs:element name="with-param"> <xs:annotation> <xs:documentation> Parameters are passed to templates using the xsl:with-param element. <br/> See more info at http://www.w3.org/TR/xslt20/#element-with-param </xs:documentation> </xs:annotation> <xs:complexType> <xs:complexContent mixed="true"> <xs:extension base="xsl:sequence-constructor"> <xs:attribute name="name" type="xsl:QName" use="required"> <xs:annotation> <xs:documentation> The required name attribute specifies the name of the template parameter (the variable the value of whose binding is to be replaced). The value of the name attribute is a QName. </xs:documentation> </xs:annotation> </xs:attribute> <xs:attribute name="select" type="xsl:expression"> <xs:annotation> <xs:documentation> Specifies a value for the parameter. The value of the parameter is computed using the expression given in the select attribute or the contained sequence constructor. </xs:documentation> </xs:annotation> </xs:attribute> <xs:attribute name="as" type="xsl:sequence-type"> <xs:annotation> <xs:documentation> The as attribute specifies the required type of the parameter. If the as attribute is specified, then the supplied value of the parameter is converted to the required type, using the function conversion rules. If the as attribute is omitted, the supplied value of the parameter is used directly, and no conversion takes place. </xs:documentation> </xs:annotation> </xs:attribute> <xs:attribute name="tunnel" type="xsl:yes-or-no"> <xs:annotation> <xs:documentation> Tunnel parameters have the property that they are automatically passed on by the called template to any further templates that it calls, and so on recursively. The optional tunnel attribute may be used to indicate that a parameter is a tunnel parameter. The default is no. </xs:documentation> </xs:annotation> </xs:attribute> </xs:extension> </xs:complexContent> </xs:complexType> </xs:element> <!-- ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ --> <xs:annotation> <xs:documentation> PART C: definition of literal result elements There are three ways to define the literal result elements permissible in a stylesheet. (a) do nothing. This allows any element to be used as a literal result element, provided it is not in the XSLT namespace (b) declare all permitted literal result elements as members of the xsl:literal-result-element substitution group (c) redefine the model group xsl:result-elements to accommodate all permitted literal result elements. Literal result elements are allowed to take certain attributes in the XSLT namespace. These are defined in the attribute group literal-result-element-attributes, which can be included in the definition of any literal result element. </xs:documentation> </xs:annotation> <!-- ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ --> <xs:element name="literal-result-element" abstract="true" type="xs:anyType"/> <xs:attributeGroup name="literal-result-element-attributes"> <xs:attribute name="default-collation" form="qualified" type="xsl:uri-list"/> <xs:attribute name="extension-element-prefixes" form="qualified" type="xsl:prefixes"/> <xs:attribute name="exclude-result-prefixes" form="qualified" type="xsl:prefixes"/> <xs:attribute name="xpath-default-namespace" form="qualified" type="xs:anyURI"/> <xs:attribute name="inherit-namespaces" form="qualified" type="xsl:yes-or-no" default="yes"/> <xs:attribute name="use-attribute-sets" form="qualified" type="xsl:QNames" default=""/> <xs:attribute name="use-when" form="qualified" type="xsl:expression"/> <xs:attribute name="version" form="qualified" type="xs:decimal"/> <xs:attribute name="type" form="qualified" type="xsl:QName"/> <xs:attribute name="validation" form="qualified" type="xsl:validation-type"/> </xs:attributeGroup> <xs:group name="result-elements"> <xs:choice> <xs:element ref="xsl:literal-result-element"/> <xs:any namespace="##other" processContents="lax"/> <xs:any namespace="##local" processContents="lax"/> </xs:choice> </xs:group> <!-- ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ --> <xs:annotation> <xs:documentation> PART D: definitions of simple types used in stylesheet attributes </xs:documentation> </xs:annotation> <!-- ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ --> <xs:simpleType name="avt"> <xs:annotation> <xs:documentation> This type is used for all attributes that allow an attribute value template. The general rules for the syntax of attribute value templates, and the specific rules for each such attribute, are described in the XSLT 2.0 Recommendation. </xs:documentation> </xs:annotation> <xs:restriction base="xs:string"/> </xs:simpleType> <xs:simpleType name="char"> <xs:annotation> <xs:documentation> A string containing exactly one character. </xs:documentation> </xs:annotation> <xs:restriction base="xs:string"> <xs:length value="1"/> </xs:restriction> </xs:simpleType> <xs:simpleType name="expression"> <xs:annotation> <xs:documentation> An XPath 2.0 expression. </xs:documentation> </xs:annotation> <xs:restriction base="xs:token"> <xs:pattern value=".+"/> </xs:restriction> </xs:simpleType> <xs:simpleType name="input-type-annotations-type"> <xs:annotation> <xs:documentation> Describes how type annotations in source documents are handled. </xs:documentation> </xs:annotation> <xs:restriction base="xs:token"> <xs:enumeration value="preserve"/> <xs:enumeration value="strip"/> <xs:enumeration value="unspecified"/> </xs:restriction> </xs:simpleType> <xs:simpleType name="level"> <xs:annotation> <xs:documentation> The level attribute of xsl:number: one of single, multiple, or any. </xs:documentation> </xs:annotation> <xs:restriction base="xs:NCName"> <xs:enumeration value="single"/> <xs:enumeration value="multiple"/> <xs:enumeration value="any"/> </xs:restriction> </xs:simpleType> <xs:simpleType name="mode"> <xs:annotation> <xs:documentation> The mode attribute of xsl:apply-templates: either a QName, or #current, or #default. </xs:documentation> </xs:annotation> <xs:union memberTypes="xsl:QName"> <xs:simpleType> <xs:restriction base="xs:token"> <xs:enumeration value="#default"/> <xs:enumeration value="#current"/> </xs:restriction> </xs:simpleType> </xs:union> </xs:simpleType> <xs:simpleType name="modes"> <xs:annotation> <xs:documentation> The mode attribute of xsl:template: either a list, each member being either a QName or #default; or the value #all </xs:documentation> </xs:annotation> <xs:union> <xs:simpleType> <xs:list> <xs:simpleType> <xs:union memberTypes="xsl:QName"> <xs:simpleType> <xs:restriction base="xs:token"> <xs:enumeration value="#default"/> </xs:restriction> </xs:simpleType> </xs:union> </xs:simpleType> </xs:list> </xs:simpleType> <xs:simpleType> <xs:restriction base="xs:token"> <xs:enumeration value="#all"/> </xs:restriction> </xs:simpleType> </xs:union> </xs:simpleType> <xs:simpleType name="nametests"> <xs:annotation> <xs:documentation> A list of NameTests, as defined in the XPath 2.0 Recommendation. Each NameTest is either a QName, or "*", or "prefix:*", or "*:localname" </xs:documentation> </xs:annotation> <xs:list> <xs:simpleType> <xs:union memberTypes="xsl:QName"> <xs:simpleType> <xs:restriction base="xs:token"> <xs:enumeration value="*"/> </xs:restriction> </xs:simpleType> <xs:simpleType> <xs:restriction base="xs:token"> <xs:pattern value="\i\c*:\*"/> <xs:pattern value="\*:\i\c*"/> </xs:restriction> </xs:simpleType> </xs:union> </xs:simpleType> </xs:list> </xs:simpleType> <xs:simpleType name="prefixes"> <xs:list itemType="xs:NCName"/> </xs:simpleType> <xs:simpleType name="prefix-list-or-all"> <xs:union memberTypes="xsl:prefix-list"> <xs:simpleType> <xs:restriction base="xs:token"> <xs:enumeration value="#all"/> </xs:restriction> </xs:simpleType> </xs:union> </xs:simpleType> <xs:simpleType name="prefix-list"> <xs:list itemType="xsl:prefix-or-default"/> </xs:simpleType> <xs:simpleType name="method"> <xs:annotation> <xs:documentation> The method attribute of xsl:output: Either one of the recognized names "xml", "xhtml", "html", "text", or a QName that must include a prefix. </xs:documentation> </xs:annotation> <xs:union> <xs:simpleType> <xs:restriction base="xs:NCName"> <xs:enumeration value="xml"/> <xs:enumeration value="xhtml"/> <xs:enumeration value="html"/> <xs:enumeration value="text"/> </xs:restriction> </xs:simpleType> <xs:simpleType> <xs:restriction base="xsl:QName"> <xs:pattern value="\c*:\c*"/> </xs:restriction> </xs:simpleType> </xs:union> </xs:simpleType> <xs:simpleType name="pattern"> <xs:annotation> <xs:documentation> A match pattern as defined in the XSLT 2.0 Recommendation. The syntax for patterns is a restricted form of the syntax for XPath 2.0 expressions. </xs:documentation> </xs:annotation> <xs:restriction base="xsl:expression"/> </xs:simpleType> <xs:simpleType name="prefix-or-default"> <xs:annotation> <xs:documentation> Either a namespace prefix, or #default. Used in the xsl:namespace-alias element. </xs:documentation> </xs:annotation> <xs:union memberTypes="xs:NCName"> <xs:simpleType> <xs:restriction base="xs:token"> <xs:enumeration value="#default"/> </xs:restriction> </xs:simpleType> </xs:union> </xs:simpleType> <xs:simpleType name="QNames"> <xs:annotation> <xs:documentation> A list of QNames. Used in the [xsl:]use-attribute-sets attribute of various elements, and in the cdata-section-elements attribute of xsl:output </xs:documentation> </xs:annotation> <xs:list itemType="xsl:QName"/> </xs:simpleType> <xs:simpleType name="QName"> <xs:annotation> <xs:documentation> A QName. This schema does not use the built-in type xs:QName, but rather defines its own QName type. Although xs:QName would define the correct validation on these attributes, a schema processor would expand unprefixed QNames incorrectly when constructing the PSVI, because (as defined in XML Schema errata) an unprefixed xs:QName is assumed to be in the default namespace, which is not the correct assumption for XSLT. The data type is defined as a restriction of the built-in type Name, restricted so that it can only contain one colon which must not be the first or last character. </xs:documentation> </xs:annotation> <xs:restriction base="xs:Name"> <xs:pattern value="([^:]+:)?[^:]+"/> </xs:restriction> </xs:simpleType> <xs:simpleType name="sequence-type"> <xs:annotation> <xs:documentation> The description of a data type, conforming to the SequenceType production defined in the XPath 2.0 Recommendation </xs:documentation> </xs:annotation> <xs:restriction base="xs:token"> <xs:pattern value=".+"/> </xs:restriction> </xs:simpleType> <xs:simpleType name="uri-list"> <xs:list itemType="xs:anyURI"/> </xs:simpleType> <xs:simpleType name="validation-strip-or-preserve"> <xs:annotation> <xs:documentation> Describes different ways of type-annotating an element or attribute. </xs:documentation> </xs:annotation> <xs:restriction base="xsl:validation-type"> <xs:enumeration value="preserve"/> <xs:enumeration value="strip"/> </xs:restriction> </xs:simpleType> <xs:simpleType name="validation-type"> <xs:annotation> <xs:documentation> Describes different ways of type-annotating an element or attribute. </xs:documentation> </xs:annotation> <xs:restriction base="xs:token"> <xs:enumeration value="strict"/> <xs:enumeration value="lax"/> <xs:enumeration value="preserve"/> <xs:enumeration value="strip"/> </xs:restriction> </xs:simpleType> <xs:simpleType name="yes-or-no"> <xs:annotation> <xs:documentation> One of the values "yes" or "no". </xs:documentation> </xs:annotation> <xs:restriction base="xs:token"> <xs:enumeration value="yes"/> <xs:enumeration value="no"/> </xs:restriction> </xs:simpleType> <xs:simpleType name="yes-or-no-or-omit"> <xs:annotation> <xs:documentation> One of the values "yes" or "no" or "omit". </xs:documentation> </xs:annotation> <xs:restriction base="xs:token"> <xs:enumeration value="yes"/> <xs:enumeration value="no"/> <xs:enumeration value="omit"/> </xs:restriction> </xs:simpleType> </xs:schema> 
