Saxon » SaxonC

<?xml version="1.0" encoding="UTF-8"?>

<!--* <!DOCTYPE xs:schema PUBLIC "-//W3C//DTD XMLSCHEMA 200105//EN"

"http://www.w3.org/2001/XMLSchema.dtd" [

<!ENTITY % schemaAttrs "

xmlns:xs CDATA #IMPLIED

xmlns:xsl CDATA #IMPLIED

xmlns:xsd CDATA #IMPLIED"

>

<!ENTITY % p "xs:">

<!ENTITY % s ":xs">

]> *-->

<?xml-stylesheet href="http://www.w3.org/2008/09/xsd.xsl" type="text/xsl"?>

<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema"

xmlns:xsl="http://www.w3.org/1999/XSL/Transform"

xmlns:vc="http://www.w3.org/2007/XMLSchema-versioning"

targetNamespace="http://www.w3.org/1999/XSL/Transform"

elementFormDefault="qualified"

vc:minVersion="1.1">

<!-- ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ -->

<xs:annotation>

<xs:documentation>

<p>

This is an XSD 1.1 schema for XSLT 3.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.

</p>

<p>

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

</p>

<p>

The schema is organized as follows:

</p>

<ul>

<li>

PART A: definitions of complex types and model groups used as the basis

for element definitions

</li>

<li>

PART B: definitions of individual XSLT elements

</li>

<li>

PART C: definitions for literal result elements

</li>

<li>

PART D: definitions of simple types used in attribute definitions

</li>

</ul>

<p>

The schema has a number of limitations:

</p>

<ul>

<li>

The XSLT specification allows additional elements and attributes to be

present where forwards compatibility is invoked. This schema does not.

</li>

<li>

The XSLT specification allows arbitrary content in a part of the

stylesheet that is excluded by virtue of a use-when attribute. This

schema does not.

</li>

<li>

The handling of literal result elements in this schema is imperfect;

although various options are allowed, none matches the specification

exactly. For example, the content of a literal result element uses lax

validation, which permits child elements in the XSLT namespace that have

no declaration in this schema.

</li>

<li>

The schema makes no attempt to check XPath expressions for syntactic or

semantic correctness, nor to check that component references are

resolved (for example that a template named in xsl:call-template has a

declaration). Doing this in general requires cross-document validation,

which is beyond the scope of XSD.

</li>

<li>

The schema imports the schema for XSD 1.0 schema documents. In

stylesheets that contain an inline XSD 1.1 schema, this import should be

replaced with one for the schema for XSD 1.1 schema documents.

</li>

</ul>

</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="http://www.w3.org/2001/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. We use the XSD 1.1 version.

-->

<xs:import namespace="http://www.w3.org/2001/XMLSchema"

schemaLocation="http://www.w3.org/TR/xmlschema11-1/XMLSchema.xsd"/>

<!-- ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ -->

<xs:annotation>

<xs:documentation>

<p>

PART A: definitions of complex types and model groups used as the basis

for element definitions

</p>

</xs:documentation>

</xs:annotation>

<!-- ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ -->

<xs:complexType name="generic-element-type" mixed="true">

<xs:annotation>

<xs:documentation>

<p>

This complex type provides a generic supertype for all XSLT elements; it

contains the definitions of the standard attributes that may appear on

any element.

</p>

</xs:documentation>

</xs:annotation>

<xs:attribute name="default-collation" type="xsl:uri-list"/>

<xs:attribute name="default-mode" type="xsl:default-mode-type"/>

<xs:attribute name="default-validation"

type="xsl:validation-strip-or-preserve"

default="strip"/>

<xs:attribute name="exclude-result-prefixes" type="xsl:prefix-list-or-all"/>

<xs:attribute name="expand-text" type="xsl:yes-or-no"/>

<xs:attribute name="extension-element-prefixes" type="xsl:prefix-list"/>

<xs:attribute name="use-when" type="xsl:expression"/>

<xs:attribute name="xpath-default-namespace" type="xs:anyURI"/>

<xs:attribute name="_default-collation" type="xs:string"/>

<xs:attribute name="_default-mode" type="xs:string"/>

<xs:attribute name="_default-validation" type="xs:string"/>

<xs:attribute name="_exclude-result-prefixes" type="xs:string"/>

<xs:attribute name="_expand-text" type="xs:string"/>

<xs:attribute name="_extension-element-prefixes" type="xs:string"/>

<xs:attribute name="_use-when" type="xs:string"/>

<xs:attribute name="_xpath-default-namespace" type="xs:string"/>

<xs:anyAttribute namespace="##other" processContents="lax"/>

</xs:complexType>

<xs:complexType name="versioned-element-type" mixed="true">

<xs:annotation>

<xs:documentation>

<p>

This complex type provides a generic supertype for all XSLT elements

with the exception of xsl:output; it contains the definitions of the

version attribute that may appear on any element.

</p>

<p>

The xsl:output does not use this definition because, although it has a

version attribute, the syntax and semantics of this attribute are

unrelated to the standard version attribute allowed on other elements.

</p>

</xs:documentation>

</xs:annotation>

<xs:complexContent>

<xs:extension base="xsl:generic-element-type">

<xs:attribute name="version" type="xs:decimal" use="optional"/>

<xs:attribute name="_version" type="xs:string"/>

</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:annotation>

<xs:documentation>

<p>

This complex type provides a generic supertype for all XSLT elements

that allow a sequence constructor as their content.

</p>

</xs:documentation>

</xs:annotation>

<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:complexType name="sequence-constructor-and-select">

<xs:annotation>

<xs:documentation>

<p>

This complex type allows a sequence constructor and a select attribute.

</p>

</xs:documentation>

</xs:annotation>

<xs:complexContent mixed="true">

<xs:extension base="xsl:sequence-constructor">

<xs:attribute name="select" type="xsl:expression"/>

<xs:attribute name="_select" type="xs:string"/>

</xs:extension>

</xs:complexContent>

</xs:complexType>

<xs:complexType name="sequence-constructor-or-select">

<xs:annotation>

<xs:documentation>

<p>

This complex type allows a sequence constructor or a select attribute,

but not both.

</p>

</xs:documentation>

</xs:annotation>

<xs:complexContent mixed="true">

<xs:restriction base="xsl:sequence-constructor-and-select">

<xs:group ref="xsl:sequence-constructor-group"

minOccurs="0"

maxOccurs="unbounded"/>

<xs:anyAttribute namespace="##other" processContents="lax"/>

<xs:assert test="not(exists(@select | @_select) and

(exists(* except xsl:fallback) or exists(text()[normalize-space()])))"/>

</xs:restriction>

</xs:complexContent>

</xs:complexType>

<xs:group name="sequence-constructor-group">

<xs:annotation>

<xs:documentation>

<p>

This complex type provides a generic supertype for all XSLT elements

that allow a sequence constructor as their content.

</p>

</xs:documentation>

</xs:annotation>

<xs:choice>

<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>

<p>

PART B: definitions of individual XSLT elements Elements are listed in

alphabetical order.

</p>

</xs:documentation>

</xs:annotation>

<!-- ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ -->

<xs:element name="accept">

<xs:annotation>

<xs:documentation>

<p>

This element appears as a child of xsl:use-package and defines any

variations that the containing package wishes to make to the visibility

of components made available from a library package. For example, it may

indicate that some of the public components in the library package are

not to be made available to the containing package.

</p>

</xs:documentation>

</xs:annotation>

<xs:complexType>

<xs:complexContent>

<xs:extension base="xsl:element-only-versioned-element-type">

<xs:attribute name="component" type="xsl:component-kind-type"/>

<xs:attribute name="names" type="xsl:EQNames"/>

<xs:attribute name="visibility" type="xsl:visibility-type"/>

<xs:attribute name="_component" type="xs:string"/>

<xs:attribute name="_names" type="xs:string"/>

<xs:attribute name="_visibility" type="xs:string"/>

<xs:assert test="exists(@component | @_component)"/>

<xs:assert test="exists(@names | @_names)"/>

<xs:assert test="exists(@visibility | @_visibility)"/>

</xs:extension>

</xs:complexContent>

</xs:complexType>

</xs:element>

<xs:element name="accumulator" substitutionGroup="xsl:declaration">

<xs:complexType>

<xs:complexContent>

<xs:extension base="xsl:element-only-versioned-element-type">

<xs:sequence>

<xs:element ref="xsl:accumulator-rule" minOccurs="1" maxOccurs="unbounded"/>

</xs:sequence>

<xs:attribute name="name" type="xsl:EQName"/>

<xs:attribute name="initial-value" type="xsl:expression"/>

<xs:attribute name="as" type="xsl:sequence-type"/>

<xs:attribute name="streamable" type="xsl:yes-or-no"/>

<xs:attribute name="_name" type="xs:string"/>

<xs:attribute name="_initial-value" type="xs:string"/>

<xs:attribute name="_as" type="xs:string"/>

<xs:attribute name="_streamable" type="xs:string"/>

</xs:extension>

</xs:complexContent>

</xs:complexType>

</xs:element>

<xs:element name="accumulator-rule">

<xs:complexType>

<xs:complexContent mixed="true">

<xs:extension base="xsl:sequence-constructor-or-select">

<xs:sequence/>

<xs:attribute name="match" type="xsl:pattern"/>

<xs:attribute name="phase">

<xs:simpleType>

<xs:restriction base="xs:token">

<xs:enumeration value="start"/>

<xs:enumeration value="end"/>

</xs:restriction>

</xs:simpleType>

</xs:attribute>

<xs:attribute name="_match" type="xs:string"/>

<xs:attribute name="_phase" type="xs:string"/>

<xs:assert test="exists(@match | @_match)"/>

</xs:extension>

</xs:complexContent>

</xs:complexType>

</xs:element>

<xs:element name="analyze-string" substitutionGroup="xsl:instruction">

<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"/>

<xs:attribute name="regex" type="xsl:avt"/>

<xs:attribute name="flags" type="xsl:avt" default=""/>

<xs:attribute name="_select" type="xs:string"/>

<xs:attribute name="_regex" type="xs:string"/>

<xs:attribute name="_flags" type="xs:string"/>

<xs:assert test="exists(@select | @_select)"/>

<xs:assert test="exists(@regex | @_regex)"/>

</xs:extension>

</xs:complexContent>

</xs:complexType>

</xs:element>

<xs:element name="apply-imports" substitutionGroup="xsl:instruction">

<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: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:attribute name="mode" type="xsl:mode"/>

<xs:attribute name="_select" type="xs:string"/>

<xs:attribute name="_mode" type="xs:string"/>

<xs:assert test="every $e in subsequence(xsl:sort, 2)

satisfies empty($e/(@stable | @_stable))">

<xs:annotation>

<xs:documentation>

<p>

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.

</p>

</xs:documentation>

</xs:annotation>

</xs:assert>

</xs:extension>

</xs:complexContent>

</xs:complexType>

</xs:element>

<xs:element name="assert" substitutionGroup="xsl:instruction">

<xs:complexType>

<xs:complexContent mixed="true">

<xs:extension base="xsl:sequence-constructor">

<xs:attribute name="test" type="xsl:expression"/>

<xs:attribute name="select" type="xsl:expression"/>

<xs:attribute name="error-code" type="xsl:avt"/>

<xs:attribute name="_test" type="xs:string"/>

<xs:attribute name="_select" type="xs:string"/>

<xs:attribute name="_error-code" type="xs:string"/>

<xs:assert test="exists(@test | @_test)"/>

</xs:extension>

</xs:complexContent>

</xs:complexType>

</xs:element>

<xs:element name="attribute" substitutionGroup="xsl:instruction">

<xs:complexType>

<xs:complexContent mixed="true">

<xs:extension base="xsl:sequence-constructor-or-select">

<xs:attribute name="name" type="xsl:avt"/>

<xs:attribute name="namespace" type="xsl:avt"/>

<xs:attribute name="separator" type="xsl:avt"/>

<xs:attribute name="type" type="xsl:EQName"/>

<xs:attribute name="validation" type="xsl:validation-type"/>

<xs:attribute name="_name" type="xs:string"/>

<xs:attribute name="_namespace" type="xs:string"/>

<xs:attribute name="_separator" type="xs:string"/>

<xs:attribute name="_type" type="xs:string"/>

<xs:attribute name="_validation" type="xs:string"/>

<xs:assert test="not(exists(@type | @_type) and exists(@validation | @_validation))">

<xs:annotation>

<xs:documentation>

<p>

The type and validation attributes are mutually exclusive (if

one is present, the other must be absent).

</p>

</xs:documentation>

</xs:annotation>

</xs:assert>

<xs:assert test="exists(@name | @_name)"/>

</xs:extension>

</xs:complexContent>

</xs:complexType>

</xs:element>

<xs:element name="attribute-set" substitutionGroup="xsl:declaration">

<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:EQName"/>

<xs:attribute name="streamable" type="xsl:yes-or-no"/>

<xs:attribute name="use-attribute-sets" type="xsl:EQNames" default=""/>

<xs:attribute name="visibility" type="xsl:visibility-type"/>

<xs:attribute name="_name" type="xs:string"/>

<xs:attribute name="_streamable" type="xs:string"/>

<xs:attribute name="_use-attribute-sets" type="xs:string"/>

<xs:attribute name="_visibility" type="xs:string"/>

<xs:assert test="exists(@name | @_name)"/>

</xs:extension>

</xs:complexContent>

</xs:complexType>

</xs:element>

<xs:element name="break"

substitutionGroup="xsl:instruction"

type="xsl:sequence-constructor-or-select"/>

<xs:element name="call-template" substitutionGroup="xsl:instruction">

<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:EQName"/>

<xs:attribute name="_name" type="xs:string"/>

<xs:assert test="exists(@name | @_name)"/>

</xs:extension>

</xs:complexContent>

</xs:complexType>

</xs:element>

<xs:element name="catch">

<xs:complexType>

<xs:complexContent mixed="true">

<xs:extension base="xsl:sequence-constructor-or-select">

<xs:attribute name="errors" type="xs:token" use="optional"/>

<xs:attribute name="_errors" type="xs:string"/>

</xs:extension>

</xs:complexContent>

</xs:complexType>

</xs:element>

<xs:element name="character-map" substitutionGroup="xsl:declaration">

<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:EQName"/>

<xs:attribute name="use-character-maps" type="xsl:EQNames" default=""/>

<xs:attribute name="_name" type="xs:string"/>

<xs:attribute name="_use-character-maps" type="xs:string"/>

<xs:assert test="exists(@name | @_name)"/>

</xs:extension>

</xs:complexContent>

</xs:complexType>

</xs:element>

<xs:element name="choose" substitutionGroup="xsl:instruction">

<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"

type="xsl:sequence-constructor-or-select"/>

<xs:element name="context-item">

<xs:complexType>

<xs:complexContent>

<xs:extension base="xsl:element-only-versioned-element-type">

<xs:attribute name="as" type="xsl:item-type"/>

<xs:attribute name="use">

<xs:simpleType>

<xs:restriction base="xs:token">

<xs:enumeration value="required"/>

<xs:enumeration value="optional"/>

<xs:enumeration value="absent"/>

</xs:restriction>

</xs:simpleType>

</xs:attribute>

<xs:attribute name="_as" type="xs:string"/>

<xs:attribute name="_use" type="xs:string"/>

</xs:extension>

</xs:complexContent>

</xs:complexType>

</xs:element>

<xs:element name="copy" substitutionGroup="xsl:instruction">

<xs:complexType>

<xs:complexContent mixed="true">

<xs:extension base="xsl:sequence-constructor">

<xs:attribute name="select" type="xsl:expression"/>

<xs:attribute name="copy-namespaces" type="xsl:yes-or-no" default="yes"/>

<xs:attribute name="inherit-namespaces" type="xsl:yes-or-no" default="yes"/>

<xs:attribute name="use-attribute-sets" type="xsl:EQNames" default=""/>

<xs:attribute name="type" type="xsl:EQName"/>

<xs:attribute name="validation" type="xsl:validation-type"/>

<xs:attribute name="_select" type="xs:string"/>

<xs:attribute name="_copy-namespaces" type="xs:string"/>

<xs:attribute name="_inherit-namespaces" type="xs:string"/>

<xs:attribute name="_use-attribute-sets" type="xs:string"/>

<xs:attribute name="_type" type="xs:string"/>

<xs:attribute name="_validation" type="xs:string"/>

<xs:assert test="not(exists(@type | @_type) and exists(@validation | @_validation))">

<xs:annotation>

<xs:documentation>

<p>

The type and validation attributes are mutually exclusive (if

one is present, the other must be absent).

</p>

</xs:documentation>

</xs:annotation>

</xs:assert>

</xs:extension>

</xs:complexContent>

</xs:complexType>

</xs:element>

<xs:element name="copy-of" substitutionGroup="xsl:instruction">

<xs:complexType>

<xs:complexContent mixed="true">

<xs:extension base="xsl:versioned-element-type">

<xs:attribute name="select" type="xsl:expression"/>

<xs:attribute name="copy-accumulators" type="xsl:yes-or-no" default="no"/>

<xs:attribute name="copy-namespaces" type="xsl:yes-or-no" default="yes"/>

<xs:attribute name="type" type="xsl:EQName"/>

<xs:attribute name="validation" type="xsl:validation-type"/>

<xs:attribute name="_select" type="xs:string"/>

<xs:attribute name="_copy-accumulators" type="xs:string"/>

<xs:attribute name="_copy-namespaces" type="xs:string"/>

<xs:attribute name="_type" type="xs:string"/>

<xs:attribute name="_validation" type="xs:string"/>

<xs:assert test="not(exists(@type | @_type) and exists(@validation | @_validation))">

<xs:annotation>

<xs:documentation>

<p>

The type and validation attributes are mutually exclusive (if

one is present, the other must be absent).

</p>

</xs:documentation>

</xs:annotation>

</xs:assert>

<xs:assert test="exists(@select | @_select)"/>

</xs:extension>

</xs:complexContent>

</xs:complexType>

</xs:element>

<xs:element name="document" substitutionGroup="xsl:instruction">

<xs:complexType>

<xs:complexContent mixed="true">

<xs:extension base="xsl:sequence-constructor">

<xs:attribute name="type" type="xsl:EQName"/>

<xs:attribute name="validation" type="xsl:validation-type"/>

<xs:attribute name="_type" type="xs:string"/>

<xs:attribute name="_validation" type="xs:string"/>

<xs:assert test="not(exists(@type | @_type) and exists(@validation | @_validation))">

<xs:annotation>

<xs:documentation>

<p>

The type and validation attributes are mutually exclusive (if

one is present, the other must be absent).

</p>

</xs:documentation>

</xs:annotation>

</xs:assert>

</xs:extension>

</xs:complexContent>

</xs:complexType>

</xs:element>

<xs:element name="decimal-format" substitutionGroup="xsl:declaration">

<xs:complexType>

<xs:complexContent>

<xs:extension base="xsl:element-only-versioned-element-type">

<xs:attribute name="name" type="xsl:EQName"/>

<xs:attribute name="decimal-separator" type="xsl:char" default="."/>

<xs:attribute name="grouping-separator" type="xsl:char" default=","/>

<xs:attribute name="infinity" type="xs:string" default="Infinity"/>

<xs:attribute name="minus-sign" type="xsl:char" default="-"/>

<xs:attribute name="exponent-separator" type="xsl:char" default="e"/>

<xs:attribute name="NaN" type="xs:string" default="NaN"/>

<xs:attribute name="percent" type="xsl:char" default="%"/>

<xs:attribute name="per-mille" type="xsl:char" default="~"/>

<xs:attribute name="zero-digit" type="xsl:zero-digit" default="0"/>

<xs:attribute name="digit" type="xsl:char" default="#"/>

<xs:attribute name="pattern-separator" type="xsl:char" default=";"/>

<xs:attribute name="_name" type="xs:string"/>

<xs:attribute name="_decimal-separator" type="xs:string"/>

<xs:attribute name="_grouping-separator" type="xs:string"/>

<xs:attribute name="_infinity" type="xs:string"/>

<xs:attribute name="_minus-sign" type="xs:string"/>

<xs:attribute name="_exponent-separator" type="xs:string"/>

<xs:attribute name="_NaN" type="xs:string"/>

<xs:attribute name="_percent" type="xs:string"/>

<xs:attribute name="_per-mille" type="xs:string"/>

<xs:attribute name="_zero-digit" type="xs:string"/>

<xs:attribute name="_digit" type="xs:string"/>

<xs:attribute name="_pattern-separator" type="xs:string"/>

</xs:extension>

</xs:complexContent>

</xs:complexType>

</xs:element>

<xs:element name="element" substitutionGroup="xsl:instruction">

<xs:complexType mixed="true">

<xs:complexContent>

<xs:extension base="xsl:sequence-constructor">

<xs:attribute name="name" type="xsl:avt"/>

<xs:attribute name="namespace" type="xsl:avt"/>

<xs:attribute name="inherit-namespaces" type="xsl:yes-or-no" default="yes"/>

<xs:attribute name="use-attribute-sets" type="xsl:EQNames" default=""/>

<xs:attribute name="type" type="xsl:EQName"/>

<xs:attribute name="validation" type="xsl:validation-type"/>

<xs:attribute name="_name" type="xs:string"/>

<xs:attribute name="_namespace" type="xs:string"/>

<xs:attribute name="_inherit-namespaces" type="xs:string"/>

<xs:attribute name="_use-attribute-sets" type="xs:string"/>

<xs:attribute name="_type" type="xs:string"/>

<xs:attribute name="_validation" type="xs:string"/>

<xs:assert test="exists(@name | @_name)"/>

<xs:assert test="not(exists(@type | @_type) and exists(@validation | @_validation))">

<xs:annotation>

<xs:documentation>

<p>

The type and validation attributes are mutually exclusive (if

one is present, the other must be absent).

</p>

</xs:documentation>

</xs:annotation>

</xs:assert>

</xs:extension>

</xs:complexContent>

</xs:complexType>

</xs:element>

<xs:element name="evaluate" substitutionGroup="xsl:instruction">

<xs:complexType>

<xs:complexContent mixed="true">

<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:attribute name="xpath" type="xsl:expression"/>

<xs:attribute name="as" type="xsl:sequence-type"/>

<xs:attribute name="base-uri" type="xsl:avt"/>

<xs:attribute name="context-item" type="xsl:expression"/>

<xs:attribute name="namespace-context" type="xsl:expression"/>

<xs:attribute name="schema-aware" type="xsl:avt"/>

<xs:attribute name="with-params" type="xsl:expression"/>

<xs:attribute name="_xpath" type="xs:string"/>

<xs:attribute name="_as" type="xs:string"/>

<xs:attribute name="_base-uri" type="xs:string"/>

<xs:attribute name="_context-item" type="xs:string"/>

<xs:attribute name="_namespace-context" type="xs:string"/>

<xs:attribute name="_schema-aware" type="xs:string"/>

<xs:attribute name="_with-params" type="xs:string"/>

<xs:assert test="exists(@xpath | @_xpath)"/>

</xs:extension>

</xs:complexContent>

</xs:complexType>

</xs:element>

<xs:element name="expose">

<xs:annotation>

<xs:documentation>

<p>

This element appears as a child of xsl:use-package and defines the

visibility of components that are made available (or not) by this

package to other using packages.

</p>

</xs:documentation>

</xs:annotation>

<xs:complexType>

<xs:complexContent>

<xs:extension base="xsl:element-only-versioned-element-type">

<xs:attribute name="component" type="xsl:component-kind-type"/>

<xs:attribute name="names" type="xsl:EQNames"/>

<xs:attribute name="visibility" type="xsl:visibility-not-hidden-type"/>

<xs:attribute name="_component" type="xs:string"/>

<xs:attribute name="_names" type="xs:string"/>

<xs:attribute name="_visibility" type="xs:string"/>

</xs:extension>

</xs:complexContent>

</xs:complexType>

</xs:element>

<xs:element name="fallback"

substitutionGroup="xsl:instruction"

type="xsl:sequence-constructor"/>

<xs:element name="for-each" substitutionGroup="xsl:instruction">

<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"/>

<xs:attribute name="_select" type="xs:string"/>

<xs:assert test="every $e in subsequence(xsl:sort, 2)

satisfies empty($e/(@stable | @_stable))">

<xs:annotation>

<xs:documentation>

<p>

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.

</p>

</xs:documentation>

</xs:annotation>

</xs:assert>

<xs:assert test="exists(@select | @_select)"/>

</xs:extension>

</xs:complexContent>

</xs:complexType>

</xs:element>

<xs:element name="for-each-group" substitutionGroup="xsl:instruction">

<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"/>

<xs:attribute name="group-by" type="xsl:expression"/>

<xs:attribute name="group-adjacent" type="xsl:expression"/>

<xs:attribute name="group-starting-with" type="xsl:pattern"/>

<xs:attribute name="group-ending-with" type="xsl:pattern"/>

<xs:attribute name="composite" type="xsl:yes-or-no"/>

<xs:attribute name="collation" type="xsl:avt"/>

<xs:attribute name="_select" type="xs:string"/>

<xs:attribute name="_group-by" type="xs:string"/>

<xs:attribute name="_group-adjacent" type="xs:string"/>

<xs:attribute name="_group-starting-with" type="xs:string"/>

<xs:attribute name="_group-ending-with" type="xs:string"/>

<xs:attribute name="_composite" type="xs:string"/>

<xs:attribute name="_collation" type="xs:string"/>

<xs:assert test="exists(@select | @_select)"/>

<xs:assert test="every $e in subsequence(xsl:sort, 2)

satisfies empty($e/(@stable | @_stable))">

<xs:annotation>

<xs:documentation>

<p>

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.

</p>

</xs:documentation>

</xs:annotation>

</xs:assert>

<xs:assert test="count(((@group-by|@_group-by)[1],

(@group-adjacent|@_group-adjacent)[1],

(@group-starting-with|@_group-starting-with)[1],

(@group-ending-with|@_group-ending-with)[1])) = 1">

<xs:annotation>

<xs:documentation>

<p>

These four attributes are mutually exclusive: it is a static

error if none of these four attributes is present or if more

than one of them is present.

</p>

</xs:documentation>

</xs:annotation>

</xs:assert>

<xs:assert test="if (exists(@collation|@_collation) or exists(@composite|@_composite))

then (exists(@group-by|@_group-by) or exists(@group-adjacent|@_group-adjacent))

else true()">

<xs:annotation>

<xs:documentation>

<p>

It is an error to specify the collation attribute or the

composite attribute if neither the group-by attribute nor

group-adjacent attribute is specified.

</p>

</xs:documentation>

</xs:annotation>

</xs:assert>

</xs:extension>

</xs:complexContent>

</xs:complexType>

</xs:element>

<xs:element name="fork" substitutionGroup="xsl:instruction">

<xs:complexType>

<xs:complexContent mixed="true">

<xs:extension base="xsl:versioned-element-type">

<xs:sequence>

<xs:element ref="xsl:fallback" minOccurs="0" maxOccurs="unbounded"/>

<xs:choice>

<xs:sequence minOccurs="0" maxOccurs="unbounded">

<xs:element ref="xsl:sequence"/>

<xs:element ref="xsl:fallback" minOccurs="0" maxOccurs="unbounded"/>

</xs:sequence>

<xs:sequence>

<xs:element ref="xsl:for-each-group"/>

<xs:element ref="xsl:fallback" minOccurs="0" maxOccurs="unbounded"/>

</xs:sequence>

</xs:choice>

</xs:sequence>

</xs:extension>

</xs:complexContent>

</xs:complexType>

</xs:element>

<xs:element name="function" substitutionGroup="xsl:declaration">

<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:EQName-in-namespace"/>

<xs:attribute name="override" type="xsl:yes-or-no" default="yes"/>

<xs:attribute name="as" type="xsl:sequence-type" default="item()*"/>

<xs:attribute name="visibility" type="xsl:visibility-type"/>

<xs:attribute name="streamability" type="xsl:streamability-type"/>

<xs:attribute name="override-extension-function" type="xsl:yes-or-no"/>

<xs:attribute name="new-each-time" type="xsl:yes-or-no-or-maybe"/>

<xs:attribute name="cache" type="xsl:yes-or-no"/>

<xs:attribute name="_name" type="xs:string"/>

<xs:attribute name="_override" type="xs:string"/>

<xs:attribute name="_as" type="xs:string"/>

<xs:attribute name="_visibility" type="xs:string"/>

<xs:attribute name="_streamability" type="xs:string"/>

<xs:attribute name="_override-extension-function" type="xs:string"/>

<xs:attribute name="_identity-sensitive" type="xs:string"/>

<xs:attribute name="_cache" type="xs:string"/>

<xs:assert test="exists(@name | @_name)"/>

<xs:assert test="every $e in xsl:param

satisfies (empty($e/(@select | @_select)) and empty($e/child::node()))">

<xs:annotation>

<xs:documentation>

<p>

A parameter for a function must have no default value.

</p>

</xs:documentation>

</xs:annotation>

</xs:assert>

<xs:assert test="every $e in xsl:param satisfies empty($e/(@visibility | @_visibility))">

<xs:annotation>

<xs:documentation>

<p>

A parameter for a function must have no visibility attribute.

</p>

</xs:documentation>

</xs:annotation>

</xs:assert>

<xs:assert test="every $e in xsl:param satisfies empty($e/(@required | @_required))">

<xs:annotation>

<xs:documentation>

<p>

A parameter for a function must have no required attribute.

</p>

</xs:documentation>

</xs:annotation>

</xs:assert>

</xs:extension>

</xs:complexContent>

</xs:complexType>

</xs:element>

<xs:element name="global-context-item" substitutionGroup="xsl:declaration">

<xs:complexType>

<xs:complexContent>

<xs:extension base="xsl:element-only-versioned-element-type">

<xs:attribute name="as" type="xsl:item-type"/>

<xs:attribute name="use">

<xs:simpleType>

<xs:restriction base="xs:token">

<xs:enumeration value="required"/>

<xs:enumeration value="optional"/>

<xs:enumeration value="absent"/>

</xs:restriction>

</xs:simpleType>

</xs:attribute>

<xs:attribute name="_as" type="xs:string"/>

<xs:attribute name="_use" type="xs:string"/>

</xs:extension>

</xs:complexContent>

</xs:complexType>

</xs:element>

<xs:element name="if" substitutionGroup="xsl:instruction">

<xs:complexType>

<xs:complexContent mixed="true">

<xs:extension base="xsl:sequence-constructor">

<xs:attribute name="test" type="xsl:expression"/>

<xs:attribute name="_test" type="xs:string"/>

<xs:assert test="exists(@test | @_test)"/>

</xs:extension>

</xs:complexContent>

</xs:complexType>

</xs:element>

<xs:element name="import" substitutionGroup="xsl:declaration">

<xs:complexType>

<xs:complexContent>

<xs:extension base="xsl:element-only-versioned-element-type">

<xs:attribute name="href" type="xs:anyURI"/>

<xs:attribute name="_href" type="xs:string"/>

<xs:assert test="exists(@href | @_href)"/>

</xs:extension>

</xs:complexContent>

</xs:complexType>

</xs:element>

<xs:element name="import-schema" substitutionGroup="xsl:declaration">

<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:attribute name="schema-location" type="xs:anyURI"/>

<xs:attribute name="_namespace" type="xs:string"/>

<xs:attribute name="_schema-location" type="xs:string"/>

<xs:assert test="not(exists(@schema-location | @_schema-location) and exists(xs:schema))">

<xs:annotation>

<xs:documentation>

<p>

XTSE0215: It is a static error if an xsl:import-schema element

that contains an xs:schema element has a schema-location

attribute

</p>

</xs:documentation>

</xs:annotation>

</xs:assert>

</xs:extension>

</xs:complexContent>

</xs:complexType>

</xs:element>

<xs:element name="include" substitutionGroup="xsl:declaration">

<xs:complexType>

<xs:complexContent>

<xs:extension base="xsl:element-only-versioned-element-type">

<xs:attribute name="href" type="xs:anyURI"/>

<xs:attribute name="_href" type="xs:string"/>

<xs:assert test="exists(@href | @_href)"/>

</xs:extension>

</xs:complexContent>

</xs:complexType>

</xs:element>

<xs:element name="iterate" substitutionGroup="xsl:instruction">

<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:element ref="xsl:on-completion" minOccurs="0" maxOccurs="1"/>

<xs:group ref="xsl:sequence-constructor-group"

minOccurs="0"

maxOccurs="unbounded"/>