### Define XSLT Template Element with XSD Schema

Source: https://www.w3.org/TR/xslt-30/schema-for-xslt30

Declares the template element as a substitution group member of xsl:declaration. The template supports optional context-item and parameters, sequence constructors, and attributes for matching patterns, priority, mode, and return types. Multiple xs:assert elements enforce constraints requiring either a match or name attribute, restricting mode/priority to match-based templates, and preventing abstract templates from containing instructions.

```XML
<xs:element
      name="template"
      substitutionGroup="xsl:declaration">
  <xs:complexType>
    <xs:complexContent mixed="true">
      <xs:extension base="xsl:versioned-element-type">
        <xs:sequence>
          <xs:element
                ref="xsl:context-item"
                minOccurs="0"
                maxOccurs="1"/>
          <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:attribute name="priority" type="xs:decimal"/>
        <xs:attribute name="mode" type="xsl:modes"/>
        <xs:attribute name="name" type="xsl:EQName"/>
        <xs:attribute
              name="as"
              type="xsl:sequence-type"
              default="item()*"/>
        <xs:attribute
              name="visibility"
              type="xsl:visibility-type"/>
        <xs:attribute name="_match" type="xs:string"/>
        <xs:attribute name="_priority" type="xs:string"/>
        <xs:attribute name="_mode" type="xs:string"/>
        <xs:attribute name="_name" type="xs:string"/>
        <xs:attribute name="_as" type="xs:string"/>
        <xs:attribute
              name="_visibility"
              type="xs:string"/>
        <xs:assert
              test="exists(@match | @_match) or exists(@name | @_name)"/>
        <xs:assert
              test="if (empty(@match | @_match)) then (empty(@mode | @_mode) and empty(@priority | @_priority)) else true()"/>
        <xs:assert
              test="not(exists(@visibility | @_visibility) and empty(@name | @_name))"/>
        <xs:assert
              test="if (normalize-space(@visibility) = 'abstract') then empty(* except (xsl:context-item, xsl:param)) else true()"/>
        <xs:assert
              test="not(normalize-space(@visibility) = 'abstract' and exists(@match))"/>
        <xs:assert
              test="every $e in xsl:param satisfies empty($e/(@visibility | @_visibility))"/>
      </xs:extension>
    </xs:complexContent>
  </xs:complexType>
</xs:element>
```

--------------------------------

### Define element Instruction XSD Schema

Source: https://www.w3.org/TR/xslt-30/schema-for-xslt30

XSD schema definition for the xsl:element instruction in XSLT 3.0. This mixed-content element extends sequence-constructor and specifies attributes for dynamic element creation including name, namespace, attribute set usage, type annotation, and validation mode. Includes validation assertions ensuring name attribute presence and mutual exclusivity between type and validation attributes.

```XML
<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:assert>
      </xs:extension>
    </xs:complexContent>
  </xs:complexType>
</xs:element>
```

--------------------------------

### XSLT 3.0 xsl:output method Type Definition

Source: https://www.w3.org/TR/xslt-30/schema-for-xslt30

Defines the 'method' simple type for the xsl:output element. It allows recognized names like 'xml', 'html', 'text', or a QName.

```xsd
  <xs:simpleType name="method">
    
    <xs:union>
      <xs:simpleType>
        <xs:restriction base="xs:token">
          <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:EQName">
          <xs:pattern value="\c*:\c*"/>
        </xs:restriction>
      </xs:simpleType>
    </xs:union>
  </xs:simpleType>
```

--------------------------------

### Define XSLT Try Element for Error Handling in XSD

Source: https://www.w3.org/TR/xslt-30/schema-for-xslt30

Declares the xs:element for 'try' as a substitution for xsl:instruction with mixed content. Contains sequence constructor and one or more xsl:catch elements plus optional fallback elements. Attributes control rollback-output behavior and optional select expression. Enables exception handling in XSLT templates.

```XSD
<xs:element name="try" substitutionGroup="xsl:instruction">
  <xs:complexType>
    <xs:complexContent mixed="true">
      <xs:extension base="xsl:versioned-element-type">
        <xs:sequence>
          <xs:group ref="xsl:sequence-constructor-group" minOccurs="0" maxOccurs="unbounded"/>
          <xs:element ref="xsl:catch" minOccurs="1" maxOccurs="1"/>
          <xs:choice minOccurs="0" maxOccurs="unbounded">
            <xs:element ref="xsl:catch"/>
            <xs:element ref="xsl:fallback"/>
          </xs:choice>
        </xs:sequence>
        <xs:attribute name="rollback-output" type="xsl:yes-or-no" default="yes"/>
        <xs:attribute name="select" type="xsl:expression" use="optional"/>
        <xs:attribute name="_rollback-output" type="xs:string"/>
        <xs:attribute name="_select" type="xs:string"/>
      </xs:extension>
    </xs:complexContent>
  </xs:complexType>
</xs:element>
```

--------------------------------

### XSD Declaration for xs:iterate

Source: https://www.w3.org/TR/xslt-30/schema-for-xslt30

Formal declaration for the 'iterate' instruction. It supports parameters, an 'on-completion' handler, and a sequence constructor. The 'select' attribute specifies the expression to iterate over. An assertion ensures 'select' is present.

```xsd
  <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"/>
          </xs:sequence>
          <xs:attribute
                name="select"
                type="xsl:expression"/>
          <xs:attribute name="_select" type="xs:string"/>
          <xs:assert test="exists(@select | @_select)"/>
        </xs:extension>
      </xs:complexContent>
    </xs:complexType>
  </xs:element>
```

--------------------------------

### XSD: Define sequence-constructor-group model group

Source: https://www.w3.org/TR/xslt-30/schema-for-xslt30

Defines the 'sequence-constructor-group' model group, used in sequence constructors. It allows either an 'xsl:instruction' element or a group of 'xsl:result-elements'.

```xml
<xs:group name="sequence-constructor-group">
    
    <xs:choice>
      <xs:element ref="xsl:instruction"/>
      <xs:group ref="xsl:result-elements"/>
    </xs:choice>
  </xs:group>
```

--------------------------------

### XSD Declaration for assert Element

Source: https://www.w3.org/TR/xslt-30/schema-for-xslt30

Defines the assert XSLT instruction element for runtime assertions in stylesheets. Requires either test or _test attribute. Supports select and error-code attributes for custom error handling. Extends sequence-constructor for mixed content and nested instructions.

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

--------------------------------

### XSLT 3.0 EQName Type Definition

Source: https://www.w3.org/TR/xslt-30/schema-for-xslt30

Defines the 'EQName' simple type for extended QNames. It handles local names, prefixed QNames, and the extended QName notation Q{uri}local, ensuring correct PSVI construction.

```xsd
  <xs:simpleType name="EQName">
    
    <xs:union memberTypes="xs:NCName xs:QName">
      <xs:simpleType>
        <xs:restriction base="xs:token">
          <xs:pattern value="Q\{[^\{\}]*\}[\i-[:]][\c-[:]]*"/>
        </xs:restriction>
      </xs:simpleType>
    </xs:union>
  </xs:simpleType>
```

--------------------------------

### XSD: Define sequence-constructor-and-select type

Source: https://www.w3.org/TR/xslt-30/schema-for-xslt30

Defines the 'sequence-constructor-and-select' complex type, allowing both a sequence constructor and a 'select' attribute. It extends 'xsl:sequence-constructor'.

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

--------------------------------

### XSD Declaration for attribute Element

Source: https://www.w3.org/TR/xslt-30/schema-for-xslt30

Defines the attribute XSLT instruction element for creating output attributes. Requires name attribute (AVT format). Supports optional namespace, separator, type, and validation attributes. Includes assertion preventing simultaneous use of type and validation attributes.

```xml
<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:assert>
        <xs:assert test="exists(@name | @_name)"/>
      </xs:extension>
    </xs:complexContent>
  </xs:complexType>
</xs:element>
```

--------------------------------

### XSD Simple Type: uri-list (XSD)

Source: https://www.w3.org/TR/xslt-30/schema-for-xslt30

Defines a simple type 'uri-list' which is a list of 'xs:anyURI' types, suitable for holding multiple URIs.

```xslt

  <xs:simpleType name="uri-list">
    <xs:list itemType="xs:anyURI"/>
  </xs:simpleType>
```

--------------------------------

### Define XSLT Use-Package Element for Package Dependencies in XSD

Source: https://www.w3.org/TR/xslt-30/schema-for-xslt30

Declares the xs:element for 'use-package' as a declaration substitution group element. Specifies package dependencies with name (URI) and package-version attributes indicating required version or version range. Contains optional xsl:accept and xsl:override child elements for fine-grained import control.

```XSD
<xs:element name="use-package" substitutionGroup="xsl:declaration">
  <xs:complexType>
    <xs:complexContent mixed="false">
      <xs:extension base="xsl:element-only-versioned-element-type">
        <xs:choice minOccurs="0" maxOccurs="unbounded">
          <xs:element ref="xsl:accept"/>
          <xs:element ref="xsl:override"/>
        </xs:choice>
        <xs:attribute name="name" type="xs:anyURI"/>
        <xs:attribute name="package-version" type="xs:string"/>
        <xs:attribute name="_name" type="xs:string"/>
        <xs:attribute name="_package-version" type="xs:string"/>
      </xs:extension>
    </xs:complexContent>
  </xs:complexType>
</xs:element>
```

--------------------------------

### XSD Declaration for xs:map-entry

Source: https://www.w3.org/TR/xslt-30/schema-for-xslt30

Formal declaration for the 'map-entry' instruction. This element is used within a 'map' to define individual key-value pairs. It requires a 'key' attribute (an expression) and can have a sequence constructor.

```xsd
  <xs:element
        name="map-entry"
        substitutionGroup="xsl:instruction">
    <xs:complexType>
      <xs:complexContent mixed="true">
        <xs:extension
              base="xsl:sequence-constructor-and-select">
          <xs:attribute name="key" type="xsl:expression"/>
          <xs:attribute name="_key" type="xs:string"/>
          <xs:assert test="exists(@key | @_key)"/>
        </xs:extension>
      </xs:complexContent>
    </xs:complexType>
  </xs:element>
```

--------------------------------

### XSD Declaration for xs:import-schema

Source: https://www.w3.org/TR/xslt-30/schema-for-xslt30

Defines the 'import-schema' element, used for importing XSD schemas. It can specify a namespace and schema location, and optionally include the schema itself. Assertions enforce correct usage.

```xsd
  <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:assert>
        </xs:extension>
      </xs:complexContent>
    </xs:complexType>
  </xs:element>
```

--------------------------------

### XSD Declaration for XSLT 'copy' Instruction

Source: https://www.w3.org/TR/xslt-30/schema-for-xslt30

Defines the 'copy' instruction in XSD, which is part of the xsl:instruction substitution group. It supports attributes for namespace handling, attribute sets, typing, and validation. The 'select' attribute is used to specify the content to be copied.

```xml
  <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:assert>
        </xs:extension>
      </xs:complexContent>
    </xs:complexType>
  </xs:element>
```

--------------------------------

### XSD Declaration for XSLT comment Element

Source: https://www.w3.org/TR/xslt-30/schema-for-xslt30

Defines the comment element for generating XML comments in output. Uses sequence-constructor-or-select type allowing either sequence constructors or select attributes. Functions as an XSLT instruction for dynamic comment generation.

```XSD
<xs:element
      name="comment"
      substitutionGroup="xsl:instruction"
      type="xsl:sequence-constructor-or-select"/>
```

--------------------------------

### Define XSLT Output Element with XSD Schema

Source: https://www.w3.org/TR/xslt-30/schema-for-xslt30

XSD schema definition for the XSLT output element that extends generic-element-type with substitutionGroup as xsl:declaration. Includes 50+ attributes controlling output serialization such as method, encoding, indentation, DOCTYPE declaration, and various formatting options for XML, HTML, and JSON output.

```XML
<xs:element
      name="output"
      substitutionGroup="xsl:declaration">
  <xs:complexType>
    <xs:complexContent mixed="true">
      <xs:extension base="xsl:generic-element-type">
        <xs:attribute name="name" type="xsl:EQName"/>
        <xs:attribute name="method" type="xsl:method"/>
        <xs:attribute
              name="allow-duplicate-names"
              type="xsl:yes-or-no"/>
        <xs:attribute
              name="build-tree"
              type="xsl:yes-or-no"/>
        <xs:attribute
              name="byte-order-mark"
              type="xsl:yes-or-no"/>
        <xs:attribute
              name="cdata-section-elements"
              type="xsl:EQNames"/>
        <xs:attribute
              name="doctype-public"
              type="xs:string"/>
        <xs:attribute
              name="doctype-system"
              type="xs:string"/>
        <xs:attribute name="encoding" type="xs:string"/>
        <xs:attribute
              name="escape-uri-attributes"
              type="xsl:yes-or-no"/>
        <xs:attribute
              name="html-version"
              type="xs:decimal"/>
        <xs:attribute
              name="include-content-type"
              type="xsl:yes-or-no"/>
        <xs:attribute name="indent" type="xsl:yes-or-no"/>
        <xs:attribute
              name="item-separator"
              type="xs:string"/>
        <xs:attribute
              name="json-node-output-method"
              type="xsl:method"/>
        <xs:attribute name="media-type" type="xs:string"/>
        <xs:attribute
              name="normalization-form"
              type="xs:NMTOKEN"/>
        <xs:attribute
              name="omit-xml-declaration"
              type="xsl:yes-or-no"/>
        <xs:attribute
              name="parameter-document"
              type="xs:anyURI"/>
        <xs:attribute
              name="standalone"
              type="xsl:yes-or-no-or-omit"/>
        <xs:attribute
              name="suppress-indentation"
              type="xsl:EQNames"/>
        <xs:attribute
              name="undeclare-prefixes"
              type="xsl:yes-or-no"/>
        <xs:attribute
              name="use-character-maps"
              type="xsl:EQNames"/>
        <xs:attribute name="version" type="xs:NMTOKEN"/>
        <xs:attribute name="_name" type="xs:string"/>
        <xs:attribute name="_method" type="xs:string"/>
        <xs:attribute
              name="_byte-order-mark"
              type="xs:string"/>
        <xs:attribute
              name="_cdata-section-elements"
              type="xs:string"/>
        <xs:attribute
              name="_doctype-public"
              type="xs:string"/>
        <xs:attribute
              name="_doctype-system"
              type="xs:string"/>
        <xs:attribute name="_encoding" type="xs:string"/>
        <xs:attribute
              name="_escape-uri-attributes"
              type="xs:string"/>
        <xs:attribute
              name="_html-version"
              type="xs:string"/>
        <xs:attribute
              name="_include-content-type"
              type="xs:string"/>
        <xs:attribute name="_indent" type="xs:string"/>
        <xs:attribute
              name="_item-separator"
              type="xs:string"/>
        <xs:attribute
              name="_media-type"
              type="xs:string"/>
        <xs:attribute
              name="_normalization-form"
              type="xs:string"/>
        <xs:attribute
              name="_omit-xml-declaration"
              type="xs:string"/>
        <xs:attribute
              name="_parameter-document"
              type="xs:string"/>
        <xs:attribute
              name="_standalone"
              type="xs:string"/>
        <xs:attribute
              name="_suppress-indentation"
              type="xs:string"/>
        <xs:attribute
              name="_undeclare-prefixes"
              type="xs:string"/>
        <xs:attribute
              name="_use-character-maps"
              type="xs:string"/>
        <xs:attribute name="_version" type="xs:string"/>
      </xs:extension>
    </xs:complexContent>
  </xs:complexType>
</xs:element>
```

--------------------------------

### Define next-match Instruction Element in XSD

Source: https://www.w3.org/TR/xslt-30/schema-for-xslt30

XSD schema declaration for the next-match XSLT instruction element. It extends element-only-versioned-element-type and allows zero or more xsl:with-param or xsl:fallback child elements. Used to invoke the next matching template rule with optional parameters or fallback behavior.

```XSD
<xs:element
      name="next-match"
      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:with-param"/>
          <xs:element ref="xsl:fallback"/>
        </xs:choice>
      </xs:extension>
    </xs:complexContent>
  </xs:complexType>
</xs:element>
```

--------------------------------

### XSD Declaration for xs:key

Source: https://www.w3.org/TR/xslt-30/schema-for-xslt30

Defines the 'key' element for defining named keys used for indexing and lookup. It requires 'name', 'match', and 'use' attributes, with optional 'composite' and 'collation'. Assertions validate the presence of required attributes.

```xsd
  <xs:element
        name="key"
        substitutionGroup="xsl:declaration">
    <xs:complexType>
      <xs:complexContent mixed="true">
        <xs:extension base="xsl:sequence-constructor">
          <xs:attribute name="name" type="xsl:EQName"/>
          <xs:attribute name="match" type="xsl:pattern"/>
          <xs:attribute name="use" type="xsl:expression"/>
          <xs:attribute
                name="composite"
                type="xsl:yes-or-no"/>
          <xs:attribute name="collation" type="xs:anyURI"/>
          <xs:attribute name="_name" type="xs:string"/>
          <xs:attribute name="_match" type="xs:string"/>
          <xs:attribute name="_use" type="xs:string"/>
          <xs:attribute name="_composite" type="xs:string"/>
          <xs:attribute name="_collation" type="xs:string"/>
          <xs:assert test="exists(@name | @_name)"/>
          <xs:assert test="exists(@match | @_match)"/>
        </xs:extension>
      </xs:complexContent>
    </xs:complexType>
  </xs:element>
```

--------------------------------

### Define XSLT evaluate Element with Dynamic XPath in XSD

Source: https://www.w3.org/TR/xslt-30/schema-for-xslt30

XSD schema definition for the xsl:evaluate instruction element that enables dynamic XPath evaluation. Extends element-only-versioned-element-type and supports optional xsl:with-param and xsl:fallback child elements. Includes attributes for XPath expression, sequence type, base URI, context item, namespace context, and schema awareness configuration with both static and dynamic attribute variants.

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

--------------------------------

### Define Accumulator Names Simple Type - XSD Union Type

Source: https://www.w3.org/TR/xslt-30/schema-for-xslt30

XSD simple type defining valid values for accumulator name attributes in XSLT source documents. Accepts either a space-separated list of QNames or the special keyword '#all' to reference all accumulators. Used by xsl:source-document, xsl:merge-source, and xsl:global-context-item elements.

```XML
<xs:simpleType name="accumulator-names">
  <xs:union>
    <xs:simpleType>
      <xs:list itemType="xsl:EQName"/>
    </xs:simpleType>
    <xs:simpleType>
      <xs:restriction base="xs:token">
        <xs:enumeration value="#all"/>
      </xs:restriction>
    </xs:simpleType>
  </xs:union>
</xs:simpleType>
```

--------------------------------

### XSD Declaration for xs:include

Source: https://www.w3.org/TR/xslt-30/schema-for-xslt30

Declares the 'include' element, which is used to include another schema document. It requires an 'href' attribute pointing to the schema to be included. An assertion validates the presence of the 'href' attribute.

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

--------------------------------

### XSD Declaration for XSLT 'source-document' Element

Source: https://www.w3.org/TR/xslt-30/schema-for-xslt30

Specifies the XSD for the 'source-document' element, which extends xsl:sequence-constructor and is a member of the xsl:instruction substitution group. It handles document retrieval with attributes like href, streamable, use-accumulators, type, and validation. Includes assertions for href presence and type/validation exclusivity.

```xml
<xs:element
        name="source-document"
        substitutionGroup="xsl:instruction">
    <xs:complexType>
      <xs:complexContent>
        <xs:extension base="xsl:sequence-constructor">
          <xs:attribute name="href" type="xsl:avt"/>
          <xs:attribute
                name="streamable"
                type="xsl:yes-or-no"
                default="no"/>
          <xs:attribute
                name="use-accumulators"
                type="xsl:accumulator-names"/>
          <xs:attribute name="type" type="xsl:EQName"/>
          <xs:attribute
                name="validation"
                type="xsl:validation-type"/>
          <xs:attribute name="_href" type="xs:string"/>
          <xs:attribute
                name="_streamable"
                type="xs:string"/>
          <xs:attribute
                name="_use-accumulators"
                type="xs:string"/>
          <xs:attribute name="_type" type="xs:string"/>
          <xs:attribute
                name="_validation"
                type="xs:string"/>
          <xs:assert test="exists(@href | @_href)"/>
          <xs:assert
                test="not(exists(@type | @_type) and exists(@validation | @_validation))">
            
          </xs:assert>
        </xs:extension>
      </xs:complexContent>
    </xs:complexType>
  </xs:element>
```

--------------------------------

### XSD Declaration for XSLT 'document' Instruction

Source: https://www.w3.org/TR/xslt-30/schema-for-xslt30

Defines the 'document' instruction in XSD, part of the xsl:instruction substitution group. It is used to access external XML documents. Supports attributes for specifying the document type and validation mode.

```xml
  <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:assert>
        </xs:extension>
      </xs:complexContent>
    </xs:complexType>
  </xs:element>
```

--------------------------------

### XSD Declaration for xs:matching-substring

Source: https://www.w3.org/TR/xslt-30/schema-for-xslt30

Declares the 'matching-substring' element, which is an XSLT instruction. It inherits from 'xsl:sequence-constructor', meaning it can contain a sequence of items. Its specific use case is not detailed here but implies substring operations.

```xsd
  <xs:element
        name="matching-substring"
        type="xsl:sequence-constructor"/>
```

--------------------------------

### XSD Declaration for XSLT 'copy-of' Instruction

Source: https://www.w3.org/TR/xslt-30/schema-for-xslt30

Defines the 'copy-of' instruction in XSD, which is part of the xsl:instruction substitution group. It requires a 'select' attribute to specify the source of the copy. This instruction handles namespace copying and can optionally copy accumulators.

```xml
  <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:assert>
          <xs:assert test="exists(@select | @_select)"/>
        </xs:extension>
      </xs:complexContent>
    </xs:complexType>
  </xs:element>
```

--------------------------------

### Define on-non-empty Instruction Element in XSD

Source: https://www.w3.org/TR/xslt-30/schema-for-xslt30

XSD schema declaration for the on-non-empty XSLT instruction element with type sequence-constructor-or-select. Used to specify content or actions to execute when a sequence contains items, supporting both inline sequences and select expressions.

```XSD
<xs:element
      name="on-non-empty"
      substitutionGroup="xsl:instruction"
      type="xsl:sequence-constructor-or-select"/>
```

--------------------------------

### Define on-empty Instruction Element in XSD

Source: https://www.w3.org/TR/xslt-30/schema-for-xslt30

XSD schema declaration for the on-empty XSLT instruction element with type sequence-constructor-or-select. Used to specify fallback content or actions when a sequence is empty, supporting both inline sequences and select expressions.

```XSD
<xs:element
      name="on-empty"
      substitutionGroup="xsl:instruction"
      type="xsl:sequence-constructor-or-select"/>
```

--------------------------------

### Define next-iteration Instruction Element in XSD

Source: https://www.w3.org/TR/xslt-30/schema-for-xslt30

XSD schema declaration for the next-iteration XSLT instruction element. It extends element-only-versioned-element-type and allows zero or more xsl:with-param child elements. Used in XSLT 3.0 to invoke the next template rule with optional parameters.

```XSD
<xs:element
      name="next-iteration"
      substitutionGroup="xsl:instruction">
  <xs:complexType>
    <xs:complexContent mixed="true">
      <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>
```

--------------------------------

### XSD Declaration: param

Source: https://www.w3.org/TR/xslt-30/schema-for-xslt30

Defines the 'param' element in XSD source form. This element is used for declaring parameters in XSLT, including function parameters, template parameters, parameters for xsl:iterate, and global stylesheet parameters. It supports attributes for name, type, and various optional flags like 'required', 'tunnel', and 'static'.

```xml
<xs:element
        name="param"
        substitutionGroup="xsl:declaration">
    
    <xs:complexType>
      <xs:complexContent mixed="true">
        <xs:extension
              base="xsl:sequence-constructor-or-select">
          <xs:attribute name="name" type="xsl:EQName"/>
          <xs:attribute name="as" type="xsl:sequence-type"/>
          <xs:attribute
                name="required"
                type="xsl:yes-or-no"/>
          <xs:attribute name="tunnel" type="xsl:yes-or-no"/>
          <xs:attribute name="static" type="xsl:yes-or-no"/>
          <xs:attribute name="_name" type="xs:string"/>
          <xs:attribute name="_as" type="xs:string"/>
          <xs:attribute name="_required" type="xs:string"/>
          <xs:attribute name="_tunnel" type="xs:string"/>
          <xs:attribute name="_static" type="xs:string"/>
          <xs:assert test="exists(@name | @_name)"/>
          <xs:assert
                test="if (normalize-space(@static) = ('yes', 'true', '1'))                             then empty((*,text()))                             else true()">
            
          </xs:assert>
        </xs:extension>
      </xs:complexContent>
    </xs:complexType>
  </xs:element>
```

--------------------------------

### XSD Declaration: xsl:with-param Element

Source: https://www.w3.org/TR/xslt-30/schema-for-xslt30

Formal declaration for the xsl:with-param element in XSLT 3.0, used for passing parameters to templates or functions. It supports attributes like name, as, and tunnel, along with prefixed versions for parsing. An assertion validates the presence of a name attribute.

```xml
  <xs:element name="with-param">
    <xs:complexType>
      <xs:complexContent mixed="true">
        <xs:extension
              base="xsl:sequence-constructor-or-select">
          <xs:attribute name="name" type="xsl:EQName"/>
          <xs:attribute name="as" type="xsl:sequence-type"/>
          <xs:attribute name="tunnel" type="xsl:yes-or-no"/>
          <xs:attribute name="_name" type="xs:string"/>
          <xs:attribute name="_as" type="xs:string"/>
          <xs:attribute name="_tunnel" type="xs:string"/>
          <xs:assert test="exists(@name | @_name)"/>
        </xs:extension>
      </xs:complexContent>
    </xs:complexType>
  </xs:element>
```

--------------------------------

### Define analyze-string Element in XSD Schema

Source: https://www.w3.org/TR/xslt-30/schema-for-xslt30

Declares the analyze-string instruction element with required select and regex attributes for string analysis. Includes optional matching-substring and non-matching-substring child elements, plus fallback elements for error handling and optional flags attribute.

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

--------------------------------

### Define NameTests list simple type in XSD

Source: https://www.w3.org/TR/xslt-30/schema-for-xslt30

Defines a list-based simple type named 'nametests' that accepts space-separated NameTests as defined in XPath 2.0. Each NameTest can be a QName, literal asterisk, prefixed wildcard (prefix:*), or namespaced wildcard (*:localname), enabling flexible element matching patterns.

```XML
<xs:simpleType name="nametests">
  <xs:list>
    <xs:simpleType>
      <xs:union memberTypes="xsl:EQName">
        <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>
```

--------------------------------

### Define for-each-group instruction element in XSD

Source: https://www.w3.org/TR/xslt-30/schema-for-xslt30

XSD schema definition for the XSLT for-each-group instruction element. It extends the versioned-element-type and supports grouping operations through attributes like group-by, group-adjacent, group-starting-with, and group-ending-with. Includes validation assertions to ensure proper attribute usage and collation/composite configurations.

```XML
<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: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: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:extension>
    </xs:complexContent>
  </xs:complexType>
</xs:element>
```

--------------------------------

### XSD Declaration for xs:map

Source: https://www.w3.org/TR/xslt-30/schema-for-xslt30

Declares the 'map' element, which is an XSLT instruction used for creating maps. It inherits from 'xsl:sequence-constructor', indicating it can contain a sequence of items to form the map.

```xsd
  <xs:element
        name="map"
        type="xsl:sequence-constructor"
        substitutionGroup="xsl:instruction"/>
```