<?xml version="1.0" encoding="UTF-8"?>
<package id="Saxon.Api">
   <class id="Processor"
          fulltype="Saxon.Api.Processor"
          visibility="public"
          superclass="object"
          superclassfulltype="System.Object">
      <comment>
         <sentence>
            The Processor class serves three purposes: it allows global Saxon configuration
            options to be set; it acts as a factory for generating XQuery, XPath, and XSLT
            compilers; and it owns certain shared resources such as the Saxon NamePool and 
            compiled schemas. This is the first object that a Saxon application should create. Once
            established, a Processor may be used in multiple threads.
            </sentence>
      </comment>
      <property id="ProductTitle" type="string" get="true">
         <comment>
            <sentence>
            Get the full name of the Saxon product version implemented by this Processor
            </sentence>
         </comment>
      </property>
      <property id="ProductVersion" type="string" get="true">
         <comment>
            <sentence>
            Get the Saxon product version number (for example, "9.2.0.2")
            </sentence>
         </comment>
      </property>
      <property id="Edition" type="string" get="true">
         <comment>
            <sentence>
            Get the Saxon product edition (for example, "EE" for Enterprise Edition)
            </sentence>
         </comment>
      </property>
      <property id="IsSchemaAware" type="bool" get="true">
         <comment>
            <sentence>
            Indicates whether the Processor is schema-aware. In Saxon 9.2, returns true if using Saxon
            Enterprise Edition.
            </sentence>
            <body>
               <div>
                  <p>
            Indicates whether the Processor is schema-aware. In Saxon 9.2, returns true if using Saxon
            Enterprise Edition.
            </p>
                  <p>
            Deprecated since Saxon 9.2; schema-awareness is not directly a property of a Processor any more.
            Use the Edition property to determine which Saxon edition is in use.
            </p>
               </div>
            </body>
         </comment>
      </property>
      <property id="SchemaManager" type="SchemaManager" get="true">
         <comment>
            <sentence>
            Gets the SchemaManager for the Processor. Returns null
            if the Processor is not schema-aware.
            </sentence>
         </comment>
      </property>
      <property id="XmlResolver" type="XmlResolver" get="true" set="true">
         <comment>
            <sentence>
            An XmlResolver, which will be used while compiling and running queries, 
            XPath expressions, and stylesheets, if no other XmlResolver is nominated
            </sentence>
            <body>
               <div>
                  <p>
            An XmlResolver, which will be used while compiling and running queries, 
            XPath expressions, and stylesheets, if no other XmlResolver is nominated
            </p>
                  <p>By default an <code>XmlUrlResolver</code> is used. This means that the responsibility
            for resolving and dereferencing URIs rests with the .NET platform, not with the
            GNU Classpath.</p>
                  <p>When Saxon invokes a user-written <code>XmlResolver</code>, the <code>GetEntity</code> method
            may return any of: a <code>System.IO.Stream</code>; a <code>System.IO.TextReader</code>; or a
            <code>java.xml.transform.Source</code>.</p>
               </div>
            </body>
         </comment>
      </property>
      <property id="XmlVersion" type="decimal" get="true" set="true">
         <comment>
            <sentence>
            The XML version used in this <code>Processor</code> (for example, this determines what characters
            are permitted in a name)
            </sentence>
            <body>
               <div>
                  <p>
            The XML version used in this <code>Processor</code> (for example, this determines what characters
            are permitted in a name)
            </p>
                  <p>
            The value must be 1.0 or 1.1, as a <c>decimal</c>. The default version is currently 1.0, but may
            change in the future.
            </p>
               </div>
            </body>
         </comment>
      </property>
      <property id="Implementation" type="net.sf.saxon.Configuration" get="true">
         <comment>
            <sentence>
            The underlying Configuration object in the Saxon implementation
            </sentence>
            <body>
               <div>
                  <p>
            The underlying Configuration object in the Saxon implementation
            </p>
                  <p>This property provides access to internal methods in the Saxon engine that are
            not specifically exposed in the .NET API. In general these methods should be
            considered to be less stable than the classes in the Saxon.Api namespace.</p> 
                  <p>The internal methods follow
            Java naming conventions rather than .NET conventions.</p>
                  <p>Information about the returned object (and the objects it provides access to)
            is included in the Saxon JavaDoc docmentation, available 
            online.
            </p>
               </div>
            </body>
         </comment>
      </property>
      <methods>
         <constructor id="Processor" visibility="public">
            <params/>
            <comment>
               <sentence>
            Create a new Processor. This Processor will have capabilities that depend on the version
            of the software that has been loaded, and on the features that have been licensed.
            </sentence>
            </comment>
         </constructor>
         <constructor id="Processor" visibility="public">
            <params>
               <param fulltype="bool" type="bool" name="licensedEdition">Set to true if the Processor is to use a licensed edition of Saxon
            (that is, Saxon-PE or Saxon-EE). If true, the Processor will attempt to enable the capabilities
            of the licensed edition of Saxon, according to the version of the software that is loaded, and will
            verify the license key. If false, the Processor will load a default Configuration that gives restricted
            capability and does not require a license, regardless of which version of the software is actually being run.</param>
            </params>
            <comment>
               <sentence>
            Create a Processor.
            </sentence>
            
            </comment>
         </constructor>
         <constructor id="Processor" visibility="public">
            <params>
               <param fulltype="bool" type="bool" name="licensedEdition">Set to true if the Processor is to use a licensed edition of Saxon
            (that is, Saxon-PE or Saxon-EE). If true, the Processor will attempt to enable the capabilities
            of the licensed edition of Saxon, according to the version of the software that is loaded, and will
            verify the license key. If false, the Processor will load a default Configuration that gives restricted
            capability and does not require a license, regardless of which version of the software is actually being run.</param>
               <param fulltype="bool" type="bool" name="loadLocally">This option has no effect at this release.</param>
            </params>
            <comment>
               <sentence>
            Create a Processor.
            </sentence>
            
            
            </comment>
         </constructor>
         <constructor id="Processor" visibility="public">
            <params>
               <param fulltype="System.IO.Stream" type="Stream" name="configurationFile">A stream holding the text of the XML configuration file. Details of the file format
            can be found in the Saxon documentation.</param>
            </params>
            <comment>
               <sentence>
            Create a Processor, based on configuration information supplied in a configuration file.
            </sentence>
               <body>
                  <div>
                     <p>
            Create a Processor, based on configuration information supplied in a configuration file.
            </p>
                     <p>
            Not fully supported in this release: for experimental use only.
            </p>
                  </div>
               </body>
            
            </comment>
         </constructor>
         <method id="NewDocumentBuilder"
                 visibility="public"
                 type="DocumentBuilder"
                 fulltype="Saxon.Api.DocumentBuilder">
            <comment>
               <sentence>
            Create a new <code>DocumentBuilder</code>, which may be used to build XDM documents from
            a variety of sources.
            </sentence>
               <return>
                  <body>
                     <div>A new <code>DocumentBuilder</code>
                     </div>
                  </body>
               </return>
            </comment>
            <params/>
         </method>
         <method id="NewXQueryCompiler"
                 visibility="public"
                 type="XQueryCompiler"
                 fulltype="Saxon.Api.XQueryCompiler">
            <comment>
               <sentence>
            Create a new XQueryCompiler, which may be used to compile XQuery queries.
            </sentence>
               <body>
                  <div>
                     <p>
            Create a new XQueryCompiler, which may be used to compile XQuery queries.
            </p>
                     <p>
            The returned XQueryCompiler retains a live link to the Processor, and
            may be affected by subsequent changes to the Processor.
            </p>
                  </div>
               </body>
               <return>
                  <body>
                     <div>A new XQueryCompiler</div>
                  </body>
               </return>
            </comment>
            <params/>
         </method>
         <method id="NewXsltCompiler"
                 visibility="public"
                 type="XsltCompiler"
                 fulltype="Saxon.Api.XsltCompiler">
            <comment>
               <sentence>
            Create a new XsltCompiler, which may be used to compile XSLT stylesheets.
            </sentence>
               <body>
                  <div>
                     <p>
            Create a new XsltCompiler, which may be used to compile XSLT stylesheets.
            </p>
                     <p>
            The returned XsltCompiler retains a live link to the Processor, and
            may be affected by subsequent changes to the Processor.
            </p>
                  </div>
               </body>
               <return>
                  <body>
                     <div>A new XsltCompiler</div>
                  </body>
               </return>
            </comment>
            <params/>
         </method>
         <method id="NewXPathCompiler"
                 visibility="public"
                 type="XPathCompiler"
                 fulltype="Saxon.Api.XPathCompiler">
            <comment>
               <sentence>
            Create a new XPathCompiler, which may be used to compile XPath expressions.
            </sentence>
               <body>
                  <div>
                     <p>
            Create a new XPathCompiler, which may be used to compile XPath expressions.
            </p>
                     <p>
            The returned XPathCompiler retains a live link to the Processor, and
            may be affected by subsequent changes to the Processor.
            </p>
                  </div>
               </body>
               <return>
                  <body>
                     <div>A new XPathCompiler</div>
                  </body>
               </return>
            </comment>
            <params/>
         </method>
         <method id="NewSerializer"
                 visibility="public"
                 type="Serializer"
                 fulltype="Saxon.Api.Serializer">
            <comment>
               <sentence>
            Create a Serializer
            </sentence>
               <return>
                  <body>
                     <div> a new Serializer </div>
                  </body>
               </return>
            </comment>
            <params/>
         </method>
         <method id="NewSerializer"
                 visibility="public"
                 type="Serializer"
                 fulltype="Saxon.Api.Serializer">
         
            <comment>
               <sentence>
            Create a Serializer initialized to write to a given Writer.
            Closing the writer after use is the responsibility of the caller.
            </sentence>
            
               <return>
                  <body>
                     <div> a new Serializer </div>
                  </body>
               </return>
            </comment>
            <params>
               <param fulltype="System.IO.TextWriter" type="TextWriter" name="textWriter">writer The TextWriter to which the Serializer will write</param>
            </params>
         </method>
         <method id="NewSerializer"
                 visibility="public"
                 type="Serializer"
                 fulltype="Saxon.Api.Serializer">
         
            <comment>
               <sentence>
            Create a Serializer initialized to write to a given OutputStream.
            Closing the output stream after use is the responsibility of the caller.
            </sentence>
            
               <return>
                  <body>
                     <div> a new Serializer </div>
                  </body>
               </return>
            </comment>
            <params>
               <param fulltype="System.IO.Stream" type="Stream" name="stream">stream The OutputStream to which the Serializer will write</param>
            </params>
         </method>
         <method id="RegisterCollection"
                 visibility="public"
                 type="void"
                 fulltype="Saxon.Api.void">
         
         
            <comment>
               <sentence>
            Register a named collection. A collection is identified by a URI (the collection URI),
            and its content is represented by an <code>IEnumerable</code> that enumerates the contents
            of the collection. The values delivered by this enumeration are Uri values, which 
            can be mapped to nodes using the registered <code>XmlResolver</code>.
            </sentence>
            
            
               <body>
                  <div>
                     <p>
            Register a named collection. A collection is identified by a URI (the collection URI),
            and its content is represented by an <code>IEnumerable</code> that enumerates the contents
            of the collection. The values delivered by this enumeration are Uri values, which 
            can be mapped to nodes using the registered <code>XmlResolver</code>.
            </p>
                     <p>Collections should be stable: that is, two calls to retrieve the same collection URI
            should return the same sequence of document URIs. This requirement is imposed by the
            W3C specifications, but in the case of a user-defined collection it is not enforced by
            the Saxon product.</p>
                     <p>A collection may be "unregistered" by providing null as the value of the
            contents argument. A collection may be replaced by specifying the URI of an existing
            collection.</p>
                     <p>Collections registered with a processor are available to all queries and stylesheets
            running under the control of that processor. Collections should not normally be registered
            while queries and transformations are in progress.</p>
                  </div>
               </body>
            </comment>
            <params>
               <param fulltype="System.Uri" type="Uri" name="collectionUri">The URI used to identify the collection in a call
            of the XPath <c>collection()</c> function. The default collection is registered
            by supplying null as the value of this argument (this is the collection returned
            when the XPath <c>collection()</c> function is called with no arguments).</param>
               <param fulltype="System.Collections.IEnumerable"
                      type="IEnumerable"
                      name="contents">An enumerable object that represents the contents of the
            collection, as a sequence of document URIs. The enumerator returned by this
            IEnumerable object must return instances of the Uri class.</param>
            </params>
         </method>
         <method id="RegisterExtensionFunction"
                 visibility="public"
                 type="void"
                 fulltype="Saxon.Api.void">
         
            <comment>
               <sentence>
            Register an extension function with the Processor
            </sentence>
            
            </comment>
            <params>
               <param fulltype="Saxon.Api.ExtensionFunctionDefinition"
                      type="ExtensionFunctionDefinition"
                      name="function">
            An object that defines the extension function, including its name, arity, arguments types, and
            a reference to the class that implements the extension function call.
            </param>
            </params>
         </method>
         <method id="WriteXdmValue"
                 visibility="public"
                 type="void"
                 fulltype="Saxon.Api.void">
         
         
            <comment>
               <sentence>
            Copy an XdmValue to an XmlDestination
            </sentence>
               <body>
                  <div>
                     <p>
            Copy an XdmValue to an XmlDestination
            </p>
                     <p>
            This method can be used to copy any kind of <c>XdmValue</c> to any kind
            of <c>XdmDestination</c>. The supplied <c>XdmValue</c> is first converted
            to an XML document according to the rules of the XSLT/XQuery serialization
            specification (for example, if the <c>XdmValue</c> is a sequence of atomic
            values, they will be turned in a text node in which the values are converted
            to strings and separated by single spaces). The resulting document is then
            written to the supplied <c>XmlDestination</c>.</p>
                  </div>
               </body>
            
            
            </comment>
            <params>
               <param fulltype="Saxon.Api.XdmValue" type="XdmValue" name="sequence">The value to be written</param>
               <param fulltype="Saxon.Api.XmlDestination"
                      type="XmlDestination"
                      name="destination">The destination to which the value should be written</param>
            </params>
         </method>
         <method id="SetProperty"
                 visibility="public"
                 type="void"
                 fulltype="Saxon.Api.void">
         
         
            <comment>
               <sentence>
            Set a configuration property
            </sentence>
               <body>
                  <div>
                     <p>
            Set a configuration property
            </p>
                     <p>This method provides the ability to set named properties of the configuration.
            The property names are set as strings, whose values can be found in the Java
            class <code>net.sf.saxon.FeatureKeys</code>. The property values are always strings. 
            Properties whose values are other types are not available via this interface:
            however all properties have an effective equivalent whose value is a string.
            Note that on/off properties are set using the strings "true" and "false".</p>
                     <p>
                        <i>Method added in Saxon 9.1</i>
                     </p>
                  </div>
               </body>
            
            
            </comment>
            <params>
               <param fulltype="string" type="string" name="name">The property name</param>
               <param fulltype="string" type="string" name="value">The property value</param>
            </params>
         </method>
         <method id="GetProperty"
                 visibility="public"
                 type="String"
                 fulltype="System.String">
         
            <comment>
               <sentence>
            Get the value of a configuration property
            </sentence>
               <body>
                  <div>
                     <p>
            Get the value of a configuration property
            </p>
                     <p>This method provides the ability to get named properties of the configuration.
            The property names are supplied as strings, whose values can be found in the Java
            class <code>net.sf.saxon.FeatureKeys</code>. The property values are always returned as strings. 
            Properties whose values are other types are returned by converting the value to a string.
            Note that on/off properties are returned using the strings "true" and "false".</p>
                     <p>
                        <i>Method added in Saxon 9.1</i>
                     </p>
                  </div>
               </body>
            
               <return>
                  <body>
                     <div>The property value, as a string; or null if the property is unset.</div>
                  </body>
               </return>
            </comment>
            <params>
               <param fulltype="string" type="string" name="name">The property name</param>
            </params>
         </method>
      </methods>
   </class>
   <class id="DocumentBuilder"
          fulltype="Saxon.Api.DocumentBuilder"
          visibility="public"
          superclass="object"
          superclassfulltype="System.Object">
      <comment>
         <sentence>
            The <code>DocumentBuilder</code> class enables XDM documents to be built from various sources.
            The class is always instantiated using the <code>NewDocumentBuilder</code> method
            on the <code>Processor</code> object.
            </sentence>
      </comment>
      <property id="XmlResolver" type="XmlResolver" get="true" set="true">
         <comment>
            <sentence>
            An XmlResolver, which will be used to resolve URIs of documents being loaded
            and of references to external entities within those documents (including any external DTD).
            </sentence>
            <body>
               <div>
                  <p>
            An XmlResolver, which will be used to resolve URIs of documents being loaded
            and of references to external entities within those documents (including any external DTD).
            </p>
                  <p>By default an <code>XmlUrlResolver</code> is used. This means that the responsibility
            for resolving and dereferencing URIs rests with the .NET platform (and not with the
            GNU Classpath).</p>
                  <p>When Saxon invokes a user-written <code>XmlResolver</code>, the <code>GetEntity</code> method
            may return any of: a <code>System.IO.Stream</code>; a <code>System.IO.TextReader</code>; or a
            <code>java.xml.transform.Source</code>. However, if the <code>XmlResolver</code> is called
            by the XML parser to resolve external entity references, then it must return an 
            instance of <code>System.IO.Stream</code>.</p>
               </div>
            </body>
         </comment>
      </property>
      <property id="IsLineNumbering" type="bool" get="true" set="true">
         <comment>
            <sentence>
            Determines whether line numbering is enabled for documents loaded using this
            <code>DocumentBuilder</code>.
            </sentence>
            <body>
               <div>
                  <p>
            Determines whether line numbering is enabled for documents loaded using this
            <code>DocumentBuilder</code>.
            </p>
                  <p>By default, line numbering is disabled.</p>
                  <p>Line numbering is not available for all kinds of source: in particular,
            it is not available when loading from an existing XmlDocument.</p>
                  <p>The resulting line numbers are accessible to applications using the
            extension function saxon:line-number() applied to a node.</p>  
                  <p>Line numbers are maintained only for element nodes; the line number
            returned for any other node will be that of the most recent element.</p> 
               </div>
            </body>
         </comment>
      </property>
      <property id="SchemaValidationMode"
                type="SchemaValidationMode"
                get="true"
                set="true">
         <comment>
            <sentence>
            Determines whether schema validation is applied to documents loaded using this
            <code>DocumentBuilder</code>, and if so, whether it is strict or lax.
            </sentence>
            <body>
               <div>
                  <p>
            Determines whether schema validation is applied to documents loaded using this
            <code>DocumentBuilder</code>, and if so, whether it is strict or lax.
            </p>
                  <p>By default, no schema validation takes place.</p>
                  <p>This option requires the schema-aware version of the Saxon product (Saxon-SA).</p>
               </div>
            </body>
         </comment>
      </property>
      <property id="TopLevelElementName" type="QName" get="true" set="true">
         <comment>
            <sentence>
            The required name of the top level element in a document instance being validated
            against a schema.
            </sentence>
            <body>
               <div>
                  <p>
            The required name of the top level element in a document instance being validated
            against a schema.
            </p>
                  <p>If this property is set, and if schema validation is requested, then validation will
            fail unless the outermost element of the document has the required name.</p>
                  <p>This option requires the schema-aware version of the Saxon product (Saxon-SA).</p>
               </div>
            </body>
         </comment>
      </property>
      <property id="DtdValidation" type="bool" get="true" set="true">
         <comment>
            <sentence>
             Determines whether DTD validation is applied to documents loaded using this
             <code>DocumentBuilder</code>.
             </sentence>
            <body>
               <div>
                  <p>
             Determines whether DTD validation is applied to documents loaded using this
             <code>DocumentBuilder</code>.
             </p>
            
                  <p>By default, no DTD validation takes place.</p>
             
               </div>
            </body>
         </comment>
      </property>
      <property id="WhitespacePolicy"
                type="WhitespacePolicy"
                get="true"
                set="true">
         <comment>
            <sentence>
            Determines the whitespace stripping policy applied when loading a document
            using this <code>DocumentBuilder</code>.
            </sentence>
            <body>
               <div>
                  <p>
            Determines the whitespace stripping policy applied when loading a document
            using this <code>DocumentBuilder</code>.
            </p>
                  <p>By default, whitespace text nodes appearing in element-only content
            are stripped, and all other whitespace text nodes are retained.</p>
               </div>
            </body>
         </comment>
      </property>
      <property id="TreeModel" type="TreeModel" get="true" set="true">
         <comment>
            <sentence>
             The Tree Model implementation to be used for the constructed document. By default
             the TinyTree is used. The main reason for using the LinkedTree alternative is if
             updating is required (the TinyTree is not updateable).
            </sentence>
         </comment>
      </property>
      <property id="BaseUri" type="Uri" get="true" set="true">
         <comment>
            <sentence>
            The base URI of a document loaded using this <code>DocumentBuilder</code>.
            This is used for resolving any relative URIs appearing
            within the document, for example in references to DTDs and external entities.
            </sentence>
            <body>
               <div>
                  <p>
            The base URI of a document loaded using this <code>DocumentBuilder</code>.
            This is used for resolving any relative URIs appearing
            within the document, for example in references to DTDs and external entities.
            </p>
                  <p>
            This information is required when the document is loaded from a source that does not
            provide an intrinsic URI, notably when loading from a Stream or a TextReader.
            </p>
               </div>
            </body>
         </comment>
      </property>
      <methods>
         <method id="Build"
                 visibility="public"
                 type="XdmNode"
                 fulltype="Saxon.Api.XdmNode">
         
            <comment>
               <sentence>
            Load an XML document, retrieving it via a URI.
            </sentence>
               <body>
                  <div>
                     <p>
            Load an XML document, retrieving it via a URI.
            </p>
                     <p>Note that the type <code>Uri</code> requires an absolute URI.</p>
                     <p>The URI is dereferenced using the registered <code>XmlResolver</code>.</p>
                     <p>This method takes no account of any fragment part in the URI.</p>
                     <p>The <code>role</code> passed to the <code>GetEntity</code> method of the <code>XmlResolver</code> 
            is "application/xml", and the required return type is <code>System.IO.Stream</code>.</p>
                     <p>The document located via the URI is parsed using the <code>System.Xml</code> parser.</p>
                     <p>Note that the Microsoft <code>System.Xml</code> parser does not report whether attributes are
            defined in the DTD as being of type <code>ID</code> and <code>IDREF</code>. This is true whether or not
            DTD-based validation is enabled. This means that such attributes are not accessible to the 
            <code>id()</code> and <code>idref()</code> functions.</p>
                  </div>
               </body>
            
               <return>
                  <body>
                     <div>An <code>XdmNode</code>. This will be
             the document node at the root of the tree of the resulting in-memory document. 
            </div>
                  </body>
               </return>
            </comment>
            <params>
               <param fulltype="System.Uri" type="Uri" name="uri">The URI identifying the location where the document can be
            found. This will also be used as the base URI of the document (regardless
            of the setting of the <c>BaseUri</c> property).</param>
            </params>
         </method>
         <method id="Build"
                 visibility="public"
                 type="XdmNode"
                 fulltype="Saxon.Api.XdmNode">
         
            <comment>
               <sentence>
            Load an XML document supplied as raw (lexical) XML on a Stream.
            </sentence>
               <body>
                  <div>
                     <p>
            Load an XML document supplied as raw (lexical) XML on a Stream.
            </p>
                     <p>The document is parsed using the Microsoft <code>System.Xml</code> parser if the
            "http://saxon.sf.net/feature/preferJaxpParser" property on the <code>Processor</code> is set to false;
            otherwise it is parsed using the Apache Xerces XML parser.</p>
                     <p>Before calling this method, the <code>BaseUri</code> property must be set to identify the
            base URI of this document, used for resolving any relative URIs contained within it.</p>
                     <p>Note that the Microsoft <code>System.Xml</code> parser does not report whether attributes are
            defined in the DTD as being of type <code>ID</code> and <code>IDREF</code>. This is true whether or not
            DTD-based validation is enabled. This means that such attributes are not accessible to the 
            <code>id()</code> and <code>idref()</code> functions.</p>         
                  </div>
               </body>
            
               <return>
                  <body>
                     <div>An <code>XdmNode</code>, the document node at the root of the tree of the resulting
            in-memory document
            </div>
                  </body>
               </return>
            </comment>
            <params>
               <param fulltype="System.IO.Stream" type="Stream" name="input">The Stream containing the XML source to be parsed</param>
            </params>
         </method>
         <method id="Build"
                 visibility="public"
                 type="XdmNode"
                 fulltype="Saxon.Api.XdmNode">
         
            <comment>
               <sentence>
            Load an XML document supplied using a TextReader.
            </sentence>
               <body>
                  <div>
                     <p>
            Load an XML document supplied using a TextReader.
            </p>
                     <p>The document is parsed using the Microsoft <code>System.Xml</code> parser if the
            "http://saxon.sf.net/feature/preferJaxpParser" property on the <code>Processor</code> is set to false;
            otherwise it is parsed using the Apache Xerces XML parser.</p>
                     <p>Before calling this method, the <code>BaseUri</code> property must be set to identify the
            base URI of this document, used for resolving any relative URIs contained within it.</p>
                     <p>Note that the Microsoft <code>System.Xml</code> parser does not report whether attributes are
            defined in the DTD as being of type <code>ID</code> and <code>IDREF</code>. This is true whether or not
            DTD-based validation is enabled. This means that such attributes are not accessible to the 
            <code>id()</code> and <code>idref()</code> functions.</p>         
                  </div>
               </body>
            
               <return>
                  <body>
                     <div>An <code>XdmNode</code>, the document node at the root of the tree of the resulting
            in-memory document
            </div>
                  </body>
               </return>
            </comment>
            <params>
               <param fulltype="System.IO.TextReader" type="TextReader" name="input">The <c>TextReader</c> containing the XML source to be parsed</param>
            </params>
         </method>
         <method id="Build"
                 visibility="public"
                 type="XdmNode"
                 fulltype="Saxon.Api.XdmNode">
         
            <comment>
               <sentence>
            Load an XML document, delivered using an XmlReader.
            </sentence>
               <body>
                  <div>
                     <p>
            Load an XML document, delivered using an XmlReader.
            </p>
                     <p>The XmlReader is responsible for parsing the document; this method builds a tree
            representation of the document (in an internal Saxon format) and returns its document node.
            The XmlReader is not required to perform validation but it must expand any entity references.
            Saxon uses the properties of the <code>XmlReader</code> as supplied.</p>
                     <p>Use of a plain <code>XmlTextReader</code> is discouraged, because it does not expand entity
            references. This should only be used if you know in advance that the document will contain
            no entity references (or perhaps if your query or stylesheet is not interested in the content
            of text and attribute nodes). Instead, with .NET 1.1 use an <code>XmlValidatingReader</code> (with <code>ValidationType</code>
            set to <code>None</code>). The constructor for <code>XmlValidatingReader</code> is obsolete in .NET 2.0,
            but the same effect can be achieved by using the <code>Create</code> method of <code>XmlReader</code> with
            appropriate <code>XmlReaderSettings</code>
                     </p>
                     <p>Conformance with the W3C specifications requires that the <code>Normalization</code> property
            of an <code>XmlTextReader</code> should be set to <code>true</code>. However, Saxon does not insist
            on this.</p>
                     <p>If the <code>XmlReader</code> performs schema validation, Saxon will ignore any resulting type
            information. Type information can only be obtained by using Saxon's own schema validator, which
            will be run if the <code>SchemaValidationMode</code> property is set to <code>Strict</code> or <code>Lax</code>
                     </p>
                     <p>Note that the Microsoft <code>System.Xml</code> parser does not report whether attributes are
            defined in the DTD as being of type <code>ID</code> and <code>IDREF</code>. This is true whether or not
            DTD-based validation is enabled. This means that such attributes are not accessible to the 
            <code>id()</code> and <code>idref()</code> functions.</p>
                     <p>Note that setting the <code>XmlResolver</code> property of the <code>DocumentBuilder</code>
            has no effect when this method is used; if an <code>XmlResolver</code> is required, it must
            be set on the <code>XmlReader</code> itself.</p>
                  </div>
               </body>
            
               <return>
                  <body>
                     <div>An <code>XdmNode</code>, the document node at the root of the tree of the resulting
            in-memory document
            </div>
                  </body>
               </return>
            </comment>
            <params>
               <param fulltype="System.Xml.XmlReader" type="XmlReader" name="reader">The XMLReader that supplies the parsed XML source</param>
            </params>
         </method>
         <method id="Build"
                 visibility="public"
                 type="XdmNode"
                 fulltype="Saxon.Api.XdmNode">
         
            <comment>
               <sentence>
            Load an XML DOM document, supplied as an <code>XmlNode</code>, into a Saxon XdmNode.
            </sentence>
               <body>
                  <div>
                     <p>
            Load an XML DOM document, supplied as an <code>XmlNode</code>, into a Saxon XdmNode.
            </p>
                     <p>
            The returned document will contain only the subtree rooted at the supplied node.
            </p>
                     <p>
            This method copies the DOM tree to create a Saxon tree. See the <code>Wrap</code> method for
            an alternative that creates a wrapper around the DOM tree, allowing it to be modified in situ.
            </p>
                  </div>
               </body>
            
               <return>
                  <body>
                     <div>An <code>XdmNode</code>, the document node at the root of the tree of the resulting
            in-memory document
            </div>
                  </body>
               </return>
            </comment>
            <params>
               <param fulltype="System.Xml.XmlNode" type="XmlNode" name="source">The DOM Node to be copied to form a Saxon tree</param>
            </params>
         </method>
         <method id="Wrap"
                 visibility="public"
                 type="XdmNode"
                 fulltype="Saxon.Api.XdmNode">
         
            <comment>
               <sentence>
            Wrap an XML DOM document, supplied as an <code>XmlNode</code>, as a Saxon XdmNode.
            </sentence>
               <body>
                  <div>
                     <p>
            Wrap an XML DOM document, supplied as an <code>XmlNode</code>, as a Saxon XdmNode.
            </p>
                     <p>
            This method must be applied at the level of the Document Node. Unlike the
            <code>Build</code> method, the original DOM is not copied. This saves memory and
            time, but it also means that it is not possible to perform operations such as
            whitespace stripping and schema validation.
            </p>
                  </div>
               </body>
            
               <return>
                  <body>
                     <div>An <code>XdmNode</code>, the Saxon document node at the root of the tree of the resulting
            in-memory document
            </div>
                  </body>
               </return>
            </comment>
            <params>
               <param fulltype="System.Xml.XmlDocument" type="XmlDocument" name="doc">The DOM document node to be wrapped</param>
            </params>
         </method>
      </methods>
   </class>
   <enum id="SchemaValidationMode"
         fulltype="Saxon.Api.SchemaValidationMode"
         visibility="public">
      <comment>
         <sentence>
            Enumeration identifying the various Schema validation modes
            </sentence>
      </comment>
      <fields>
         <field id="None" type="" visibility="public">
            <comment>
               <sentence>No validation (or strip validation, which removes existing type annotations)</sentence>
            </comment>
         </field>
         <field id="Strict" type="" visibility="public">
            <comment>
               <sentence>Strict validation</sentence>
            </comment>
         </field>
         <field id="Lax" type="" visibility="public">
            <comment>
               <sentence>Lax validation</sentence>
            </comment>
         </field>
         <field id="Preserve" type="" visibility="public">
            <comment>
               <sentence>Validation mode preserve, which preserves any existing type annotations</sentence>
            </comment>
         </field>
         <field id="Unspecified" type="" visibility="public">
            <comment>
               <sentence>Unspecified validation: this means that validation is defined elsewhere, for example in the
            Saxon Configuration</sentence>
            </comment>
         </field>
      </fields>
   </enum>
   <enum id="WhitespacePolicy"
         fulltype="Saxon.Api.WhitespacePolicy"
         visibility="public">
      <comment>
         <sentence>
            Enumeration identifying the various Whitespace stripping policies
            </sentence>
      </comment>
      <fields>
         <field id="PreserveAll" type="" visibility="public">
            <comment>
               <sentence>No whitespace is stripped</sentence>
            </comment>
         </field>
         <field id="StripIgnorable" type="" visibility="public">
            <comment>
               <sentence>Whitespace text nodes appearing in element-only content are stripped</sentence>
            </comment>
         </field>
         <field id="StripAll" type="" visibility="public">
            <comment>
               <sentence>All whitespace text nodes are stripped</sentence>
            </comment>
         </field>
      </fields>
   </enum>
   <enum id="TreeModel" fulltype="Saxon.Api.TreeModel" visibility="public">
      <comment>
         <sentence>
            Enumeration identifying the different tree model implementations
            </sentence>
      </comment>
      <fields>
         <field id="TinyTree" type="" visibility="public">
            <comment>
               <sentence>
            Saxon TinyTree. This is the default model and is suitable for most purposes.
            </sentence>
            </comment>
         </field>
         <field id="TinyTreeCondensed" type="" visibility="public">
            <comment>
               <sentence>
            Saxon Condensed TinyTree. This is a variant of the TinyTree that shares storage for 
            duplicated text and attribute nodes. It gives a further saving in space occupied, at the cost
            of some increase in the time taken for tree construction.
            </sentence>
            </comment>
         </field>
         <field id="LinkedTree" type="" visibility="public">
            <comment>
               <sentence>
            Saxon LinkedTree. This tree model is primarily useful when using XQuery Update, since it is the
            only standard tree model to support updates.
            </sentence>
            </comment>
         </field>
         <field id="Unspecified" type="" visibility="public">
            <comment>
               <sentence>
            Unspecified tree model. This value is used to indicate that there is no preference for any specific
            tree model, which allows the choice to fall back to other interfaces.
            </sentence>
            </comment>
         </field>
      </fields>
   </enum>
   <class id="DotNetObjectModelDefinition"
          fulltype="Saxon.Api.DotNetObjectModelDefinition"
          visibility="protected"
          superclass="JDotNetObjectModel"
          superclassfulltype="net.sf.saxon.dotnet.DotNetObjectModel">
      <methods>
         <method id="isXdmValue" visibility="public" type="bool" fulltype="bool">
         
            <params/>
         </method>
         <method id="isXdmAtomicValueType"
                 visibility="public"
                 type="bool"
                 fulltype="bool">
         
            <params/>
         </method>
         <method id="isXdmValueType"
                 visibility="public"
                 type="bool"
                 fulltype="bool">
         
            <params/>
         </method>
         <method id="unwrapXdmValue"
                 visibility="public"
                 type="JSequence"
                 fulltype="net.sf.saxon.Sequence">
         
            <params/>
         </method>
         <method id="wrapAsXdmValue"
                 visibility="public"
                 type="object"
                 fulltype="System.Object">
         
            <params/>
         </method>
         <method id="isXmlNodeType"
                 visibility="public"
                 type="bool"
                 fulltype="bool">
         
            <params/>
         </method>
      </methods>
   </class>
   <class id="XmlDestination"
          fulltype="Saxon.Api.XmlDestination"
          visibility="public"
          superclass="object"
          superclassfulltype="System.Object"
          abstract="true">
      <comment>
         <sentence>
            An abstract destination for the results of a query or transformation
            </sentence>
         <body>
            <div>
               <p>
            An abstract destination for the results of a query or transformation
            </p>
               <p>Note to implementors: To implement a new kind of destination, you need
            to supply a method <code>getResult</code> which returns an implementation of
            the JAXP <code>Result</code> interface. Optionally, if the destination
            performs serialization, you can also implement <code>getOutputProperties</code>,
            which returns the properties used for serialization.
            </p>
            </div>
         </body>
      </comment>
      <methods>
         <method id="GetResult"
                 visibility="public"
                 type="JResult"
                 fulltype="javax.xml.transform.Result"
                 abstract="true">
         
            <comment>
               <sentence>
            Get a <code>Result</code> to which the XML document can be sent as a series
            of events. This method is intended primarily for internal use.
            </sentence>
               <body>
                  <div>
                     <p>
            Get a <code>Result</code> to which the XML document can be sent as a series
            of events. This method is intended primarily for internal use.
            </p>
                     <p>
            The returned value must be an implementation of the JAXP <c>Result</c> interface that is
            recognized by Saxon.
            </p>
                  </div>
               </body>
            
            </comment>
            <params>
               <param fulltype="net.sf.saxon.event.PipelineConfiguration"
                      type="PipelineConfiguration"
                      name="pipe">Configuration information for use by the implementation</param>
            </params>
         </method>
         <method id="GetOutputProperties"
                 visibility="public"
                 type="JProperties"
                 fulltype="java.util.Properties">
            <comment>
               <sentence>
            Get a set of <code>Properties</code> representing the parameters to the serializer.
            The default implementation returns an empty set of properties.
            </sentence>
            </comment>
            <params/>
         </method>
         <method id="Close"
                 visibility="public"
                 type="void"
                 fulltype="Saxon.Api.void">
            <comment>
               <sentence>
            Close the Destination, releasing any resources that need to be released.
            </sentence>
               <body>
                  <div>
                     <p>
            Close the Destination, releasing any resources that need to be released.
            </p>
                     <p>
            This method is called by the system on completion of a query or transformation.
            Some kinds of Destination may need to close an output stream, others might
            not need to do anything. The default implementation does nothing.
            </p>
                  </div>
               </body>
            </comment>
            <params/>
         </method>
      </methods>
   </class>
   <class id="Serializer"
          fulltype="Saxon.Api.Serializer"
          visibility="public"
          superclass="XmlDestination"
          superclassfulltype="Saxon.Api.XmlDestination">
      <comment>
         <sentence>
            A <code>Serializer</code> takes a tree representation of XML and turns
            it into lexical XML markup.
            </sentence>
         <body>
            <div>
               <p>
            A <code>Serializer</code> takes a tree representation of XML and turns
            it into lexical XML markup.
            </p>
               <p>
            Note that this is serialization in the sense of the W3C XSLT and XQuery specifications.
            Unlike the class <c>System.Xml.Serialization.XmlSerializer</c>, this object does not
            serialize arbitrary CLI objects.
            </p>
            </div>
         </body>
      </comment>
      <property id="METHOD" type="QName" static="true">
         
      </property>
      <property id="BYTE_ORDER_MARK" type="QName" static="true">
         
      </property>
      <property id="CDATA_SECTION_ELEMENTS" type="QName" static="true">
         
      </property>
      <property id="DOCTYPE_PUBLIC" type="QName" static="true">
         
      </property>
      <property id="DOCTYPE_SYSTEM" type="QName" static="true">
         
      </property>
      <property id="ENCODING" type="QName" static="true">
         
      </property>
      <property id="ESCAPE_URI_ATTRIBUTES" type="QName" static="true">
         
      </property>
      <property id="INCLUDE_CONTENT_TYPE" type="QName" static="true">
         
      </property>
      <property id="INDENT" type="QName" static="true">
         
      </property>
      <property id="MEDIA_TYPE" type="QName" static="true">
         
      </property>
      <property id="NORMALIZATION_FORM" type="QName" static="true">
         
      </property>
      <property id="OMIT_XML_DECLARATION" type="QName" static="true">
         
      </property>
      <property id="STANDALONE" type="QName" static="true">
         
      </property>
      <property id="SUPPRESS_INDENTATION" type="QName" static="true">
         
      </property>
      <property id="UNDECLARE_PREFIXES" type="QName" static="true">
         
      </property>
      <property id="USE_CHARACTER_MAPS" type="QName" static="true">
         
      </property>
      <property id="VERSION" type="QName" static="true">
         
      </property>
      <property id="SAXON_CHARACTER_REPRESENTATION" type="QName" static="true">
         
      </property>
      <property id="SAXON_INDENT_SPACES" type="QName" static="true">
         
      </property>
      <property id="SAXON_DOUBLE_SPACE" type="QName" static="true">
         
      </property>
      <property id="SAXON_SUPPRESS_INDENTATION" type="QName" static="true">
         
      </property>
      <property id="NEXT_IN_CHAIN" type="QName" static="true">
         
      </property>
      <property id="SAXON_REQUIRE_WELL_FORMED" type="QName" static="true">
         
      </property>
      <methods>
         <constructor id="Serializer" visibility="public">
            <params/>
            <comment>
               <sentence>Create a Serializer</sentence>
            </comment>
         </constructor>
         <method id="SetOutputProperty"
                 visibility="public"
                 type="void"
                 fulltype="Saxon.Api.void">
         
         
            <comment>
               <sentence>Set a serialization property</sentence>
               <body>
                  <div>
                     <p>Set a serialization property</p>
                     <p>In the case of XSLT, properties set within the serializer override
            any properties set in <c>xsl:output</c> declarations in the stylesheet.
            Similarly, with XQuery, they override any properties set in the Query
            prolog using <c>declare option saxon:output</c>.</p>
                  </div>
               </body>
               <div class="example">
                  <code>
                Serializer qout = new Serializer();
                qout.SetOutputProperty(Serializer.METHOD, "xml");
                qout.SetOutputProperty(Serializer.INDENT, "yes");
                qout.SetOutputProperty(Serializer.SAXON_INDENT_SPACES, "1");
              </code>
               </div>
            
            
            </comment>
            <params>
               <param fulltype="Saxon.Api.QName" type="QName" name="name">The name of the serialization property to be set</param>
               <param fulltype="string" type="string" name="value">The value to be set for the serialization property. May be null
            to unset the property (that is, to set it back to the default value).</param>
            </params>
         </method>
         <method id="SetOutputFile"
                 visibility="public"
                 type="void"
                 fulltype="Saxon.Api.void">
         
            <comment>
               <sentence>Specify the destination of the serialized output, in the
            form of a file name</sentence>
            
            
            </comment>
            <params>
               <param fulltype="string" type="string" name="filename">The name of the file to receive the serialized output</param>
            </params>
            <exceptions/>
         </method>
         <method id="SetOutputStream"
                 visibility="public"
                 type="void"
                 fulltype="Saxon.Api.void">
         
            <comment>
               <sentence>Specify the destination of the serialized output, in the
            form of a <code>Stream</code>
               </sentence>
               <body>
                  <div>
                     <p>Specify the destination of the serialized output, in the
            form of a <code>Stream</code>
                     </p>
                     <p>Saxon will not close the stream on completion; this is the
            caller's responsibility.</p>
                  </div>
               </body>
            
            </comment>
            <params>
               <param fulltype="System.IO.Stream" type="Stream" name="stream">The stream to which the output will be written.
            This must be a stream that allows writing.</param>
            </params>
         </method>
         <method id="SetProcessor"
                 visibility="public"
                 type="void"
                 fulltype="Saxon.Api.void">
         
            <comment>
               <sentence>Set the Processor associated with this Serializer. This will be called automatically if the
             serializer is created using one of the <code>Processor.NewSerializer()</code> methods.</sentence>
            
            </comment>
            <params>
               <param fulltype="Saxon.Api.Processor" type="Processor" name="processor"> processor the associated Processor</param>
            </params>
         </method>
         <method id="SetOutputWriter"
                 visibility="public"
                 type="void"
                 fulltype="Saxon.Api.void">
         
            <comment>
               <sentence>Specify the destination of the serialized output, in the
            form of a <code>TextWriter</code>
               </sentence>
               <body>
                  <div>
                     <p>Specify the destination of the serialized output, in the
            form of a <code>TextWriter</code>
                     </p>
                     <p>Note that when writing to a <c>TextWriter</c>, character encoding is
            the responsibility of the <c>TextWriter</c>, not the <c>Serializer</c>. This
            means that the encoding requested in the output properties is ignored; it also
            means that characters that cannot be represented in the target encoding will
            use whatever fallback representation the <c>TextWriter</c> defines, rather than
            being represented as XML character references.</p>
                  </div>
               </body>
            
            </comment>
            <params>
               <param fulltype="System.IO.TextWriter" type="TextWriter" name="textWriter">The stream to which the output will be written.
            This must be a stream that allows writing. Saxon will not close the
            <c>textWriter</c> on completion; this is the caller's responsibility.</param>
            </params>
         </method>
         <method id="GetResult"
                 visibility="public"
                 type="JResult"
                 fulltype="javax.xml.transform.Result">
         
         
            <params>
               <param fulltype="net.sf.saxon.event.PipelineConfiguration"
                      type="PipelineConfiguration"/>
            </params>
         </method>
         <method id="GetOutputProperties"
                 visibility="public"
                 type="JProperties"
                 fulltype="java.util.Properties">
         
            <params/>
         </method>
         <method id="Close"
                 visibility="public"
                 type="void"
                 fulltype="Saxon.Api.void">
         
            <params/>
         </method>
      </methods>
   </class>
   <class id="DomDestination"
          fulltype="Saxon.Api.DomDestination"
          visibility="public"
          superclass="XmlDestination"
          superclassfulltype="Saxon.Api.XmlDestination">
      <comment>
         <sentence>
            A <code>DomDestination</code> represents an XmlDocument that is constructed to hold the
            output of a query or transformation.
            </sentence>
         <body>
            <div>
               <p>
            A <code>DomDestination</code> represents an XmlDocument that is constructed to hold the
            output of a query or transformation.
            </p>
               <p>
            No data needs to be supplied to the <c>DomDestination</c> object. The query or transformation
            populates an <c>XmlDocument</c>, which may then be retrieved as the value of the <c>XmlDocument</c>
            property
            </p>
            </div>
         </body>
      </comment>
      <property id="XmlDocument" type="XmlDocument" get="true">
         <comment>
            <sentence>After construction, retrieve the constructed document node</sentence>
            <body>
               <div>
                  <p>After construction, retrieve the constructed document node</p>
                  <p>If the zero-argument constructor was used, this will be a newly
            constructed document node. If the constructor supplied a document node, the
            same document node will be returned. If the constructor supplied a document fragment
            node or an element node, this method returns the <c>OwnerDocument</c> property of 
            that node.</p>
               </div>
            </body>
         </comment>
      </property>
      <methods>
         <constructor id="DomDestination" visibility="public">
            <params/>
            <comment>
               <sentence>Construct a <code>DomDestination</code>
               </sentence>
               <body>
                  <div>
                     <p>Construct a <code>DomDestination</code>
                     </p>
                     <p>With this constructor, the system will create a new DOM Document
            to act as the destination of the query or transformation results. The document
            node of the new document may be retrieved via the XmlDocument property.</p>
                  </div>
               </body>
            </comment>
         </constructor>
         <constructor id="DomDestination" visibility="public">
            <params>
               <param fulltype="System.Xml.XmlDocument"
                      type="XmlDocument"
                      name="attachmentPoint">The document node to which new contents will
            be attached. To ensure that the new document is well-formed, this document node
            should have no existing children.</param>
            </params>
            <comment>
               <sentence>Construct a <code>DomDestination</code> based on an existing Document node.</sentence>
               <body>
                  <div>
                     <p>Construct a <code>DomDestination</code> based on an existing Document node.</p>
                     <p>The new data will be added as a child of the supplied node.</p>
                  </div>
               </body>
            
            </comment>
         </constructor>
         <constructor id="DomDestination" visibility="public">
            <params>
               <param fulltype="System.Xml.XmlDocumentFragment"
                      type="XmlDocumentFragment"
                      name="attachmentPoint">The document fragment node to which new contents will
            be attached. The new contents will be added after any existing children.</param>
            </params>
            <comment>
               <sentence>Construct a <code>DomDestination</code> based on an existing DocumentFragment node.</sentence>
               <body>
                  <div>
                     <p>Construct a <code>DomDestination</code> based on an existing DocumentFragment node.</p>
                     <p>The new data will be added as a child of the supplied node.</p>
                  </div>
               </body>
            
            </comment>
         </constructor>
         <constructor id="DomDestination" visibility="public">
            <params>
               <param fulltype="System.Xml.XmlElement"
                      type="XmlElement"
                      name="attachmentPoint">The element node to which new contents will
            be attached. The new contents will be added after any existing children.</param>
            </params>
            <comment>
               <sentence>Construct a <code>DomDestination</code> based on an existing Element node.</sentence>
               <body>
                  <div>
                     <p>Construct a <code>DomDestination</code> based on an existing Element node.</p>
                     <p>The new data will be added as a child of the supplied element node.</p>
                  </div>
               </body>
            
            </comment>
         </constructor>
         <method id="GetResult"
                 visibility="public"
                 type="JResult"
                 fulltype="javax.xml.transform.Result">
         
         
            <params>
               <param fulltype="net.sf.saxon.event.PipelineConfiguration"
                      type="PipelineConfiguration"/>
            </params>
         </method>
      </methods>
   </class>
   <class id="NullDestination"
          fulltype="Saxon.Api.NullDestination"
          visibility="public"
          superclass="XmlDestination"
          superclassfulltype="Saxon.Api.XmlDestination">
      <comment>
         <sentence>
            A <code>NullDestination</code> is an XmlDestination that discards all its output.
            </sentence>
      </comment>
      <methods>
         <constructor id="NullDestination" visibility="public">
            <params/>
            <comment>
               <sentence>Construct a <code>NullDestination</code>
               </sentence>
            </comment>
         </constructor>
         <method id="GetResult"
                 visibility="public"
                 type="JResult"
                 fulltype="javax.xml.transform.Result">
         
         
            <params>
               <param fulltype="net.sf.saxon.event.PipelineConfiguration"
                      type="PipelineConfiguration"/>
            </params>
         </method>
      </methods>
   </class>
   <class id="TextWriterDestination"
          fulltype="Saxon.Api.TextWriterDestination"
          visibility="public"
          superclass="XmlDestination"
          superclassfulltype="Saxon.Api.XmlDestination">
      <comment>
         <sentence>
            A <code>TextWriterDestination</code> is an implementation of <code>XmlDestination</code> that wraps
            an instance of <code>XmlWriter</code>.
            </sentence>
         <body>
            <div>
               <p>
            A <code>TextWriterDestination</code> is an implementation of <code>XmlDestination</code> that wraps
            an instance of <code>XmlWriter</code>.
            </p>
               <p>The name <code>TextWriterDestination</code> is a misnomer; originally this class would
            only wrap an <code>XmlTextWriter</code>. It will now wrap any <code>XmlWriter</code>.</p>
               <p>Note that when a <code>TextWriterDestination</code> is used to process the output of a stylesheet
            or query, the output format depends only on the way the underlying <code>XmlWriter</code>
            is configured; serialization parameters present in the stylesheet or query are ignored.
            The XSLT <code>disable-output-escaping</code> option is also ignored. If serialization
            is to be controlled from the stylesheet or query, use a <code>Serializer</code> as the
            <code>Destination</code>.</p>
            </div>
         </body>
      </comment>
      <property id="CloseAfterUse" type="bool" get="true" set="true">
         <comment>
            <sentence>
            The <code>CloseAfterUse</code> property indicates whether the underlying <code>XmlWriter</code> is closed
            (by calling its <code>Close()</code> method) when Saxon has finished writing to it. The default
            value is true, in which case <code>Close()</code> is called. If the property is set to <code>false</code>,
            Saxon will refrain from calling the <code>Close()</code> method, and merely call <code>Flush()</code>,
            which can be useful if further output is to be written to the <code>XmlWriter</code> by the application.
            </sentence>
         </comment>
      </property>
      <methods>
         <constructor id="TextWriterDestination" visibility="public">
            <params>
               <param fulltype="System.Xml.XmlWriter" type="XmlWriter" name="writer">The <c>XmlWriter</c> that is to be notified of the events
            representing the XML document.</param>
            </params>
            <comment>
               <sentence>Construct a TextWriterDestination</sentence>
            
            </comment>
         </constructor>
         <method id="GetResult"
                 visibility="public"
                 type="JResult"
                 fulltype="javax.xml.transform.Result">
         
         
            <params>
               <param fulltype="net.sf.saxon.event.PipelineConfiguration"
                      type="PipelineConfiguration"/>
            </params>
         </method>
      </methods>
   </class>
   <class id="XdmDestination"
          fulltype="Saxon.Api.XdmDestination"
          visibility="public"
          superclass="XmlDestination"
          superclassfulltype="Saxon.Api.XmlDestination">
      <comment>
         <sentence>
            An <code>XdmDestination</code> is an <code>XmlDestination</code> in which an <code>XdmNode</code> 
            is constructed to hold the output of a query or transformation: 
            that is, a tree using Saxon's implementation of the XDM data model
            </sentence>
         <body>
            <div>
               <p>
            An <code>XdmDestination</code> is an <code>XmlDestination</code> in which an <code>XdmNode</code> 
            is constructed to hold the output of a query or transformation: 
            that is, a tree using Saxon's implementation of the XDM data model
            </p>
               <p>No data needs to be supplied to the <code>XdmDestination</code> object. The query or transformation
            populates an <code>XmlNode</code>, which may then be retrieved as the value of the <code>XmlNode</code>
            property.</p>
               <p>An <code>XdmDestination</code> can be reused to hold the results of a second transformation only
            if the <code>reset</code> method is first called to reset its state.</p>
            </div>
         </body>
      </comment>
      <property id="TreeModel" type="TreeModel" get="true" set="true">
         <comment>
            <sentence>
             The Tree Model implementation to be used for the constructed document. By default
             the TinyTree is used. The main reason for using the LinkedTree alternative is if
             updating is required (the TinyTree is not updateable)
            </sentence>
         </comment>
      </property>
      <property id="BaseUri" type="Uri" get="true" set="true">
         <comment>
            <sentence>This property determines the base URI of the constructed XdmNode. 
            If the baseURI property of the XdmDestination is set before the destination is written to,
            then the constructed XdmNode will have this base URI. Setting this property after constructing the node
            has no effect.
            </sentence>
         </comment>
      </property>
      <property id="XdmNode" type="XdmNode" get="true">
         <comment>
            <sentence>After construction, retrieve the constructed document node</sentence>
            <body>
               <div>
                  <p>After construction, retrieve the constructed document node</p>
                  <p>The value of the property will be null if no data has been written to the
            XdmDestination, either because the process that writes to the destination has not
            yet been run, or because the process produced no output.</p>
               </div>
            </body>
         </comment>
      </property>
      <methods>
         <constructor id="XdmDestination" visibility="public">
            <params/>
            <comment>
               <sentence>Construct an <code>XdmDestination</code>
               </sentence>
            </comment>
         </constructor>
         <method id="Reset"
                 visibility="public"
                 type="void"
                 fulltype="Saxon.Api.void">
            <comment>
               <sentence>Reset the state of the <code>XdmDestination</code> so that it can be used to hold
            the result of another query or transformation.</sentence>
            </comment>
            <params/>
         </method>
         <method id="GetResult"
                 visibility="public"
                 type="JResult"
                 fulltype="javax.xml.transform.Result">
         
         
            <params>
               <param fulltype="net.sf.saxon.event.PipelineConfiguration"
                      type="PipelineConfiguration"/>
            </params>
         </method>
      </methods>
   </class>
   <class id="StaticError"
          fulltype="Saxon.Api.StaticError"
          visibility="public"
          superclass="Exception"
          superclassfulltype="Saxon.Api.Exception">
      <comment>
         <sentence>
            The StaticError class contains information about a static error detected during
            compilation of a stylesheet, query, or XPath expression.
            </sentence>
      </comment>
      <property id="ErrorCode" type="QName" get="true">
         <comment>
            <sentence>
            The error code, as a QName. May be null if no error code has been assigned
            </sentence>
         </comment>
      </property>
      <property id="Message" type="String" get="true">
         <comment>
            <sentence>
            Return the message associated with this error
            </sentence>
         </comment>
      </property>
      <property id="ModuleUri" type="String" get="true">
         <comment>
            <sentence>
            The URI of the query or stylesheet module in which the error was detected
            (as a string)
            </sentence>
            <body>
               <div>
                  <p>
            The URI of the query or stylesheet module in which the error was detected
            (as a string)
            </p>
                  <p>
            May be null if the location of the error is unknown, or if the error is not
            localized to a specific module, or if the module in question has no known URI
            (for example, if it was supplied as an anonymous Stream)
            </p>
               </div>
            </body>
         </comment>
      </property>
      <property id="LineNumber" type="int" get="true">
         <comment>
            <sentence>
            The line number locating the error within a query or stylesheet module
            </sentence>
            <body>
               <div>
                  <p>
            The line number locating the error within a query or stylesheet module
            </p>
                  <p>
            May be set to -1 if the location of the error is unknown
            </p>
               </div>
            </body>
         </comment>
      </property>
      <property id="IsWarning" type="bool" get="true" set="true">
         <comment>
            <sentence>
            Indicate whether this error is being reported as a warning condition. If so, applications
            may ignore the condition, though the results may not be as intended.
            </sentence>
         </comment>
      </property>
      <property id="IsTypeError" type="bool" get="true">
         <comment>
            <sentence>
            Indicate whether this condition is a type error.
            </sentence>
         </comment>
      </property>
      <methods>
         <method id="ToString"
                 visibility="public"
                 type="String"
                 fulltype="System.String">
            <comment>
               <sentence>
            Return the error message.
            </sentence>
            </comment>
            <params/>
         </method>
      </methods>
   </class>
   <class id="DynamicError"
          fulltype="Saxon.Api.DynamicError"
          visibility="public"
          superclass="Exception"
          superclassfulltype="Saxon.Api.Exception">
      <comment>
         <sentence>
            The DynamicError class contains information about a dynamic error detected during
            execution of a stylesheet, query, or XPath expression.
            </sentence>
      </comment>
      <property id="ErrorCode" type="QName" get="true">
         <comment>
            <sentence>
            The error code, as a QName. May be null if no error code has been assigned
            </sentence>
         </comment>
      </property>
      <property id="Message" type="String" get="true">
         <comment>
            <sentence>
            Return the message associated with this error
            </sentence>
         </comment>
      </property>
      <property id="ModuleUri" type="String" get="true">
         <comment>
            <sentence>
            The URI of the query or stylesheet module in which the error was detected
            (as a string)
            </sentence>
            <body>
               <div>
                  <p>
            The URI of the query or stylesheet module in which the error was detected
            (as a string)
            </p>
                  <p>
            May be null if the location of the error is unknown, or if the error is not
            localized to a specific module, or if the module in question has no known URI
            (for example, if it was supplied as an anonymous Stream)
            </p>
               </div>
            </body>
         </comment>
      </property>
      <property id="LineNumber" type="int" get="true">
         <comment>
            <sentence>
            The line number locating the error within a query or stylesheet module
            </sentence>
            <body>
               <div>
                  <p>
            The line number locating the error within a query or stylesheet module
            </p>
                  <p>
            May be set to -1 if the location of the error is unknown
            </p>
               </div>
            </body>
         </comment>
      </property>
      <property id="IsWarning" type="bool" get="true" set="true">
         <comment>
            <sentence>
            Indicate whether this error is being reported as a warning condition. If so, applications
            may ignore the condition, though the results may not be as intended.
            </sentence>
         </comment>
      </property>
      <property id="IsTypeError" type="bool" get="true">
         <comment>
            <sentence>
            Indicate whether this condition is a type error.
            </sentence>
         </comment>
      </property>
      <methods>
         <constructor id="DynamicError" visibility="public">
            <params>
               <param fulltype="string" type="string" name="message">The error message</param>
            </params>
            <comment>
               <sentence>
            Create a new DynamicError, specifying the error message
            </sentence>
            
            </comment>
         </constructor>
         <method id="ToString"
                 visibility="public"
                 type="String"
                 fulltype="System.String">
            <comment>
               <sentence>
            Return the error message.
            </sentence>
            </comment>
            <params/>
         </method>
      </methods>
   </class>
   <class id="ErrorGatherer"
          fulltype="Saxon.Api.ErrorGatherer"
          visibility="protected"
          superclass="javax.xml.transform.ErrorListener"
          superclassfulltype="Saxon.Api.javax.xml.transform.ErrorListener">
      <methods>
         <constructor id="ErrorGatherer" visibility="public">
            <params/>
         </constructor>
         <method id="warning"
                 visibility="public"
                 type="void"
                 fulltype="Saxon.Api.void">
         
            <params/>
         </method>
         <method id="error"
                 visibility="public"
                 type="void"
                 fulltype="Saxon.Api.void">
         
            <params/>
         </method>
         <method id="fatalError"
                 visibility="public"
                 type="void"
                 fulltype="Saxon.Api.void">
         
            <params/>
         </method>
      </methods>
   </class>
   <class id="StaticContext"
          fulltype="Saxon.Api.StaticContext"
          visibility="public"
          superclass="object"
          superclassfulltype="System.Object">
      <comment>
         <sentence>
            The class <code>StaticContext</code> provides information about the static context of an expression
            </sentence>
      </comment>
      <property id="ModuleUri" type="Uri" get="true">
         <comment>
            <sentence>
            The URI of the module where an expression appears, suitable for use in diagnostics
            </sentence>
         </comment>
      </property>
      <property id="LineNumber" type="int" get="true">
         <comment>
            <sentence>
            The line number within a module where an expression appears, suitable for use in diagnostics
            </sentence>
         </comment>
      </property>
      <property id="BaseUri" type="Uri" get="true">
         <comment>
            <sentence>
            The static base URI of the expression. Often the same as the URI of the containing module,
            but not necessarily so, for example in a stylesheet that uses external XML entities or the
            xml:base attribute
            </sentence>
         </comment>
      </property>
      <property id="Processor" type="Processor" get="true">
         <comment>
            <sentence>
            The <code>Processor</code> that was used to create the query or stylesheet from which this extension
            function was invoked.
            </sentence>
            <body>
               <div>
                  <p>
            The <code>Processor</code> that was used to create the query or stylesheet from which this extension
            function was invoked.
            </p>
                  <p>This property is useful if the extension function wishes to create new nodes (the <code>Processor</code>
            can be used to obtain a <code>DocumentBuilder</code>), or to execute XPath expressions or queries.</p>
                  <p>There may be circumstances in which the <code>Processor</code> is not available, in which case this method
            may return null, or may return a different <code>Processor</code>. This will happen only if low-level interfaces
            have been used to cause a <code>Configuration</code> to be shared between several <code>Processor</code> instances,
            or between a <code>Processor</code> and other applications.</p>
               </div>
            </body>
         </comment>
      </property>
      <property id="Implementation" type="JStaticContext" get="true">
         <comment>
            <sentence>
            The underlying object in the Saxon implementation, an instance of class
            <code>net.sf.saxon.expr.StaticContext</code>
            </sentence>
            <body>
               <div>
                  <p>
            The underlying object in the Saxon implementation, an instance of class
            <code>net.sf.saxon.expr.StaticContext</code>
                  </p>
                  <p>This property provides access to internal methods in the Saxon engine that are
            not specifically exposed in the .NET API. In general these methods should be
            considered to be less stable than the classes in the Saxon.Api namespace.</p> 
                  <p>The internal methods follow
            Java naming conventions rather than .NET conventions.</p>
                  <p>Information about the returned object (and the objects it provides access to)
            is included in the Saxon JavaDoc docmentation, available 
            online.
            </p>
               </div>
            </body>
         </comment>
      </property>
      <methods>
         <method id="GetNamespaceForPrefix"
                 visibility="public"
                 type="String"
                 fulltype="System.String">
         
            <comment>
               <sentence>
            Resolve an in-scope namespace prefix to obtain the corresponding namespace URI. If the prefix
            is a zero-length string, the default namespace for elements and types is returned.
            </sentence>
            
               <return>
                  <body>
                     <div>The corresponding namespace URI if there is one, or null otherwise</div>
                  </body>
               </return>
            </comment>
            <params>
               <param fulltype="string" type="string" name="Prefix">The namespace prefix</param>
            </params>
         </method>
      </methods>
   </class>
   <class id="DynamicContext"
          fulltype="Saxon.Api.DynamicContext"
          visibility="public"
          superclass="object"
          superclassfulltype="System.Object">
      <comment>
         <sentence>
            The class <code>DynamicContext</code> provides information about the dynamic context of an expression
            </sentence>
      </comment>
      <property id="ContextItem" type="XdmItem" get="true">
         <comment>
            <sentence>
            The context item. May be null if no context item is defined
            </sentence>
         </comment>
      </property>
      <property id="ContextPosition" type="int" get="true">
         <comment>
            <sentence>
            The context position (equivalent to the XPath position() function).
            </sentence>
            <body>
               <div>
                  <p>
            The context position (equivalent to the XPath position() function).
            </p>
                  <p>Calling this method throws an exception if the context item is undefined.</p>
               </div>
            </body>
         </comment>
      </property>
      <property id="ContextSize" type="int" get="true">
         <comment>
            <sentence>
            The context size (equivalent to the XPath last() function).
            </sentence>
            <body>
               <div>
                  <p>
            The context size (equivalent to the XPath last() function).
            </p>
                  <p>Calling this method throws an exception if the context item is undefined.</p>
               </div>
            </body>
         </comment>
      </property>
      <property id="Implementation" type="JXPathContext" get="true">
         <comment>
            <sentence>
            The underlying object in the Saxon implementation, an instance of class
            <code>net.sf.saxon.expr.XPathContext</code>
            </sentence>
            <body>
               <div>
                  <p>
            The underlying object in the Saxon implementation, an instance of class
            <code>net.sf.saxon.expr.XPathContext</code>
                  </p>
                  <p>This property provides access to internal methods in the Saxon engine that are
            not specifically exposed in the .NET API. In general these methods should be
            considered to be less stable than the classes in the Saxon.Api namespace.</p> 
                  <p>The internal methods follow
            Java naming conventions rather than .NET conventions.</p>
                  <p>Information about the returned object (and the objects it provides access to)
            is included in the Saxon JavaDoc docmentation, available 
            online.
            </p>
               </div>
            </body>
         </comment>
      </property>
   </class>
   <class id="ExtensionFunctionDefinition"
          fulltype="Saxon.Api.ExtensionFunctionDefinition"
          visibility="public"
          superclass="object"
          superclassfulltype="System.Object"
          abstract="true">
      <comment>
         <sentence>
            <p>Abstract superclass for user-written extension functions. An extension function may be implemented as a subclass
            of this class, with appropriate implementations of the defined methods.</p>
            <p>More precisely, a subclass of <code>ExtensionFunctionDefinition</code> identifies a family of extension functions
            with the same (namespace-qualified) name but potentially having different arity (number of arguments).</p>
            </sentence>
         <body>
            <div>
               <p>
                  <p>Abstract superclass for user-written extension functions. An extension function may be implemented as a subclass
            of this class, with appropriate implementations of the defined methods.</p>
                  <p>More precisely, a subclass of <code>ExtensionFunctionDefinition</code> identifies a family of extension functions
            with the same (namespace-qualified) name but potentially having different arity (number of arguments).</p>
               </p>
               <p>A user-defined extension function is typically implemented using a pair of classes: a class that extends 
            <code>ExtensionFunctionDefinition</code>, whose purpose is to define the properties of the extension function
            (in particular, its signature -- the types of its arguments and result); and a class that extends
            <code>ExtensionFunctionCall</code>, whose purpose is to perform the actual evaluation.</p> 
               <p>The <code>ExtensionFunctionDefinition</code> is immutable and will normally have a singleton instance
            for each subclass; this singleton instance is registered with the <code>Processor</code> to associate the
            name of the extension function with its definition.</p>
               <p>The <code>ExtensionFunctionCall</code> has one instance for each call on the extension function appearing
            in the source code of a stylesheet or query; this instance is created when Saxon calls the method <code>MakeFunctionCall</code>
            provided by the <code>ExtensionFunctionDefinition</code> object. The instance of <code>ExtensionFunctionCall</code>
            holds information about the static context of the function call, and its <code>Call</code> method is called
            (by Saxon) to evaluate the extension function at run-time.</p>
            </div>
         </body>
      </comment>
      <property id="FunctionName" type="QName" abstract="true">
         <comment>
            <sentence>
            Read-only property returning the name of the extension function, as a QName.
            </sentence>
            <body>
               <div>
                  <p>
            Read-only property returning the name of the extension function, as a QName.
            </p>
                  <p>
            A getter for this property must be implemented in every subclass.
            </p>
               </div>
            </body>
         </comment>
      </property>
      <property id="MinimumNumberOfArguments" type="int" abstract="true">
         <comment>
            <sentence>
            Read-only property giving the minimum number of arguments in a call to this extension function.
            </sentence>
            <body>
               <div>
                  <p>
            Read-only property giving the minimum number of arguments in a call to this extension function.
            </p>
                  <p>
            A getter for this property must be implemented in every subclass.
            </p>
               </div>
            </body>
         </comment>
      </property>
      <property id="MaximumNumberOfArguments" type="int" abstract="true">
         <comment>
            <sentence>
            Read-only property giving the maximum number of arguments in a call to this extension function.
            </sentence>
            <body>
               <div>
                  <p>
            Read-only property giving the maximum number of arguments in a call to this extension function.
            </p>
                  <p>
            A getter for this property must be implemented in every subclass.
            </p>
               </div>
            </body>
         </comment>
      </property>
      <property id="ArgumentTypes" type="XdmSequenceType[]" abstract="true">
         <comment>
            <sentence>
            Read-only property giving the required types of the arguments to this extension function. 
            If the number of items in the array is less than the maximum number of arguments, 
            then the last entry in the returned ArgumentTypes is assumed to apply to all the rest; 
            if the returned array is empty, then all arguments are assumed to be of type <code>item()*</code>
            </sentence>
            <body>
               <div>
                  <p>
            Read-only property giving the required types of the arguments to this extension function. 
            If the number of items in the array is less than the maximum number of arguments, 
            then the last entry in the returned ArgumentTypes is assumed to apply to all the rest; 
            if the returned array is empty, then all arguments are assumed to be of type <code>item()*</code>
                  </p>
                  <p>
            A getter for this property must be implemented in every subclass.
            </p>
               </div>
            </body>
         </comment>
      </property>
      <property id="TrustResultType" type="Boolean">
         <comment>
            <sentence>
            This property may return true for a subclass if it guarantees that the returned result of the function
            will always be of the declared return type: setting this to true by-passes the run-time checking of the type
            of the value, together with code that would otherwise perform atomization, numeric type promotion, and similar
            conversions. If the value is set to true and the value is not of the correct type, the effect is unpredictable
            and probably disastrous.
            </sentence>
            <body>
               <div>
                  <p>
            This property may return true for a subclass if it guarantees that the returned result of the function
            will always be of the declared return type: setting this to true by-passes the run-time checking of the type
            of the value, together with code that would otherwise perform atomization, numeric type promotion, and similar
            conversions. If the value is set to true and the value is not of the correct type, the effect is unpredictable
            and probably disastrous.
            </p>
                  <p>
            The default value of this property is <c>false</c>. A getter for this property may be implemented in a subclass
            to return a different value.
            </p>
               </div>
            </body>
         </comment>
      </property>
      <property id="DependsOnFocus" type="Boolean">
         <comment>
            <sentence>
            This property must return true for a subclass if the evaluation of the function makes use of the context
            item, position, or size from the dynamic context. It should also return true (despite the property name)
            if the function makes use of parts of the static context that vary from one part of the query or stylesheet
            to another. Setting the property to true inhibits certain Saxon optimizations, such as extracting the call
            from a loop, or moving it into a global variable.
            </sentence>
            <body>
               <div>
                  <p>
            This property must return true for a subclass if the evaluation of the function makes use of the context
            item, position, or size from the dynamic context. It should also return true (despite the property name)
            if the function makes use of parts of the static context that vary from one part of the query or stylesheet
            to another. Setting the property to true inhibits certain Saxon optimizations, such as extracting the call
            from a loop, or moving it into a global variable.
            </p>
                  <p>
            The default value of this property is <c>false</c>. A getter for this property may be implemented in a subclass
            to return a different value.
            </p>
               </div>
            </body>
         </comment>
      </property>
      <property id="HasSideEffects" type="Boolean">
         <comment>
            <sentence>
            This property should return true for a subclass if the evaluation of the function has side-effects.
            Saxon never guarantees the result of calling functions with side-effects, but if this property is set,
            then certain aggressive optimizations will be avoided, making it more likely that the function behaves
            as expected.
            </sentence>
            <body>
               <div>
                  <p>
            This property should return true for a subclass if the evaluation of the function has side-effects.
            Saxon never guarantees the result of calling functions with side-effects, but if this property is set,
            then certain aggressive optimizations will be avoided, making it more likely that the function behaves
            as expected.
            </p>
                  <p>
            The default value of this property is <c>false</c>. A getter for this property may be implemented in a subclass
            to return a different value.
            </p>
               </div>
            </body>
         </comment>
      </property>
      <methods>
         <method id="ResultType"
                 visibility="public"
                 type="XdmSequenceType"
                 fulltype="Saxon.Api.XdmSequenceType"
                 abstract="true">
         
            <comment>
               <sentence>
            Method returning the declared type of the return value from the function. The type of the return
            value may be known more precisely if the types of the arguments are known (for example, some functions
            return a value that is the same type as the first argument. The method is therefore called supplying the
            static types of the actual arguments present in the call.
            </sentence>
               <body>
                  <div>
                     <p>
            Method returning the declared type of the return value from the function. The type of the return
            value may be known more precisely if the types of the arguments are known (for example, some functions
            return a value that is the same type as the first argument. The method is therefore called supplying the
            static types of the actual arguments present in the call.
            </p>
                     <p>
            This method must be implemented in every subclass.
            </p>
                  </div>
               </body>
            
               <return>
                  <body>
                     <div>
            An <code>XdmSequenceType</code> representing the declared return type of the extension function
            </div>
                  </body>
               </return>
            </comment>
            <params>
               <param fulltype="Saxon.Api.XdmSequenceType[]"
                      type="XdmSequenceType[]"
                      name="ArgumentTypes">
            The static types of the arguments present in the function call
            </param>
            </params>
         </method>
         <method id="MakeFunctionCall"
                 visibility="public"
                 type="ExtensionFunctionCall"
                 fulltype="Saxon.Api.ExtensionFunctionCall"
                 abstract="true">
            <comment>
               <sentence>
            Factory method to create an <code>ExtensionFunctionCall</code> object, representing a specific function call in the XSLT or XQuery
            source code. Saxon will call this method once it has identified that a specific call relates to this extension
            function.
            </sentence>
               <body>
                  <div>
                     <p>
            Factory method to create an <code>ExtensionFunctionCall</code> object, representing a specific function call in the XSLT or XQuery
            source code. Saxon will call this method once it has identified that a specific call relates to this extension
            function.
            </p>
                     <p>
            This method must be implemented in every subclass. The implementation should normally instantiate the relevant subclass
            of <code>ExtensionFunctionCall</code>, and return the new instance.
            </p>
                  </div>
               </body>
               <return>
                  <body>
                     <div>
            An instance of the appropriate implementation of <code>ExtensionFunctionCall</code>
                     </div>
                  </body>
               </return>
            </comment>
            <params/>
         </method>
      </methods>
   </class>
   <class id="ExtensionFunctionCall"
          fulltype="Saxon.Api.ExtensionFunctionCall"
          visibility="public"
          superclass="object"
          superclassfulltype="System.Object"
          abstract="true">
      <comment>
         <sentence>
            <p>An instance of this class will be created by the compiler for each function call to this extension function
            that is found in the source code. The class is always instantiated by calling the method <code>MakeFunctionCall()</code>
            of the corresponding <code>ExtensionFunctionDefinition</code>. 
            The implementation may therefore retain information about the static context of the
            call. Once compiled, however, the instance object must be immutable.</p>
            </sentence>
      </comment>
      <methods>
         <method id="SupplyStaticContext"
                 visibility="public"
                 type="void"
                 fulltype="Saxon.Api.void">
         
            <comment>
               <sentence>
            Method called by the compiler (at compile time) to provide information about the static context of the
            function call. The implementation may retain this information for use at run-time, if the result of the
            function depends on information in the static context.
            </sentence>
               <body>
                  <div>
                     <p>
            Method called by the compiler (at compile time) to provide information about the static context of the
            function call. The implementation may retain this information for use at run-time, if the result of the
            function depends on information in the static context.
            </p>
                     <p>
            For efficiency, the implementation should only retain copies of the information that it actually needs. It
            is not a good idea to hold a reference to the static context itself, since that can result in a great deal of
            compile-time information being locked into memory during run-time execution.
            </p>
                  </div>
               </body>
            
            </comment>
            <params>
               <param fulltype="Saxon.Api.StaticContext"
                      type="StaticContext"
                      name="context">Information about the static context in which the function is called</param>
            </params>
         </method>
         <method id="CopyLocalData"
                 visibility="public"
                 type="void"
                 fulltype="Saxon.Api.void">
         
            <comment>
               <sentence>
            A subclass must implement this method if it retains any local data at the instance level. On some occasions
            (for example, when XSLT or XQuery code is inlined), Saxon will make a copy of an <code>ExtensionFunction</code> object.
            It will then call this method on the old object, supplying the new object as the value of the argument, and the
            method must copy all local data items from the old object to the new.
            </sentence>
            
            </comment>
            <params>
               <param fulltype="Saxon.Api.ExtensionFunctionCall"
                      type="ExtensionFunctionCall"
                      name="destination">The new extension function object. This will always be an instance of the same
            class as the existing object.</param>
            </params>
         </method>
         <method id="Call"
                 visibility="public"
                 type="IXdmEnumerator"
                 fulltype="Saxon.Api.IXdmEnumerator"
                 abstract="true">
         
         
            <comment>
               <sentence>
            Method called at run time to evaluate the function.
            </sentence>
            
            
               <return>
                  <body>
                     <div>An iterator over a sequence, representing the result of the extension function.
            Note that Saxon does not guarantee to read this sequence to completion, so calls on the iterator
            must have no side-effects. In rare circumstances (for example, when <code>last()</code> is
            used) Saxon may clone the returned iterator by calling its <code>GetAnother()</code> method, 
            allowing the function results to be read more than once.</div>
                  </body>
               </return>
            </comment>
            <params>
               <param fulltype="Saxon.Api.IXdmEnumerator[]"
                      type="IXdmEnumerator[]"
                      name="arguments">The values of the arguments to the function, supplied as iterators over XPath
            sequence values.</param>
               <param fulltype="Saxon.Api.DynamicContext"
                      type="DynamicContext"
                      name="context">The dynamic context for evaluation of the function. This provides access
            to the context item, position, and size, and if required to internal data maintained by the Saxon
            engine.</param>
            </params>
         </method>
      </methods>
   </class>
   <class id="WrappedExtensionFunctionDefinition"
          fulltype="Saxon.Api.WrappedExtensionFunctionDefinition"
          visibility="protected"
          superclass="JExtensionFunctionDefinition"
          superclassfulltype="net.sf.saxon.lib.ExtensionFunctionDefinition">
      <methods>
         <constructor id="WrappedExtensionFunctionDefinition" visibility="public">
            <params/>
         </constructor>
         <method id="getFunctionQName"
                 visibility="public"
                 type="JStructuredQName"
                 fulltype="net.sf.saxon.om.StructuredQName">
         
            <params/>
         </method>
         <method id="getMinimumNumberOfArguments"
                 visibility="public"
                 type="int"
                 fulltype="Saxon.Api.int">
         
            <params/>
         </method>
         <method id="getMaximumNumberOfArguments"
                 visibility="public"
                 type="int"
                 fulltype="Saxon.Api.int">
         
            <params/>
         </method>
         <method id="getArgumentTypes"
                 visibility="public"
                 type="JSequenceType[]"
                 fulltype="Saxon.Api.JSequenceType[]">
         
            <params/>
         </method>
         <method id="getResultType"
                 visibility="public"
                 type="JSequenceType"
                 fulltype="net.sf.saxon.value.SequenceType">
         
            <params/>
         </method>
         <method id="trustResultType"
                 visibility="public"
                 type="Boolean"
                 fulltype="Saxon.Api.Boolean">
         
            <params/>
         </method>
         <method id="dependsOnFocus"
                 visibility="public"
                 type="Boolean"
                 fulltype="Saxon.Api.Boolean">
         
            <params/>
         </method>
         <method id="hasSideEffects"
                 visibility="public"
                 type="Boolean"
                 fulltype="Saxon.Api.Boolean">
         
            <params/>
         </method>
         <method id="makeCallExpression"
                 visibility="public"
                 type="JExtensionFunctionCall"
                 fulltype="net.sf.saxon.lib.ExtensionFunctionCall">
         
            <params/>
         </method>
      </methods>
   </class>
   <class id="WrappedExtensionFunctionCall"
          fulltype="Saxon.Api.WrappedExtensionFunctionCall"
          visibility="protected"
          superclass="JExtensionFunctionCall"
          superclassfulltype="net.sf.saxon.lib.ExtensionFunctionCall">
      <methods>
         <constructor id="WrappedExtensionFunctionCall" visibility="public">
            <params/>
         </constructor>
         <method id="supplyStaticContext"
                 visibility="public"
                 type="void"
                 fulltype="Saxon.Api.void">
         
            <params/>
         </method>
         <method id="copyLocalData"
                 visibility="public"
                 type="void"
                 fulltype="Saxon.Api.void">
         
            <params/>
         </method>
         <method id="call"
                 visibility="public"
                 type="JSequence"
                 fulltype="net.sf.saxon.Sequence">
         
            <params/>
         </method>
      </methods>
   </class>
   <class id="XdmValue"
          fulltype="Saxon.Api.XdmValue"
          visibility="public"
          superclass="IEnumerable"
          superclassfulltype="Saxon.Api.IEnumerable">
      <comment>
         <sentence>
            An value in the XDM data model. A value is a sequence of zero or more
            items, each item being either an atomic value or a node.
            </sentence>
         <body>
            <div>
               <p>
            An value in the XDM data model. A value is a sequence of zero or more
            items, each item being either an atomic value or a node.
            </p>
               <p>An <code>XdmValue</code> is immutable.</p>
               <p>A sequence consisting of a single item <i>may</i> be represented
            as an instance of <code>XdmItem</code>, which is a subtype of <code>XdmValue</code>. However,
            there is no guarantee that all single-item sequences will be instances of
            <code>XdmItem</code>: if you want to ensure this, use the <code>Simplify</code> property.</p>
               <p>There are various ways of creating an <code>XdmValue</code>. To create an atomic
            value, use one of the constructors on <code>XdmAtomicValue</code> (which is a subtype of <code>XdmValue</code>).
            To construct an <code>XdmNode</code> (another subtype) by parsing an XML document, or by wrapping a DOM document,
            use a <code>DocumentBuilder</code>. To create a sequence of values, use the <code>Append</code>
            method on this class to form a list from individual items or sublists.</p>
               <p>An <code>dmValue</code> is also returned as the result of evaluating a query
            using the XQuery and XPath interfaces.</p>
               <p>The subtype <code>XdmEmptySequence</code> represents an empty sequence: an
            <code>XdmValue</code> of length zero. Again, there is no guarantee that every empty sequence
            will be represented as an instance of <code>XdmEmptySequence</code>, unless you use
            the <code>Simplify</code> property.</p>
            </div>
         </body>
      </comment>
      <property id="Count" type="int" get="true">
         <comment>
            <sentence>
            Get the number of items in the sequence
            </sentence>
            <return>
               <body>
                  <div>
            The number of items in the sequence
            </div>
               </body>
            </return>
         </comment>
      </property>
      <property id="Simplify" type="XdmValue" get="true">
         <comment>
            <sentence>
            Simplify a value: that is, reduce it to the simplest possible form.
            If the sequence is empty, the result will be an instance of <code>XdmEmptySequence</code>.
            If the sequence is a single node, the result will be an instance of <code>XdmNode</code>;
            if it is a single atomic value, it will be an instance of <code>XdmAtomicValue</code>.
            </sentence>
         </comment>
      </property>
      <methods>
         <constructor id="XdmValue" visibility="public">
            <params>
               <param fulltype="System.Collections.IEnumerable"
                      type="IEnumerable"
                      name="items">An enumerable collection providing the items to make up the sequence. Every
            member of this collection must be an instance of <c>XdmItem</c>
               </param>
            </params>
            <comment>
               <sentence>
            Create a value from a collection of items
            </sentence>
            
            </comment>
         </constructor>
         <method id="Append"
                 visibility="public"
                 type="XdmValue"
                 fulltype="Saxon.Api.XdmValue">
         
            <comment>
               <sentence>
            Create a new XdmValue by concatenating the sequences of items in this XdmValue and another XdmValue
            </sentence>
               <body>
                  <div>
                     <p>
            Create a new XdmValue by concatenating the sequences of items in this XdmValue and another XdmValue
            </p>
                     <p>
            Neither of the input XdmValue objects is modified by this operation
            </p>
                  </div>
               </body>
            
            </comment>
            <params>
               <param fulltype="Saxon.Api.XdmValue" type="XdmValue" name="otherValue">
            The other XdmValue, whose items are to be appended to the items from this XdmValue
            </param>
            </params>
         </method>
         <method id="Wrap"
                 visibility="public"
                 type="XdmValue"
                 fulltype="Saxon.Api.XdmValue"
                 static="true">
         
            <comment>
               <sentence>
            Create an XdmValue from an underlying Saxon Sequence object.
            This method is provided for the benefit of applications that need to mix
            use of the Saxon .NET API with direct use of the underlying objects
            and methods offered by the Java implementation.
            </sentence>
            
               <return>
                  <body>
                     <div>An XdmValue that wraps the underlying Saxon value
            representation.</div>
                  </body>
               </return>
            </comment>
            <params>
               <param fulltype="net.sf.saxon.om.Sequence" type="Sequence" name="value">An object representing an XDM value in the
            underlying Saxon implementation. If the parameter is null,
            the method returns null.</param>
            </params>
         </method>
         <method id="Unwrap"
                 visibility="public"
                 type="Sequence"
                 fulltype="Saxon.Api.Sequence">
            <comment>
               <sentence>
            Extract the underlying Saxon Sequence object from an XdmValue.
            This method is provided for the benefit of applications that need to mix
            use of the Saxon .NET API with direct use of the underlying objects
            and methods offered by the Java implementation.
            </sentence>
               <return>
                  <body>
                     <div>An object representing the XDM value in the
            underlying Saxon implementation.</div>
                  </body>
               </return>
            </comment>
            <params/>
         </method>
         <method id="GetList"
                 visibility="public"
                 type="IList"
                 fulltype="Saxon.Api.IList">
            <comment>
               <sentence>
            Get the sequence of items in the form of an <code>IList</code>
               </sentence>
               <return>
                  <body>
                     <div>
            The list of items making up this value. Each item in the list
            will be an object of type <code>XdmItem</code>
                     </div>
                  </body>
               </return>
            </comment>
            <params/>
         </method>
         <method id="GetEnumerator"
                 visibility="public"
                 type="IEnumerator"
                 fulltype="IEnumerator">
            <comment>
               <sentence>
            Get the sequence of items in the form of an <code>IXdmEnumerator</code>
               </sentence>
               <return>
                  <body>
                     <div>
            An enumeration over the list of items making up this value. Each item in the list
            will be an object of type <code>XdmItem</code>
                     </div>
                  </body>
               </return>
            </comment>
            <params/>
         </method>
      </methods>
   </class>
   <class id="XdmItem"
          fulltype="Saxon.Api.XdmItem"
          visibility="public"
          superclass="XdmValue"
          superclassfulltype="Saxon.Api.XdmValue"
          abstract="true">
      <comment>
         <sentence>
            The class <code>XdmItem</code> represents an item in a sequence, as defined
            by the XDM data model. An item is either an atomic value or a node.
            </sentence>
         <body>
            <div>
               <p>
            The class <code>XdmItem</code> represents an item in a sequence, as defined
            by the XDM data model. An item is either an atomic value or a node.
            </p>
               <p>An item is a member of a sequence, but it can also be considered as
            a sequence (of length one) in its own right. <code>XdmItem</code> is a subtype
            of <code>XdmValue</code> because every Item in the XDM data model is also a
            value.</p>
               <p>It cannot be assumed that every sequence of length one will be 
            represented by an <code>XdmItem</code>. It is quite possible for an <code>XdmValue</code>
            that is not an <code>XdmItem</code> to hold a singleton sequence.</p>
            </div>
         </body>
      </comment>
      <methods>
         <method id="IsAtomic"
                 visibility="public"
                 type="bool"
                 fulltype="bool"
                 abstract="true">
            <comment>
               <sentence>
            Determine whether the item is an atomic value
            </sentence>
               <return>
                  <body>
                     <div>
            true if the item is an atomic value, false if it is a Node
            </div>
                  </body>
               </return>
            </comment>
            <params/>
         </method>
      </methods>
   </class>
   <class id="XdmAtomicValue"
          fulltype="Saxon.Api.XdmAtomicValue"
          visibility="public"
          superclass="XdmItem"
          superclassfulltype="Saxon.Api.XdmItem">
      <comment>
         <sentence>
            The class <code>XdmAtomicValue</code> represents an item in an XPath 2.0 sequence
            that is an atomic value. The value may belong to any of the 19 primitive types
            defined in XML Schema, or to a type derived from these primitive types, or to 
            the XPath 2.0 type <code>xs:untypedAtomic</code>
            </sentence>
         <body>
            <div>
               <p>
            The class <code>XdmAtomicValue</code> represents an item in an XPath 2.0 sequence
            that is an atomic value. The value may belong to any of the 19 primitive types
            defined in XML Schema, or to a type derived from these primitive types, or to 
            the XPath 2.0 type <code>xs:untypedAtomic</code>
               </p>
               <p>
            Note that there is no guarantee that every <c>XdmValue</c> comprising a single
            atomic value will be an instance of this class. To force this, use the <c>Simplify</c>
            property of the <c>XdmValue</c>.
            </p>
            </div>
         </body>
      </comment>
      <property id="Value" type="Object" get="true">
         <comment>
            <sentence>Get the value as a CLI object of the nearest equivalent type.</sentence>
            <body>
               <div>
                  <p>Get the value as a CLI object of the nearest equivalent type.</p>
                  <p>The return type is as follows:</p>
                  <p>xs:string - String</p>
                  <p>xs:integer - Long</p>
                  <p>xs:decimal - Decimal</p>
                  <p>xs:double - Double</p>
                  <p>xs:float - Float</p>
                  <p>xs:boolean - Bool</p>
                  <p>xs:QName - QName</p>
                  <p>xs:anyURI - Uri</p>
                  <p>xs:untypedAtomic - String</p>
                  <p>wrapped external object - the original external object</p>
                  <p>Other types - currently String, but this may change in the future</p>
               </div>
            </body>
            <return>
               <body>
                  <div>The value converted to the most appropriate CLI type</div>
               </body>
            </return>
         </comment>
      </property>
      <methods>
         <method id="IsAtomic" visibility="public" type="bool" fulltype="bool">
            <comment>
               <sentence>
            Determine whether the item is an atomic value
            </sentence>
               <return>
                  <body>
                     <div>
            true (the item is an atomic value)
            </div>
                  </body>
               </return>
            </comment>
            <params/>
         </method>
         <constructor id="XdmAtomicValue" visibility="public">
            <params>
               <param fulltype="long" type="long" name="i">The integer value</param>
            </params>
            <comment>
               <sentence>
            Construct an atomic value of type <code>xs:integer</code>
               </sentence>
            
            </comment>
         </constructor>
         <constructor id="XdmAtomicValue" visibility="public">
            <params>
               <param fulltype="decimal" type="decimal" name="d">The decimal value</param>
            </params>
            <comment>
               <sentence>
            Construct an atomic value of type <code>xs:decimal</code>
               </sentence>
            
            </comment>
         </constructor>
         <constructor id="XdmAtomicValue" visibility="public">
            <params>
               <param fulltype="float" type="float" name="f">The float value</param>
            </params>
            <comment>
               <sentence>
            Construct an atomic value of type <code>xs:float</code>
               </sentence>
            
            </comment>
         </constructor>
         <constructor id="XdmAtomicValue" visibility="public">
            <params>
               <param fulltype="double" type="double" name="d">The double value</param>
            </params>
            <comment>
               <sentence>
            Construct an atomic value of type <code>xs:double</code>
               </sentence>
            
            </comment>
         </constructor>
         <constructor id="XdmAtomicValue" visibility="public">
            <params>
               <param fulltype="bool" type="bool" name="b">The boolean value</param>
            </params>
            <comment>
               <sentence>
            Construct an atomic value of type <code>xs:boolean</code>
               </sentence>
            
            </comment>
         </constructor>
         <constructor id="XdmAtomicValue" visibility="public">
            <params>
               <param fulltype="System.Uri" type="Uri" name="u">The uri value</param>
            </params>
            <comment>
               <sentence>
            Construct an atomic value of type <code>xs:anyURI</code>
               </sentence>
            
            </comment>
         </constructor>
         <constructor id="XdmAtomicValue" visibility="public">
            <params>
               <param fulltype="Saxon.Api.QName" type="QName" name="q">The QName value</param>
            </params>
            <comment>
               <sentence>
            Construct an atomic value of type <code>xs:QName</code>
               </sentence>
            
            </comment>
         </constructor>
         <constructor id="XdmAtomicValue" visibility="public">
            <params>
               <param fulltype="string" type="string" name="lexicalForm">The string representation of the value (any value that is acceptable
            in the lexical space, as defined by XML Schema Part 2). Whitespace normalization as defined by
            the target type will be applied to the value.</param>
               <param fulltype="Saxon.Api.QName" type="QName" name="type">The QName giving the name of the target type. This must be an atomic
            type, and it must not be a type that is namespace-sensitive (QName, NOTATION, or types derived
            from these). If the type is a user-defined type then its definition must be present
            in the schema cache maintained by the <c>SchemaManager</c>.</param>
               <param fulltype="Saxon.Api.Processor" type="Processor" name="processor">The <c>Processor</c> object. This is needed for looking up user-defined
            types, and also because some conversions are context-sensitive, for example they depend on the
            implicit timezone or the choice of XML 1.0 versus XML 1.1 for validating names.</param>
            </params>
            <exceptions/>
            <comment>
               <sentence>
            Construct an atomic value of a given built-in or user-defined type
            </sentence>
               <div class="example">
                  <code>AtomicValue("abcd", QName.XDT_UNTYPED_ATOMIC)</code>
                  <p>creates an untyped atomic value containing the string "abcd"</p>
               </div>
            
            
            
            
            </comment>
         </constructor>
         <constructor id="XdmAtomicValue" visibility="public">
            <params/>
         </constructor>
         <method id="WrapExternalObject"
                 visibility="public"
                 type="XdmAtomicValue"
                 fulltype="Saxon.Api.XdmAtomicValue"
                 static="true">
         
            <comment>
               <sentence>
            Create an atomic value that wraps an external object. Such values can be used
            in conjunction with extension functions.
            </sentence>
               <body>
                  <div>
                     <p>
            Create an atomic value that wraps an external object. Such values can be used
            in conjunction with extension functions.
            </p>
                     <p>This method should not be used to create simple atomic values representing strings,
            numbers, booleans, and so on. For that purpose, use the relevant constructor.
            Wrapped external objects are used only when calling .NET native code external
            to a query or stylesheet.</p>
                     <p>In releases prior to 9.2, this method also existed with the alternative spelling
            <code>wrapExternalObject</code> (lower-case "w"). This was retained for backwards compatibility,
            but caused problems for Visual Basic users, where it is not permitted to have two methods whose
            names differ only in case. Any applications using <code>wrapExternalObject</code> must
            therefore be changed to use <code>WrapExternalObject</code>. Apologies for the inconvenience.</p>
                  </div>
               </body>
            
               <return>
                  <body>
                     <div>The wrapped object</div>
                  </body>
               </return>
            </comment>
            <params>
               <param fulltype="object" type="object" name="external">The object to be wrapped.</param>
            </params>
         </method>
         <method id="GetBooleanValue"
                 visibility="public"
                 type="bool"
                 fulltype="bool">
            <comment>
               <sentence>
            Get the value converted to a boolean using the XPath casting rules
            </sentence>
               <return>
                  <body>
                     <div>the result of converting to a boolean (Note: this is not the same as the
            effective boolean value).</div>
                  </body>
               </return>
            </comment>
            <params/>
         </method>
         <method id="GetLongValue"
                 visibility="public"
                 type="long"
                 fulltype="Saxon.Api.long">
            <comment>
               <sentence>
            Get the value converted to a boolean using the XPath casting rules
            </sentence>
               <return>
                  <body>
                     <div>the result of converting to an integer</div>
                  </body>
               </return>
            </comment>
            <params/>
         </method>
         <method id="GetDoubleValue"
                 visibility="public"
                 type="double"
                 fulltype="Saxon.Api.double">
            <comment>
               <sentence>
            Get the value converted to a double using the XPath casting rules.
            <p>If the value is a string, the XSD 1.1 rules are used, which means that the string
            "+INF" is recognised.</p>
               </sentence>
               <return>
                  <body>
                     <div>the result of converting to a double</div>
                  </body>
               </return>
            </comment>
            <params/>
         </method>
         <method id="GetDecimalValue"
                 visibility="public"
                 type="Decimal"
                 fulltype="Saxon.Api.Decimal">
            <comment>
               <sentence>
            Get the value converted to a decimal using the XPath casting rules
            </sentence>
               <return>
                  <body>
                     <div>return the result of converting to a decimal</div>
                  </body>
               </return>
            </comment>
            <params/>
         </method>
         <method id="ToString"
                 visibility="public"
                 type="String"
                 fulltype="System.String">
            <comment>
               <sentence>
            Convert the atomic value to a string
            </sentence>
               <return>
                  <body>
                     <div>The value converted to a string, according to the rules
            of the XPath 2.0 cast operator</div>
                  </body>
               </return>
            </comment>
            <params/>
         </method>
         <method id="GetTypeName"
                 visibility="public"
                 type="QName"
                 fulltype="Saxon.Api.QName">
         
            <comment>
               <sentence>
            Get the name of the value's XDM type
            </sentence>
            
               <return>
                  <body>
                     <div>The type of the value, as a QName. This may be a built-in type or a user-defined
            atomic type.
            </div>
                  </body>
               </return>
            </comment>
            <params>
               <param fulltype="Saxon.Api.Processor" type="Processor" name="processor">The <c>Processor</c> object. 
            This is needed for access to the NamePool,
            which maps the internal form of type names to their external form.</param>
            </params>
         </method>
         <method id="GetPrimitiveTypeName"
                 visibility="public"
                 type="QName"
                 fulltype="Saxon.Api.QName">
            <comment>
               <sentence>
            Get the name of the primitive type of the value
            </sentence>
               <return>
                  <body>
                     <div>The primitive type of the value, as a QName. This will be the name of
            one of the primitive types defined in XML Schema Part 2, or the XPath-defined
            type <code>xs:untypedAtomic</code>. For the purposes of this method, <code>xs:integer</code> is considered
            to be a primitive type.
            </div>
                  </body>
               </return>
            </comment>
            <params/>
         </method>
      </methods>
   </class>
   <class id="XdmFunctionItem"
          fulltype="Saxon.Api.XdmFunctionItem"
          visibility="public"
          superclass="XdmItem"
          superclassfulltype="Saxon.Api.XdmItem">
      <comment>
         <sentence>
            The class <code>XdmFunctionItem</code> represents an item in an XPath 3.0 sequence
            that represents a function.
            </sentence>
         <body>
            <div>
               <p>
            The class <code>XdmFunctionItem</code> represents an item in an XPath 3.0 sequence
            that represents a function.
            </p>
               <p>Note that there is no guarantee that every <code>XdmValue</code> comprising a single
            function item will be an instance of this class. To force this, use the <code>Simplify</code>
            property of the <code>XdmValue</code>.</p>
               <p>At present the only way of creating an instance of this class is as the result of
            an XPath or XQuery expression that returns a function item. Note that this feature requires
            XPath 3.0 or XQuery 3.0 to be enabled, which in turn requires use of Saxon-EE.</p>
            </div>
         </body>
      </comment>
      <property id="FunctionName" type="QName" get="true">
         <comment>
            <sentence>
            The name of the function, as a QName. The result will be null if the function is anonymous.
            </sentence>
         </comment>
      </property>
      <property id="Arity" type="int" get="true">
         <comment>
            <sentence>
            The arity of the function, that is, the number of arguments it expects
            </sentence>
         </comment>
      </property>
      <methods>
         <method id="IsAtomic" visibility="public" type="bool" fulltype="bool">
            <comment>
               <sentence>
            Determine whether the item is an atomic value
            </sentence>
               <return>
                  <body>
                     <div>
            false (a function item is not an atomic value)
            </div>
                  </body>
               </return>
            </comment>
            <params/>
         </method>
         <method id="invoke"
                 visibility="public"
                 type="XdmValue"
                 fulltype="Saxon.Api.XdmValue">
         
         
            <comment>
               <sentence>
            Invoke the function
            </sentence>
            
            
               <return>
                  <body>
                     <div>The result of calling the function</div>
                  </body>
               </return>
            </comment>
            <params>
               <param fulltype="Saxon.Api.XdmValue[]" type="XdmValue[]" name="arguments">The arguments to the function</param>
               <param fulltype="Saxon.Api.Processor" type="Processor" name="processor">The Saxon processor, used to provide context information</param>
            </params>
         </method>
      </methods>
   </class>
   <class id="XdmNode"
          fulltype="Saxon.Api.XdmNode"
          visibility="public"
          superclass="XdmItem"
          superclassfulltype="Saxon.Api.XdmItem">
      <comment>
         <sentence>
            The class <code>XdmNode</code> represents a Node in the XDM Data Model. A Node
            is an <code>XdmItem</code>, and is therefore an <code>XdmValue</code> in its own right, and may also participate
            as one item within a sequence value.
            </sentence>
         <body>
            <div>
               <p>
            The class <code>XdmNode</code> represents a Node in the XDM Data Model. A Node
            is an <code>XdmItem</code>, and is therefore an <code>XdmValue</code> in its own right, and may also participate
            as one item within a sequence value.
            </p>
               <p>An <code>XdmNode</code> is implemented as a wrapper around an object
            of type <code>net.sf.saxon.NodeInfo</code>. Because this is a key interface
            within Saxon, it is exposed via this API, even though it is a Java
            interface that is not part of the API proper.</p>
               <p>The <code>XdmNode</code> interface exposes basic properties of the node, such
            as its name, its string value, and its typed value. Navigation to other nodes
            is supported through a single method, <code>EnumerateAxis</code>, which allows
            other nodes to be retrieved by following any of the XPath axes.</p>
            </div>
         </body>
      </comment>
      <property id="NodeName" type="QName" get="true">
         <comment>
            <sentence>
            The name of the node, as a <code>QName</code>. Returns null in the case of unnamed nodes.
            </sentence>
         </comment>
      </property>
      <property id="NodeKind" type="XmlNodeType" get="true">
         <comment>
            <sentence>
            The kind of node, as an instance of <code>System.Xml.XmlNodeType</code>.
            </sentence>
            <body>
               <div>
                  <p>
            The kind of node, as an instance of <code>System.Xml.XmlNodeType</code>.
            </p>
                  <p>For a namespace node in the XDM model, the value XmlNodeType.None 
            is returned.
            </p>
               </div>
            </body>
         </comment>
      </property>
      <property id="TypedValue" type="XdmValue" get="true">
         <comment>
            <sentence>
            The typed value of the node, as an instance of <code>XdmValue</code>.
            </sentence>
            
         </comment>
      </property>
      <property id="StringValue" type="String" get="true">
         <comment>
            <sentence>
            The string value of the node.
            </sentence>
         </comment>
      </property>
      <property id="Parent" type="XdmNode" get="true">
         <comment>
            <sentence>
            Get the parent of this node.
            </sentence>
            <body>
               <div>
                  <p>
            Get the parent of this node.
            </p>
                  <p>
            Returns either a document node, and element node, or null in the case where
            this node has no parent. 
            </p>
               </div>
            </body>
         </comment>
      </property>
      <property id="Root" type="XdmNode" get="true">
         <comment>
            <sentence>
            Get the root of the tree containing this node.
            </sentence>
            <body>
               <div>
                  <p>
            Get the root of the tree containing this node.
            </p>
                  <p>
            Returns the root of the tree containing this node (which might be this node itself).
            </p>
               </div>
            </body>
         </comment>
      </property>
      <property id="BaseUri" type="Uri" get="true">
         <comment>
            <sentence>
            The Base URI of the node.
            </sentence>
         </comment>
      </property>
      <property id="DocumentUri" type="Uri" get="true">
         <comment>
            <sentence>
            The Document URI of the node.
            </sentence>
         </comment>
      </property>
      <property id="OuterXml" type="String" get="true">
         <comment>
            <sentence>
            Return a serialization of this node as lexical XML
            </sentence>
            <body>
               <div>
                  <p>
            Return a serialization of this node as lexical XML
            </p>
                  <p>In the case of an element node, the result will be a well-formed
            XML document serialized as defined in the W3C XSLT/XQuery serialization specification,
            using options method="xml", indent="yes", omit-xml-declaration="yes".</p>
                  <p>In the case of a document node, the result will be a well-formed
            XML document provided that the document node contains exactly one element child,
            and no text node children. In other cases it will be a well-formed external
            general parsed entity.</p>
                  <p>In the case of an attribute node, the output is a string in the form
            <code>name="value"</code>. The name will use the original namespace prefix.</p>
                  <p>Other nodes, such as text nodes, comments, and processing instructions, are
            represented as they would appear in lexical XML.</p>
               </div>
            </body>
         </comment>
      </property>
      <property id="Implementation" type="NodeInfo" get="true">
         <comment>
            <sentence>
            Escape hatch to the underlying class in the Java implementation
            </sentence>
         </comment>
      </property>
      <methods>
         <method id="IsAtomic" visibility="public" type="bool" fulltype="bool">
            <comment>
               <sentence>
            Determine whether the item is an atomic value
            </sentence>
               <return>
                  <body>
                     <div>
            false (the item is not an atomic value)
            </div>
                  </body>
               </return>
            </comment>
            <params/>
         </method>
         <method id="GetAttributeValue"
                 visibility="public"
                 type="String"
                 fulltype="System.String">
         
            <comment>
               <sentence>
            Get a the string value of a named attribute of this element. 
            </sentence>
               <body>
                  <div>
                     <p>
            Get a the string value of a named attribute of this element. 
            </p>
                     <p>
            Returns null if this node is not an element, or if this element has no
            attribute with the specified name.
            </p>
                  </div>
               </body>
            
            </comment>
            <params>
               <param fulltype="Saxon.Api.QName" type="QName" name="name">The name of the attribute whose value is required</param>
            </params>
         </method>
         <method id="EnumerateAxis"
                 visibility="public"
                 type="IEnumerator"
                 fulltype="IEnumerator">
         
            <comment>
               <sentence>
            Get an enumerator that supplies all the nodes on one of the XPath
            axes, starting with this node.
            </sentence>
            
               <body>
                  <div>
                     <p>
            Get an enumerator that supplies all the nodes on one of the XPath
            axes, starting with this node.
            </p>
                     <p>
            The nodes are returned in axis order: that is, document order for a forwards
            axis, reverse document order for a reverse AxisInfo.
            </p>
                  </div>
               </body>
            </comment>
            <params>
               <param fulltype="Saxon.Api.XdmAxis" type="XdmAxis" name="axis">
            The axis to be navigated, for example <c>XdmAxis.Child</c> for the child AxisInfo.
            </param>
            </params>
         </method>
         <method id="EnumerateAxis"
                 visibility="public"
                 type="IEnumerator"
                 fulltype="IEnumerator">
         
         
            <comment>
               <sentence>
            Get an enumerator that selects all the nodes on one of the XPath
            axes, provided they have a given name. The nodes selected are those of the principal
            node kind (elements for most axes, attributes for the attribute axis, namespace nodes
            for the namespace axis) whose name matches the name given in the second argument.
            </sentence>
            
            
               <body>
                  <div>
                     <p>
            Get an enumerator that selects all the nodes on one of the XPath
            axes, provided they have a given name. The nodes selected are those of the principal
            node kind (elements for most axes, attributes for the attribute axis, namespace nodes
            for the namespace axis) whose name matches the name given in the second argument.
            </p>
                     <p>
            The nodes are returned in axis order: that is, document order for a forwards
            axis, reverse document order for a reverse AxisInfo.
            </p>
                  </div>
               </body>
            </comment>
            <params>
               <param fulltype="Saxon.Api.XdmAxis" type="XdmAxis" name="axis">
            The axis to be navigated, for example <c>XdmAxis.Child</c> for the child AxisInfo.
            </param>
               <param fulltype="Saxon.Api.QName" type="QName" name="nodeName">
            The name of the required nodes, for example <c>new QName("", "item")</c> to select
            nodes with local name "item", in no namespace.
            </param>
            </params>
         </method>
         <method id="WriteTo"
                 visibility="public"
                 type="void"
                 fulltype="Saxon.Api.void">
         
            <comment>
               <sentence>
            Send the node (that is, the subtree rooted at this node) to an <code>XmlWriter</code>
               </sentence>
               <body>
                  <div>
                     <p>
            Send the node (that is, the subtree rooted at this node) to an <code>XmlWriter</code>
                     </p>
                     <p>
            Note that a <c>XmlWriter</c> can only handle a well-formed XML document. This method
            will therefore signal an exception if the node is a document node with no children, or with
            more than one element child.
            </p>
                  </div>
               </body>
            
            </comment>
            <params>
               <param fulltype="System.Xml.XmlWriter" type="XmlWriter" name="writer">
            The <c>XmlWriter</c> to which the node is to be written
            </param>
            </params>
         </method>
         <method id="Equals" visibility="public" type="bool" fulltype="bool">
         
            <comment>
               <sentence>
            Two instances of XdmNode are equal if they represent the same node. That is, the Equals()
            method returns the same result as the XPath "is" operator.
            </sentence>
            
            </comment>
            <params>
               <param fulltype="object" type="object" name="obj">The object node to be compared</param>
            </params>
         </method>
         <method id="GetHashCode"
                 visibility="public"
                 type="int"
                 fulltype="Saxon.Api.int">
            <comment>
               <sentence>
            The hashCode of a node reflects the equality relationship: if two XdmNode instances
            represent the same node, then they have the same hashCode
            </sentence>
            </comment>
            <params/>
         </method>
         <method id="ToString"
                 visibility="public"
                 type="String"
                 fulltype="System.String">
            <comment>
               <sentence>
            Return a string representation of the node.
            </sentence>
               <body>
                  <div>
                     <p>
            Return a string representation of the node.
            </p>
                     <p>
            This currently returns the same as the <c>OuterXml</c> property.
            To get the string value as defined in XPath, use the <c>StringValue</c> property.
            </p>
                  </div>
               </body>
            </comment>
            <params/>
         </method>
      </methods>
   </class>
   <class id="XdmEmptySequence"
          fulltype="Saxon.Api.XdmEmptySequence"
          visibility="public"
          superclass="XdmValue"
          superclassfulltype="Saxon.Api.XdmValue">
      <comment>
         <sentence>
            The class <code>XdmEmptySequence</code> represents an empty sequence in the XDM Data Model.
            </sentence>
         <body>
            <div>
               <p>
            The class <code>XdmEmptySequence</code> represents an empty sequence in the XDM Data Model.
            </p>
               <p>An empty sequence <i>may</i> also be represented by an <code>XdmValue</code> whose length
            happens to be zero. Applications should therefore not test to see whether an object
            is an instance of this class in order to decide whether it is empty.</p>
               <p>In interfaces that expect an <code>XdmItem</code>, an empty sequence is represented
            by a CLI <code>null</code> value.</p> 
            </div>
         </body>
      </comment>
      <property id="INSTANCE" type="XdmEmptySequence" static="true">
         
      </property>
   </class>
   <class id="QName"
          fulltype="Saxon.Api.QName"
          visibility="public"
          superclass="object"
          superclassfulltype="System.Object">
      <comment>
         <sentence>
            The QName class represents an instance of xs:QName, as defined in the XPath 2.0
            data model. Internally, it has three components, a namespace URI, a local name, and
            a prefix. The prefix is intended to be used only when converting the value back to 
            a string.
            </sentence>
         <body>
            <div>
               <p>
            The QName class represents an instance of xs:QName, as defined in the XPath 2.0
            data model. Internally, it has three components, a namespace URI, a local name, and
            a prefix. The prefix is intended to be used only when converting the value back to 
            a string.
            </p>
               <p>
            Note that a QName is not itself an <c>XdmItem</c> in this model; however it can
            be wrapped in an XdmItem.
            </p>
            </div>
         </body>
      </comment>
      <property id="XS_STRING" type="QName" static="true">
         
      </property>
      <property id="XS_INTEGER" type="QName" static="true">
         
      </property>
      <property id="XS_DOUBLE" type="QName" static="true">
         
      </property>
      <property id="XS_FLOAT" type="QName" static="true">
         
      </property>
      <property id="XS_DECIMAL" type="QName" static="true">
         
      </property>
      <property id="XS_BOOLEAN" type="QName" static="true">
         
      </property>
      <property id="XS_ANYURI" type="QName" static="true">
         
      </property>
      <property id="XS_QNAME" type="QName" static="true">
         
      </property>
      <property id="XS_UNTYPED_ATOMIC" type="QName" static="true">
         
      </property>
      <property id="XDT_UNTYPED_ATOMIC" type="QName" static="true">
         
      </property>
      <property id="Prefix" type="String" get="true">
         <comment>
            <sentence>The prefix of the QName. This plays no role in operations such as comparison
            of QNames for equality, but is retained (as specified in XPath) so that a string representation
            can be reconstructed.
            </sentence>
            <body>
               <div>
                  <p>The prefix of the QName. This plays no role in operations such as comparison
            of QNames for equality, but is retained (as specified in XPath) so that a string representation
            can be reconstructed.
            </p>
                  <p>
            Returns the zero-length string in the case of a QName that has no prefix.
            </p>
               </div>
            </body>
         </comment>
      </property>
      <property id="Uri" type="String" get="true">
         <comment>
            <sentence>The namespace URI of the QName. Returns "" (the zero-length string) if the
            QName is not in a namespace.
            </sentence>
         </comment>
      </property>
      <property id="LocalName" type="String" get="true">
         <comment>
            <sentence>The local part of the QName</sentence>
         </comment>
      </property>
      <property id="ClarkName" type="String" get="true">
         <comment>
            <sentence>The expanded name, as a string using the notation devised by James Clark.
            If the name is in a namespace, the resulting string takes the form <code>{uri}local</code>.
            Otherwise, the value is the local part of the name.
            </sentence>
         </comment>
      </property>
      <methods>
         <constructor id="QName" visibility="public">
            <params>
               <param fulltype="string" type="string" name="local">The local part of the name
            </param>
            </params>
            <comment>
               <sentence>
            Construct a QName representing a name in no namespace
            </sentence>
               <body>
                  <div>
                     <p>
            Construct a QName representing a name in no namespace
            </p>
                     <p>
            This constructor does not check that the components of the QName are
            lexically valid.
            </p>
                  </div>
               </body>
            
            </comment>
         </constructor>
         <constructor id="QName" visibility="public">
            <params>
               <param fulltype="string" type="string" name="uri">The namespace URI. Use either the string "" or null
            for names that are not in any namespace.
            </param>
               <param fulltype="string" type="string" name="lexical">Either the local part of the name, or the prefix
            and local part in the format <c>prefix:local</c>
               </param>
            </params>
            <comment>
               <sentence>
            Construct a QName using a namespace URI and a lexical representation.
            The lexical representation may be a local name on its own, or it may 
            be in the form <code>prefix:local-name</code>
               </sentence>
               <body>
                  <div>
                     <p>
            Construct a QName using a namespace URI and a lexical representation.
            The lexical representation may be a local name on its own, or it may 
            be in the form <code>prefix:local-name</code>
                     </p>
                     <p>
            This constructor does not check that the components of the QName are
            lexically valid.
            </p>
                  </div>
               </body>
            
            
            </comment>
         </constructor>
         <constructor id="QName" visibility="public">
            <params>
               <param fulltype="string" type="string" name="prefix">The prefix of the name. Use either the string ""
            or null for names that have no prefix (that is, they are in the default
            namespace)</param>
               <param fulltype="string" type="string" name="uri">The namespace URI. Use either the string "" or null
            for names that are not in any namespace.
            </param>
               <param fulltype="string" type="string" name="local">The local part of the name</param>
            </params>
            <comment>
               <sentence>
            Construct a QName using a namespace prefix, a namespace URI, and a local name
            (in that order).
            </sentence>
               <body>
                  <div>
                     <p>
            Construct a QName using a namespace prefix, a namespace URI, and a local name
            (in that order).
            </p>
                     <p>
            This constructor does not check that the components of the QName are
            lexically valid.
            </p>
                  </div>
               </body>
            
            
            
            </comment>
         </constructor>
         <constructor id="QName" visibility="public">
            <params>
               <param fulltype="string" type="string" name="lexicalQName">The lexical QName, in the form <code>prefix:local</code>
            or simply <c>local</c>.</param>
               <param fulltype="Saxon.Api.XdmNode" type="XdmNode" name="element">The element node whose in-scope namespaces are to be used
            to resolve the prefix part of the lexical QName.</param>
            </params>
            <exceptions/>
            <comment>
               <sentence>
            Construct a QName from a lexical QName, supplying an element node whose
            in-scope namespaces are to be used to resolve any prefix contained in the QName.
            </sentence>
               <body>
                  <div>
                     <p>
            Construct a QName from a lexical QName, supplying an element node whose
            in-scope namespaces are to be used to resolve any prefix contained in the QName.
            </p>
                     <p>This constructor checks that the components of the QName are
            lexically valid.</p>
                     <p>If the lexical QName has no prefix, the name is considered to be in the
            default namespace, as defined by <code>xmlns="..."</code>.</p>
                     <p>If the prefix of the lexical QName is not in scope, returns null.</p>
                  </div>
               </body>
            
            
            
            
            </comment>
         </constructor>
         <constructor id="QName" visibility="public">
            <params>
               <param fulltype="System.Xml.XmlQualifiedName"
                      type="XmlQualifiedName"
                      name="qualifiedName">The XmlQualifiedName</param>
            </params>
            <comment>
               <sentence>
            Construct a <code>QName</code> from an <code>XmlQualifiedName</code> (as defined in the
            <code>System.Xml</code> package).
            </sentence>
               <body>
                  <div>
                     <p>
            Construct a <code>QName</code> from an <code>XmlQualifiedName</code> (as defined in the
            <code>System.Xml</code> package).
            </p>
                     <p>
            Note that an <c>XmlQualifiedName</c> does not contain any prefix, so the result
            will always have a prefix of ""
            </p>
                  </div>
               </body>
            
            </comment>
         </constructor>
         <method id="FromClarkName"
                 visibility="public"
                 type="QName"
                 fulltype="Saxon.Api.QName"
                 static="true">
         
            <comment>
               <sentence>
            Factory method to construct a QName from a string containing the expanded
            QName in Clark notation, that is, <code>{uri}local</code>
               </sentence>
               <body>
                  <div>
                     <p>
            Factory method to construct a QName from a string containing the expanded
            QName in Clark notation, that is, <code>{uri}local</code>
                     </p>
                     <p>
            The prefix part of the <c>QName</c> will be set to an empty string.
            </p>
                  </div>
               </body>
            
            </comment>
            <params>
               <param fulltype="string" type="string" name="expandedName">The URI in Clark notation: <c>{uri}local</c> if the
            name is in a namespace, or simply <c>local</c> if not.</param>
            </params>
         </method>
         <method id="FromEQName"
                 visibility="public"
                 type="QName"
                 fulltype="Saxon.Api.QName"
                 static="true">
         
            <comment>
               <sentence>
            Factory method to construct a QName from a string containing the expanded
            QName in EQName notation, that is, <code>Q{uri}local</code>
               </sentence>
               <body>
                  <div>
                     <p>
            Factory method to construct a QName from a string containing the expanded
            QName in EQName notation, that is, <code>Q{uri}local</code>
                     </p>
                     <p>
            The prefix part of the <c>QName</c> will be set to an empty string.
             </p>
                  </div>
               </body>
            
               <return>
                  <body>
                     <div> the QName corresponding to the supplied name in EQName notation. This will always
            have an empty prefix.</div>
                  </body>
               </return>
            </comment>
            <params>
               <param fulltype="string" type="string" name="expandedName">The URI in EQName notation: <c>{uri}local</c> if the
             name is in a namespace. For a name in no namespace, either of the
             forms <c>Q{}local</c> or simply <c>local</c> are accepted.</param>
            </params>
         </method>
         <method id="Register"
                 visibility="public"
                 type="void"
                 fulltype="Saxon.Api.void">
         
            <comment>
               <sentence>
            Register a QName with the <code>Processor</code>. This makes comparison faster
            when the QName is compared with others that are also registered with the <code>Processor</code>.
            </sentence>
               <body>
                  <div>
                     <p>
            Register a QName with the <code>Processor</code>. This makes comparison faster
            when the QName is compared with others that are also registered with the <code>Processor</code>.
            </p>
                     <p>
            A given <c>QName</c> object can only be registered with one <c>Processor</c>.
            </p>
                  </div>
               </body>
            
            </comment>
            <params>
               <param fulltype="Saxon.Api.Processor" type="Processor" name="processor">The Processor in which the name is to be registered.</param>
            </params>
         </method>
         <method id="IsValid" visibility="public" type="bool" fulltype="bool">
         
            <comment>
               <sentence>
            Validate the QName against the XML 1.0 or XML 1.1 rules for valid names.
            </sentence>
            
               <return>
                  <body>
                     <div>true if the name is valid, false if not</div>
                  </body>
               </return>
            </comment>
            <params>
               <param fulltype="Saxon.Api.Processor" type="Processor" name="processor">The Processor in which the name is to be validated.
            This determines whether the XML 1.0 or XML 1.1 rules for forming names are used.</param>
            </params>
         </method>
         <method id="ToString"
                 visibility="public"
                 type="String"
                 fulltype="System.String">
            <comment>
               <sentence>
            Convert the value to a string. The resulting string is the lexical form of the QName,
            using the original prefix if there was one.
            </sentence>
            </comment>
            <params/>
         </method>
         <method id="GetHashCode"
                 visibility="public"
                 type="int"
                 fulltype="Saxon.Api.int">
            <comment>
               <sentence>
            Get a hash code for the QName, to support equality matching. This supports the
            semantics of equality, which considers only the namespace URI and local name, and
            not the prefix.
            </sentence>
               <body>
                  <div>
                     <p>
            Get a hash code for the QName, to support equality matching. This supports the
            semantics of equality, which considers only the namespace URI and local name, and
            not the prefix.
            </p>
                     <p>
            The algorithm for allocating a hash code does not depend on registering the QName 
            with the <c>Processor</c>.
            </p>
                  </div>
               </body>
            </comment>
            <params/>
         </method>
         <method id="Equals" visibility="public" type="bool" fulltype="bool">
         
            <comment>
               <sentence>
            Test whether two QNames are equal. This supports the
            semantics of equality, which considers only the namespace URI and local name, and
            not the prefix.
            </sentence>
               <body>
                  <div>
                     <p>
            Test whether two QNames are equal. This supports the
            semantics of equality, which considers only the namespace URI and local name, and
            not the prefix.
            </p>
                     <p>
            The result of the function does not depend on registering the QName 
            with the <c>Processor</c>, but is computed more quickly if the QNames have
            both been registered
            </p>
                  </div>
               </body>
            
            </comment>
            <params>
               <param fulltype="object" type="object" name="other">The value to be compared with this QName. If this value is not a QName, the
            result is always false. Otherwise, it is true if the namespace URI and local name both match.</param>
            </params>
         </method>
         <method id="ToXmlQualifiedName"
                 visibility="public"
                 type="XmlQualifiedName"
                 fulltype="Saxon.Api.XmlQualifiedName">
            <comment>
               <sentence>
            Convert the value to an <code>XmlQualifiedName</code> (as defined in the
            <code>System.Xml</code> package)
            </sentence>
               <body>
                  <div>
                     <p>
            Convert the value to an <code>XmlQualifiedName</code> (as defined in the
            <code>System.Xml</code> package)
            </p>
                     <p>
            Note that this loses the prefix.
            </p>
                  </div>
               </body>
            </comment>
            <params/>
         </method>
      </methods>
   </class>
   <interface id="IXdmEnumerator"
              fulltype="Saxon.Api.IXdmEnumerator"
              visibility="public"
              superclass="IEnumerator"
              superclassfulltype="IEnumerator">
      <comment>
         <sentence>
            This class represents an enumeration of the values in an XPath
            sequence. It implements the IEnumerator interface, and the objects
            returned are always instances of <code>XdmItem</code>. In addition to the
            methods defined by <code>IEnumerator</code>, an additional method <code>GetAnother</code>
            must be implemented: this provides a new iterator over the same sequence
            of items, positioned at the start of the sequence.
            </sentence>
         <body>
            <div>
               <p>
            This class represents an enumeration of the values in an XPath
            sequence. It implements the IEnumerator interface, and the objects
            returned are always instances of <code>XdmItem</code>. In addition to the
            methods defined by <code>IEnumerator</code>, an additional method <code>GetAnother</code>
            must be implemented: this provides a new iterator over the same sequence
            of items, positioned at the start of the sequence.
            </p>
               <p>
            Because the underlying value can be evaluated lazily, it is possible
            for exceptions to occur as the sequence is being read.
            </p>
            </div>
         </body>
      </comment>
      <methods>
         <method id="GetAnother"
                 visibility="public"
                 type="IXdmEnumerator"
                 fulltype="Saxon.Api.IXdmEnumerator">
         
            <params/>
         </method>
      </methods>
   </interface>
   <class id="SequenceEnumerator"
          fulltype="Saxon.Api.SequenceEnumerator"
          visibility="protected"
          superclass="IXdmEnumerator"
          superclassfulltype="Saxon.Api.IXdmEnumerator">
      <comment>
         <sentence>
            This class is an implementation of <code>IXdmEnumerator</code> that wraps
            a (Java) SequenceIterator.
            </sentence>
         <body>
            <div>
               <p>
            This class is an implementation of <code>IXdmEnumerator</code> that wraps
            a (Java) SequenceIterator.
            </p>
               <p>
            Because the underlying value can be evaluated lazily, it is possible
            for exceptions to occur as the sequence is being read.
            </p>
            </div>
         </body>
      </comment>
      <property id="Current" type="object" get="true">
         <comment>
            <sentence>Return the current item in the sequence</sentence>
            <return>
               <body>
                  <div>An object which will always be an instance of <code>XdmItem</code>
                  </div>
               </body>
            </return>
         </comment>
      </property>
      <methods>
         <method id="MoveNext" visibility="public" type="bool" fulltype="bool">
            <comment>
               <sentence>Move to the next item in the sequence</sentence>
               <return>
                  <body>
                     <div>true if there are more items in the sequence</div>
                  </body>
               </return>
            </comment>
            <params/>
         </method>
         <method id="Reset"
                 visibility="public"
                 type="void"
                 fulltype="Saxon.Api.void">
            <comment>
               <sentence>Reset the enumeration so that the next call of
            <code>MoveNext</code> will position the enumeration at the
            first item in the sequence</sentence>
            </comment>
            <params/>
         </method>
         <method id="GetAnother"
                 visibility="public"
                 type="IXdmEnumerator"
                 fulltype="Saxon.Api.IXdmEnumerator">
            <comment>
               <sentence>
            Create another XdmEnumerator over the same sequence of values, positioned at the start
            of the sequence, with no change to this XdmEnumerator.
            </sentence>
               <return>
                  <body>
                     <div>
            A new XdmEnumerator over the same sequence of XDM items, positioned at the start of the sequence.
            </div>
                  </body>
               </return>
            </comment>
            <params/>
         </method>
      </methods>
   </class>
   <class id="DotNetSequenceIterator"
          fulltype="Saxon.Api.DotNetSequenceIterator"
          visibility="protected"
          superclass="JSequenceIterator"
          superclassfulltype="net.sf.saxon.om.SequenceIterator">
      <comment>
         <sentence>
            Implementation of the (Java) interface SequenceIterator that wraps
            a (.NET) IXdmEnumerator
            </sentence>
      </comment>
      <methods>
         <constructor id="DotNetSequenceIterator" visibility="public">
            <params/>
         </constructor>
         <method id="next"
                 visibility="public"
                 type="JItem"
                 fulltype="net.sf.saxon.om.Item">
         
            <params/>
         </method>
         <method id="current"
                 visibility="public"
                 type="JItem"
                 fulltype="net.sf.saxon.om.Item">
         
            <params/>
         </method>
         <method id="position"
                 visibility="public"
                 type="int"
                 fulltype="Saxon.Api.int">
         
            <params/>
         </method>
         <method id="close"
                 visibility="public"
                 type="void"
                 fulltype="Saxon.Api.void">
         
            <params/>
         </method>
         <method id="getAnother"
                 visibility="public"
                 type="SequenceIterator"
                 fulltype="Saxon.Api.SequenceIterator">
         
            <params/>
         </method>
         <method id="getProperties"
                 visibility="public"
                 type="int"
                 fulltype="Saxon.Api.int">
         
            <params/>
         </method>
      </methods>
   </class>
   <enum id="XdmAxis" fulltype="Saxon.Api.XdmAxis" visibility="public">
      <comment>
         <sentence>
            Enumeration identifying the thirteen XPath axes
            </sentence>
      </comment>
      <fields>
         <field id="Ancestor" type="" visibility="public">
            <comment>
               <sentence>The XPath ancestor axis</sentence>
            </comment>
         </field>
         <field id="AncestorOrSelf" type="" visibility="public">
            <comment>
               <sentence>The XPath ancestor-or-self axis</sentence>
            </comment>
         </field>
         <field id="Attribute" type="" visibility="public">
            <comment>
               <sentence>The XPath attribute axis</sentence>
            </comment>
         </field>
         <field id="Child" type="" visibility="public">
            <comment>
               <sentence>The XPath child axis</sentence>
            </comment>
         </field>
         <field id="Descendant" type="" visibility="public">
            <comment>
               <sentence>The XPath descendant axis</sentence>
            </comment>
         </field>
         <field id="DescendantOrSelf" type="" visibility="public">
            <comment>
               <sentence>The XPath descandant-or-self axis</sentence>
            </comment>
         </field>
         <field id="Following" type="" visibility="public">
            <comment>
               <sentence>The XPath following axis</sentence>
            </comment>
         </field>
         <field id="FollowingSibling" type="" visibility="public">
            <comment>
               <sentence>The XPath following-sibling axis</sentence>
            </comment>
         </field>
         <field id="Namespace" type="" visibility="public">
            <comment>
               <sentence>The XPath namespace axis</sentence>
            </comment>
         </field>
         <field id="Parent" type="" visibility="public">
            <comment>
               <sentence>The XPath parent axis</sentence>
            </comment>
         </field>
         <field id="Preceding" type="" visibility="public">
            <comment>
               <sentence>The XPath preceding axis</sentence>
            </comment>
         </field>
         <field id="PrecedingSibling" type="" visibility="public">
            <comment>
               <sentence>The XPath preceding-sibling axis</sentence>
            </comment>
         </field>
         <field id="Self" type="" visibility="public">
            <comment>
               <sentence>The XPath self axis</sentence>
            </comment>
         </field>
      </fields>
   </enum>
   <class id="EmptyEnumerator"
          fulltype="Saxon.Api.EmptyEnumerator"
          visibility="public"
          superclass="IXdmEnumerator"
          superclassfulltype="Saxon.Api.IXdmEnumerator">
      <comment>
         <sentence>
            An implementation of <code>IXdmEnumerator</code> that iterates over an empty sequence.
            </sentence>
      </comment>
      <property id="INSTANCE" type="EmptyEnumerator" static="true">
         
      </property>
      <property id="Current" type="object" get="true">
         
      </property>
      <methods>
         <method id="Reset"
                 visibility="public"
                 type="void"
                 fulltype="Saxon.Api.void">
         
            <params/>
         </method>
         <method id="MoveNext" visibility="public" type="bool" fulltype="bool">
         
            <params/>
         </method>
         <method id="GetAnother"
                 visibility="public"
                 type="IXdmEnumerator"
                 fulltype="Saxon.Api.IXdmEnumerator">
         
            <params/>
         </method>
      </methods>
   </class>
   <class id="SchemaManager"
          fulltype="Saxon.Api.SchemaManager"
          visibility="public"
          superclass="object"
          superclassfulltype="System.Object">
      <comment>
         <sentence>
            A <code>SchemaManager</code> is responsible for compiling schemas and
            maintaining a cache of compiled schemas that can be used for validating
            instance documents.
            </sentence>
         <body>
            <div>
               <p>
            A <code>SchemaManager</code> is responsible for compiling schemas and
            maintaining a cache of compiled schemas that can be used for validating
            instance documents.
            </p>
               <p>To obtain a <code>SchemaManager</code>, use the 
            <code>SchemaManager</code> property of the <code>Processor</code> object.</p>
               <p>In a schema-aware Processor there is exactly one
            <code>SchemaManager</code> (in a non-schema-aware Processor there is none).</p>
               <p>The cache of compiled schema definitions can include only one schema
            component (for example a type, or an element declaration) with any given name.
            An attempt to compile two different schemas in the same namespace will usually
            therefore fail.</p>
               <p>As soon as a type definition or element declaration is used for the first
            time in a validation episode, it is marked as being "sealed": this prevents subsequent
            modifications to the component. Examples of modifications that are thereby disallowed
            include adding to the substitution group of an existing element declaration, adding subtypes
            to an existing type, or redefining components using &lt;xs:redefine&gt;</p>
            </div>
         </body>
      </comment>
      <property id="XsdVersion" type="String" get="true" set="true">
         <comment>
            <sentence>
            The version of the W3C XML Schema Specification handled by this SchemaManager
            </sentence>
            <body>
               <div>
                  <p>
            The version of the W3C XML Schema Specification handled by this SchemaManager
            </p>
                  <p>The value must be "1.0" (indicating XML Schema 1.0) or "1.1" (indicating XML Schema 1.1.
            The default is "1.0". New constructs defined in XSD 1.1 are rejected unless this property
            is set to "1.1" before compiling the schema.
            </p>
               </div>
            </body>
         </comment>
      </property>
      <property id="SchemaResolver" type="SchemaResolver" get="true" set="true">
         <comment>
            <sentence>
            The SchemaResolver is a user-supplied class used for resolving references to
            schema documents. It applies to references from one schema document to another
            appearing in <code>xs:import</code>, <code>xs:include</code>, and <code>xs:redefine</code>; to
            references from an instance document to a schema in <code>xsi:schemaLocation</code> and
            <code>xsi:noNamespaceSchemaLocation</code>, to <code>xsl:import-schema</code> in XSLT, and to
            the <code>import schema</code> declaration in XQuery.
            </sentence>
         </comment>
      </property>
      <property id="ErrorList" type="IList" get="true" set="true">
         <comment>
            <sentence>
            List of errors. The caller may supply an empty list before calling Compile;
            the processor will then populate the list with error information obtained during
            the schema compilation. Each error will be included as an object of type StaticError.
            If no error list is supplied by the caller, error information will be written to
            the standard error stream.
            </sentence>
            <body>
               <div>
                  <p>
            List of errors. The caller may supply an empty list before calling Compile;
            the processor will then populate the list with error information obtained during
            the schema compilation. Each error will be included as an object of type StaticError.
            If no error list is supplied by the caller, error information will be written to
            the standard error stream.
            </p>
                  <p>By supplying a custom List with a user-written add() method, it is possible to
            intercept error conditions as they occur.</p>
                  <p>Note that this error list is used only for errors detected during the compilation
            of the schema. It is not used for errors detected when using the schema to validate
            a source document.</p>
               </div>
            </body>
         </comment>
      </property>
      <methods>
         <method id="Compile"
                 visibility="public"
                 type="void"
                 fulltype="Saxon.Api.void">
         
         
            <comment>
               <sentence>
            Compile a schema supplied as a Stream. The resulting schema components are added
            to the cache.
            </sentence>
            
            
            </comment>
            <params>
               <param fulltype="System.IO.Stream" type="Stream" name="input">A stream containing the source text of the schema. This method
            will consume the supplied stream. It is the caller's responsibility to close the stream
            after use.</param>
               <param fulltype="System.Uri" type="Uri" name="baseUri">The base URI of the schema document, for resolving any references to other
            schema documents</param>
            </params>
         </method>
         <method id="Compile"
                 visibility="public"
                 type="void"
                 fulltype="Saxon.Api.void">
         
            <comment>
               <sentence>
            Compile a schema, retrieving the source using a URI. The resulting schema components are added
            to the cache.
            </sentence>
               <body>
                  <div>
                     <p>
            Compile a schema, retrieving the source using a URI. The resulting schema components are added
            to the cache.
            </p>
                     <p>
            The document located via the URI is parsed using the <c>System.Xml</c> parser.
            </p>
                  </div>
               </body>
            
            </comment>
            <params>
               <param fulltype="System.Uri" type="Uri" name="uri">The URI identifying the location where the schema document can be
            found</param>
            </params>
         </method>
         <method id="Compile"
                 visibility="public"
                 type="void"
                 fulltype="Saxon.Api.void">
         
            <comment>
               <sentence>
            Compile a schema, delivered using an XmlReader. The resulting schema components are added
            to the cache.
            </sentence>
               <body>
                  <div>
                     <p>
            Compile a schema, delivered using an XmlReader. The resulting schema components are added
            to the cache.
            </p>
                     <p>
            The <c>XmlReader</c> is responsible for parsing the document; this method builds a tree
            representation of the document (in an internal Saxon format) and compiles it.
            The <c>XmlReader</c> is used as supplied; it is the caller's responsibility to ensure that
            its settings are appropriate for parsing a schema document (for example, that entity references
            are expanded and whitespace is retained.)
            </p>
                  </div>
               </body>
            
            </comment>
            <params>
               <param fulltype="System.Xml.XmlReader" type="XmlReader" name="reader">The XmlReader (that is, the XML parser) used to supply the source schema document</param>
            </params>
         </method>
         <method id="Compile"
                 visibility="public"
                 type="void"
                 fulltype="Saxon.Api.void">
         
            <comment>
               <sentence>
            Compile a schema document, located at an XdmNode. This may be a document node whose
            child is an <code>xs:schema</code> element, or it may be
            the <code>xs:schema</code> element itself. The resulting schema components are added
            to the cache.
            </sentence>
            
            </comment>
            <params>
               <param fulltype="Saxon.Api.XdmNode" type="XdmNode" name="node">The document node or the outermost element node of a schema document.</param>
            </params>
         </method>
         <method id="NewSchemaValidator"
                 visibility="public"
                 type="SchemaValidator"
                 fulltype="Saxon.Api.SchemaValidator">
            <comment>
               <sentence>
            Create a new <code>SchemaValidator</code>, which may be used for validating instance
            documents.
            </sentence>
               <body>
                  <div>
                     <p>
            Create a new <code>SchemaValidator</code>, which may be used for validating instance
            documents.
            </p>
                     <p>The <code>SchemaValidator</code> uses the cache of schema components held by the
            <code>SchemaManager</code>. It may also add new components to this cache (for example,
            when the instance document references a schema using <code>xsi:schemaLocation</code>).
            It is also affected by changes to the schema cache that occur after the 
            <code>SchemaValidator</code> is created.</p>
                     <p>When schema components are used for validating instance documents (or for compiling
            schema-aware queries and stylesheets) they are <i>sealed</i> to prevent subsequent modification.
            The modifications disallowed once a component is sealed include adding to the substitution group
            of an element declaration, adding subtypes derived by extension to an existing complex type, and
            use of <code>&lt;xs:redefine&gt;</code>
                     </p>
                  </div>
               </body>
            </comment>
            <params/>
         </method>
         <method id="GetAtomicType"
                 visibility="public"
                 type="XdmAtomicType"
                 fulltype="Saxon.Api.XdmAtomicType">
         
            <comment>
               <sentence>
            Factory method to get an <code>AtomicType</code> object representing the atomic type with a given QName.
            </sentence>
               <body>
                  <div>
                     <p>
            Factory method to get an <code>AtomicType</code> object representing the atomic type with a given QName.
            </p>
                     <p>
            It is undefined whether two calls on this method supplying the same QName will return the same
            <c>XdmAtomicType</c> object instance.
            </p>
                  </div>
               </body>
            
               <return>
                  <body>
                     <div>An <code>AtomicType</code> object representing this type if it is present in this schema (and is an
            atomic type); otherwise, null. </div>
                  </body>
               </return>
            </comment>
            <params>
               <param fulltype="Saxon.Api.QName" type="QName" name="qname">The QName of the required type</param>
            </params>
         </method>
      </methods>
   </class>
   <class id="SchemaValidator"
          fulltype="Saxon.Api.SchemaValidator"
          visibility="public"
          superclass="object"
          superclassfulltype="System.Object">
      <comment>
         <sentence>
            A <code>SchemaValidator</code> is an object that is used for validating instance documents
            against a schema. The schema consists of the collection of schema components that are
            available within the schema cache maintained by the <code>SchemaManager</code>, together with
            any additional schema components located during the course of validation by means of an
            <code>xsl:schemaLocation</code> or <code>xsi:noNamespaceSchemaLocation</code> attribute within the
            instance document.
            </sentence>
         <body>
            <div>
               <p>
            A <code>SchemaValidator</code> is an object that is used for validating instance documents
            against a schema. The schema consists of the collection of schema components that are
            available within the schema cache maintained by the <code>SchemaManager</code>, together with
            any additional schema components located during the course of validation by means of an
            <code>xsl:schemaLocation</code> or <code>xsi:noNamespaceSchemaLocation</code> attribute within the
            instance document.
            </p>
               <p>
            If validation fails, an exception is thrown. If validation succeeds, the validated
            document can optionally be written to a specified destination. This will be a copy of
            the original document, augmented with default values for absent elements and attributes,
            and carrying type annotations derived from the schema processing. Saxon does not deliver
            the full PSVI as described in the XML schema specifications, only the subset of the
            PSVI properties featured in the XDM data model.
            </p>
            </div>
         </body>
      </comment>
      <property id="IsLax" type="bool" get="true" set="true">
         <comment>
            <sentence>
            The validation mode may be either strict or lax. The default is strict;
            this property is set to indicate that lax validation is required. With strict validation,
            validation fails if no element declaration can be located for the outermost element. With lax
            validation, the absence of an element declaration results in the content being considered valid.
            </sentence>
         </comment>
      </property>
      <property id="UseXsiSchemaLocation" type="Boolean" get="true" set="true">
         <comment>
            <sentence>
            This property defines whether the schema processor will recognize, and attempt to
            dereference, any <code>xsi:schemaLocation</code> and <code>xsi:noNamespaceSchemaLocation</code>
            attributes encountered in the instance document. The default value is true.
            </sentence>
         </comment>
      </property>
      <property id="ErrorList" type="IList" get="true" set="true">
         <comment>
            <sentence>
            List of errors. The caller may supply an empty list before calling Compile;
            the processor will then populate the list with error information obtained during
            the schema compilation. Each error will be included as an object of type StaticError.
            If no error list is supplied by the caller, error information will be written to
            the standard error stream.
            </sentence>
            <body>
               <div>
                  <p>
            List of errors. The caller may supply an empty list before calling Compile;
            the processor will then populate the list with error information obtained during
            the schema compilation. Each error will be included as an object of type StaticError.
            If no error list is supplied by the caller, error information will be written to
            the standard error stream.
            </p>
                  <p>By supplying a custom List with a user-written add() method, it is possible to
            intercept error conditions as they occur.</p>
                  <p>Note that this error list is used only for errors detected while 
            using the schema to validate a source document. It is not used to report errors
            in the schema itself.</p>
               </div>
            </body>
         </comment>
      </property>
      <methods>
         <method id="SetSource"
                 visibility="public"
                 type="void"
                 fulltype="Saxon.Api.void">
         
         
            <comment>
               <sentence>
            Supply the instance document to be validated in the form of a Stream
            </sentence>
            
            
            </comment>
            <params>
               <param fulltype="System.IO.Stream" type="Stream" name="source">A stream containing the XML document to be parsed
            and validated. This stream will be consumed by the validation process,
            but it will not be closed after use: that is the responsibility of the
            caller.</param>
               <param fulltype="System.Uri" type="Uri" name="baseUri">The base URI to be used for resolving any relative
            references, for example a reference to an <c>xsi:schemaLocation</c>
               </param>
            </params>
         </method>
         <method id="SetSource"
                 visibility="public"
                 type="void"
                 fulltype="Saxon.Api.void">
         
            <comment>
               <sentence>
            Supply the instance document to be validated in the form of a Uri reference
            </sentence>
            
            </comment>
            <params>
               <param fulltype="System.Uri" type="Uri" name="uri">URI of the document to be validated</param>
            </params>
         </method>
         <method id="SetSource"
                 visibility="public"
                 type="void"
                 fulltype="Saxon.Api.void">
         
            <comment>
               <sentence>
            Supply the instance document to be validated, in the form of an XmlReader.
            </sentence>
               <body>
                  <div>
                     <p>
            Supply the instance document to be validated, in the form of an XmlReader.
            </p>
                     <p>
            The XmlReader is responsible for parsing the document; this method validates it.
            </p>
                  </div>
               </body>
            
            </comment>
            <params>
               <param fulltype="System.Xml.XmlReader" type="XmlReader" name="reader">The <c>XmlReader</c> used to read and parse the instance
            document being validated. This is used as supplied. For conformance, use of a
            plain <c>XmlTextReader</c> is discouraged, because it does not expand entity
            references. This may cause validation failures.
            </param>
            </params>
         </method>
         <method id="SetSource"
                 visibility="public"
                 type="void"
                 fulltype="Saxon.Api.void">
         
            <comment>
               <sentence>
            Supply the instance document to be validated in the form of an XdmNode
            </sentence>
               <body>
                  <div>
                     <p>
            Supply the instance document to be validated in the form of an XdmNode
            </p>
                     <p>The supplied node must be either a document node or an element node.
            If an element node is supplied, then the subtree rooted at this element is
            validated as if it were a complete document: that is, it must not only conform
            to the structure required of that element, but any referential constraints
            (keyref, IDREF) must be satisfied within that subtree.
            </p>
                  </div>
               </body>
            
            </comment>
            <params>
               <param fulltype="Saxon.Api.XdmNode" type="XdmNode" name="source">The document or element node at the root of the tree
            to be validated</param>
            </params>
         </method>
         <method id="SetDestination"
                 visibility="public"
                 type="void"
                 fulltype="Saxon.Api.void">
         
            <comment>
               <sentence>
            Supply the destination to hold the validated document. If no destination
            is supplied, the validated document is discarded.
            </sentence>
               <body>
                  <div>
                     <p>
            Supply the destination to hold the validated document. If no destination
            is supplied, the validated document is discarded.
            </p>
                     <p>
            The destination differs from the source in that (a) default values of missing
            elements and attributes are supplied, and (b) the typed values of elements and
            attributes are available. However, typed values can only be accessed if the result
            is represented using the XDM data model, that is, if the destination is supplied
            as an XdmDestination.
            </p>
                  </div>
               </body>
            
            </comment>
            <params>
               <param fulltype="Saxon.Api.XmlDestination"
                      type="XmlDestination"
                      name="destination">
            The destination to hold the validated document.
            </param>
            </params>
         </method>
         <method id="Run"
                 visibility="public"
                 type="void"
                 fulltype="Saxon.Api.void">
            <comment>
               <sentence>
            Run the validation of the supplied source document, optionally
            writing the validated document to the supplied destination.
            </sentence>
            </comment>
            <params/>
         </method>
      </methods>
   </class>
   <interface id="SchemaResolver"
              fulltype="Saxon.Api.SchemaResolver"
              visibility="public"
              superclass="object"
              superclassfulltype="System.Object">
      <comment>
         <sentence>
            The SchemaResolver is a user-supplied class used for resolving references to
            schema documents. It applies to references from one schema document to another
            appearing in <code>xs:import</code>, <code>xs:include</code>, and <code>xs:redefine</code>; to
            references from an instance document to a schema in <code>xsi:schemaLocation</code> and
            <code>xsi:noNamespaceSchemaLocation</code>, to <code>xsl:import-schema</code> in XSLT, and to
            the <code>import schema</code> declaration in XQuery.
            </sentence>
      </comment>
      <methods>
         <method id="GetSchemaDocuments"
                 visibility="public"
                 type="Uri[]"
                 fulltype="Saxon.Api.Uri[]">
         
         
         
         
            <params>
               <param fulltype="string" type="string"/>
               <param fulltype="System.Uri" type="Uri"/>
               <param fulltype="System.String[]" type="String[]"/>
            </params>
         </method>
         <method id="GetEntity"
                 visibility="public"
                 type="Object"
                 fulltype="Saxon.Api.Object">
         
         
            <params>
               <param fulltype="System.Uri" type="Uri"/>
            </params>
         </method>
      </methods>
   </interface>
   <class id="DotNetSchemaURIResolver"
          fulltype="Saxon.Api.DotNetSchemaURIResolver"
          visibility="protected"
          superclass="net.sf.saxon.lib.SchemaURIResolver"
          superclassfulltype="Saxon.Api.net.sf.saxon.lib.SchemaURIResolver">
      <methods>
         <constructor id="DotNetSchemaURIResolver" visibility="public">
            <params/>
         </constructor>
         <method id="setConfiguration"
                 visibility="public"
                 type="void"
                 fulltype="Saxon.Api.void">
         
            <params/>
         </method>
         <method id="resolve"
                 visibility="public"
                 type="Source[]"
                 fulltype="Saxon.Api.Source[]">
         
            <params/>
         </method>
      </methods>
   </class>
   <class id="XdmItemType"
          fulltype="Saxon.Api.XdmItemType"
          visibility="public"
          superclass="object"
          superclassfulltype="System.Object"
          abstract="true">
      <comment>
         <sentence>
            Abstract class representing an item type. This may be the generic item type <code>item()</code>,
            an atomic type, the generic node type <code>node()</code>, a specific node kind such as
            <code>element()</code> or <code>text()</code>, or the generic function type <code>function()</code>.
            </sentence>
         <body>
            <div>
               <p>
            Abstract class representing an item type. This may be the generic item type <code>item()</code>,
            an atomic type, the generic node type <code>node()</code>, a specific node kind such as
            <code>element()</code> or <code>text()</code>, or the generic function type <code>function()</code>.
            </p>
               <p>
            More specific node types (such as <c>element(E)</c> or <c>schema-element(E)</c> cannot currently
            be instantiated in this API.
            </p>
            </div>
         </body>
      </comment>
   </class>
   <class id="XdmAnyItemType"
          fulltype="Saxon.Api.XdmAnyItemType"
          visibility="public"
          superclass="XdmItemType"
          superclassfulltype="Saxon.Api.XdmItemType">
      <comment>
         <sentence>
            Singleton class representing the item type item(), which matches any item.
            </sentence>
      </comment>
      <property id="Instance" type="XdmAnyItemType" static="true">
         
      </property>
   </class>
   <class id="XdmAnyNodeType"
          fulltype="Saxon.Api.XdmAnyNodeType"
          visibility="public"
          superclass="XdmItemType"
          superclassfulltype="Saxon.Api.XdmItemType">
      <comment>
         <sentence>
            Singleton class representing the item type node(), which matches any node.
            </sentence>
      </comment>
      <property id="Instance" type="XdmAnyNodeType" static="true">
         
      </property>
   </class>
   <class id="XdmAnyFunctionType"
          fulltype="Saxon.Api.XdmAnyFunctionType"
          visibility="public"
          superclass="XdmItemType"
          superclassfulltype="Saxon.Api.XdmItemType">
      <comment>
         <sentence>
            Singleton class representing the item type function(), which matches any function item.
            </sentence>
      </comment>
      <property id="Instance" type="XdmAnyFunctionType" static="true">
         
      </property>
   </class>
   <class id="XdmAtomicType"
          fulltype="Saxon.Api.XdmAtomicType"
          visibility="public"
          superclass="XdmItemType"
          superclassfulltype="Saxon.Api.XdmItemType">
      <comment>
         <sentence>
            An instance of class <code>XdmAtomicType</code> represents a specific atomic type, for example
            <code>xs:double</code>, <code>xs:integer</code>, or <code>xs:anyAtomicType</code>. This may be either a built-in
            atomic type or a type defined in a user-written schema.
            </sentence>
         <body>
            <div>
               <p>
            An instance of class <code>XdmAtomicType</code> represents a specific atomic type, for example
            <code>xs:double</code>, <code>xs:integer</code>, or <code>xs:anyAtomicType</code>. This may be either a built-in
            atomic type or a type defined in a user-written schema.
            </p>
               <p>
            To get an <c>XdmAtomicType</c> instance representing a built-in atomic type, use one of the predefined instances
            of the subclass <c>XdmBuiltInAtomicType</c>. To get an <c>XdmAtomicType</c> instance representing a user-defined
            atomic type (defined in a schema), use the method <c>GetAtomicType</c> defined on the <c>SchemaManager</c> class.
            </p>
            </div>
         </body>
      </comment>
      <property id="Name" type="QName" get="true">
         <comment>
            <sentence>
            The name of the atomic type, or null if the type is anonymous
            </sentence>
         </comment>
      </property>
      <methods>
         <method id="BuiltInAtomicType"
                 visibility="public"
                 type="XdmAtomicType"
                 fulltype="Saxon.Api.XdmAtomicType"
                 static="true">
         
            <comment>
               <sentence>
            Get an XdmAtomicType object representing a built-in atomic type with a given name
            </sentence>
            
               <return>
                  <body>
                     <div>An XdmAtomicType object representing the built-in atomic type with the supplied name.
            Returns null if there is no built-in atomic type with this name.
            It is undefined whether two requests for the same built-in type will return the same object.</div>
                  </body>
               </return>
            </comment>
            <params>
               <param fulltype="Saxon.Api.QName" type="QName" name="name">The name of the required built-in atomic type</param>
            </params>
         </method>
      </methods>
   </class>
   <class id="XdmNodeKind"
          fulltype="Saxon.Api.XdmNodeKind"
          visibility="public"
          superclass="XdmItemType"
          superclassfulltype="Saxon.Api.XdmItemType">
      <comment>
         <sentence>
            Instances of <code>XdmNodeKind</code> represent the item types denoted in XPath as <code>document-node()</code>,
            <code>element()</code>, <code>attribute()</code>, <code>text()</code>, and so on. These are all represented by singular named instances.
            </sentence>
      </comment>
      <property id="Document" type="XdmNodeKind" static="true">
         
      </property>
      <property id="Element" type="XdmNodeKind" static="true">
         
      </property>
      <property id="Attribute" type="XdmNodeKind" static="true">
         
      </property>
      <property id="Text" type="XdmNodeKind" static="true">
         
      </property>
      <property id="Comment" type="XdmNodeKind" static="true">
         
      </property>
      <property id="ProcessingInstruction" type="XdmNodeKind" static="true">
         
      </property>
      <property id="Namespace" type="XdmNodeKind" static="true">
         
      </property>
      <methods>
         <method id="ForNode"
                 visibility="public"
                 type="XdmNodeKind"
                 fulltype="Saxon.Api.XdmNodeKind"
                 static="true">
         
            <comment>
               <sentence>
            Get the item type representing the node kind of a supplied node
            </sentence>
            
               <return>
                  <body>
                     <div>The relevant node kind</div>
                  </body>
               </return>
            </comment>
            <params>
               <param fulltype="Saxon.Api.XdmNode" type="XdmNode" name="node">The node whose node kind is required</param>
            </params>
         </method>
         <method id="ForNodeType"
                 visibility="public"
                 type="XdmNodeKind"
                 fulltype="Saxon.Api.XdmNodeKind"
                 static="true">
         
            <comment>
               <sentence>
            Get the item type corresponding to an <code>XmlNodeType</code> as defined in the System.Xml package
            </sentence>
            
               <return>
                  <body>
                     <div>The corresponding <code>XdmNodeKind</code>
                     </div>
                  </body>
               </return>
            </comment>
            <params>
               <param fulltype="System.Xml.XmlNodeType" type="XmlNodeType" name="type">The <c>XmlNodeType</c> to be converted</param>
            </params>
         </method>
      </methods>
   </class>
   <class id="XdmSequenceType"
          fulltype="Saxon.Api.XdmSequenceType"
          visibility="public"
          superclass="object"
          superclassfulltype="System.Object">
      <comment>
         <sentence>
            An instance of class <code>XdmSequenceType</code> represents a sequence type, that is, the combination
            of an item type and an occurrence indicator.
            </sentence>
      </comment>
      <property id="ZERO_OR_MORE" type="char">
         
      </property>
      <property id="ONE_OR_MORE" type="char">
         
      </property>
      <property id="ZERO_OR_ONE" type="char">
         
      </property>
      <property id="ZERO" type="char">
         
      </property>
      <property id="ONE" type="char">
         
      </property>
      <methods>
         <constructor id="XdmSequenceType" visibility="public">
            <params>
               <param fulltype="Saxon.Api.XdmItemType" type="XdmItemType" name="itemType">The item type</param>
               <param fulltype="System.Char" type="Char" name="occurrenceIndicator">The occurrence indicator, one of '?' (zero-or-one), 
            '*' (zero-or-more), '+' (one-or-more), ' ' (a single space) (exactly one),
            or 'º' (masculine ordinal indicator, xBA) (exactly zero). The type empty-sequence()
            can be represented by an occurrence indicator of 'º' with any item type.</param>
            </params>
            <comment>
               <sentence>
            Create an XdmSequenceType corresponding to a given XdmItemType and occurrence indicator
            </sentence>
            
            
            </comment>
         </constructor>
      </methods>
   </class>
   <class id="XPathCompiler"
          fulltype="Saxon.Api.XPathCompiler"
          visibility="public"
          superclass="object"
          superclassfulltype="System.Object">
      <comment>
         <sentence>
            An XPathCompiler object allows XPath queries to be compiled.
            The compiler holds information that represents the static context
            for the expression.
            </sentence>
         <body>
            <div>
               <p>
            An XPathCompiler object allows XPath queries to be compiled.
            The compiler holds information that represents the static context
            for the expression.
            </p>
               <p>To construct an XPathCompiler, use the factory method
            <code>newXPathCompiler</code> on the <code>Processor</code> object.</p>
               <p>An XPathCompiler may be used repeatedly to compile multiple
            queries. Any changes made to the XPathCompiler (that is, to the
            static context) do not affect queries that have already been compiled.
            An XPathCompiler may be used concurrently in multiple threads, but
            it should not then be modified once initialized.</p>
               <p> The <code>XPathCompiler</code> has the ability to maintain a cache of compiled
            expressions. This is active only if enabled by setting the <code>Caching</code> property.
            If caching is enabled, then the compiler will recognize an attempt to compile
            the same expression twice, and will avoid the cost of recompiling it. The cache
            is emptied by any method that changes the static context for subsequent expressions,
            for example, by setting the <code>BaseUri</code> property. Unless the cache is emptied,
            it grows indefinitely: compiled expressions are never discarded.</p>
            </div>
         </body>
      </comment>
      <property id="Processor" type="Processor" get="true" set="true">
         <comment>
            <sentence>
            Get the Processor from which this XPathCompiler was constructed
            </sentence>
         </comment>
      </property>
      <property id="AllowUndeclaredVariables"
                type="Boolean"
                get="true"
                set="true">
         <comment>
            <sentence>
            This property indicates whether the XPath expression may contain references to variables that have not been
            explicitly declared by calling <code>DeclareVariable</code>. The property is false by default (that is, variables
            must be declared).
            </sentence>
            <body>
               <div>
                  <p>
            This property indicates whether the XPath expression may contain references to variables that have not been
            explicitly declared by calling <code>DeclareVariable</code>. The property is false by default (that is, variables
            must be declared).
            </p>
                  <p>
            If undeclared variables are permitted, then it is possible to determine after compiling the expression which
            variables it refers to by calling the method <c>EnumerateExternalVariables</c> on the <c>XPathExecutable</c> object.
            </p>
               </div>
            </body>
         </comment>
      </property>
      <property id="SchemaAware" type="Boolean" get="true" set="true">
         <comment>
            <sentence>
            Say whether XPath expressions compiled using this XPathCompiler are
            schema-aware. They will automatically be schema-aware if the method
            {@link #importSchemaNamespace(String)} is called. An XPath expression
            must be marked as schema-aware if it is to handle typed (validated)
            input documents.
            </sentence>
         </comment>
      </property>
      <property id="XPathLanguageVersion" type="string" get="true" set="true">
         <comment>
            <sentence>
            This property indicates which version of XPath language syntax is accepted. The default
            value is "1.0". This property must be set to "3.0" before compiling a query that
            uses XPath 3.0 (formerly known as XPath 2.1) syntax.
            </sentence>
            <body>
               <div>
                  <p>
            This property indicates which version of XPath language syntax is accepted. The default
            value is "1.0". This property must be set to "3.0" before compiling a query that
            uses XPath 3.0 (formerly known as XPath 2.1) syntax.
            </p>
                  <p>Support for XPath 3.0 is currently limited: for details see the Saxon documentation.</p>
                  <p>
                     <i>Property added in Saxon 9.4</i>
                  </p>
               </div>
            </body>
         </comment>
      </property>
      <property id="ContextItemType" type="XdmItemType" get="true" set="true">
         <comment>
            <sentence>
            The required context item type for the expression. This is used for
            optimizing the expression at compile time, and to check at run-time
            that the value supplied for the context item is the correct type.
            </sentence>
         </comment>
      </property>
      <property id="BaseUri" type="String" get="true" set="true">
         <comment>
            <sentence>
            The base URI of the expression, which forms part of the static context
            of the expression. This is used for resolving any relative URIs appearing
            within the expression, for example in references to library modules, schema
            locations, or as an argument to the <code>doc()</code> function.
            </sentence>
         </comment>
      </property>
      <property id="BackwardsCompatible" type="Boolean" get="true" set="true">
         <comment>
            <sentence>
            XPath 1.0 Backwards Compatibility Mode. If true, backwards compatibility mode
            is set. In backwards compatibility mode, more implicit type conversions are
            allowed in XPath expressions, for example it is possible to compare a number
            with a string. The default is false (backwards compatibility mode is off).
            </sentence>
         </comment>
      </property>
      <property id="Caching" type="Boolean" get="true" set="true">
         <comment>
            <sentence>
            XPath 1.0 Backwards Compatibility Mode. If true, backwards compatibility mode
            is set. In backwards compatibility mode, more implicit type conversions are
            allowed in XPath expressions, for example it is possible to compare a number
            with a string. The default is false (backwards compatibility mode is off).
            </sentence>
         </comment>
      </property>
      <methods>
         <method id="DeclareCollation"
                 visibility="public"
                 type="void"
                 fulltype="Saxon.Api.void">
         
         
         
         
            <comment>
               <sentence>
            Create a collation based on a given <code>CompareInfo</code> and <code>CompareOptions</code>    
               </sentence>
            
            
            
            
            </comment>
            <params>
               <param fulltype="System.Uri" type="Uri" name="uri">The collation URI to be used within the XPath expression to refer to this collation</param>
               <param fulltype="System.Globalization.CompareInfo"
                      type="CompareInfo"
                      name="compareInfo">The <c>CompareInfo</c>, which determines the language-specific
            collation rules to be used</param>
               <param fulltype="System.Globalization.CompareOptions"
                      type="CompareOptions"
                      name="options">Options to be used in performing comparisons, for example
            whether they are to be case-blind and/or accent-blind</param>
               <param fulltype="bool" type="bool" name="isDefault">If true, this collation will be used as the default collation</param>
            </params>
         </method>
         <method id="DeclareNamespace"
                 visibility="public"
                 type="void"
                 fulltype="Saxon.Api.void">
         
         
            <comment>
               <sentence>
            Declare a namespace for use by the XPath expression.
            </sentence>
            
            
            </comment>
            <params>
               <param fulltype="string" type="string" name="prefix">The namespace prefix to be declared. Use
            a zero-length string to declare the default namespace (that is, the
            default namespace for elements and types).</param>
               <param fulltype="string" type="string" name="uri">The namespace URI. It is possible to specify
            a zero-length string to "undeclare" a namespace.</param>
            </params>
         </method>
         <method id="GetNamespaceURI"
                 visibility="public"
                 type="string"
                 fulltype="System.String">
         
            <params/>
         </method>
         <method id="ImportSchemaNamespace"
                 visibility="public"
                 type="void"
                 fulltype="Saxon.Api.void">
         
            <comment>
               <sentence>
            Import schema definitions for a specified namespace. That is, add the element and attribute declarations and type definitions
            contained in a given namespace to the static context for the XPath expression.
            </sentence>
               <body>
                  <div>
                     <p>
            Import schema definitions for a specified namespace. That is, add the element and attribute declarations and type definitions
            contained in a given namespace to the static context for the XPath expression.
            </p>
                     <p>This method will not cause the schema to be loaded. That must be done separately, using the
            <code>SchemaManager</code>}. This method will not fail if the schema has not been loaded (but in that case
            the set of declarations and definitions made available to the XPath expression is empty). The schema
            document for the specified namespace may be loaded before or after this method is called.
            </p>
                     <p>
            This method does not bind a prefix to the namespace. That must be done separately, using the
            <code>declareNamespace</code> method.
            </p>
                  </div>
               </body>
            
            </comment>
            <params>
               <param fulltype="string" type="string" name="uri">The namespace URI whose declarations and type definitions are to
            be made available for use within the XPath expression.</param>
            </params>
         </method>
         <method id="SetDecimalFormatProperty"
                 visibility="public"
                 type="void"
                 fulltype="Saxon.Api.void">
         
         
         
            <comment>
               <sentence>
            Sets a property of a selected decimal format, for use by the <code>format-number</code> function.
            </sentence>
               <body>
                  <div>
                     <p>
            Sets a property of a selected decimal format, for use by the <code>format-number</code> function.
            </p>
                     <p>
            This method checks that the value is valid for the particular property, but it does not
            check that all the values for the decimal format are consistent (for example, that the
            decimal separator and grouping separator have different values). This consistency
            check is performed only when the decimal format is used.
            </p>
                  </div>
               </body>
            
            
            
            </comment>
            <params>
               <param fulltype="Saxon.Api.QName" type="QName" name="format">The name of the decimal format whose property is to be set.
             Supply null to set a property of the default (unnamed) decimal format.
             This correponds to a name used in the third argument of <c>format-number</c>.</param>
               <param fulltype="string" type="string" name="property">The name of the property to set: one of
              "decimal-separator", "grouping-separator", "infinity", "NaN",
              "minus-sign", "percent", "per-mille", "zero-digit", "digit",
              or "pattern-separator".</param>
               <param fulltype="string" type="string" name="value">The new value for the property.</param>
            </params>
         </method>
         <method id="DeclareVariable"
                 visibility="public"
                 type="void"
                 fulltype="Saxon.Api.void">
         
            <comment>
               <sentence>
            Declare a variable for use by the XPath expression. If the expression
            refers to any variables, then they must be declared here, unless the
            <code>AllowUndeclaredVariables</code> property has been set to true.
            </sentence>
            
            </comment>
            <params>
               <param fulltype="Saxon.Api.QName" type="QName" name="name">The name of the variable, as a <c>QName</c>
               </param>
            </params>
         </method>
         <method id="Compile"
                 visibility="public"
                 type="XPathExecutable"
                 fulltype="Saxon.Api.XPathExecutable">
         
            <comment>
               <sentence>
            Compile an expression supplied as a String.
            </sentence>
               <div class="example">
                  <code>
            XPathExecutable q = compiler.Compile("distinct-values(//*/node-name()");
            </code>
               </div>
            
               <return>
                  <body>
                     <div>An <code>XPathExecutable</code> which represents the compiled xpath expression object.
            The XPathExecutable may be run as many times as required, in the same or a different
            thread. The <code>XPathExecutable</code> is not affected by any changes made to the <code>XPathCompiler</code>
            once it has been compiled.</div>
                  </body>
               </return>
            
            </comment>
            <params>
               <param fulltype="string" type="string" name="source">A string containing the source text of the XPath expression</param>
            </params>
            <exceptions/>
         </method>
         <method id="Evaluate"
                 visibility="public"
                 type="XdmValue"
                 fulltype="Saxon.Api.XdmValue">
         
         
            <comment>
               <sentence>
            Compile and execute an expression supplied as a String, with a given context item.
            </sentence>
            
            
               <return>
                  <body>
                     <div>An <code>XdmValue</code> which is the result of evaluating the XPath expression.</div>
                  </body>
               </return>
            
            
            </comment>
            <params>
               <param fulltype="string" type="string" name="expression">A string containing the source text of the XPath expression</param>
               <param fulltype="Saxon.Api.XdmItem" type="XdmItem" name="contextItem">The context item to be used for evaluation of the XPath expression.
            May be null, in which case the expression is evaluated without any context item.</param>
            </params>
            <exceptions/>
         </method>
         <method id="EvaluateSingle"
                 visibility="public"
                 type="XdmItem"
                 fulltype="Saxon.Api.XdmItem">
         
         
            <comment>
               <sentence>
            Compile and execute an expression supplied as a String, with a given context item, where
            the expression is expected to return a single item as its result
            </sentence>
            
            
               <return>
                  <body>
                     <div>If the XPath expression returns a singleton, then the the <code>XdmItem</code> 
            which is the result of evaluating the XPath expression. If the expression returns an empty sequence,
            then null. If the expression returns a sequence containing more than one item, then the first
            item in the result.</div>
                  </body>
               </return>
            
            
            </comment>
            <params>
               <param fulltype="string" type="string" name="expression">A string containing the source text of the XPath expression</param>
               <param fulltype="Saxon.Api.XdmItem" type="XdmItem" name="contextItem">The context item to be used for evaluation of the XPath expression.
            May be null, in which case the expression is evaluated without any context item.</param>
            </params>
            <exceptions/>
         </method>
      </methods>
   </class>
   <class id="XPathExecutable"
          fulltype="Saxon.Api.XPathExecutable"
          visibility="public"
          superclass="object"
          superclassfulltype="System.Object">
      <comment>
         <sentence>
            An <code>XPathExecutable</code> represents the compiled form of an XPath expression. 
            To evaluate the expression,
            it must first be loaded to form an <code>XPathSelector</code>.
            </sentence>
         <body>
            <div>
               <p>
            An <code>XPathExecutable</code> represents the compiled form of an XPath expression. 
            To evaluate the expression,
            it must first be loaded to form an <code>XPathSelector</code>.
            </p>
               <p>An <code>XPathExecutable</code> is immutable, and therefore thread-safe. It is simplest to
            load a new <code>XPathSelector</code> each time the expression is to be evaluated. However, the 
            <code>XPathSelector</code> is serially reusable within a single thread.</p>
               <p>An <code>XPathExecutable</code> is created by using one of the <code>Compile</code>
            methods on the <code>XPathCompiler</code> class.</p>
            </div>
         </body>
      </comment>
      <methods>
         <method id="EnumerateExternalVariables"
                 visibility="public"
                 type="IEnumerator"
                 fulltype="IEnumerator">
            <comment>
               <sentence>
            Get a list of external variables used by the expression. This will include both variables that were explicitly
            declared to the <code>XPathCompiler</code>, and (if the <code>AllowUndeclaredVariables</code> option was set) variables that
            are referenced within the expression but not explicitly declared.
            </sentence>
               <return>
                  <body>
                     <div>
            An IEnumerator over the names of the external variables, as instances of <code>QName</code>.</div>
                  </body>
               </return>
            </comment>
            <params/>
         </method>
         <method id="GetRequiredCardinalityForVariable"
                 visibility="public"
                 type="char"
                 fulltype="Saxon.Api.char">
         
            <comment>
               <sentence>
            Get the required cardinality of a declared variable in the static context of the expression.
            The occurrence indicator, one of '?' (zero-or-one), 
            '*' (zero-or-more), '+' (one-or-more), ' ' (a single space) (exactly one),
            or 'º' (masculine ordinal indicator, xBA) (exactly zero). The type empty-sequence()
            can be represented by an occurrence indicator of 'º' with any item type.
            If the variable was explicitly declared, this will be the occurrence indicator that was set when the
            variable was declared. If no item type was set, it will be {@link OccurrenceIndicator#ZERO_OR_MORE}.
            If the variable was implicitly declared by reference (which can happen only when the
            allowUndeclaredVariables option is set), the returned type will be
            {@link OccurrenceIndicator#ZERO_OR_MORE}.
            If no variable with the specified QName has been declared either explicitly or implicitly,
            the method returns 0.
            </sentence>
            
               <return>
                  <body>
                     <div>the required cardinality.</div>
                  </body>
               </return>
            </comment>
            <params>
               <param fulltype="Saxon.Api.QName" type="QName" name="variableName">the name of a declared variable</param>
            </params>
         </method>
         <method id="Load"
                 visibility="public"
                 type="XPathSelector"
                 fulltype="Saxon.Api.XPathSelector">
            <comment>
               <sentence>
            Load the compiled XPath expression to prepare it for execution.
            </sentence>
               <return>
                  <body>
                     <div>
            An <code>XPathSelector</code>. The returned <code>XPathSelector</code> can be used to
            set up the dynamic context, and then to evaluate the expression.
            </div>
                  </body>
               </return>
            </comment>
            <params/>
         </method>
      </methods>
   </class>
   <class id="XPathSelector"
          fulltype="Saxon.Api.XPathSelector"
          visibility="public"
          superclass="IEnumerable"
          superclassfulltype="Saxon.Api.IEnumerable">
      <comment>
         <sentence>
            An <code>XPathSelector</code> represents a compiled and loaded XPath expression ready for execution.
            The <code>XPathSelector</code> holds details of the dynamic evaluation context for the XPath expression.
            </sentence>
         <body>
            <div>
               <p>
            An <code>XPathSelector</code> represents a compiled and loaded XPath expression ready for execution.
            The <code>XPathSelector</code> holds details of the dynamic evaluation context for the XPath expression.
            </p>
               <p>An <code>XPathSelector</code> should not be used concurrently in multiple threads. It is safe,
            however, to reuse the object within a single thread to evaluate the same XPath expression several times.
            Evaluating the expression does not change the context that has been established.</p>
               <p>An <code>XPathSelector</code> is always constructed by running the <code>Load</code> method of
            an <code>XPathExecutable</code>.</p>
            </div>
         </body>
      </comment>
      <property id="ContextItem" type="XdmItem" get="true" set="true">
         <comment>
            <sentence>
            The context item for the XPath expression evaluation.
            </sentence>
            <body>
               <div>
                  <p>
            The context item for the XPath expression evaluation.
            </p>
                  <p> This may be either a node or an atomic
            value. Most commonly it will be a document node, which might be constructed
            using the <c>Build</c> method of the <c>DocumentBuilder</c> object.
            </p>
               </div>
            </body>
         </comment>
      </property>
      <property id="InputXmlResolver" type="XmlResolver" get="true" set="true">
         <comment>
            <sentence>
            The <code>XmlResolver</code> to be used at run-time to resolve and dereference URIs
            supplied to the <code>doc()</code> function.
            </sentence>
         </comment>
      </property>
      <methods>
         <method id="SetVariable"
                 visibility="public"
                 type="void"
                 fulltype="Saxon.Api.void">
         
         
            <comment>
               <sentence>
            Set the value of a variable
            </sentence>
            
            
            </comment>
            <params>
               <param fulltype="Saxon.Api.QName" type="QName" name="name">The name of the variable. This must match the name of a variable
            that was declared to the XPathCompiler. No error occurs if the expression does not
            actually reference a variable with this name.</param>
               <param fulltype="Saxon.Api.XdmValue" type="XdmValue" name="value">The value to be given to the variable.</param>
            </params>
         </method>
         <method id="Evaluate"
                 visibility="public"
                 type="XdmValue"
                 fulltype="Saxon.Api.XdmValue">
            <comment>
               <sentence>
            Evaluate the expression, returning the result as an <code>XdmValue</code> (that is,
            a sequence of nodes and/or atomic values).
            </sentence>
               <body>
                  <div>
                     <p>
            Evaluate the expression, returning the result as an <code>XdmValue</code> (that is,
            a sequence of nodes and/or atomic values).
            </p>
                     <p>
            Although a singleton result <i>may</i> be represented as an <c>XdmItem</c>, there is
            no guarantee that this will always be the case. If you know that the expression will return at
            most one node or atomic value, it is best to use the <c>EvaluateSingle</c> method, which 
            does guarantee that an <c>XdmItem</c> (or null) will be returned.
            </p>
                  </div>
               </body>
               <return>
                  <body>
                     <div>
            An <code>XdmValue</code> representing the results of the expression. 
            </div>
                  </body>
               </return>
            
            </comment>
            <params/>
            <exceptions/>
         </method>
         <method id="EvaluateSingle"
                 visibility="public"
                 type="XdmItem"
                 fulltype="Saxon.Api.XdmItem">
            <comment>
               <sentence>
            Evaluate the XPath expression, returning the result as an <code>XdmItem</code> (that is,
            a single node or atomic value).
            </sentence>
               <return>
                  <body>
                     <div>
            An <code>XdmItem</code> representing the result of the expression, or null if the expression
            returns an empty sequence. If the expression returns a sequence of more than one item,
            any items after the first are ignored.
            </div>
                  </body>
               </return>
            
            </comment>
            <params/>
            <exceptions/>
         </method>
         <method id="EffectiveBooleanValue"
                 visibility="public"
                 type="Boolean"
                 fulltype="Saxon.Api.Boolean">
            <comment>
               <sentence>
            Evaluate the effective boolean value of the XPath expression, returning the result as a <code>Boolean</code>
               </sentence>
               <return>
                  <body>
                     <div>
            A <code>Boolean</code> representing the result of the expression, converted to its
            effective boolean value as if by applying the XPath boolean() function
            </div>
                  </body>
               </return>
            
            </comment>
            <params/>
            <exceptions/>
         </method>
         <method id="GetEnumerator"
                 visibility="public"
                 type="IEnumerator"
                 fulltype="IEnumerator">
            <comment>
               <sentence>
            Evaluate the expression, returning the result as an <code>IEnumerator</code> (that is,
            an enumerator over a sequence of nodes and/or atomic values).
            </sentence>
               <return>
                  <body>
                     <div>
            An enumerator over the sequence that represents the results of the expression.
            Each object in this sequence will be an instance of <code>XdmItem</code>. Note
            that the expression may be evaluated lazily, which means that a successful response
            from this method does not imply that the expression has executed successfully: failures
            may be reported later while retrieving items from the iterator. 
            </div>
                  </body>
               </return>
            
            </comment>
            <params/>
            <exceptions/>
         </method>
      </methods>
   </class>
   <class id="XQueryCompiler"
          fulltype="Saxon.Api.XQueryCompiler"
          visibility="public"
          superclass="object"
          superclassfulltype="System.Object">
      <comment>
         <sentence>
            An XQueryCompiler object allows XQuery queries to be compiled.
            </sentence>
         <body>
            <div>
               <p>
            An XQueryCompiler object allows XQuery queries to be compiled.
            </p>
               <p>To construct an <code>XQueryCompiler</code>, use the factory method
            <code>newXQueryCompiler</code> on the <code>Processor</code> object.</p>
               <p>The <code>XQueryCompiler</code> holds information that represents the static context
            for the queries that it compiles. This information remains intact after performing
            a compilation. An <code>XQueryCompiler</code> may therefore be used repeatedly to compile multiple
            queries. Any changes made to the <code>XQueryCompiler</code> (that is, to the
            static context) do not affect queries that have already been compiled.
            An <code>XQueryCompiler</code> may be used concurrently in multiple threads, but
            it should not then be modified once initialized.</p>
            
            </div>
         </body>
      </comment>
      <property id="Processor" type="Processor" get="true" set="true">
         <comment>
            <sentence>
            Get the Processor from which this XQueryCompiler was constructed
            </sentence>
         </comment>
      </property>
      <property id="ContextItemType" type="XdmItemType" get="true" set="true">
         <comment>
            <sentence>
            The required context item type for the expression. This is used for
            optimizing the expression at compile time, and to check at run-time
            that the value supplied for the context item is the correct type.
            </sentence>
         </comment>
      </property>
      <property id="BaseUri" type="String" get="true" set="true">
         <comment>
            <sentence>
            The base URI of the query, which forms part of the static context
            of the query. This is used for resolving any relative URIs appearing
            within the query, for example in references to library modules, schema
            locations, or as an argument to the <code>doc()</code> function.
            </sentence>
         </comment>
      </property>
      <property id="SchemaAware" type="Boolean" get="true" set="true">
         <comment>
            <sentence>
            Say that the query must be compiled to be schema-aware, even if it contains no
            "import schema" declarations. Normally a query is treated as schema-aware
            only if it contains one or more "import schema" declarations. If it is not schema-aware,
            then all input documents must be untyped (or xs:anyType), and validation of temporary nodes is disallowed
            (though validation of the final result tree is permitted). Setting the argument to true
            means that schema-aware code will be compiled regardless.
            schemaAware If true, the stylesheet will be compiled with schema-awareness
            enabled even if it contains no xsl:import-schema declarations. If false, the stylesheet
            is treated as schema-aware only if it contains one or more xsl:import-schema declarations.
            </sentence>
         </comment>
      </property>
      <property id="UpdatingEnabled" type="bool" get="true" set="true">
         <comment>
            <sentence>
            This property indicates whether XQuery Update syntax is accepted. The default
            value is false. This property must be set to true before compiling a query that
            uses update syntax.
            </sentence>
            <body>
               <div>
                  <p>
            This property indicates whether XQuery Update syntax is accepted. The default
            value is false. This property must be set to true before compiling a query that
            uses update syntax.
            </p>
                  <p>This propery must be set to true before any query can be compiled
            that uses updating syntax. This applies even if the query is not actually an updating
            query (for example, a copy-modify expression). XQuery Update syntax is accepted
            only by Saxon-SA. Non-updating queries are accepted regardless of the value of this
            property.</p>
                  <p>
                     <i>Property added in Saxon 9.1</i>
                  </p>
               </div>
            </body>
         </comment>
      </property>
      <property id="XQueryLanguageVersion" type="string" get="true" set="true">
         <comment>
            <sentence>
            This property indicates which version of XQuery language syntax is accepted. The default
            value is "1.0". This property must be set to "3.0" before compiling a query that
            uses XQuery 3.0 (formerly known as XQuery 1.1) syntax.
            </sentence>
            <body>
               <div>
                  <p>
            This property indicates which version of XQuery language syntax is accepted. The default
            value is "1.0". This property must be set to "3.0" before compiling a query that
            uses XQuery 3.0 (formerly known as XQuery 1.1) syntax.
            </p>
                  <p>Support for XQuery 3.0 is currently limited: for details see the Saxon documentation.
            It cannot be used together with
            XQuery Updates. As well as enabling XQuery 3.0 via this API call, it must also be enabled
            by setting version="3.0" in the query prolog.</p>
                  <p>
                     <i>Property added in Saxon 9.2</i>
                  </p>
               </div>
            </body>
         </comment>
      </property>
      <property id="QueryResolver" type="IQueryResolver" get="true" set="true">
         <comment>
            <sentence>
            A user-supplied <code>IQueryResolver</code> used to resolve location hints appearing in an
            <code>import module</code> declaration.
            </sentence>
            <body>
               <div>
                  <p>
            A user-supplied <code>IQueryResolver</code> used to resolve location hints appearing in an
            <code>import module</code> declaration.
            </p>
                  <p>In the absence of a user-supplied <code>QueryResolver</code>, an <code>import module</code> declaration
            is interpreted as follows. First, if the module URI identifies an already loaded module, that module
            is used and the location hints are ignored. Otherwise, each URI listed in the location hints is
            resolved using the <code>XmlResolver</code> registered with the <code>Processor</code>.</p>
               </div>
            </body>
         </comment>
      </property>
      <property id="ErrorList" type="IList" get="true" set="true">
         <comment>
            <sentence>
            List of errors. The caller should supply an empty list before calling Compile;
            the processor will then populate the list with error information obtained during
            the compilation. Each error will be included as an object of type StaticError.
            If no error list is supplied by the caller, error information will be written to
            the standard error stream.
            </sentence>
            <body>
               <div>
                  <p>
            List of errors. The caller should supply an empty list before calling Compile;
            the processor will then populate the list with error information obtained during
            the compilation. Each error will be included as an object of type StaticError.
            If no error list is supplied by the caller, error information will be written to
            the standard error stream.
            </p>
                  <p>
            By supplying a custom List with a user-written add() method, it is possible to
            intercept error conditions as they occur.
            </p>
               </div>
            </body>
         </comment>
      </property>
      <property id="Implementation"
                type="net.sf.saxon.query.StaticQueryContext"
                get="true">
         <comment>
            <sentence>
            Escape hatch to the underying Java implementation
            </sentence>
         </comment>
      </property>
      <methods>
         <method id="DeclareCollation"
                 visibility="public"
                 type="void"
                 fulltype="Saxon.Api.void">
         
         
         
         
            <comment>
               <sentence>
            Create a collation based on a given <code>CompareInfo</code> and <code>CompareOptions</code>    
               </sentence>
            
            
            
            
            </comment>
            <params>
               <param fulltype="System.Uri" type="Uri" name="uri">The collation URI to be used within the XPath expression to refer to this collation</param>
               <param fulltype="System.Globalization.CompareInfo"
                      type="CompareInfo"
                      name="comparerInfo">The <c>CompareInfo</c>, which determines the language-specific
            collation rules to be used</param>
               <param fulltype="System.Globalization.CompareOptions"
                      type="CompareOptions"
                      name="options">Options to be used in performing comparisons, for example
            whether they are to be case-blind and/or accent-blind</param>
               <param fulltype="bool" type="bool" name="isDefault">If true, this collation will be used as the default collation</param>
            </params>
         </method>
         <method id="DeclareNamespace"
                 visibility="public"
                 type="void"
                 fulltype="Saxon.Api.void">
         
         
            <comment>
               <sentence>
            Declare a namespace for use by the query. This has the same
            status as a namespace appearing within the query prolog (though
            a declaration in the query prolog of the same prefix will take
            precedence)
            </sentence>
            
            
            </comment>
            <params>
               <param fulltype="string" type="string" name="prefix">The namespace prefix to be declared. Use
            a zero-length string to declare the default namespace (that is, the
            default namespace for elements and types).</param>
               <param fulltype="string" type="string" name="uri">The namespace URI. It is possible to specify
            a zero-length string to "undeclare" a namespace.</param>
            </params>
         </method>
         <method id="Compile"
                 visibility="public"
                 type="XQueryExecutable"
                 fulltype="Saxon.Api.XQueryExecutable">
         
            <comment>
               <sentence>
            Compile a query supplied as a Stream.
            </sentence>
               <body>
                  <div>
                     <p>
            Compile a query supplied as a Stream.
            </p>
                     <p>The XQuery processor attempts to deduce the encoding of the query
            by looking for a byte-order-mark, or if none is present, by looking
            for the encoding declaration in the XQuery version declaration.
            For this to work, the stream must have the <code>CanSeek</code> property.
            If no encoding information is present, UTF-8 is assumed.</p>
                     <p>The base URI of the query is set to the value of the <code>BaseUri</code>
            property. If this has not been set, then the base URI will be undefined, which
            means that any use of an expression that depends on the base URI will cause
            an error.</p>
                  </div>
               </body>
               <div class="example">
                  <code>
            XQueryExecutable q = compiler.Compile(new FileStream("input.xq", FileMode.Open, FileAccess.Read));
            </code>
               </div>
            
               <return>
                  <body>
                     <div>An <code>XQueryExecutable</code> which represents the compiled query object.
            The XQueryExecutable may be run as many times as required, in the same or a different
            thread. The <code>XQueryExecutable</code> is not affected by any changes made to the <code>XQueryCompiler</code>
            once it has been compiled.</div>
                  </body>
               </return>
            
            </comment>
            <params>
               <param fulltype="System.IO.Stream" type="Stream" name="query">A stream containing the source text of the query</param>
            </params>
            <exceptions/>
         </method>
         <method id="Compile"
                 visibility="public"
                 type="XQueryExecutable"
                 fulltype="Saxon.Api.XQueryExecutable">
         
            <comment>
               <sentence>
            Compile a query supplied as a String.
            </sentence>
               <body>
                  <div>
                     <p>
            Compile a query supplied as a String.
            </p>
                     <p>
            Using this method the query processor is provided with a string of Unicode
            characters, so no decoding is necessary. Any encoding information present in the
            version declaration is therefore ignored.
            </p>
                  </div>
               </body>
               <div class="example">
                  <code>
            XQueryExecutable q = compiler.Compile("distinct-values(//*/node-name()");
            </code>
               </div>
            
               <return>
                  <body>
                     <div>An <code>XQueryExecutable</code> which represents the compiled query object.
            The XQueryExecutable may be run as many times as required, in the same or a different
            thread. The <code>XQueryExecutable</code> is not affected by any changes made to the <code>XQueryCompiler</code>
            once it has been compiled.</div>
                  </body>
               </return>
            
            </comment>
            <params>
               <param fulltype="string" type="string" name="query">A string containing the source text of the query</param>
            </params>
            <exceptions/>
         </method>
      </methods>
   </class>
   <class id="XQueryExecutable"
          fulltype="Saxon.Api.XQueryExecutable"
          visibility="public"
          superclass="object"
          superclassfulltype="System.Object">
      <comment>
         <sentence>
            An <code>XQueryExecutable</code> represents the compiled form of a query. To execute the query,
            it must first be loaded to form an <code>XQueryEvaluator</code>.
            </sentence>
         <body>
            <div>
               <p>
            An <code>XQueryExecutable</code> represents the compiled form of a query. To execute the query,
            it must first be loaded to form an <code>XQueryEvaluator</code>.
            </p>
               <p>An <code>XQueryExecutable</code> is immutable, and therefore thread-safe. It is simplest to
            load a new <code>XQueryEvaluator</code> each time the query is to be run. However, the 
            <code>XQueryEvaluator</code> is serially reusable within a single thread.</p>
               <p>An <code>XQueryExecutable</code> is created by using one of the <code>Compile</code>
            methods on the <code>XQueryCompiler</code> class.</p>
            </div>
         </body>
      </comment>
      <property id="IsUpdateQuery" type="bool" get="true">
         <comment>
            <sentence>Ask whether this is an updating query (that is, one that returns a pending
            update list rather than a convensional value).</sentence>
            <body>
               <div>
                  <p>Ask whether this is an updating query (that is, one that returns a pending
            update list rather than a convensional value).</p>
                  <p>
                     <i>Property added in Saxon 9.1</i>
                  </p>
               </div>
            </body>
         </comment>
      </property>
      <methods>
         <method id="Load"
                 visibility="public"
                 type="XQueryEvaluator"
                 fulltype="Saxon.Api.XQueryEvaluator">
            <comment>
               <sentence>
            Load the query to prepare it for execution.
            </sentence>
               <return>
                  <body>
                     <div>
            An <code>XQueryEvaluator</code>. The returned <code>XQueryEvaluator</code> can be used to
            set up the dynamic context for query evaluation, and to run the query.
            </div>
                  </body>
               </return>
            </comment>
            <params/>
         </method>
      </methods>
   </class>
   <class id="XQueryEvaluator"
          fulltype="Saxon.Api.XQueryEvaluator"
          visibility="public"
          superclass="IEnumerable"
          superclassfulltype="Saxon.Api.IEnumerable">
      <comment>
         <sentence>
            An <code>XQueryEvaluator</code> represents a compiled and loaded query ready for execution.
            The <code>XQueryEvaluator</code> holds details of the dynamic evaluation context for the query.
            </sentence>
         <body>
            <div>
               <p>
            An <code>XQueryEvaluator</code> represents a compiled and loaded query ready for execution.
            The <code>XQueryEvaluator</code> holds details of the dynamic evaluation context for the query.
            </p>
               <p>An <code>XQueryEvaluator</code> should not be used concurrently in multiple threads. It is safe,
            however, to reuse the object within a single thread to run the same query several times.
            Running the query does not change the context that has been established.</p>
               <p>An <code>XQueryEvaluator</code> is always constructed by running the <code>Load</code> method of
            an <code>XQueryExecutable</code>.</p>
            </div>
         </body>
      </comment>
      <property id="ContextItem" type="XdmItem" get="true" set="true">
         <comment>
            <sentence>
            The context item for the query.
            </sentence>
            <body>
               <div>
                  <p>
            The context item for the query.
            </p>
                  <p> This may be either a node or an atomic
            value. Most commonly it will be a document node, which might be constructed
            using the <c>LoadDocument</c> method of the <c>Processor</c> object.
            </p>
               </div>
            </body>
         </comment>
      </property>
      <property id="SchemaValidationMode"
                type="SchemaValidationMode"
                get="true"
                set="true">
         <comment>
            <sentence>
            The <code>SchemaValidationMode</code> to be used in this transformation, especially for documents
            loaded using the <code>doc()</code>, <code>document()</code>, or <code>collection()</code> functions.
            </sentence>
         </comment>
      </property>
      <property id="InputXmlResolver" type="XmlResolver" get="true" set="true">
         <comment>
            <sentence>
            The <code>XmlResolver</code> to be used at run-time to resolve and dereference URIs
            supplied to the <code>doc()</code> function.
            </sentence>
         </comment>
      </property>
      <property id="TraceFunctionDestination"
                type="Stream"
                get="true"
                set="true">
         <comment>
            <sentence>
            Destination for output of messages produced using &lt;trace()&gt;. 
            <p>If no specific destination is supplied by the caller, message information will be written to
            the standard error stream.</p>
            </sentence>
            <body>
               <div>
                  <p>
            Destination for output of messages produced using &lt;trace()&gt;. 
            <p>If no specific destination is supplied by the caller, message information will be written to
            the standard error stream.</p>
                  </p>
                  <p>The supplied destination is ignored if a <code>TraceListener</code> is in use.</p>
                  <p>
                     <i>Property added in Saxon 9.1</i>
                  </p>
               </div>
            </body>
         </comment>
      </property>
      <property id="Implementation" type="DynamicQueryContext" get="true">
         <comment>
            <sentence>
            Escape hatch to the <code>net.sf.saxon.query.DynamicQueryContext</code> object in the underlying Java implementation
            </sentence>
         </comment>
      </property>
      <methods>
         <method id="SetExternalVariable"
                 visibility="public"
                 type="void"
                 fulltype="Saxon.Api.void">
         
         
            <comment>
               <sentence>
            Set the value of an external variable declared in the query.
            </sentence>
            
            
            </comment>
            <params>
               <param fulltype="Saxon.Api.QName" type="QName" name="name">The name of the external variable, expressed
            as a QName. If an external variable of this name has been declared in the
            query prolog, the given value will be assigned to the variable. If the
            variable has not been declared, calling this method has no effect (it is
            not an error).</param>
               <param fulltype="Saxon.Api.XdmValue" type="XdmValue" name="value">The value to be given to the external variable.
            If the variable declaration defines a required type for the variable, then
            this value must match the required type: no conversions are applied.</param>
            </params>
         </method>
         <method id="Evaluate"
                 visibility="public"
                 type="XdmValue"
                 fulltype="Saxon.Api.XdmValue">
            <comment>
               <sentence>
            Evaluate the query, returning the result as an <code>XdmValue</code> (that is,
            a sequence of nodes and/or atomic values).
            </sentence>
               <return>
                  <body>
                     <div>
            An <code>XdmValue</code> representing the results of the query
            </div>
                  </body>
               </return>
            
            </comment>
            <params/>
            <exceptions/>
         </method>
         <method id="EvaluateSingle"
                 visibility="public"
                 type="XdmItem"
                 fulltype="Saxon.Api.XdmItem">
            <comment>
               <sentence>
            Evaluate the query, returning the result as an <code>XdmItem</code> (that is,
            a single node or atomic value).
            </sentence>
               <return>
                  <body>
                     <div>
            An <code>XdmItem</code> representing the result of the query, or null if the query
            returns an empty sequence. If the query returns a sequence of more than one item,
            any items after the first are ignored.
            </div>
                  </body>
               </return>
            
            </comment>
            <params/>
            <exceptions/>
         </method>
         <method id="GetEnumerator"
                 visibility="public"
                 type="IEnumerator"
                 fulltype="IEnumerator">
            <comment>
               <sentence>
            Evaluate the query, returning the result as an <code>IEnumerator</code> (that is,
            an enumerator over a sequence of nodes and/or atomic values).
            </sentence>
               <return>
                  <body>
                     <div>
            An enumerator over the sequence that represents the results of the query.
            Each object in this sequence will be an instance of <code>XdmItem</code>. Note
            that the query may be evaluated lazily, which means that a successful response
            from this method does not imply that the query has executed successfully: failures
            may be reported later while retrieving items from the iterator. 
            </div>
                  </body>
               </return>
            
            </comment>
            <params/>
            <exceptions/>
         </method>
         <method id="Run"
                 visibility="public"
                 type="void"
                 fulltype="Saxon.Api.void">
         
            <comment>
               <sentence>
            Evaluate the query, sending the result to a specified destination.
            </sentence>
            
            
            </comment>
            <params>
               <param fulltype="Saxon.Api.XmlDestination"
                      type="XmlDestination"
                      name="destination">
            The destination for the results of the query. The class <c>XmlDestination</c>
            is an abstraction that allows a number of different kinds of destination
            to be specified.
            </param>
            </params>
            <exceptions/>
         </method>
         <method id="RunUpdate"
                 visibility="public"
                 type="XdmNode[]"
                 fulltype="Saxon.Api.XdmNode[]">
            <comment>
               <sentence>
            Execute an updating query.
            </sentence>
               <return>
                  <body>
                     <div>An array containing the root nodes of documents that have been
            updated by the query.</div>
                  </body>
               </return>
            
            </comment>
            <params/>
            <exceptions/>
         </method>
         <method id="CallFunction"
                 visibility="public"
                 type="XdmValue"
                 fulltype="Saxon.Api.XdmValue">
         
         
            <comment>
               <sentence>
             Call a global user-defined function in the compiled query.
            </sentence>
               <body>
                  <div>
                     <p>
             Call a global user-defined function in the compiled query.
            </p>
                     <p>
             If this is called more than once (to evaluate the same function repeatedly with different arguments,
             or to evaluate different functions) then the sequence of evaluations uses the same values of global
             variables including external variables (query parameters); the effect of any changes made to query parameters
             between calls is undefined.
             </p>
                  </div>
               </body>
            
            
            
            
            </comment>
            <params>
               <param fulltype="Saxon.Api.QName" type="QName" name="function">
             The name of the function to be called
             </param>
               <param fulltype="Saxon.Api.XdmValue[]" type="XdmValue[]" name="arguments">
             The values of the arguments to be supplied to the function. These
             must be of the correct type as defined in the function signature (there is no automatic
             conversion to the required type).
             </param>
            </params>
            <exceptions/>
         </method>
      </methods>
   </class>
   <interface id="IQueryResolver"
              fulltype="Saxon.Api.IQueryResolver"
              visibility="public"
              superclass="object"
              superclassfulltype="System.Object">
      <comment>
         <sentence>
            Interface defining a user-supplied class used to retrieve XQuery library modules listed
            in an <code>import module</code> declaration in the query prolog.
            </sentence>
      </comment>
      <methods>
         <method id="GetModules"
                 visibility="public"
                 type="Uri[]"
                 fulltype="Saxon.Api.Uri[]">
         
         
         
         
            <params>
               <param fulltype="string" type="string"/>
               <param fulltype="System.Uri" type="Uri"/>
               <param fulltype="System.String[]" type="String[]"/>
            </params>
         </method>
         <method id="GetEntity"
                 visibility="public"
                 type="Object"
                 fulltype="Saxon.Api.Object">
         
         
            <params>
               <param fulltype="System.Uri" type="Uri"/>
            </params>
         </method>
      </methods>
   </interface>
   <class id="DotNetModuleURIResolver"
          fulltype="Saxon.Api.DotNetModuleURIResolver"
          visibility="protected"
          superclass="net.sf.saxon.lib.ModuleURIResolver"
          superclassfulltype="Saxon.Api.net.sf.saxon.lib.ModuleURIResolver">
      <methods>
         <constructor id="DotNetModuleURIResolver" visibility="public">
            <params/>
         </constructor>
         <method id="resolve"
                 visibility="public"
                 type="JStreamSource[]"
                 fulltype="Saxon.Api.JStreamSource[]">
         
            <params/>
         </method>
      </methods>
   </class>
   <class id="XsltCompiler"
          fulltype="Saxon.Api.XsltCompiler"
          visibility="public"
          superclass="object"
          superclassfulltype="System.Object">
      <comment>
         <sentence>
            An <code>XsltCompiler</code> object allows XSLT 2.0 stylesheets to be compiled.
            The compiler holds information that represents the static context
            for the compilation.
            </sentence>
         <body>
            <div>
               <p>
            An <code>XsltCompiler</code> object allows XSLT 2.0 stylesheets to be compiled.
            The compiler holds information that represents the static context
            for the compilation.
            </p>
               <p>To construct an <code>XsltCompiler</code>, use the factory method
            <code>NewXsltCompiler</code> on the <code>Processor</code> object.</p>
               <p>An <code>XsltCompiler</code> may be used repeatedly to compile multiple
            queries. Any changes made to the <code>XsltCompiler</code> (that is, to the
            static context) do not affect queries that have already been compiled.
            An <code>XsltCompiler</code> may be used concurrently in multiple threads, but
            it should not then be modified once initialized.</p>
            </div>
         </body>
      </comment>
      <property id="BaseUri" type="Uri" get="true" set="true">
         <comment>
            <sentence>
            The base URI of the stylesheet, which forms part of the static context
            of the stylesheet. This is used for resolving any relative URIs appearing
            within the stylesheet, for example in <code>xsl:include</code> and <code>xsl:import</code>
            declarations, in schema locations defined to <code>xsl:import-schema</code>, 
            or as an argument to the <code>document()</code> or <code>doc()</code> function.
            </sentence>
            <body>
               <div>
                  <p>
            The base URI of the stylesheet, which forms part of the static context
            of the stylesheet. This is used for resolving any relative URIs appearing
            within the stylesheet, for example in <code>xsl:include</code> and <code>xsl:import</code>
            declarations, in schema locations defined to <code>xsl:import-schema</code>, 
            or as an argument to the <code>document()</code> or <code>doc()</code> function.
            </p>
                  <p>
            This base URI is used only if the input supplied to the <c>Compile</c> method
            does not provide its own base URI. It is therefore used on the version of the
            method that supplies input from a <c>Stream</c>. On the version that supplies
            input from an <c>XmlReader</c>, this base URI is used only if the <c>XmlReader</c>
            does not have its own base URI.
            </p>
               </div>
            </body>
         </comment>
      </property>
      <property id="Processor" type="Processor" get="true" set="true">
         <comment>
            <sentence>
            Get the Processor from which this XsltCompiler was constructed
            </sentence>
         </comment>
      </property>
      <property id="XmlResolver" type="XmlResolver" get="true" set="true">
         <comment>
            <sentence>
            An <code>XmlResolver</code>, which will be used to resolve URI references while compiling
            a stylesheet
            </sentence>
            <body>
               <div>
                  <p>
            An <code>XmlResolver</code>, which will be used to resolve URI references while compiling
            a stylesheet
            </p>
                  <p>
            If no <c>XmlResolver</c> is set for the <c>XsltCompiler</c>, the <c>XmlResolver</c>
            is used that was set on the <c>Processor</c> at the time <c>NewXsltCompiler</c>
            was called.
            </p>
               </div>
            </body>
         </comment>
      </property>
      <property id="SchemaAware" type="bool" get="true" set="true">
         <comment>
            <sentence>
            The <code>SchemaAware</code> property determines whether the stylesheet is schema-aware. By default, a stylesheet
            is schema-aware if it contains one or more <code>xsl:import-schema</code> declarations. This option allows
            a stylesheet to be marked as schema-aware even if it does not contain such a declaration.
            </sentence>
            <body>
               <div>
                  <p>
            The <code>SchemaAware</code> property determines whether the stylesheet is schema-aware. By default, a stylesheet
            is schema-aware if it contains one or more <code>xsl:import-schema</code> declarations. This option allows
            a stylesheet to be marked as schema-aware even if it does not contain such a declaration.
            </p>
                  <p>If the stylesheet is not schema-aware, then schema-validated input documents will be rejected.</p>
                  <p>The reason for this option is that it is expensive to generate code that can handle typed input
            documents when they will never arise in practice.</p>
                  <p>The initial setting of this property is false, regardless of whether or not the <code>Processor</code>
            is schema-aware. Setting this property to true if the processor is not schema-aware will cause an Exception.</p>
               </div>
            </body>
         </comment>
      </property>
      <property id="XsltLanguageVersion" type="string" get="true" set="true">
         <comment>
            <sentence>
            The <code>XsltLanguageVersion</code> property determines whether the version of the XSLT language specification
            implemented by the compiler. The values 2.0 and 3.0 refer to the XSLT 2.0 and XSLT 3.0 (formerly XSLT 2.1) specifications.
            The value 0.0 (which is the initial default) indicates that the value is to be taken from the <code>version</code>
            attribute of the <code>xsl:stylesheet</code> element.
            </sentence>
            <body>
               <div>
                  <p>
            The <code>XsltLanguageVersion</code> property determines whether the version of the XSLT language specification
            implemented by the compiler. The values 2.0 and 3.0 refer to the XSLT 2.0 and XSLT 3.0 (formerly XSLT 2.1) specifications.
            The value 0.0 (which is the initial default) indicates that the value is to be taken from the <code>version</code>
            attribute of the <code>xsl:stylesheet</code> element.
            </p>
                  <p>Values that are not numerically equal to one of the above values are rejected.</p>
                  <p>A warning is output (unless suppressed) when the XSLT language version supported by the processor
            is different from the value of the <code>version</code> attribute of the <code>xsl:stylesheet</code> element.</p>
                  <p>XSLT 3.0 features are supported only in Saxon-PE and Saxon-EE. Setting the value to 3.0 under 
            Saxon-HE will cause an error if (and only if) the stylesheet actually uses XSLT 3.0 constructs.</p>
               </div>
            </body>
         </comment>
      </property>
      <property id="ErrorList" type="IList" get="true" set="true">
         <comment>
            <sentence>
            List of errors. The caller should supply an empty list before calling Compile;
            the processor will then populate the list with error information obtained during
            the compilation. Each error will be included as an object of type StaticError.
            If no error list is supplied by the caller, error information will be written to
            the standard error stream.
            </sentence>
            <body>
               <div>
                  <p>
            List of errors. The caller should supply an empty list before calling Compile;
            the processor will then populate the list with error information obtained during
            the compilation. Each error will be included as an object of type StaticError.
            If no error list is supplied by the caller, error information will be written to
            the standard error stream.
            </p>
                  <p>
            By supplying a custom List with a user-written add() method, it is possible to
            intercept error conditions as they occur.
            </p>
               </div>
            </body>
         </comment>
      </property>
      <methods>
         <method id="DeclareCollation"
                 visibility="public"
                 type="void"
                 fulltype="Saxon.Api.void">
         
         
         
         
            <comment>
               <sentence>
            Create a collation based on a given <code>CompareInfo</code> and <code>CompareOptions</code>    
               </sentence>
            
            
            
            
            </comment>
            <params>
               <param fulltype="System.Uri" type="Uri" name="uri">The collation URI to be used within the XPath expression to refer to this collation</param>
               <param fulltype="System.Globalization.CompareInfo"
                      type="CompareInfo"
                      name="compareInfo">The <c>CompareInfo</c>, which determines the language-specific
            collation rules to be used</param>
               <param fulltype="System.Globalization.CompareOptions"
                      type="CompareOptions"
                      name="options">Options to be used in performing comparisons, for example
            whether they are to be case-blind and/or accent-blind</param>
               <param fulltype="bool" type="bool" name="isDefault">If true, this collation will be used as the default collation</param>
            </params>
         </method>
         <method id="Compile"
                 visibility="public"
                 type="XsltExecutable"
                 fulltype="Saxon.Api.XsltExecutable">
         
            <comment>
               <sentence>
            Compile a stylesheet supplied as a Stream.
            </sentence>
               <div class="example">
                  <code>
            Stream source = new FileStream("input.xsl", FileMode.Open, FileAccess.Read);
            XsltExecutable q = compiler.Compile(source);
            source.Close();
            </code>
               </div>
            
               <return>
                  <body>
                     <div>An <code>XsltExecutable</code> which represents the compiled stylesheet object.
            The XsltExecutable may be loaded as many times as required, in the same or a different
            thread. The <code>XsltExecutable</code> is not affected by any changes made to the <code>XsltCompiler</code>
            once it has been compiled.</div>
                  </body>
               </return>
               <body>
                  <div>
                     <p>
            Compile a stylesheet supplied as a Stream.
            </p>
                     <p>If the stylesheet contains any <code>xsl:include</code> or <code>xsl:import</code> declarations,
            then the <code>BaseURI</code> property must be set to allow these to be resolved.</p>
                     <p>The stylesheet is contained in the part of the input stream between its current
            position and the end of the stream. It is the caller's responsibility to close the input 
            stream after use. If the compilation succeeded, then on exit the stream will be 
            exhausted; if compilation failed, the current position of the stream on exit is
            undefined.</p>
                  </div>
               </body>
            </comment>
            <params>
               <param fulltype="System.IO.Stream" type="Stream" name="input">A stream containing the source text of the stylesheet</param>
            </params>
         </method>
         <method id="GetUnderlyingCompilerInfo"
                 visibility="public"
                 type="JCompilerInfo"
                 fulltype="net.sf.saxon.trans.CompilerInfo">
            <comment>
               <sentence>  
              Get the underlying CompilerInfo object, which provides more detailed (but less stable) control
              over some compilation options
              </sentence>
               <return>
                  <body>
                     <div> the underlying CompilerInfo object, which holds compilation-time options. The methods on
             this object are not guaranteed stable from release to release.
             </div>
                  </body>
               </return>
            </comment>
            <params/>
         </method>
         <method id="SetParameter"
                 visibility="public"
                 type="void"
                 fulltype="Saxon.Api.void">
         
         
            <comment>
               <sentence>
            Externally set the value of a static parameter (new facility in XSLT 3.0) 
            </sentence>
            
            
            </comment>
            <params>
               <param fulltype="Saxon.Api.QName" type="QName" name="name">The name of the parameter, expressed
            as a QName. If a parameter of this name has been declared in the
            stylesheet, the given value will be assigned to the variable. If the
            variable has not been declared, calling this method has no effect (it is
            not an error).</param>
               <param fulltype="Saxon.Api.XdmValue" type="XdmValue" name="value">The value to be given to the parameter.
            If the parameter declaration defines a required type for the variable, then
            this value will be converted in the same way as arguments to function calls
            (for example, numeric promotion is applied).</param>
            </params>
         </method>
         <method id="Compile"
                 visibility="public"
                 type="XsltExecutable"
                 fulltype="Saxon.Api.XsltExecutable">
         
            <comment>
               <sentence>
            Compile a stylesheet supplied as a TextReader.
            </sentence>
               <div class="example">
                  <code>
            String ss = "&lt;xsl:stylesheet version='2.0'&gt;....&lt;/xsl:stylesheet&gt;";
            TextReader source = new StringReader(ss);
            XsltExecutable q = compiler.Compile(source);
            source.Close();
            </code>
               </div>
            
               <return>
                  <body>
                     <div>An <code>XsltExecutable</code> which represents the compiled stylesheet object.
            The XsltExecutable may be loaded as many times as required, in the same or a different
            thread. The <code>XsltExecutable</code> is not affected by any changes made to the <code>XsltCompiler</code>
            once it has been compiled.</div>
                  </body>
               </return>
               <body>
                  <div>
                     <p>
            Compile a stylesheet supplied as a TextReader.
            </p>
                     <p>If the stylesheet contains any <code>xsl:include</code> or <code>xsl:import</code> declarations,
            then the <code>BaseURI</code> property must be set to allow these to be resolved.</p>
                     <p>The stylesheet is contained in the part of the input stream between its current
            position and the end of the stream. It is the caller's responsibility to close the 
            <code>TextReader</code> after use. If the compilation succeeded, then on exit the stream will be 
            exhausted; if compilation failed, the current position of the stream on exit is
            undefined.</p>
                  </div>
               </body>
            </comment>
            <params>
               <param fulltype="System.IO.TextReader" type="TextReader" name="input">A <c>TextReader</c> containing the source text of the stylesheet</param>
            </params>
         </method>
         <method id="Compile"
                 visibility="public"
                 type="XsltExecutable"
                 fulltype="Saxon.Api.XsltExecutable">
         
            <comment>
               <sentence>
            Compile a stylesheet, retrieving the source using a URI.
            </sentence>
               <body>
                  <div>
                     <p>
            Compile a stylesheet, retrieving the source using a URI.
            </p>
                     <p>
            The document located via the URI is parsed using the <c>System.Xml</c> parser. This
            URI is used as the base URI of the stylesheet: the <c>BaseUri</c> property of the
            <c>Compiler</c> is ignored.
            </p>
                  </div>
               </body>
            
               <return>
                  <body>
                     <div>An <code>XsltExecutable</code> which represents the compiled stylesheet object.
            The XsltExecutable may be run as many times as required, in the same or a different
            thread. The <code>XsltExecutable</code> is not affected by any changes made to the <code>XsltCompiler</code>
            once it has been compiled.</div>
                  </body>
               </return>
            </comment>
            <params>
               <param fulltype="System.Uri" type="Uri" name="uri">The URI identifying the location where the stylesheet document can be
            found</param>
            </params>
         </method>
         <method id="Compile"
                 visibility="public"
                 type="XsltExecutable"
                 fulltype="Saxon.Api.XsltExecutable">
         
            <comment>
               <sentence>
            Compile a stylesheet, delivered using an XmlReader.
            </sentence>
               <body>
                  <div>
                     <p>
            Compile a stylesheet, delivered using an XmlReader.
            </p>
                     <p>
            The <c>XmlReader</c> is responsible for parsing the document; this method builds a tree
            representation of the document (in an internal Saxon format) and compiles it.
            The <c>XmlReader</c> will be used as supplied; it is the caller's responsibility to
            ensure that the settings of the <c>XmlReader</c> are consistent with the requirements
            of the XSLT specification (for example, that entity references are expanded and whitespace
            is preserved).
            </p>
                  </div>
               </body>
               <body>
                  <div>
                     <p>
            Compile a stylesheet, delivered using an XmlReader.
            </p>
                     <p>
            If the <c>XmlReader</c> has a <c>BaseUri</c> property, then that property determines
            the base URI of the stylesheet module, which is used when resolving any <c>xsl:include</c>
            or <c>xsl:import</c> declarations. If the <c>XmlReader</c> has no <c>BaseUri</c>
            property, then the <c>BaseUri</c> property of the <c>Compiler</c> is used instead.
            An <c>ArgumentNullException</c> is thrown if this property has not been supplied.
            </p>
                  </div>
               </body>
            
               <return>
                  <body>
                     <div>An <code>XsltExecutable</code> which represents the compiled stylesheet object.
            The XsltExecutable may be run as many times as required, in the same or a different
            thread. The <code>XsltExecutable</code> is not affected by any changes made to the <code>XsltCompiler</code>
            once it has been compiled.</div>
                  </body>
               </return>
            </comment>
            <params>
               <param fulltype="System.Xml.XmlReader" type="XmlReader" name="reader">The XmlReader (that is, the XML parser) used to supply the document containing
            the principal stylesheet module.</param>
            </params>
         </method>
         <method id="Compile"
                 visibility="public"
                 type="XsltExecutable"
                 fulltype="Saxon.Api.XsltExecutable">
         
            <comment>
               <sentence>
            Compile a stylesheet, located at an XdmNode. This may be a document node whose
            child is an <code>xsl:stylesheet</code> or <code>xsl:transform</code> element, or it may be
            the <code>xsl:stylesheet</code> or <code>xsl:transform</code> element itself.
            </sentence>
            
               <return>
                  <body>
                     <div>An <code>XsltExecutable</code> which represents the compiled stylesheet object.
            The XsltExecutable may be run as many times as required, in the same or a different
            thread. The <code>XsltExecutable</code> is not affected by any changes made to the <code>XsltCompiler</code>
            once it has been compiled.</div>
                  </body>
               </return>
            </comment>
            <params>
               <param fulltype="Saxon.Api.XdmNode" type="XdmNode" name="node">The document node or the outermost element node of the document
            containing the principal stylesheet module.</param>
            </params>
         </method>
         <method id="CompileAssociatedStylesheet"
                 visibility="public"
                 type="XsltExecutable"
                 fulltype="Saxon.Api.XsltExecutable">
         
            <comment>
               <sentence>Locate and compile a stylesheet identified by an &lt;?xml-stylesheet?&gt;
            processing instruction within a source document.
            </sentence>
            
               <return>
                  <body>
                     <div>An <code>XsltExecutable</code> which represents the compiled stylesheet object.</div>
                  </body>
               </return>
               <body>
                  <div>
                     <p>Locate and compile a stylesheet identified by an &lt;?xml-stylesheet?&gt;
            processing instruction within a source document.
            </p>
                     <p>There are some limitations in the current implementation. The media type
            is ignored, as are the other parameters of the xml-stylesheet instruction. The
            href attribute must either reference an embedded stylesheet within the same
            document or a non-embedded external stylesheet.</p>
                  </div>
               </body>
            </comment>
            <params>
               <param fulltype="Saxon.Api.XdmNode" type="XdmNode" name="source">The document node of the source document containing the
            xml-stylesheet processing instruction.</param>
            </params>
         </method>
      </methods>
   </class>
   <class id="XsltExecutable"
          fulltype="Saxon.Api.XsltExecutable"
          visibility="public"
          superclass="object"
          superclassfulltype="System.Object">
      <comment>
         <sentence>
            An <code>XsltExecutable</code> represents the compiled form of a stylesheet. To execute the stylesheet,
            it must first be loaded to form an <code>XsltTransformer</code>.
            </sentence>
         <body>
            <div>
               <p>
            An <code>XsltExecutable</code> represents the compiled form of a stylesheet. To execute the stylesheet,
            it must first be loaded to form an <code>XsltTransformer</code>.
            </p>
               <p>An <code>XsltExecutable</code> is immutable, and therefore thread-safe. It is simplest to
            load a new <code>XsltEvaluator</code> each time the stylesheet is to be run. However, the 
            <code>XsltEvaluator</code> is serially reusable within a single thread.</p>
               <p>An <code>XsltExecutable</code> is created by using one of the <code>Compile</code>
            methods on the <code>XsltCompiler</code> class.</p>
            </div>
         </body>
      </comment>
      <property id="Implementation" type="PreparedStylesheet" get="true">
         <comment>
            <sentence>
            Escape hatch to the underlying Java implementation object
            </sentence>
         </comment>
      </property>
      <methods>
         <method id="Load"
                 visibility="public"
                 type="XsltTransformer"
                 fulltype="Saxon.Api.XsltTransformer">
            <comment>
               <sentence>
            Load the stylesheet to prepare it for execution.
            </sentence>
               <return>
                  <body>
                     <div>
            An <code>XsltTransformer</code>. The returned <code>XsltTransformer</code> can be used to
            set up the dynamic context for stylesheet evaluation, and to run the stylesheet.
            </div>
                  </body>
               </return>
            </comment>
            <params/>
         </method>
         <method id="Explain"
                 visibility="public"
                 type="void"
                 fulltype="Saxon.Api.void">
         
            <comment>
               <sentence>
            Output an XML representation of the compiled code of the stylesheet, for purposes of 
            diagnostics and instrumentation
            </sentence>
            
            </comment>
            <params>
               <param fulltype="Saxon.Api.XmlDestination"
                      type="XmlDestination"
                      name="destination">The destination for the diagnostic output</param>
            </params>
         </method>
      </methods>
   </class>
   <class id="XsltTransformer"
          fulltype="Saxon.Api.XsltTransformer"
          visibility="public"
          superclass="object"
          superclassfulltype="System.Object">
      <comment>
         <sentence>
            An <code>XsltTransformer</code> represents a compiled and loaded stylesheet ready for execution.
            The <code>XsltTransformer</code> holds details of the dynamic evaluation context for the stylesheet.
            </sentence>
         <body>
            <div>
               <p>
            An <code>XsltTransformer</code> represents a compiled and loaded stylesheet ready for execution.
            The <code>XsltTransformer</code> holds details of the dynamic evaluation context for the stylesheet.
            </p>
               <p>An <code>XsltTransformer</code> should not be used concurrently in multiple threads. It is safe,
            however, to reuse the object within a single thread to run the same stylesheet several times.
            Running the stylesheet does not change the context that has been established.</p>
               <p>An <code>XsltTransformer</code> is always constructed by running the <code>Load</code> method of
            an <code>XsltExecutable</code>.</p>
            </div>
         </body>
      </comment>
      <property id="InitialContextNode" type="XdmNode" get="true" set="true">
         <comment>
            <sentence>
            The initial context item for the stylesheet.
            </sentence>
            <body>
               <div>
                  <p>
            The initial context item for the stylesheet.
            </p>
                  <p>This may be either a node or an atomic
            value. Most commonly it will be a document node, which might be constructed
            using the <code>Build</code> method of the <code>DocumentBuilder</code> object.</p>
                  <p>Note that this can be inefficient if the stylesheet uses <code>xsl:strip-space</code>
            to strip whitespace, or <code>input-type-annotations="strip"</code> to remove type
            annotations, since this will result in the transformation operating on a virtual document
            implemented as a view or wrapper of the supplied document.</p>
               </div>
            </body>
         </comment>
      </property>
      <property id="InitialMode" type="QName" get="true" set="true">
         <comment>
            <sentence>
            The initial mode for the stylesheet. This is either a QName, for a 
            named mode, or null, for the unnamed (default) mode.
            </sentence>
         </comment>
      </property>
      <property id="InitialTemplate" type="QName" get="true" set="true">
         <comment>
            <sentence>
            The initial template for the stylesheet. This is either a QName, for a 
            named template, or null, if no initial template has been set.
            </sentence>
            
         </comment>
      </property>
      <property id="BaseOutputUri" type="Uri" get="true" set="true">
         <comment>
            <sentence>
            The base output URI, which acts as the base URI for resolving the <code>href</code>
            attribute of <code>xsl:result-document</code>.
            </sentence>
         </comment>
      </property>
      <property id="RecoveryPolicy" type="RecoveryPolicy" get="true" set="true">
         
      </property>
      <property id="SchemaValidationMode"
                type="SchemaValidationMode"
                get="true"
                set="true">
         <comment>
            <sentence>
            The <code>SchemaValidationMode</code> to be used in this transformation, especially for documents
            loaded using the <code>doc()</code>, <code>document()</code>, or <code>collection()</code> functions.
            </sentence>
         </comment>
      </property>
      <property id="InputXmlResolver" type="XmlResolver" get="true" set="true">
         <comment>
            <sentence>
            The <code>XmlResolver</code> to be used at run-time to resolve and dereference URIs
            supplied to the <code>doc()</code> and <code>document()</code> functions.
            </sentence>
         </comment>
      </property>
      <property id="ResultDocumentHandler"
                type="IResultDocumentHandler"
                get="true"
                set="true">
         <comment>
            <sentence>
            The <code>IResultDocumentHandler</code> to be used at run-time to process the output
            produced by any <code>xsl:result-document</code> instruction with an <code>href</code>
            attribute.
            </sentence>
            <body>
               <div>
                  <p>
            The <code>IResultDocumentHandler</code> to be used at run-time to process the output
            produced by any <code>xsl:result-document</code> instruction with an <code>href</code>
            attribute.
            </p>
                  <p>
            In the absence of a user-supplied result document handler, the <c>href</c>
            attribute of the <c>xsl:result-document</c> instruction must be a valid relative
            URI, which is resolved against the value of the <c>BaseOutputUri</c> property,
            and the resulting absolute URI must identify a writable resource (typically
            a file in filestore, using the <c>file:</c> URI scheme).
            </p>
               </div>
            </body>
         </comment>
      </property>
      <property id="MessageListener"
                type="IMessageListener"
                get="true"
                set="true">
         <comment>
            <sentence>
            Listener for messages output using &lt;xsl:message&gt;. 
            <p>The caller may supply a message listener before calling <code>Run</code>;
            the processor will then invoke the listener once for each message generated during
            the transformation. Each message will be output as an object of type <code>XdmNode</code>
            representing a document node.</p>
               <p>If no message listener is supplied by the caller, message information will be written to
            the standard error stream.</p>
            </sentence>
            <body>
               <div>
                  <p>
            Listener for messages output using &lt;xsl:message&gt;. 
            <p>The caller may supply a message listener before calling <code>Run</code>;
            the processor will then invoke the listener once for each message generated during
            the transformation. Each message will be output as an object of type <code>XdmNode</code>
            representing a document node.</p>
                     <p>If no message listener is supplied by the caller, message information will be written to
            the standard error stream.</p>
                  </p>
                  <p>Each message is presented as an XML document node. Calling <code>ToString()</code>
            on the message object will usually generate an acceptable representation of the
            message.</p>
                  <p>When the &lt;xsl:message&gt; instruction specifies <code>terminate="yes"</code>,
            the message is first notified using this interface, and then an exception is thrown
            which terminates the transformation.</p>
               </div>
            </body>
         </comment>
      </property>
      <property id="TraceFunctionDestination"
                type="Stream"
                get="true"
                set="true">
         <comment>
            <sentence>
            Destination for output of messages using &lt;trace()&gt;. 
            <p>If no message listener is supplied by the caller, message information will be written to
            the standard error stream.</p>
            </sentence>
            <body>
               <div>
                  <p>
            Destination for output of messages using &lt;trace()&gt;. 
            <p>If no message listener is supplied by the caller, message information will be written to
            the standard error stream.</p>
                  </p>
                  <p>The supplied destination is ignored if a <code>TraceListener</code> is in use.</p>
               </div>
            </body>
         </comment>
      </property>
      <property id="Implementation" type="Controller" get="true">
         <comment>
            <sentence>
            Escape hatch to the underlying Java implementation
            </sentence>
         </comment>
      </property>
      <methods>
         <method id="SetInputStream"
                 visibility="public"
                 type="void"
                 fulltype="Saxon.Api.void">
         
         
            <comment>
               <sentence>
            Supply the principal input document for the transformation in the form of a stream.
            </sentence>
               <body>
                  <div>
                     <p>
            Supply the principal input document for the transformation in the form of a stream.
            </p>
                     <p>If this method is used, the <code>InitialContextNode</code> is ignored.</p>
                     <p>The supplied stream will be consumed by the <code>Run()</code> method.
            Closing the input stream after use is the client's responsibility.</p>
                     <p>A base URI must be supplied in all cases. It is used to resolve relative
            URI references appearing within the input document.</p>
                     <p>Schema validation is applied to the input document according to the value of
            the <code>SchemaValidationMode</code> property.</p>
                     <p>Whitespace stripping is applied according to the value of the
            <code>xsl:strip-space</code> and <code>xsl:preserve-space</code> declarations in the stylesheet.</p>
                  </div>
               </body>
            
            
            </comment>
            <params>
               <param fulltype="System.IO.Stream" type="Stream" name="input">
            The stream containing the source code of the principal input document to the transformation. The document
            node at the root of this document will be the initial context node for the transformation.
            </param>
               <param fulltype="System.Uri" type="Uri" name="baseUri">
            The base URI of the principal input document. This is used for example by the <c>document()</c>
            function if the document contains links to other documents in the form of relative URIs.</param>
            </params>
         </method>
         <method id="SetParameter"
                 visibility="public"
                 type="void"
                 fulltype="Saxon.Api.void">
         
         
            <comment>
               <sentence>
            Set the value of a stylesheet parameter.
            </sentence>
            
            
            </comment>
            <params>
               <param fulltype="Saxon.Api.QName" type="QName" name="name">The name of the parameter, expressed
            as a QName. If a parameter of this name has been declared in the
            stylesheet, the given value will be assigned to the variable. If the
            variable has not been declared, calling this method has no effect (it is
            not an error).</param>
               <param fulltype="Saxon.Api.XdmValue" type="XdmValue" name="value">The value to be given to the parameter.
            If the parameter declaration defines a required type for the variable, then
            this value will be converted in the same way as arguments to function calls
            (for example, numeric promotion is applied).</param>
            </params>
         </method>
         <method id="Run"
                 visibility="public"
                 type="void"
                 fulltype="Saxon.Api.void">
         
            <comment>
               <sentence>
            Run the transformation, sending the result to a specified destination.
            </sentence>
            
            
            </comment>
            <params>
               <param fulltype="Saxon.Api.XmlDestination"
                      type="XmlDestination"
                      name="destination">
            The destination for the results of the stylesheet. The class <c>XmlDestination</c>
            is an abstraction that allows a number of different kinds of destination
            to be specified.
            </param>
            </params>
            <exceptions/>
         </method>
      </methods>
   </class>
   <enum id="RecoveryPolicy"
         fulltype="Saxon.Api.RecoveryPolicy"
         visibility="public">
      <comment>
         <sentence>
            RecoveryPolicy is an enumeration of the different actions that can be taken when a "recoverable error" occurs
            </sentence>
      </comment>
      <fields>
         <field id="RecoverSilently" type="" visibility="public">
            <comment>
               <sentence>
            Ignore the error, take the recovery action, do not produce any message
            </sentence>
            </comment>
         </field>
         <field id="RecoverWithWarnings" type="" visibility="public">
            <comment>
               <sentence>
            Take the recovery action after outputting a warning message
            </sentence>
            </comment>
         </field>
         <field id="DoNotRecover" type="" visibility="public">
            <comment>
               <sentence>
            Treat the error as fatal
            </sentence>
            </comment>
         </field>
      </fields>
   </enum>
   <interface id="IResultDocumentHandler"
              fulltype="Saxon.Api.IResultDocumentHandler"
              visibility="public"
              superclass="object"
              superclassfulltype="System.Object">
      <comment>
         <sentence>An <code>IResultDocumentHandler</code> can be nominated to handle output
             produced by the <code>xsl:result-document</code> instruction in an XSLT stylesheet.
            </sentence>
         <body>
            <div>
               <p>An <code>IResultDocumentHandler</code> can be nominated to handle output
             produced by the <code>xsl:result-document</code> instruction in an XSLT stylesheet.
            </p>
               <p>This interface affects any <code>xsl:result-document</code> instruction
             executed by the stylesheet, provided that it has an <code>href</code> attribute.</p> 
               <p>If no <code>IResultDocumentHandler</code> is nominated (in the
             <code>IResultDocumentHandler</code> property of the <code>XsltTransformer</code>), the output
             of <code>xsl:result-document</code> is serialized, and is written to the file
             or other resource identified by the URI in the <code>href</code> attribute, resolved
             (if it is relative) against the URI supplied in the <code>BaseOutputUri</code> property
             of the <code>XsltTransformer</code>.</p>
               <p>If an <code>IResultDocumentHandler</code> is nominated, however, its
             <code>HandleResultDocument</code> method will be called whenever an <code>xsl:result-document</code>
             instruction with an <code>href</code> attribute is evaluated, and the generated result tree
             will be passed to the <code>XmlDestination</code> returned by that method.</p> 
            </div>
         </body>
      </comment>
      <methods>
         <method id="HandleResultDocument"
                 visibility="public"
                 type="XmlDestination"
                 fulltype="Saxon.Api.XmlDestination">
         
         
         
            <params>
               <param fulltype="string" type="string"/>
               <param fulltype="System.Uri" type="Uri"/>
            </params>
         </method>
      </methods>
   </interface>
   <class id="ResultDocumentHandlerWrapper"
          fulltype="Saxon.Api.ResultDocumentHandlerWrapper"
          visibility="protected"
          superclass="JOutputURIResolver"
          superclassfulltype="net.sf.saxon.lib.OutputURIResolver">
      <methods>
         <constructor id="ResultDocumentHandlerWrapper" visibility="public">
            <params/>
         </constructor>
         <method id="newInstance"
                 visibility="public"
                 type="JOutputURIResolver"
                 fulltype="net.sf.saxon.lib.OutputURIResolver">
         
            <params/>
         </method>
         <method id="resolve"
                 visibility="public"
                 type="JResult"
                 fulltype="javax.xml.transform.Result">
         
            <params/>
         </method>
         <method id="close"
                 visibility="public"
                 type="void"
                 fulltype="Saxon.Api.void">
         
            <params/>
         </method>
      </methods>
   </class>
   <interface id="IMessageListener"
              fulltype="Saxon.Api.IMessageListener"
              visibility="public"
              superclass="object"
              superclassfulltype="System.Object">
      <comment>
         <sentence>An <code>IMessageListener</code> can be nominated to handle output
             produced by the <code>xsl:message</code> instruction in an XSLT stylesheet.
            </sentence>
         <body>
            <div>
               <p>An <code>IMessageListener</code> can be nominated to handle output
             produced by the <code>xsl:message</code> instruction in an XSLT stylesheet.
            </p>
               <p>This interface affects any <code>xsl:message</code> instruction
             executed by the stylesheet.</p> 
               <p>If no <code>IMessageListener</code> is nominated (in the
             <code>MessageListener</code> property of the <code>XsltTransformer</code>), the output
             of <code>xsl:message</code> is serialized, and is written to standard error
             output stream.</p>
               <p>If an <code>IMessageListener</code> is nominated, however, its
             <code>Message</code> method will be called whenever an <code>xsl:message</code>
             instruction is evaluated.</p> 
            </div>
         </body>
      </comment>
      <methods>
         <method id="Message"
                 visibility="public"
                 type="void"
                 fulltype="Saxon.Api.void">
         
         
         
         
            <params>
               <param fulltype="Saxon.Api.XdmNode" type="XdmNode"/>
               <param fulltype="bool" type="bool"/>
               <param fulltype="Saxon.Api.IXmlLocation" type="IXmlLocation"/>
            </params>
         </method>
      </methods>
   </interface>
   <interface id="IXmlLocation"
              fulltype="Saxon.Api.IXmlLocation"
              visibility="public"
              superclass="object"
              superclassfulltype="System.Object">
      <comment>
         <sentence>
            An <code>IXmlLocation</code> represents the location of a node within an XML document.
            It is in two parts: the base URI (or system ID) of the external entity (which will usually
            be the XML document entity itself), and the line number of a node relative
            to the base URI of the containing external entity.
            </sentence>
      </comment>
      <property id="BaseUri" type="Uri" get="true" set="true">
         
      </property>
      <property id="LineNumber" type="int" get="true" set="true">
         
      </property>
      <methods/>
   </interface>
   <class id="XmlLocation"
          fulltype="Saxon.Api.XmlLocation"
          visibility="protected"
          superclass="IXmlLocation"
          superclassfulltype="Saxon.Api.IXmlLocation">
      <property id="BaseUri" type="Uri" get="true" set="true">
         
      </property>
      <property id="LineNumber" type="int" get="true" set="true">
         
      </property>
   </class>
   <class id="MessageListenerProxy"
          fulltype="Saxon.Api.MessageListenerProxy"
          visibility="protected"
          superclass="JSequenceWriter"
          superclassfulltype="Saxon.Api.JSequenceWriter">
      <property id="listener" type="IMessageListener">
         
      </property>
      <property id="terminate" type="bool">
         
      </property>
      <property id="locationId" type="int">
         
      </property>
      <methods>
         <constructor id="MessageListenerProxy" visibility="public">
            <params/>
         </constructor>
         <method id="startDocument"
                 visibility="public"
                 type="void"
                 fulltype="Saxon.Api.void">
         
            <params/>
         </method>
         <method id="startElement"
                 visibility="public"
                 type="void"
                 fulltype="Saxon.Api.void">
         
            <params/>
         </method>
         <method id="characters"
                 visibility="public"
                 type="void"
                 fulltype="Saxon.Api.void">
         
            <params/>
         </method>
         <method id="append"
                 visibility="public"
                 type="void"
                 fulltype="Saxon.Api.void">
         
            <params/>
         </method>
         <method id="write"
                 visibility="public"
                 type="void"
                 fulltype="Saxon.Api.void">
         
            <params/>
         </method>
      </methods>
   </class>
</package>