<?xml version="1.0"?>
<doc>
    <assembly>
        <name>saxon-he-api-10.9</name>
    </assembly>
    <members>
        <member name="T:Saxon.Api.Processor">
            <summary>
            The <c>Processor</c> 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 <c>NamePool</c> and 
            compiled schemas. This is the first object that a Saxon application should create. Once
            established, a <c>Processor</c> may be used in multiple threads.
            </summary>
        </member>
        <member name="M:Saxon.Api.Processor.#ctor">
            <summary>
            Create a new <c>Processor</c>. This <c>Processor</c> will have capabilities that depend on the version
            of the software that has been loaded, and on the features that have been licensed.
            </summary>
        </member>
        <member name="M:Saxon.Api.Processor.#ctor(System.Boolean)">
            <summary>
            Create a <c>Processor</c>.
            </summary>
            <param name="licensedEdition">Set to true if the <c>Processor</c> is to use a licensed edition of Saxon
            (that is, Saxon-PE or Saxon-EE). If true, the <c>Processor</c> 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 <c>Processor</c> will load a default <c>Configuration</c> that gives restricted
            capability and does not require a license, regardless of which version of the software is actually being run.</param>
        </member>
        <member name="M:Saxon.Api.Processor.#ctor(System.Boolean,System.Boolean)">
            <summary>
            Create a <c>Processor</c>.
            </summary>
            <param name="licensedEdition">Set to true if the <c>Processor</c> is to use a licensed edition of Saxon
            (that is, Saxon-PE or Saxon-EE). If true, the <c>Processor</c> 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 <c>Processor</c> will load a default <c>Configuration</c> that gives restricted
            capability and does not require a license, regardless of which version of the software is actually being run.</param>
            <param name="loadLocally">This option has no effect at this release.</param>
        </member>
        <member name="M:Saxon.Api.Processor.#ctor(System.IO.Stream)">
            <summary>
            Create a <c>Processor</c>, based on configuration information supplied in a configuration file.
            </summary>
            <param 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>
        </member>
        <member name="M:Saxon.Api.Processor.#ctor(System.IO.Stream,System.Uri)">
            <summary>
            Create a <c>Processor</c>, based on configuration information supplied in a configuration file.
            </summary>
            <param 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>
            <param name="baseUri">baseUri of the configuration file used for resolving any relative URIs in the file</param> 
        </member>
        <member name="M:Saxon.Api.Processor.RegisterCollection(System.String,Saxon.Api.IResourceCollection)">
            <summary>
            Register a specific URI and bind it to a specific <c>ResourceCollection</c>
            </summary>
            <param name="collectionURI">the collection URI to be registered. Must not be null.</param>
            <param name="collection">the ResourceCollection to be associated with this URI. Must not be null.</param>
        </member>
        <member name="M:Saxon.Api.Processor.BindExtensions(System.String,System.Type)">
            <summary>
            Declare a mapping from a specific namespace URI to a .NET class
            This will get applied to Saxon-PEN or Saxon-EEN product
            </summary>
            <param name="uri">the namespace URI of the function name</param>
            <param name="type">the .NET class that implements the functions in this namespace</param>
        </member>
        <member name="M:Saxon.Api.Processor.NewDocumentBuilder">
            <summary>
            Create a new <c>DocumentBuilder</c>, which may be used to build XDM documents from
            a variety of sources.
            </summary>
            <returns>A new <c>DocumentBuilder</c></returns>
        </member>
        <member name="M:Saxon.Api.Processor.NewXQueryCompiler">
            <summary>
            Create a new <c>XQueryCompiler</c>, which may be used to compile XQuery queries.
            </summary>
            <remarks>
            The returned <c>XQueryCompiler</c> retains a live link to the <c>Processor</c>, and
            may be affected by subsequent changes to the <c>Processor</c>.
            </remarks>
            <returns>A new <c>XQueryCompiler</c></returns>
        </member>
        <member name="M:Saxon.Api.Processor.NewXsltCompiler">
            <summary>
            Create a new <c>XsltCompiler</c>, which may be used to compile XSLT stylesheets.
            </summary>
            <remarks>
            The returned <c>XsltCompiler</c> retains a live link to the <c>Processor</c>, and
            may be affected by subsequent changes to the <c>Processor</c>.
            </remarks>
            <returns>A new <c>XsltCompiler</c></returns>
        </member>
        <member name="M:Saxon.Api.Processor.NewXPathCompiler">
            <summary>
            Create a new <c>XPathCompiler</c>, which may be used to compile XPath expressions.
            </summary>
            <remarks>
            The returned <c>XPathCompiler</c> retains a live link to the <c>Processor</c>, and
            may be affected by subsequent changes to the <c>Processor</c>.
            </remarks>
            <returns>A new <c>XPathCompiler</c></returns>
        </member>
        <member name="M:Saxon.Api.Processor.NewSerializer">
            <summary>
            Create a <c>Serializer</c>
            </summary>
            <returns> a new <c>Serializer</c> </returns>
        </member>
        <member name="M:Saxon.Api.Processor.NewSerializer(System.IO.TextWriter)">
            <summary>
            Create a <c>Serializer</c> initialized to write to a given <c>TextWriter</c>.
            Closing the writer after use is the responsibility of the caller.
            </summary>
            <param name="textWriter">The <c>TextWriter</c> to which the <c>Serializer</c> will write</param>
            <returns> a new <c>Serializer</c> </returns>
        </member>
        <member name="M:Saxon.Api.Processor.NewSerializer(System.IO.Stream)">
            <summary>
            Create a <c>Serializer</c> initialized to write to a given output <c>Stream</c>.
            Closing the output stream after use is the responsibility of the caller.
            </summary>
            <param name="stream">The output <c>Stream</c> to which the <c>Serializer</c> will write</param>
            <returns> a new Serializer </returns>
        </member>
        <member name="M:Saxon.Api.Processor.DeclareCollation(System.Uri,System.Globalization.CompareInfo,System.Globalization.CompareOptions)">
            <summary>
            Create a collation based on a given <c>CompareInfo</c> and <c>CompareOptions</c>    
            </summary>
            <param name="uri">The collation URI to be used within an XPath expression to refer to this collation</param>
            <param name="compareInfo">The <c>CompareInfo</c>, which determines the language-specific
            collation rules to be used</param>
            <param name="options">Options to be used in performing comparisons, for example
            whether they are to be case-blind and/or accent-blind</param>
        </member>
        <member name="M:Saxon.Api.Processor.RegisterCollection(System.Uri,System.Collections.IEnumerable)">
            <summary>
            Register a named collection. A collection is identified by a URI (the collection URI),
            and its content is represented by an <c>IEnumerable</c> 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 <c>XmlResolver</c>.
            </summary>
            <param 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 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>
            <remarks>
            <para>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.</para>
            <para>A collection may be replaced by specifying the URI of an existing
            collection.</para>
            <para>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.</para>
            </remarks>
            
        </member>
        <member name="M:Saxon.Api.Processor.RegisterExtensionFunction(Saxon.Api.ExtensionFunctionDefinition)">
            <summary>
            Register an extension function with the <c>Processor</c>
            </summary>
            <param 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>
        </member>
        <member name="M:Saxon.Api.Processor.RegisterExtensionFunction(Saxon.Api.ExtensionFunction)">
            <summary>
            Register a simple external/extension function that is to be made available within any stylesheet, query
            or XPath expression compiled under the control of this <c>Processor</c>
            </summary>
            <param name="function">
            This interface provides only for simple extensions that have no side-effects and no
            dependencies on the static or dynamic context.
            </param>
        </member>
        <member name="M:Saxon.Api.Processor.RegisterFileExtension(System.String,System.String)">
            <summary>
            Set the media type to be associated with a file extension by  the standard collection handler
            </summary>
            <param name="extension">the file extension, for exmaple "xml". The value "" sets the 
            default media type to be used for unregistered file extensions</param>
            <param name="mediaType">the corresponding media type, for example "application/xml". The
            choice of media type determines how a resource with this extension gets parsed, when the file 
            appears as part of a collection</param>
        </member>
        <member name="M:Saxon.Api.Processor.RegisterMediaType(System.String,Saxon.Api.IResourceFactory)">
            <summary>
            Associated a media type with a resource factory. This methodm may be called
            to customize the behaviour of a collection to recognize different file extensions
            </summary>
            <param name="contentType">a media type or MIME type, for example application/xsd+xml</param>
            <param name="factory">a ResourceFactory used to parse (or otherweise process) resource of that type</param>
        </member>
        <member name="M:Saxon.Api.Processor.GetMediaTypeForFileExtension(System.String)">
            <summary>
            Get the media type to be associated with a file extension by the standard 
            collection handler
            </summary>
            <param name="extension">the file extension, for example "xml". The value "" gets
            the default media type to be used for unregistered file extensions. The default 
            media type is also returned if the supplied file extension is not registered</param>
            <returns>the corresponding media type, for example "application/xml". The choice
            of media type determines how a resource with this extension gets parsed, when the file
            appears as part of a collection.</returns>
        </member>
        <member name="M:Saxon.Api.Processor.WriteXdmValue(Saxon.Api.XdmValue,Saxon.Api.XmlDestination)">
            <summary>
            Copy an <c>XdmValue</c> to an <c>XmlDestination</c>
            </summary>
            <remarks>
            In principle this method can be used to copy any kind of <c>XdmValue</c> to any kind
            of <c>XmlDestination</c>. However, some kinds of destination may not accept arbitrary
            sequences of items; for example, some may reject function items. Some destinations
            perform sequence normalization, as defined in the W3C serialization specification,
            to convert the supplied sequence to a well-formed XML document; it is a property
            of the chosen <c>XmlDestination</c> whether it does this or not.</remarks>
            <param name="sequence">The value to be written</param>
            <param name="destination">The destination to which the value should be written</param>
            
        </member>
        <member name="M:Saxon.Api.Processor.SetProperty(System.String,System.String)">
            <summary>
            Set a configuration property
            </summary>
            <remarks>
            <para>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 <c>net.sf.saxon.FeatureKeys</c>. 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".</para>
            <para><i>Method added in Saxon 9.1</i></para>
            </remarks>
            <param name="name">The property name</param>
            <param name="value">The property value</param>
        </member>
        <member name="M:Saxon.Api.Processor.SetProperty``1(Saxon.Api.Feature{``0},``0)">
            <summary>
            Set a configuration property
            </summary>
            <param name="feature">The property feature</param>
            <param name="value">The property value</param>
        </member>
        <member name="M:Saxon.Api.Processor.GetProperty(System.String)">
            <summary>
            Get the value of a configuration property
            </summary>
            <remarks>
            <para>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 <c>net.sf.saxon.FeatureKeys</c>. 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".</para>
            <para><i>Method added in Saxon 9.1</i></para>
            </remarks>
            <param name="name">The property name</param>
            <returns>The property value, as a string; or null if the property is unset.</returns>
        </member>
        <member name="M:Saxon.Api.Processor.GetProperty``1(Saxon.Api.Feature{``0})">
            <summary>
            Get a property of the configuration
            </summary>
            <typeparam name="T">See the class <c>Feature</c> for constants 
            representing the properties that can be requested.</typeparam>
            <param name="feature">the required property. </param>
            <returns>the value of the property</returns>
        </member>
        <member name="P:Saxon.Api.Processor.CollectionFinder">
            <summary>
            A used-supplied callback that is used to retrieve a resource collection given a collection URI.
            </summary>
            <remarks>
            <para>If no collection finder is supplied, then the built-in collection finder is used. The
            built-in collection finder recognizes various kinds of collection including directory collections
            and catalog collections. A user-defined collection finder can delegate to the built-in collection finder
            by invoking the function available as <c>Processor.StandardCollectionFinder</c>.</para>
            <para>A collection finder should be set only while the processor is being initialized; the
            effect of changing the collection finder (or changing any data on which it depends) while
            queries or transformations are in progress is undefined.</para>
            <para>The collection finder returns a set of <c>IResource</c> objects. Typically a used-defined
            class implementing <c>IResource</c> is used. An <c>IResource</c> has a resource URI, a content type
            (MIME or media type), and a method to deliver the resource content as an <c>XdmItem</c>. Typically
            fetching the resource over the network, and parsing it according to the rules of the relevant content
            type, is delayed until the <c>GetXdmItem</c> method is called.</para>
            <para>For deterministic results, and for W3C conformance, it is recommended that the supplied function
            should be deterministic: repeated calls for the same collection URI should deliver the same set of
            resources. However, this requirement can lead to high memory requirements, so Saxon does not enforce it.</para>
            <para>The <c>CollectionFinder</c> registered with a processor is available to all queries and stylesheets
            running under the control of that processor.</para>
            </remarks>
        </member>
        <member name="P:Saxon.Api.Processor.StandardCollectionFinder">
            <summary>
            The standard (built-in) collection finder that is used by default if no user-defined
            collection finder has been supplied. This is exposed as a property of the <c>Processor</c>
            so that it can be invoked by a user-written collection finder.
            </summary>
        </member>
        <member name="P:Saxon.Api.Processor.ProductTitle">
            <summary>
            Get the full name of the Saxon product version implemented by this <c>Processor</c>
            </summary>
        </member>
        <member name="P:Saxon.Api.Processor.ProductVersion">
            <summary>
            Get the Saxon product version number (for example, "9.2.0.2")
            </summary>
        </member>
        <member name="P:Saxon.Api.Processor.Edition">
            <summary>
            Get the Saxon product edition (for example, "EE" for Enterprise Edition)
            </summary>
            
        </member>
        <member name="P:Saxon.Api.Processor.SchemaManager">
            <summary>
            Gets the <c>SchemaManager</c> for the <c>Processor</c>. Returns null
            if the <c>Processor</c> is not schema-aware.
            </summary>
        </member>
        <member name="P:Saxon.Api.Processor.XmlResolver">
            <summary>
            An <c>XmlResolver</c>, which will be used while compiling and running queries, 
            XPath expressions, and stylesheets, if no other <c>XmlResolver</c> is nominated
            </summary>
            <remarks>
            <para>By default an <c>XmlUrlResolver</c> is used. This means that the responsibility
            for resolving and dereferencing URIs rests with the .NET platform, not with the
            IKVM/OpenJDK runtime.</para>
            <para>When Saxon invokes a user-written <c>XmlResolver</c>, the <c>GetEntity</c> method
            may return any of: a <c>System.IO.Stream</c>; a <c>System.IO.TextReader</c>; or a
            <c>java.xml.transform.Source</c>.</para>
            </remarks>
        </member>
        <member name="P:Saxon.Api.Processor.ErrorWriter">
            <summary>
            A <c>TextWriter</c> used as the destination of miscellaneous error, warning, and progress messages.
            </summary>
            <remarks>
            <para>By default the <c>Console.Error</c> is used for all such messages.</para>
            <para>A user can supply their own <c>TextWriter</c> to redirect error messages from the standard output.</para>
            </remarks>
        </member>
        <member name="P:Saxon.Api.Processor.XmlVersion">
            <summary>
            The XML version used in this <c>Processor</c>
            </summary>
            <remarks>
            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.
            </remarks>
        </member>
        <member name="P:Saxon.Api.Processor.Implementation">
            <summary>
            The underlying <c>Configuration</c> object in the Saxon implementation
            </summary>
            <remarks>
            <para>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.</para> 
            <para>The internal methods follow
            Java naming conventions rather than .NET conventions.</para>
            <para>Information about the returned <see cref="T:net.sf.saxon.Configuration"/> object 
            (and the objects it provides access to) is included in the Saxon JavaDoc docmentation.
            </para>
            </remarks>
        </member>
        <member name="P:Saxon.Api.Processor.QueryResolver">
            <summary>
            A user-supplied <c>IQueryResolver</c> used to resolve location hints appearing in an
            <c>import module</c> declaration.
            </summary>
            <remarks>
            <para>This acts as the default value for the ModuleURIResolver.</para>
            <para> The URI Resolver for XQuery modules. May be null, in which case any 
            existing Module URI Resolver is removed  from the Configuration</para>
            </remarks>
        </member>
        <member name="P:Saxon.Api.Processor.JProcessor">
            <summary>
            The underlying <c>net.sf.saxon.s9api.Processor</c> in the Java implementation
            </summary>
        </member>
        <member name="T:Saxon.Api.DocumentBuilder">
            <summary>
            The <c>DocumentBuilder</c> class enables XDM documents to be built from various sources.
            The class is always instantiated using the <c>NewDocumentBuilder</c> method
            on the <c>Processor</c> object.
            </summary>
        </member>
        <member name="M:Saxon.Api.DocumentBuilder.Build(System.Uri)">
            <summary>
            Load an XML document, retrieving it via a URI.
            </summary>
            <remarks>
            <para>Note that the type <c>Uri</c> requires an absolute URI.</para>
            <para>The URI is dereferenced using the registered <c>XmlResolver</c>.</para>
            <para>This method takes no account of any fragment part in the URI.</para>
            <para>The <c>role</c> passed to the <c>GetEntity</c> method of the <c>XmlResolver</c> 
            is "application/xml", and the required return type is <c>System.IO.Stream</c>.</para>
            <para>The document located via the URI is parsed using the <c>System.Xml</c> parser.</para>
            <para>Note that the Microsoft <c>System.Xml</c> parser does not report whether attributes are
            defined in the DTD as being of type <c>ID</c> and <c>IDREF</c>. This is true whether or not
            DTD-based validation is enabled. This means that such attributes are not accessible to the 
            <c>id()</c> and <c>idref()</c> functions.</para>
            </remarks>
            <param 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>
            <returns>An <c>XdmNode</c>, the document node at the root of the tree of the resulting
            in-memory document.
            </returns>
        </member>
        <member name="M:Saxon.Api.DocumentBuilder.Build(System.IO.Stream)">
            <summary>
            Load an XML document supplied as raw (lexical) XML on a <c>Stream</c>.
            </summary>
            <remarks>
            <para>The document is parsed using the Microsoft <c>System.Xml</c> parser if the
            "http://saxon.sf.net/feature/preferJaxpParser" property on the <c>Processor</c> is set to false;
            otherwise it is parsed using the Apache Xerces XML parser.</para>
            <para>Before calling this method, the <c>BaseUri</c> property must be set to identify the
            base URI of this document, used for resolving any relative URIs contained within it.</para>
            <para>Note that the Microsoft <c>System.Xml</c> parser does not report whether attributes are
            defined in the DTD as being of type <c>ID</c> and <c>IDREF</c>. This is true whether or not
            DTD-based validation is enabled. This means that such attributes are not accessible to the 
            <c>id()</c> and <c>idref()</c> functions.</para>         
            </remarks>
            <param name="input">The <c>Stream</c> containing the XML source to be parsed. Closing this stream
            on completion is the responsibility of the caller.</param>
            <returns>An <c>XdmNode</c>, the document node at the root of the tree of the resulting
            in-memory document.
            </returns>
        </member>
        <member name="M:Saxon.Api.DocumentBuilder.Build(System.IO.TextReader)">
            <summary>
            Load an XML document supplied using a <c>TextReader</c>.
            </summary>
            <remarks>
            <para>The document is parsed using the Microsoft <c>System.Xml</c> parser if the
            "http://saxon.sf.net/feature/preferJaxpParser" property on the <c>Processor</c> is set to false;
            otherwise it is parsed using the Apache Xerces XML parser.</para>
            <para>Before calling this method, the <c>BaseUri</c> property must be set to identify the
            base URI of this document, used for resolving any relative URIs contained within it.</para>
            <para>Note that the Microsoft <c>System.Xml</c> parser does not report whether attributes are
            defined in the DTD as being of type <c>ID</c> and <c>IDREF</c>. This is true whether or not
            DTD-based validation is enabled. This means that such attributes are not accessible to the 
            <c>id()</c> and <c>idref()</c> functions.</para>         
            </remarks>
            <param name="input">The <c>TextReader</c> containing the XML source to be parsed</param>
            <returns>An <c>XdmNode</c>, the document node at the root of the tree of the resulting
            in-memory document.
            </returns>
        </member>
        <member name="M:Saxon.Api.DocumentBuilder.Build(System.Xml.XmlReader)">
            <summary>
            Load an XML document, delivered using an <c>XmlReader</c>.
            </summary>
            <remarks>
            <para>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 returns its document node.
            The <c>XmlReader</c> is not required to perform validation but it must expand any entity references.
            Saxon uses the properties of the <c>XmlReader</c> as supplied.</para>
            <para>Use of a plain <c>XmlTextReader</c> 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 <c>XmlValidatingReader</c> (with <c>ValidationType</c>
            set to <c>None</c>). The constructor for <c>XmlValidatingReader</c> is obsolete in .NET 2.0,
            but the same effect can be achieved by using the <c>Create</c> method of <c>XmlReader</c> with
            appropriate <c>XmlReaderSettings</c>.</para>
            <para>Conformance with the W3C specifications requires that the <c>Normalization</c> property
            of an <c>XmlTextReader</c> should be set to <c>true</c>. However, Saxon does not insist
            on this.</para>
            <para>If the <c>XmlReader</c> 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 <c>SchemaValidationMode</c> property is set to <c>Strict</c> or <c>Lax</c>.</para>
            <para>Note that the Microsoft <c>System.Xml</c> parser does not report whether attributes are
            defined in the DTD as being of type <c>ID</c> and <c>IDREF</c>. This is true whether or not
            DTD-based validation is enabled. This means that such attributes are not accessible to the 
            <c>id()</c> and <c>idref()</c> functions.</para>
            <para>Note that setting the <c>XmlResolver</c> property of the <c>DocumentBuilder</c>
            has no effect when this method is used; if an <c>XmlResolver</c> is required, it must
            be set on the <c>XmlReader</c> itself.</para>
            </remarks>
            <param name="reader">The <c>XMLReader</c> that supplies the parsed XML source</param>
            <returns>An <c>XdmNode</c>, the document node at the root of the tree of the resulting
            in-memory document.
            </returns>
        </member>
        <member name="M:Saxon.Api.DocumentBuilder.Build(System.Xml.XmlNode)">
            <summary>
            Load an XML DOM document, supplied as an <c>XmlNode</c>, into a Saxon <c>XdmNode</c>.
            </summary>
            <remarks>
            <para>
            The returned document will contain only the subtree rooted at the supplied node.
            </para>
            <para>
            This method copies the DOM tree to create a Saxon tree. See the <c>Wrap</c> method for
            an alternative that creates a wrapper around the DOM tree, allowing it to be modified in situ.
            </para>
            </remarks>
            <param name="source">The DOM Node to be copied to form a Saxon tree</param>
            <returns>An <c>XdmNode</c>, the document node at the root of the tree of the resulting
            in-memory document.
            </returns>
        </member>
        <member name="M:Saxon.Api.DocumentBuilder.Wrap(System.Xml.XmlDocument)">
            <summary>
            Wrap an XML DOM document, supplied as an <c>XmlNode</c>, as a Saxon <c>XdmNode</c>.
            </summary>
            <remarks>
            <para>
            This method must be applied at the level of the Document Node. Unlike the
            <c>Build</c> 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.
            </para>
            </remarks>
            <param name="doc">The DOM document node to be wrapped</param>
            <returns>An <c>XdmNode</c>, the Saxon document node at the root of the tree of the resulting
            in-memory document.
            </returns>
        </member>
        <member name="P:Saxon.Api.DocumentBuilder.XmlResolver">
            <summary>
            An <c>XmlResolver</c>, which will be used to resolve URIs of documents being loaded
            and of references to external entities within those documents (including any external DTD).
            </summary>
            <remarks>
            <para>By default an <c>XmlUrlResolver</c> is used. This means that the responsibility
            for resolving and dereferencing URIs rests with the .NET platform (and not with the
            GNU Classpath).</para>
            <para>When Saxon invokes a user-written <c>XmlResolver</c>, the <c>GetEntity</c> method
            may return any of: a <c>System.IO.Stream</c>; a <c>System.IO.TextReader</c>; or a
            <c>java.xml.transform.Source</c>. However, if the <c>XmlResolver</c> is called
            by the XML parser to resolve external entity references, then it must return an 
            instance of <c>System.IO.Stream</c>.</para>
            </remarks>
        </member>
        <member name="P:Saxon.Api.DocumentBuilder.IsLineNumbering">
            <summary>
            Determines whether line numbering is enabled for documents loaded using this
            <c>DocumentBuilder</c>.
            </summary>
            <remarks>
            <para>By default, line numbering is disabled.</para>
            <para>Line numbering is not available for all kinds of source: in particular,
            it is not available when loading from an existing <c>XmlDocument</c>.</para>
            <para>The resulting line numbers are accessible to applications using the
            extension function <c>saxon:line-number()</c> applied to a node.</para>  
            <para>Line numbers are maintained only for element nodes; the line number
            returned for any other node will be that of the most recent element.</para> 
            </remarks>
        </member>
        <member name="P:Saxon.Api.DocumentBuilder.SchemaValidationMode">
            <summary>
            Determines whether schema validation is applied to documents loaded using this
            <c>DocumentBuilder</c>, and if so, whether it is strict or lax.
            </summary>
            <remarks>
            <para>By default, no schema validation takes place.</para>
            <para>This option requires Saxon Enterprise Edition (Saxon-EE).</para>
            </remarks>
        </member>
        <member name="P:Saxon.Api.DocumentBuilder.SchemaValidator">
            <summary>
            Property to set and get the schemaValidator to be used. This determines whether schema validation is applied
            to an input document and whether type annotations in a supplied document are retained. If no schemaValidator
            is supplied, then schema validation does not take place.
            </summary>
        </member>
        <member name="P:Saxon.Api.DocumentBuilder.TopLevelElementName">
            <summary>
            The required name of the top level element in a document instance being validated
            against a schema.
            </summary>
            <remarks>
            <para>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.</para>
            <para>This option requires the schema-aware version of the Saxon product (Saxon-EE).</para>
            </remarks> 
        </member>
        <member name="P:Saxon.Api.DocumentBuilder.DtdValidation">
            <summary>
            Determines whether DTD validation is applied to documents loaded using this
            <c>DocumentBuilder</c>.
            </summary>
            <remarks>
            <para>By default, no DTD validation takes place.</para>
            </remarks>
        </member>
        <member name="P:Saxon.Api.DocumentBuilder.WhitespacePolicy">
            <summary>
            Determines the whitespace stripping policy applied when loading a document
            using this <c>DocumentBuilder</c>.
            </summary>
            <remarks>
            <para>By default, whitespace text nodes appearing in element-only content
            are stripped, and all other whitespace text nodes are retained.</para>
            </remarks>
        </member>
        <member name="P:Saxon.Api.DocumentBuilder.TreeModel">
            <summary>
             The Tree Model implementation to be used for the constructed document. By default
             the <c>TinyTree</c> is used. The main reason for using the <c>LinkedTree</c> alternative is if
             updating is required (the <c>TinyTree</c> is not updateable).
            </summary>
        </member>
        <member name="P:Saxon.Api.DocumentBuilder.BaseUri">
            <summary>
            The base URI of a document loaded using this <c>DocumentBuilder</c>.
            This is used for resolving any relative URIs appearing
            within the document, for example in references to DTDs and external entities.
            </summary>
            <remarks>
            This information is required when the document is loaded from a source that does not
            provide an intrinsic URI, notably when loading from a <c>Stream</c> or a <c>TextReader</c>.
            </remarks>
        </member>
        <member name="P:Saxon.Api.DocumentBuilder.DocumentProjectionQuery">
            <summary>
            Set a compiled query to be used for implementing document projection. 
            </summary>
            <remarks>
            <para>
            The effect of using this option is that the tree constructed by the 
            <c>DocumentBuilder</c> contains only those parts
            of the source document that are needed to answer this query. Running this query against
            the projected document should give the same results as against the raw document, but the
            projected document typically occupies significantly less memory. It is permissible to run
            other queries against the projected document, but unless they are carefully chosen, they
            will give the wrong answer, because the document being used is different from the original.
            </para>
            <para>The query should be written to use the projected document as its initial context item.
            For example, if the query is <code>//ITEM[COLOR='blue']</code>, then only <code>ITEM</code>
            elements and their <code>COLOR</code> children will be retained in the projected document.</para>
            <para>This facility is only available in Saxon-EE; if the facility is not available,
            calling this method has no effect.</para>
            </remarks>
        </member>
        <member name="T:Saxon.Api.StandardLogger">
            <summary>The default Logger used by Saxon on the .NET platform. All messages are written by
            default to System.err. The logger can be configured by setting a different output
            destination, and by setting a minimum threshold for the severity of messages to be output.</summary>
        </member>
        <member name="M:Saxon.Api.StandardLogger.#ctor">
            <summary>
            Default constructor that wraps a <c>TextWriter</c> to write Saxon messages
            </summary>
        </member>
        <member name="M:Saxon.Api.StandardLogger.#ctor(System.IO.TextWriter)">
            <summary>
            Constructor method to supply a user defined TextWriter to the logger
            </summary>
            <param name="w"></param>
        </member>
        <member name="M:Saxon.Api.StandardLogger.asStreamResult">
            <summary>
            Java internal streamResult object wrapping the TextWriter
            </summary>
            <returns></returns>
        </member>
        <member name="M:Saxon.Api.StandardLogger.println(System.String,System.Int32)">
            <summary>
            Write the message to the TextWriter object
            </summary>
            <param name="str">The message</param>
            <param name="severity">the severity of the error message</param>
        </member>
        <member name="P:Saxon.Api.StandardLogger.UnderlyingTextWriter">
            <summary>
            Property to get the udnerlying TextWriter object.
            </summary>
        </member>
        <member name="P:Saxon.Api.StandardLogger.Threshold">
            <summary> Set the minimum threshold for the severity of messages to be output. Defaults to
            <see cref="!:net.sf.saxon.lib.Logger#INFO"/>. Messages whose severity is below this threshold will be ignored. </summary>
            <param name="threshold">the minimum severity of messages to be output. </param>
        </member>
        <member name="T:Saxon.Api.SchemaValidationMode">
            <summary>
            Enumeration identifying the various Schema validation modes
            </summary>
        </member>
        <member name="F:Saxon.Api.SchemaValidationMode.None">
            <summary>No validation (or strip validation, which removes existing type annotations)</summary> 
        </member>
        <member name="F:Saxon.Api.SchemaValidationMode.Strict">
            <summary>Strict validation</summary>
        </member>
        <member name="F:Saxon.Api.SchemaValidationMode.Lax">
            <summary>Lax validation</summary>
        </member>
        <member name="F:Saxon.Api.SchemaValidationMode.Preserve">
            <summary>Validation mode preserve, which preserves any existing type annotations</summary>
        </member>
        <member name="F:Saxon.Api.SchemaValidationMode.Unspecified">
            <summary>Unspecified validation: this means that validation is defined elsewhere, for example in the
            Saxon <c>Configuration</c></summary>
        </member>
        <member name="T:Saxon.Api.HostLanguage">
            <summary>
            Identifiies a host language in which XPath expressions appear. Generally used when different error codes
            need to be returned depending on the host language.
            </summary>
        </member>
        <member name="T:Saxon.Api.WhitespacePolicy">
            <summary>
            <c>WhitespacePolicy</c> is a class defining the possible policies for handling
            whitespace text nodes in a source document.
            </summary>
            <remarks>
            Please note that since Saxon 9.7.0.8 this class has been refactored from the enumeration
            type with the same name and therefore will work as before.
            </remarks>
        </member>
        <member name="F:Saxon.Api.WhitespacePolicy.StripAll">
            <summary>All whitespace text nodes are stripped</summary>
        </member>
        <member name="F:Saxon.Api.WhitespacePolicy.StripIgnorable">
            <summary>Whitespace text nodes appearing in element-only content are stripped</summary>
        </member>
        <member name="F:Saxon.Api.WhitespacePolicy.PreserveAll">
            <summary>No whitespace is stripped</summary>
        </member>
        <member name="F:Saxon.Api.WhitespacePolicy.Unspecified">
            <summary>Unspecified means that no other value has been specifically requested</summary>
        </member>
        <member name="M:Saxon.Api.WhitespacePolicy.makeCustomPolicy(System.Predicate{Saxon.Api.QName})">
            <summary>
            Create a custom whitespace stripping policy
            </summary>
            <param name="elementTest">a predicate applied to element names, which should return true if whitespace-only
            text node children of the element are to be stripped, false if they are to be retained.</param>
            <returns>A <c>WhitespacePolicy</c> object</returns>
        </member>
        <member name="M:Saxon.Api.WhitespacePolicy.MakeCustomPolicy(System.Predicate{Saxon.Api.QName})">
            <summary>
            Create a custom whitespace stripping policy
            </summary>
            <param name="elementTest">a predicate applied to element names, which should return true if whitespace-only
            text node children of the element are to be stripped, false if they are to be retained.</param>
            <returns>A <c>WhitespacePolicy</c> object</returns>
        </member>
        <member name="T:Saxon.Api.TreeModel">
            <summary>
            Enumeration identifying the different tree model implementations
            </summary>
            
        </member>
        <member name="F:Saxon.Api.TreeModel.LinkedTree">
            <summary>
            Saxon <c>LinkedTree</c>. This tree model is primarily useful when using XQuery Update, since it is the
            only standard tree model to support updates.
            </summary>
        </member>
        <member name="F:Saxon.Api.TreeModel.TinyTree">
            <summary>
            Saxon <c>TinyTree</c>. This is the default model and is suitable for most purposes.
            </summary>
        </member>
        <member name="F:Saxon.Api.TreeModel.TinyTreeCondensed">
            <summary>
            Saxon Condensed <c>TinyTree</c>. This is a variant of the <c>TinyTree</c> 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.
            </summary>
        </member>
        <member name="F:Saxon.Api.TreeModel.Unspecified">
            <summary>
            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.
            </summary>
        </member>
        <member name="T:Saxon.Api.XmlDestination">
            <summary>
            An abstract destination for the results of a query or transformation
            </summary>
            <remarks>
            </remarks>
        </member>
        <member name="M:Saxon.Api.XmlDestination.GetUnderlyingDestination">
            <summary>
            The underlying <c>Destination</c> object in the Saxon implementation
            </summary>
            <remarks>
            <para>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.</para> 
            <para>The internal methods follow
            Java naming conventions rather than .NET conventions.</para>
            <para>Information about the returned <see cref="T:net.sf.saxon.Configuration"/> object 
            (and the objects it provides access to) is included in the Saxon JavaDoc docmentation.
            </para>
            </remarks>
            <returns>returns the underlying Destination object</returns>
            public*
        </member>
        <member name="T:Saxon.Api.Serializer">
            <summary>
            A <c>Serializer</c> takes a tree representation of XML and turns
            it into lexical XML markup.
            </summary>
            <remarks>
            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.
            </remarks>
        </member>
        <member name="F:Saxon.Api.Serializer.METHOD">
            <summary>QName identifying the serialization parameter "method". If the method
            is a user-defined method, then it is given as a QName in Clark notation, that is
            "{uri}local".</summary>
        </member>
        <member name="F:Saxon.Api.Serializer.BYTE_ORDER_MARK">
            <summary>QName identifying the serialization parameter "byte-order-mark"</summary>
        </member>
        <member name="F:Saxon.Api.Serializer.CDATA_SECTION_ELEMENTS">
            <summary>QName identifying the serialization parameter "cdata-section-elements".
            The value of this parameter is given as a space-separated list of expanded QNames in
            Clark notation, that is "{uri}local".</summary>
        </member>
        <member name="F:Saxon.Api.Serializer.DOCTYPE_PUBLIC">
            <summary>QName identifying the serialization parameter "doctype-public"</summary>
        </member>
        <member name="F:Saxon.Api.Serializer.DOCTYPE_SYSTEM">
            <summary>QName identifying the serialization parameter "doctype-system"</summary>
        </member>
        <member name="F:Saxon.Api.Serializer.ENCODING">
            <summary>QName identifying the serialization parameter "encoding"</summary>
        </member>
        <member name="F:Saxon.Api.Serializer.ESCAPE_URI_ATTRIBUTES">
            <summary>QName identifying the serialization parameter "escape-uri-attributes".
            The value is the string "yes" or "no".</summary>
        </member>
        <member name="F:Saxon.Api.Serializer.INCLUDE_CONTENT_TYPE">
            <summary>QName identifying the serialization parameter "include-content-type".
            The value is the string "yes" or "no".</summary>
        </member>
        <member name="F:Saxon.Api.Serializer.INDENT">
            <summary>QName identifying the serialization parameter "indent".
            The value is the string "yes" or "no".</summary>
        </member>
        <member name="F:Saxon.Api.Serializer.MEDIA_TYPE">
            <summary>QName identifying the serialization parameter "media-type".</summary>
        </member>
        <member name="F:Saxon.Api.Serializer.NORMALIZATION_FORM">
            <summary>QName identifying the serialization parameter "normalization-form"</summary>
        </member>
        <member name="F:Saxon.Api.Serializer.ITEM_SEPARATOR">
            <summary>
            Set to a string used to separate adjacent items in an XQuery result sequence
            </summary>
        </member>
        <member name="F:Saxon.Api.Serializer.HTML_VERSION">
            <summary>
            HTML version number
            </summary>
        </member>
        <member name="F:Saxon.Api.Serializer.BUILD_TREE">
            <summary>
            Build-tree option (XSLT only)
            </summary>
        </member>
        <member name="F:Saxon.Api.Serializer.OMIT_XML_DECLARATION">
            <summary>QName identifying the serialization parameter "omit-xml-declaration".
            The value is the string "yes" or "no".</summary>
        </member>
        <member name="F:Saxon.Api.Serializer.STANDALONE">
            <summary>QName identifying the serialization parameter "standalone".
            The value is the string "yes" or "no" or "omit".</summary>
        </member>
        <member name="F:Saxon.Api.Serializer.SUPPRESS_INDENTATION">
            <summary>QName identifying the serialization parameter "suppress-indentation"
            (introduced in XSLT/XQuery 3.0). Previously available as "saxon:suppress-indentation"
            The value is the string "yes" or "no" or "omit".</summary>
        </member>
        <member name="F:Saxon.Api.Serializer.UNDECLARE_PREFIXES">
            <summary>QName identifying the serialization parameter "undeclare-prefixes".
            The value is the string "yes" or "no".</summary>
        </member>
        <member name="F:Saxon.Api.Serializer.USE_CHARACTER_MAPS">
            <summary>QName identifying the serialization parameter "use-character-maps".
            This is available only with XSLT. The value of the parameter is a list of expanded QNames
            in Clark notation giving the names of character maps defined in the XSLT stylesheet.</summary>
        </member>
        <member name="F:Saxon.Api.Serializer.VERSION">
            <summary>QName identifying the serialization parameter "version"</summary>
        </member>
        <member name="F:Saxon.Api.Serializer.SAXON_CHARACTER_REPRESENTATION">
            <summary>QName identifying the serialization parameter "saxon:character-representation"</summary>
        </member>
        <member name="F:Saxon.Api.Serializer.SAXON_RECOGNIZE_BINARY">
            <summary>
            Saxon extension for use when writing to the text output method; this option causes the processing
            instructions hex and b64 to be recognized containing hexBinary or base64 data respectively.
            </summary>
        </member>
        <member name="F:Saxon.Api.Serializer.SAXON_INDENT_SPACES">
            <summary>QName identifying the serialization parameter "saxon:indent-spaces". The value
            is an integer (represented as a string) indicating the amount of indentation required.
            If specified, this parameter overrides indent="no".</summary>
        </member>
        <member name="F:Saxon.Api.Serializer.SAXON_LINE_LENGTH">
            <summary>
            Saxon extension: set to an integer (represented as a string) giving the desired maximum
            length of lines when indenting.Default is 80.
            </summary>
        </member>
        <member name="F:Saxon.Api.Serializer.SAXON_ATTRIBUTE_ORDER">
            <summary>
            Saxon extension: set to a space-separated list of attribute names, in Clark notation,
            indicating that attributes present in the list should be serialized in the order
            indicated, followed by attributes not present in the list(these are sorted first
            by namespace, then by local name).
            </summary>
        </member>
        <member name="F:Saxon.Api.Serializer.SAXON_CANONICAL">
            <summary>
             Saxon extension: request canonical XML output.
            </summary>
        </member>
        <member name="F:Saxon.Api.Serializer.SAXON_NEWLINE">
            <summary>
            Saxon extension: set to any string. Indicates the sequence of characters used to represent
            a newline in the text output method, and in newlines used for indentation in any output
            methods that use indentation.
            </summary>
        </member>
        <member name="F:Saxon.Api.Serializer.SAXON_STYLESHEET_VERSION">
            <summary>
            Saxon extension for internal use: used in XSLT to tell the serializer whether the
            stylesheet used version="1.0" or version = "2.0"
            </summary>
        </member>
        <member name="F:Saxon.Api.Serializer.SAXON_DOUBLE_SPACE">
            <summary>QName identifying the serialization parameter "saxon:double-space". The value of this 
            parameter is given as a space-separated list of expanded QNames in Clark notation, that is 
            "{uri}local"; each QName identifies an element that should be preceded by an extra blank line within
            indented output.</summary>
        </member>
        <member name="F:Saxon.Api.Serializer.SAXON_SUPPRESS_INDENTATION">
            <summary>QName identifying the serialization parameter "suppress-indentation". Retained
            as a synonym of SUPPRESS_INDENTATION for backwards compatibility.</summary>
        </member>
        <member name="F:Saxon.Api.Serializer.NEXT_IN_CHAIN">
            <summary>QName identifying the serialization parameter "saxon:next-in-chain". This
            is available only with XSLT, and identifies the URI of a stylesheet that is to be used to
            process the results before passing them to their final destination.</summary>
        </member>
        <member name="F:Saxon.Api.Serializer.SAXON_REQUIRE_WELL_FORMED">
            <summary>QName identifying the serialization parameter "saxon:require-well-formed". The
            value is the string "yes" or "no". If set to "yes", the output must be a well-formed
            document, or an error will be reported. ("Well-formed" here means that the document node
            must have exactly one element child, and no text node children other than whitespace-only
            text nodes).</summary>
        </member>
        <member name="F:Saxon.Api.Serializer.SUPPLY_SOURCE_LOCATOR">
            <summary>
            Saxon extension for interfacing with debuggers; indicates that the location information is
            available for events in this output stream
            </summary>
        </member>
        <member name="F:Saxon.Api.Serializer.SAXON_WRAP">
            <summary>
            Saxon extension, indicates that the output of a query is to be wrapped before serialization,
            such that each item in the result sequence is enclosed in an element indicating its type
            </summary>
        </member>
        <member name="M:Saxon.Api.Serializer.#ctor(net.sf.saxon.s9api.Serializer)">
            <summary>Create a Serializer</summary>
        </member>
        <member name="M:Saxon.Api.Serializer.SetOutputProperty(Saxon.Api.QName,System.String)">
            <summary>Set a serialization property</summary>
            <remarks>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>.</remarks>
            <example>
              <code>
                Serializer qout = new Serializer();
                qout.SetOutputProperty(Serializer.METHOD, "xml");
                qout.SetOutputProperty(Serializer.INDENT, "yes");
                qout.SetOutputProperty(Serializer.SAXON_INDENT_SPACES, "1");
              </code>
            </example> 
            <param name="name">The name of the serialization property to be set</param>
            <param 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>
        </member>
        <member name="M:Saxon.Api.Serializer.SetDefaultOutputProperties(java.util.Properties)">
            <summary>
            Set default output properties, for use when no explicit properties are set using <c>SetOutputProperty()</c>.
            The values supplied are typically those specified in the stylesheet or query. In the case of XSLT,
            they are the properties associated with unamed <c>xsl:output</c> declarations.
            </summary>
            <param name="props"></param>
        </member>
        <member name="M:Saxon.Api.Serializer.GetCharacterMap">
            <summary>
            Get a character map
            </summary>
        </member>
        <member name="M:Saxon.Api.Serializer.SetCharacterMap(net.sf.saxon.serialize.CharacterMapIndex)">
            <summary>
            Set a character map to be used
            </summary>
            <param name="charMap">the character map</param>
        </member>
        <member name="M:Saxon.Api.Serializer.SetOutputFile(System.String)">
            <summary>Specify the destination of the serialized output, in the
            form of a file name</summary>
            <param name="filename">The name of the file to receive the serialized output. This
            method sets the destination base URI to the URI corresponding to the name of the supplied file.</param>
            <exception cref="T:Saxon.Api.DynamicError">Throws a <c>DynamicError</c> if it is not possible to 
            create an output stream to write to this file, for example, if the filename is in a
            directory that does not exist.</exception>
        </member>
        <member name="M:Saxon.Api.Serializer.SetOutputStream(System.IO.Stream)">
            <summary>Specify the destination of the serialized output, in the
            form of a <c>Stream</c>.</summary>
            <remarks>Saxon will not close the stream on completion; this is the
            caller's responsibility.</remarks>
            <param name="stream">The stream to which the output will be written.
            This must be a stream that allows writing.</param>
        </member>
        <member name="M:Saxon.Api.Serializer.GetOutputDestination">
            <summary>Get the current output destination.</summary> 
            <returns>an <c>OutputStream</c>, <c>Writer</c>, or <c>File</c>, depending on the previous calls to
            <c>SetOutputstream</c>, <c>SetOutputWriter</c>, or <c>SetOutputFile</c>; or null, if no output destintion has
            been set up.</returns>
        </member>
        <member name="M:Saxon.Api.Serializer.SetProcessor(Saxon.Api.Processor)">
            <summary>Set the <c>Processor</c> associated with this <c>Serializer</c>. This will be called automatically if the
            serializer is created using one of the <c>Processor.NewSerializer()</c> methods.</summary>
            <param name="processor"> the associated <c>Processor</c></param>
        </member>
        <member name="M:Saxon.Api.Serializer.SetOutputWriter(System.IO.TextWriter)">
            <summary>Specify the destination of the serialized output, in the
            form of a <c>TextWriter</c>.</summary>
            <remarks>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.</remarks>
            <param 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>
        </member>
        <member name="M:Saxon.Api.Serializer.SerializeXdmNode(Saxon.Api.XdmNode)">
            <summary>
            Serialize an <c>XdmNode</c> to the selected output destination using this serializer.
            </summary>
            <param name="node">The node to be serialized</param>
            <remarks>since 9.8</remarks>
        </member>
        <member name="M:Saxon.Api.Serializer.SerializeXdmValue(Saxon.Api.XdmValue)">
            <summary>
            Serialize an arbitary <c>XdmValue</c> to the selected output destination using this serializer.
            The supplied sequence is first wrapped in a document node according to the rules given in section 2
            (Sequence Normalization) of the XSLT/XQuery serialization specification; the resulting document node 
            is then serialized using the serialization parameters defined in this serializer. A call on this 
            method will close the writer or output stream internally.
            </summary>
            <param name="value"> The value to be serialized</param>
            <remarks>since 9.8</remarks>
        </member>
        <member name="M:Saxon.Api.Serializer.Close">
            <summary>
            Close any resources associated with this destination. Note that this does <b>not</b>
            close any user-supplied OutputStream or Writer; those must be closed explicitly
            by the calling application.
            </summary>
        </member>
        <member name="M:Saxon.Api.Serializer.GetUnderlyingDestination">
            <summary>
            The underlying <c>Destination</c> object in the Saxon implementation
            </summary>
            <remarks>
            <para>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.</para> 
            <para>The internal methods follow
            Java naming conventions rather than .NET conventions.</para>
            <para>Information about the returned <see cref="T:net.sf.saxon.Configuration"/> object 
            (and the objects it provides access to) is included in the Saxon JavaDoc docmentation.
            </para>
            </remarks>
            <returns>returns the underlying Destination object</returns>
        </member>
        <member name="M:Saxon.Api.Serializer.CloseAndNotify">
            <summary>
            Close the destination and notify all registered listeners that it has been closed.
            This method is intended for internal use by Saxon. The method first calls
            <see cref="M:Saxon.Api.Serializer.Close"/> to close the destination, then it calls <c>java.util.function.Consumer.accept()</c> 
            on each of the listeners in turn to notify the fact that it has been closed.
            </summary>
        </member>
        <member name="P:Saxon.Api.Serializer.BaseUri">
            <summary>This property determines the base Uri of the constructed <c>Serializer</c>. 
            </summary>
        </member>
        <member name="T:Saxon.Api.DomDestination">
            <summary>
            This class represents a Destination (for example, the destination of the output of a transformation)
            in which the results are written to a newly constructed DOM tree in memory.
            </summary>
        </member>
        <member name="M:Saxon.Api.DomDestination.#ctor">
            <summary>Construct a <c>DomDestination</c>.</summary>
            <remarks>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 <c>XmlDocument</c> property.</remarks>
        </member>
        <member name="M:Saxon.Api.DomDestination.#ctor(System.Xml.XmlDocument)">
            <summary>Construct a <c>DomDestination</c> based on an existing document node.</summary>
            <remarks>The new data will be added as a child of the supplied node.</remarks>
            <param 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>
        </member>
        <member name="M:Saxon.Api.DomDestination.#ctor(System.Xml.XmlDocumentFragment)">
            <summary>Construct a <c>DomDestination</c> based on an existing document fragment node.</summary>
            <remarks>The new data will be added as a child of the supplied node.</remarks>
            <param name="attachmentPoint">The document fragment node to which new contents will
            be attached. The new contents will be added after any existing children.</param>
        </member>
        <member name="M:Saxon.Api.DomDestination.#ctor(System.Xml.XmlElement)">
            <summary>Construct a <c>DomDestination</c> based on an existing element node.</summary>
            <remarks>The new data will be added as a child of the supplied element node.</remarks>
            <param name="attachmentPoint">The element node to which new contents will
            be attached. The new contents will be added after any existing children.</param>
        </member>
        <member name="M:Saxon.Api.DomDestination.Close">
            <summary>
            Close any resources associated with this destination. Note that this does <b>not</b>
            close any user-supplied OutputStream or Writer; those must be closed explicitly
            by the calling application.
            </summary>
        </member>
        <member name="M:Saxon.Api.DomDestination.GetUnderlyingDestination">
            <summary>
            The underlying <c>Destination</c> object in the Saxon implementation
            </summary>
            <remarks>
            <para>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.</para> 
            <para>The internal methods follow
            Java naming conventions rather than .NET conventions.</para>
            <para>Information about the returned <see cref="T:net.sf.saxon.Configuration"/> object 
            (and the objects it provides access to) is included in the Saxon JavaDoc docmentation.
            </para>
            </remarks>
            <returns>returns the underlying Destination object</returns>
        </member>
        <member name="P:Saxon.Api.DomDestination.XmlDocument">
            <summary>After construction, retrieve the constructed document node.</summary>
            <remarks>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.</remarks>
        </member>
        <member name="T:Saxon.Api.RawDestination">
            <summary>
            A <c>RawDestination</c> is an <c>XmlDestination</c> that accepts a sequence output
            by a stylesheet or query and returns it directly as an <c>XdmValue</c>, without
            constructing an XML tree, and without serialization. It corresponds to the serialization
            option <code>build-tree="no"</code>.
            </summary>
        </member>
        <member name="M:Saxon.Api.RawDestination.#ctor">
            <summary>Construct a <c>RawDestination</c></summary>
        </member>
        <member name="M:Saxon.Api.RawDestination.GetUnderlyingDestination">
            <summary>
            The underlying <c>Destination</c> object in the Saxon implementation
            </summary>
            <remarks>
            <para>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.</para> 
            <para>The internal methods follow
            Java naming conventions rather than .NET conventions.</para>
            <para>Information about the returned <see cref="T:net.sf.saxon.Configuration"/> object 
            (and the objects it provides access to) is included in the Saxon JavaDoc docmentation.
            </para>
            </remarks>
            <returns>returns the underlying Destination object</returns>
        </member>
        <member name="M:Saxon.Api.RawDestination.CloseAndNotify">
            <summary>
            Close the destination and notify all registered listeners that it has been closed.
            This method is intended for internal use by Saxon. The method first calls
            <see cref="M:Saxon.Api.RawDestination.Close"/> to close the destination, then it calls <c>java.util.function.Consumer.accept()</c>
            on each of the listeners in turn to notify the fact that it has been closed.
            </summary>
        </member>
        <member name="M:Saxon.Api.RawDestination.Close">
            <summary>
            Close any resources associated with this destination. Note that this does <b>not</b>
            close any user-supplied OutputStream or Writer; those must be closed explicitly
            by the calling application.
            </summary>
        </member>
        <member name="P:Saxon.Api.RawDestination.BaseUri">
            <summary>This property determines the base URI of the constructed <c>XdmNode</c>. 
            If the <c>BaseUri</c> property of the <c>XdmDestination</c> is set before the destination is written to,
            then the constructed <c>XdmNode</c> will have this base URI. Setting this property after constructing the node
            has no effect.
            </summary>
        </member>
        <member name="P:Saxon.Api.RawDestination.XdmValue">
            <summary>After construction, retrieve the constructed document node.</summary>
            <remarks>
            <para>The value of the property will be null if no data has been written to the
            <c>RawDestination</c>, either because the process that writes to the destination has not
            yet been run, or because the process produced no output.</para>
            </remarks>
        </member>
        <member name="T:Saxon.Api.NullDestination">
            <summary>
            A <c>NullDestination</c> is an <c>XmlDestination</c> that discards all its output.
            </summary>
        </member>
        <member name="M:Saxon.Api.NullDestination.#ctor">
            <summary>Construct a <c>NullDestination</c></summary>
        </member>
        <member name="M:Saxon.Api.NullDestination.GetUnderlyingDestination">
            <summary>
            The underlying <c>Destination</c> object in the Saxon implementation, which in the NullDestination is null.
            </summary>
            <returns>returns null</returns>
        </member>
        <member name="P:Saxon.Api.NullDestination.BaseUri">
            <summary>This property determines the base Uri of the constructed <c>Serializer</c>. 
            </summary>
        </member>
        <member name="T:Saxon.Api.TextWriterDestination">
            <summary>
            A <c>TextWriterDestination</c> is an implementation of <c>XmlDestination</c> that wraps
            an instance of <c>XmlWriter</c>.
            </summary>
            <remarks>
            <para>The name <c>TextWriterDestination</c> is a misnomer; originally this class would
            only wrap an <c>XmlTextWriter</c>. It will now wrap any <c>XmlWriter</c>.</para>
            <para>Note that when a <c>TextWriterDestination</c> is used to process the output of a stylesheet
            or query, the output format depends only on the way the underlying <c>XmlWriter</c>
            is configured; serialization parameters present in the stylesheet or query are ignored.
            The XSLT <c>disable-output-escaping</c> option is also ignored. If serialization
            is to be controlled from the stylesheet or query, use a <c>Serializer</c> as the
            <c>Destination</c>.</para>
            </remarks>
        </member>
        <member name="M:Saxon.Api.TextWriterDestination.#ctor(System.Xml.XmlWriter)">
            <summary>Construct a <c>TextWriterDestination</c></summary>
            <param name="writer">The <c>XmlWriter</c> that is to be notified of the events
            representing the XML document.</param>
        </member>
        <member name="M:Saxon.Api.TextWriterDestination.close">
            <summary>
            Close any resources associated with this destination. Note that this does <b>not</b>
            close any user-supplied OutputStream or Writer; those must be closed explicitly
            by the calling application.
            </summary>
        </member>
        <member name="M:Saxon.Api.TextWriterDestination.GetReceiver(net.sf.saxon.event.PipelineConfiguration,net.sf.saxon.serialize.SerializationProperties)">
            <summary>
            Return a <c>Receiver</c>. Saxon calls this method to obtain a Java <c>Receiver</c>, to which it then sends
            a sequence of events representing the content of an XML document. The method is intended
            primarily for internal use, and may give poor diagnostics if used incorrectly.
            </summary>
            <returns>The receiver</returns>
            <param name="pipe">The Saxon configuration as a <c>JPipelineConfiguration</c>. 
            This is supplied so that the destination can
            use information from the configuration (for example, a reference to the name pool)
            to construct or configure the returned <c>Receiver</c>.</param>
            <param name="params1"></param>
        </member>
        <member name="M:Saxon.Api.TextWriterDestination.getReceiver(net.sf.saxon.event.PipelineConfiguration,net.sf.saxon.serialize.SerializationProperties)">
            <summary>
            Return a <c>Receiver</c>. Saxon calls this method to obtain a Java <c>Receiver</c>, to which it then sends
            a sequence of events representing the content of an XML document. The method is intended
            primarily for internal use, and may give poor diagnostics if used incorrectly.
            </summary>
            <returns>The receiver</returns>
            <param name="pipe">The Saxon configuration as a <c>JPipelineConfiguration</c>. 
            This is supplied so that the destination can
            use information from the configuration (for example, a reference to the name pool)
            to construct or configure the returned <c>Receiver</c>.</param>
            <param name="value2">Serialization parameters known to the caller of the method; typically, output
             properties defined in a stylesheet or query. These will mainly be of interest if the destination is performing serialization, but
             soem properties (such as <c>item-separator</c>) are also used in other situations.</param>
        </member>
        <member name="M:Saxon.Api.TextWriterDestination.GetUnderlyingDestination">
            <summary>
            The underlying <c>Destination</c> object in the Saxon implementation
            </summary>
            <remarks>
            <para>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.</para> 
            <para>The internal methods follow
            Java naming conventions rather than .NET conventions.</para>
            <para>Information about the returned <see cref="T:net.sf.saxon.Configuration"/> object 
            (and the objects it provides access to) is included in the Saxon JavaDoc docmentation.
            </para>
            </remarks>
            <returns>returns the underlying Destination object</returns>
        </member>
        <member name="P:Saxon.Api.TextWriterDestination.CloseAfterUse">
            <summary>
            The <c>CloseAfterUse</c> property indicates whether the underlying <c>XmlWriter</c> is closed
            (by calling its <c>Close()</c> method) when Saxon has finished writing to it. The default
            value is true, in which case <c>Close()</c> is called. If the property is set to <c>false</c>,
            Saxon will refrain from calling the <c>Close()</c> method, and merely call <c>Flush()</c>,
            which can be useful if further output is to be written to the <c>XmlWriter</c> by the application.
            </summary>
        </member>
        <member name="T:Saxon.Api.XdmDestination">
            <summary>
            An <c>XdmDestination</c> is an <c>XmlDestination</c> in which an <c>XdmNode</c> 
            is constructed to hold the output of a query or transformation: 
            that is, a tree using Saxon's implementation of the XDM data model.
            </summary>
            <remarks>
            <para>No data needs to be supplied to the <c>XdmDestination</c> object. The query or transformation
            populates an <c>XmlNode</c>, which may then be retrieved as the value of the <c>XmlNode</c>
            property.</para>
            <para>An <c>XdmDestination</c> can be reused to hold the results of a second transformation only
            if the <c>Reset</c> method is first called to reset its state.</para>
            </remarks>
        </member>
        <member name="M:Saxon.Api.XdmDestination.#ctor">
            <summary>Construct an <c>XdmDestination</c></summary>
        </member>
        <member name="M:Saxon.Api.XdmDestination.Reset">
            <summary>Reset the state of the <c>XdmDestination</c> so that it can be used to hold
            the result of another query or transformation.</summary>
        </member>
        <member name="M:Saxon.Api.XdmDestination.GetUnderlyingDestination">
            <summary>
            Get the underlying Saxon <c>Destination</c> object from the <c>XdmDestination</c>.
            This method is for internal use but 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.
            </summary>
        </member>
        <member name="M:Saxon.Api.XdmDestination.setDestinationBaseURI(java.net.URI)">
            <summary>
            Set the base URI of the resource being written to this destination
            </summary>
            <param name="uri">the base URI to be used</param>
        </member>
        <member name="M:Saxon.Api.XdmDestination.getDestinationBaseURI">
            <summary>
            Get the base URI of the resource being written to this destination
            </summary>
            <returns>the base URI, or null if none is known</returns>
        </member>
        <member name="M:Saxon.Api.XdmDestination.Close">
            <summary>
            Close the destination, allowing resources to be released. Saxon calls this
            method when it has finished writing to the destination.
            </summary>
        </member>
        <member name="P:Saxon.Api.XdmDestination.TreeModel">
            <summary>
             The Tree Model implementation to be used for the constructed document. By default
             the <c>TinyTree</c> is used. The main reason for using the <c>LinkedTree</c> alternative is if
             updating is required (the <c>TinyTree</c> is not updateable).
            </summary>
        </member>
        <member name="P:Saxon.Api.XdmDestination.BaseUri">
            <summary>This property determines the base URI of the constructed <c>XdmNode</c>. 
            If the <c>BaseUri</c> property of the <c>XdmDestination</c> is set before the destination is written to,
            then the constructed <c>XdmNode</c> will have this base URI. Setting this property after constructing the node
            has no effect.
            </summary>
        </member>
        <member name="P:Saxon.Api.XdmDestination.XdmNode">
            <summary>After construction, retrieve the constructed document node.</summary>
            <remarks>
            <para>The value of the property will be null if no data has been written to the
            <c>XdmDestination</c>, either because the process that writes to the destination has not
            yet been run, or because the process produced no output.</para>
            </remarks>
        </member>
        <member name="T:Saxon.Api.XdmDestination.TreeProtector">
            <summary>
            <c>TreeProtector</c> is a filter that ensures that the events reaching the <c>Builder</c> constitute a single
            tree rooted at an element or document node (because anything else will crash the builder)
            </summary>
        </member>
        <member name="M:Saxon.Api.XdmDestination.TreeProtector.#ctor(net.sf.saxon.event.Receiver)">
            <summary>
            Constructor
            </summary>
            <param name="next">Set the underlying receiver</param>
        </member>
        <member name="M:Saxon.Api.XdmDestination.TreeProtector.startDocument(System.Int32)">
            <summary>
            Start of a document node
            </summary>
            <param name="properties"></param>
        </member>
        <member name="M:Saxon.Api.XdmDestination.TreeProtector.endDocument">
            <summary>
            Notify the end of a document node
            </summary>
        </member>
        <member name="M:Saxon.Api.XdmDestination.TreeProtector.startElement(net.sf.saxon.om.NodeName,net.sf.saxon.type.SchemaType,net.sf.saxon.om.AttributeMap,net.sf.saxon.om.NamespaceMap,net.sf.saxon.s9api.Location,System.Int32)">
            <summary>
            Notify the start of an element
            </summary>
            <param name="nameCode"></param>
            <param name="typeCode"></param>
            <param name="attributes"></param>
            <param name="namespaces"></param>
            <param name="location"></param>
            <param name="properties"></param>
        </member>
        <member name="M:Saxon.Api.XdmDestination.TreeProtector.endElement">
            <summary>
            End of element
            </summary>
        </member>
        <member name="M:Saxon.Api.XdmDestination.TreeProtector.characters(java.lang.CharSequence,net.sf.saxon.s9api.Location,System.Int32)">
            <summary>
            Character data
            </summary>
            <param name="chars">Character data as input</param>
            <param name="location">Provides information such as line number and system ID</param>
            <param name="properties">Bit significant value. The following bits are defined</param>
        </member>
        <member name="M:Saxon.Api.XdmDestination.TreeProtector.processingInstruction(System.String,java.lang.CharSequence,net.sf.saxon.s9api.Location,System.Int32)">
            <summary>
            Processing instruction
            </summary>
            <param name="target">The PI name. This must be a legal name (it will not be checked)</param>
            <param name="data">The data portion of the processing instruction</param>
            <param name="location">provides information about the PI</param>
            <param name="properties">Additional information about the PI</param>
        </member>
        <member name="M:Saxon.Api.XdmDestination.TreeProtector.comment(java.lang.CharSequence,net.sf.saxon.s9api.Location,System.Int32)">
            <summary>
            Output a comment
            </summary>
            <param name="chars">The content of the comment</param>
            <param name="location">provides information such as line number and system ID</param>
            <param name="properties">Additional information about the comment</param>
        </member>
        <member name="M:Saxon.Api.XdmDestination.TreeProtector.append(net.sf.saxon.om.Item,net.sf.saxon.s9api.Location,System.Int32)">
            <summary>
            Append an  arbitrary item (node or atomic value) to the output
            </summary>
            <param name="item">the item to be appended</param>
            <param name="location">the location of the calling instruction, for diagnostics</param>
            <param name="copyNamespaces">if the item is an element node, this indicates whether its namespace need to be copied. 
            0x80000 means ALL_NAMESPACE, 0x40000 means LOCAL_NAMESPACE and 0 means no namespace</param>
        </member>
        <member name="T:Saxon.Api.StaticError">
            <summary>
            The <c>StaticError</c> class contains information about a static error detected during
            compilation of a stylesheet, query, or XPath expression.
            </summary>
        </member>
        <member name="M:Saxon.Api.StaticError.ToString">
            <summary>
            Return the error message.
            </summary>
        </member>
        <member name="P:Saxon.Api.StaticError.ErrorCode">
            <summary>
            The error code, as a <c>QName</c>. May be null if no error code has been assigned.
            </summary>
        </member>
        <member name="P:Saxon.Api.StaticError.Message">
            <summary>
            Return the message associated with this error.
            </summary>
        </member>
        <member name="P:Saxon.Api.StaticError.InnerMessage">
            <summary>
            Return the message associated with this error concatenated with the message from the causing exception.
            </summary> 
        </member>
        <member name="P:Saxon.Api.StaticError.ModuleUri">
            <summary>
            The URI of the query or stylesheet module in which the error was detected
            (as a string).
            </summary>
            <remarks>
            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 <c>Stream</c>).
            </remarks>
        </member>
        <member name="P:Saxon.Api.StaticError.LineNumber">
            <summary>
            The line number locating the error within a query or stylesheet module.
            </summary>
            <remarks>
            May be set to -1 if the location of the error is unknown.
            </remarks>        
        </member>
        <member name="P:Saxon.Api.StaticError.ColumnNumber">
            <summary>
            The line number locating the error within a query or stylesheet module.
            </summary>
            <remarks>
            May be set to -1 if the location of the error is unknown.
            </remarks>        
        </member>
        <member name="P:Saxon.Api.StaticError.IsWarning">
            <summary>
            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.
            </summary>
        </member>
        <member name="P:Saxon.Api.StaticError.IsTypeError">
            <summary>
            Indicate whether this condition is a type error.
            </summary>
        </member>
        <member name="P:Saxon.Api.StaticError.UnderlyingException">
            <summary>
            Return the underlying exception. This is unstable as this is an internal object.
            </summary>
            <returns>The underlying <c>XPathException</c></returns>
        </member>
        <member name="T:Saxon.Api.IErrorReporter">
            <summary>
            The <c>IErrorReporter</c> is a generic functional interface for reporting errors and warnings.
            </summary>
            <remarks>
            <p>The error or warning is reported in the form of an <c>XmlProcessingError</c> which
            adds the possibility to report errors without expensive construction of an exception object.</p>
            </remarks>
        </member>
        <member name="M:Saxon.Api.IErrorReporter.report(Saxon.Api.XmlProcessingError)">
            <summary>
            Report an error. This method is called by Saxon when an error needs to be reported to the calling application.
            </summary>
            <param name="error">Details of the error to be reported</param>
            public*
        </member>
        <member name="T:Saxon.Api.ErrorReporterWrapper">
            <summary>
            <c>ErrorReporter</c> wrapper class for internal use in Saxon.
            </summary>
        </member>
        <member name="M:Saxon.Api.ErrorReporterWrapper.#ctor(Saxon.Api.IErrorReporter)">
            <summary>
            Create a standard <c>ErrorReporter</c>
            </summary>
            <param name="reporter">The .NET <c>IErrorReporter</c></param>
        </member>
        <member name="M:Saxon.Api.ErrorReporterWrapper.report(net.sf.saxon.s9api.XmlProcessingError)">
            <summary>
            This method is called internally in Saxon to report an error by adding it to the error list.
            </summary>
            <param name="xpe">details of the error to be reported</param>
        </member>
        <member name="P:Saxon.Api.ErrorReporterWrapper.ErrorReporter">
            <summary>
            Get property on the wrapped <c>IErrorReporter</c>.
            </summary>
        </member>
        <member name="T:Saxon.Api.ErrorReporter">
            <summary>
            The <c>ErrorReporter</c> is a generic functional class for reporting errors and warnings.
            This class wraps an <c>IList</c> of <c>XmlProcessingError</c> objects.
            It is designed to be used internally by Saxon.
            </summary>
        </member>
        <member name="M:Saxon.Api.ErrorReporter.#ctor(System.Collections.Generic.IList{Saxon.Api.XmlProcessingError})">
            <summary>
            Initializes a new instance of the <see cref="T:Saxon.Api.ErrorReporter"/> class.
            </summary>
            <param name="errorList">Error list.</param>
        </member>
        <member name="M:Saxon.Api.ErrorReporter.report(net.sf.saxon.s9api.XmlProcessingError)">
            <summary>
            This method is called internally in Saxon to report an error by adding it to the error list.
            </summary>
            <param name="xpe">details of the error to be reported</param>
        </member>
        <member name="P:Saxon.Api.ErrorReporter.ErrorList">
            <summary>
            Get property on the wrapped error list.
            </summary>
        </member>
        <member name="T:Saxon.Api.ErrorReporterToStaticError">
            <summary>
            <c>ErrorReporter</c> for gathering errors as <c>XmlProcessorError</c> to then
            convert them to a list of <c>StaticError</c>s.
            </summary>
        </member>
        <member name="M:Saxon.Api.ErrorReporterToStaticError.#ctor(System.Collections.Generic.IList{Saxon.Api.StaticError})">
            <summary>
            Initializes a new instance of the <see cref="T:Saxon.Api.ErrorReporter"/> class.
            </summary>
            <param name="errorList">Error list.</param>
        </member>
        <member name="M:Saxon.Api.ErrorReporterToStaticError.report(net.sf.saxon.s9api.XmlProcessingError)">
            <summary>
            This method is called internally in Saxon to report an error by adding it to the error list.
            </summary>
            <param name="xpe">details of the error to be reported</param>
        </member>
        <member name="P:Saxon.Api.ErrorReporterToStaticError.ErrorList">
            <summary>
            Get property on the wrapped error list.
            </summary>
        </member>
        <member name="T:Saxon.Api.DynamicError">
            <summary>
            The <c>DynamicError</c> class contains information about a dynamic error detected during
            execution of a stylesheet, query, or XPath expression.
            </summary>
        </member>
        <member name="M:Saxon.Api.DynamicError.#ctor(System.String)">
            <summary>
            Create a new <c>DynamicError</c>, specifying the error message.
            </summary>
            <param name="message">The error message</param>
        </member>
        <member name="M:Saxon.Api.DynamicError.ToString">
            <summary>
            Return the error message.
            </summary>
        </member>
        <member name="P:Saxon.Api.DynamicError.ErrorCode">
            <summary>
            The error code, as a <c>QName</c>. May be null if no error code has been assigned.
            </summary>
        </member>
        <member name="P:Saxon.Api.DynamicError.Message">
            <summary>
            Return the message associated with this error.
            </summary>
        </member>
        <member name="P:Saxon.Api.DynamicError.ModuleUri">
            <summary>
            The URI of the query or stylesheet module in which the error was detected
            (as a string).
            </summary>
            <remarks>
            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 <c>Stream</c>).
            </remarks>
        </member>
        <member name="P:Saxon.Api.DynamicError.LineNumber">
            <summary>
            The line number locating the error within a query or stylesheet module.
            </summary>
            <remarks>
            May be set to -1 if the location of the error is unknown.
            </remarks>        
        </member>
        <member name="P:Saxon.Api.DynamicError.IsWarning">
            <summary>
            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.
            </summary>
        </member>
        <member name="P:Saxon.Api.DynamicError.IsTypeError">
            <summary>
            Indicate whether this condition is a type error.
            </summary>
        </member>
        <member name="P:Saxon.Api.DynamicError.UnderlyingException">
            <summary>
            Return the underlying exception. This is unstable as this is an internal object.
            </summary>
            <returns>The underlying <c>XPathException</c></returns>
        </member>
        <member name="T:Saxon.Api.XmlProcessingError">
            <summary>
            The <c>XmlProcessorError</c> class contains information about an error detected during
            compilation or execution of a stylesheet, query, XPath expression, or schema.
            </summary>
        </member>
        <member name="M:Saxon.Api.XmlProcessingError.IsAlreadyReported">
            <summary>
            Ask whether this static error has already been reported.
            </summary>
            <returns></returns>
        </member>
        <member name="M:Saxon.Api.XmlProcessingError.SetAlreadyReported(System.Boolean)">
            <summary>
            Say whether this error has already been reported.
            </summary>
            <param name="reported">true if the error has been reported</param>
        </member>
        <member name="P:Saxon.Api.XmlProcessingError.AsWarning">
            <summary>
            This get property returns a <c>XmlProcessingError</c> containing the same information, but to be treated as a warning condition.
            </summary>
        </member>
        <member name="P:Saxon.Api.XmlProcessingError.HostLanguage">
            <summary>
            Property to get the host language where this error originates from.
            </summary>
        </member>
        <member name="P:Saxon.Api.XmlProcessingError.FatalMessage">
            <summary>
            Property to indicate that this error is to be treated as fatal, that is,
            execution will be abandoned after reporting this error. This method may be called
            by <c>ErrorReporter</c>, for example if the error is considered so server that further processing
            is not worthwhile, or if too many errors have been signalled. there is no absolute guarantee that
            setting this property will cause execution to be abandoned.
            It can also be used to ask whether this error is to be treated as fatal, 
            and if so, return the relevant message.
            </summary>
        </member>
        <member name="P:Saxon.Api.XmlProcessingError.StaticError">
            <summary>
            Property to check if this error is a <c>StaticError</c>.
            </summary>
        </member>
        <member name="P:Saxon.Api.XmlProcessingError.TypeError">
            <summary>
            Property which indicates whether this condition is a type error.
            </summary>
        </member>
        <member name="T:Saxon.Api.ValidationFailure">
            <summary>
            This exception indicates a failure when validating an instance against a type
             defined in a schema.
            </summary>
            <remarks>
            This class holds the same information as a <c>ValidationException</c>, except that it is not an exception,
             and does not carry system overheads such as a stack trace. It is used because operations such as "castable",
             and validation of values in a union, cause validation failures on a success path and it is costly to throw,
             or even to create, exception objects on a success path.
            </remarks>
        </member>
        <member name="M:Saxon.Api.ValidationFailure.GetColumnNumber">
            <summary>
            Return the character position where the current document event ends.
            </summary>
            <returns>the column number, or -1 if none is available</returns>
        </member>
        <member name="M:Saxon.Api.ValidationFailure.GetConstraintClauseNumber">
            <summary>
            Get the constraint clause number.
            </summary>
            <returns>The section number of the clause containing the constraint that has been violated.
            Generally a decimal number in the form n.n.n; possibly a sequence of such numbers separated
             by semicolons.Or null if the information is not available.</returns>
        </member>
        <member name="M:Saxon.Api.ValidationFailure.GetConstraintName">
            <summary>
            Get the constraint name.
            </summary>
            <returns>The name of the violated constraint, in the form of a fragment identifier within
             the published XML Schema specification; or null if the information is not available.</returns>
        </member>
        <member name="M:Saxon.Api.ValidationFailure.getConstraintReference">
            <summary>
            Get the constraint name and clause in the format defined in XML Schema Part C (Outcome Tabulations).
            This mandates the format validation-rule-name.clause-number
            </summary>
            <returns>The constraint reference, for example "cos-ct-extends.1.2"; or null if the reference
             is not known.</returns>
        </member>
        <member name="M:Saxon.Api.ValidationFailure.GetContextPath">
            <summary>
            Get additional location text, if any.
            </summary>
            <returns>Additional information about the location of the error, designed to be output
            as a prefix to the error message if desired.</returns>
        </member>
        <member name="M:Saxon.Api.ValidationFailure.GetErrorCode">
            <summary>
            Get the error code associated with the validity error. This is relevant only when validation
            is run from within XSLT or XQuery, which define different error codes for validation errors.
            </summary>
            <returns>The error code associated with the error, if any. The error is returned as a simple
            string if it is in the standard error namespace, or as an EQName (that is Q{uri}local) 
            otherwise.</returns>
        </member>
        <member name="M:Saxon.Api.ValidationFailure.GetLineNumber">
            <summary>
            Return the line number where the current document event ends.
            </summary>
            <returns>The line number, or -1 if none is available.</returns>
        </member>
        <member name="M:Saxon.Api.ValidationFailure.GetMessage">
            <summary>
            Get the text of a message explaining what is wrong.
            </summary>
            <returns>A human-readable message explaining the validity error.</returns>
        </member>
        <member name="M:Saxon.Api.ValidationFailure.GetPath">
            <summary>
            Get a hierarchic path giving the logical position in the instance document where the
            validation error was found.
            </summary>
            <returns>A path to the location in the document.</returns>
        </member>
        <member name="M:Saxon.Api.ValidationFailure.GetPublicId">
            <summary>
            Return the public identifier for the current document event.
            </summary>
            <returns>A string containing the public identifier, or null if none is available.</returns>
        </member>
        <member name="M:Saxon.Api.ValidationFailure.GetSchemaPart">
            <summary>
            Get the "schema part" component of the constraint reference.
            </summary>
            <returns>1 or 2 depending on whether the violated constraint is in XML Schema Part 1 or Part 2;
            or -1 if there is no constraint reference.</returns>
        </member>
        <member name="M:Saxon.Api.ValidationFailure.GetSystemId">
            <summary>
            Return the system identifier for the current document event.
            </summary>
            <returns>A string containing the system identifier, or null if none is available.</returns>
        </member>
        <member name="T:Saxon.Api.ErrorGatherer">
            <summary>
            Error gatherer. This class is used to provide customized error handling. 
            </summary>
            <remarks><para>If an application does <em>not</em> register its own custom
            <code>ErrorListener</code>, the default <code>ErrorGatherer</code>
            is used which keeps track of all warnings and errors in a list,
            and does not throw any <code>Exception</code>s.
            Applications are <em>strongly</em> encouraged to register and use
            <code>ErrorListener</code>s that insure proper behavior for warnings and
            errors.</para>
            </remarks>
        </member>
        <member name="M:Saxon.Api.ErrorGatherer.#ctor(System.Collections.Generic.IList{Saxon.Api.StaticError})">
            <summary>
            Initializes a new instance of the <see cref="T:Saxon.Api.ErrorGatherer"/> class.
            </summary>
            <param name="errorList">Error list.</param>
        </member>
        <member name="M:Saxon.Api.ErrorGatherer.warning(javax.xml.transform.TransformerException)">
            <summary>
            Warning the specified exception.
            </summary>
            <param name="exception">TransformerException.</param>
        </member>
        <member name="M:Saxon.Api.ErrorGatherer.error(javax.xml.transform.TransformerException)">
            <summary>
            Report a Transformer exception thrown.
            </summary>
            <param name="error">Error.</param>
        </member>
        <member name="M:Saxon.Api.ErrorGatherer.fatalError(javax.xml.transform.TransformerException)">
            <summary>
            Report a fatal exception thrown.
            </summary>
            <param name="error">TransformerException.</param>
        </member>
        <member name="P:Saxon.Api.ErrorGatherer.ErrorList">
            <summary>
            Gets the error list.
            </summary>
            <returns>Returns the error list</returns>
        </member>
        <member name="T:Saxon.Api.IInvalidityHandler">
            <summary>
            Interface for reporting validation errors found during validation of an instance document
            against a schema.
            </summary>
        </member>
        <member name="M:Saxon.Api.IInvalidityHandler.startReporting(System.String)">
            <summary>
            At the start of a validation episode, initialize the handler.
            </summary>
            <param name="systemId">Optional; may be used to represent the destination of any
            report produced.</param>
            public*
        </member>
        <member name="M:Saxon.Api.IInvalidityHandler.reportInvalidity(Saxon.Api.ValidationFailure)">
            <summary>
            Report a validation error found during validation of an instance document
            against a schema.
            </summary>
            <param name="i">Details of the validation error.</param>
            public*
        </member>
        <member name="M:Saxon.Api.IInvalidityHandler.endReporting">
            <summary>
            At the end of a validation episode, do any closedown actions, and optionally return
            information collected in the course of validation (for example a list of error messages).
            </summary>
            <returns>A value to be associated with a validation exception. May be the empty sequence.
            In the case of the <c>InvalidityReportGenerator</c>, this returns the XML document
            containing the validation report. This will be the value returned as the value of
            the variable <c>$err:value</c> during try/catch processing.</returns>
            public*
        </member>
        <member name="T:Saxon.Api.InvalidityHandlerWrapper">
            <summary>
            This class <c>InvalidityHandlerWrapper</c> extends the standard error handler for errors found during
            validation of an instance document against a schema, used if a user specifies the -report option on validate.
            Its effect is to output the validation errors found into the filename specified, in an XML format.
            This is a wrapper class to wrap a .NET <c>InvalidityHandler</c> class for interfacing within Java.
            </summary>
        </member>
        <member name="M:Saxon.Api.InvalidityHandlerWrapper.#ctor(Saxon.Api.IInvalidityHandler)">
            <summary>
            Create a standard Invalidity Handler.
            </summary>
            <param name="inHandler">The .NET <c>IInvalidityHandler</c>.</param>
        </member>
        <member name="M:Saxon.Api.InvalidityHandlerWrapper.endReporting">
            <summary>
            Get the value to be associated with a validation exception. May return null.
            In the case of the <c>InvalidityGenerator</c>, this returns the XML document
            containing the validation report.
            </summary>
            <returns>A value (or null). This will be the value returned as the value of the variable
            <c>$err:value</c> during try/catch processor.</returns>
        </member>
        <member name="M:Saxon.Api.InvalidityHandlerWrapper.reportInvalidity(net.sf.saxon.lib.Invalidity)">
            <summary>
            Receive notification of a validity error.
            </summary>
            <param name="i">Information about the nature of the invalidity.</param>
        </member>
        <member name="M:Saxon.Api.InvalidityHandlerWrapper.startReporting(System.String)">
            <summary>
            At the start of a validation episode, initialize the handler.
            </summary>
            <param name="systemId">Optional; may be used to represent the destination of any report produced.</param>
        </member>
        <member name="T:Saxon.Api.InvalidityGatherer">
            <summary>
            <para>If an application does <em>not</em> register its own custom
            <code>InvalidityHandler</code>, the default <code>InvalidityGatherer</code>
            is used which keeps track of all warnings and errors in a list,
            and does not throw any <code>Exception</code>s.
            Applications are <em>strongly</em> encouraged to register and use
            <code>InvalidityHandler</code>s that insure proper behavior for warnings and
            errors.</para>
            </summary>
        </member>
        <member name="M:Saxon.Api.InvalidityGatherer.#ctor(System.Collections.Generic.IList{Saxon.Api.ValidationFailure})">
            <summary>
            Initializes a new instance of the <see cref="T:Saxon.Api.InvalidityGatherer"/> class.
            </summary>
        </member>
        <member name="M:Saxon.Api.InvalidityGatherer.reportInvalidity(net.sf.saxon.lib.Invalidity)">
            <summary>
            
            </summary>
            <param name="failure">net.sf.saxon.type.ValidationFailure.</param>
        </member>
        <member name="P:Saxon.Api.InvalidityGatherer.ErrorList">
            <summary>
            List of errors. The caller may supply an empty list before calling <c>Compile</c>;
            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 <c>StaticError</c>.
            If no error list is supplied by the caller, error information will be written to
            the standard error stream.
            </summary>
            <remarks>
            <para>By supplying a custom <c>List</c> with a user-written <c>add()</c> method, it is possible to
            intercept error conditions as they occur.</para>
            <para>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.</para>
            </remarks>
        </member>
        <member name="T:Saxon.Api.StaticContext">
            <summary>
            The class <c>StaticContext</c> provides information about the static context of an expression
            </summary>
        </member>
        <member name="M:Saxon.Api.StaticContext.GetNamespaceForPrefix(System.String)">
            <summary>
            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.
            </summary>
            <param name="Prefix">The namespace prefix</param>
            <returns>The corresponding namespace URI if there is one, or null otherwise</returns>
        </member>
        <member name="P:Saxon.Api.StaticContext.ModuleUri">
            <summary>
            The URI of the module where an expression appears, suitable for use in diagnostics
            </summary>
        </member>
        <member name="P:Saxon.Api.StaticContext.BaseUri">
            <summary>
            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
            <c>xml:base</c> attribute
            </summary>
        </member>
        <member name="P:Saxon.Api.StaticContext.Processor">
            <summary>
            The <c>Processor</c> that was used to create the query or stylesheet from which this extension
            function was invoked.
            </summary>
            <remarks>
            <para>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.</para>
            <para>There may be circumstances in which the <c>Processor</c> is not available, in which case this method
            may return null, or may return a different <c>Processor</c>. This will happen only if low-level interfaces
            have been used to cause a <c>Configuration</c> to be shared between several <c>Processor</c> instances,
            or between a <c>Processor</c> and other applications.</para>
            </remarks>
        </member>
        <member name="P:Saxon.Api.StaticContext.Implementation">
            <summary>
            The underlying object in the Saxon implementation, an instance of class
            <code>net.sf.saxon.expr.StaticContext</code>
            </summary>
            <remarks>
            <para>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.</para> 
            <para>The internal methods follow
            Java naming conventions rather than .NET conventions.</para>
            <para>Information about the returned object (and the objects it provides access to)
            is included in the Saxon JavaDoc documentation, see <see cref="T:net.sf.saxon.expr.StaticContext"/>.
            </para>
            </remarks>
        </member>
        <member name="T:Saxon.Api.DynamicContext">
            <summary>
            The class <c>DynamicContext</c> provides information about the dynamic context of an expression
            </summary>
        </member>
        <member name="P:Saxon.Api.DynamicContext.ContextItem">
            <summary>
            The context item. May be null if no context item is defined
            </summary>
        </member>
        <member name="P:Saxon.Api.DynamicContext.ContextPosition">
            <summary>
            The context position (equivalent to the XPath <c>position()</c> function).
            </summary>
            <remarks>Calling this method throws an exception if the context item is undefined.</remarks>
        </member>
        <member name="P:Saxon.Api.DynamicContext.ContextSize">
            <summary>
            The context size (equivalent to the XPath <c>last()</c> function).
            </summary>
            <remarks>Calling this method throws an exception if the context item is undefined.</remarks>
        </member>
        <member name="P:Saxon.Api.DynamicContext.Implementation">
            <summary>
            The underlying object in the Saxon implementation, an instance of class
            <code>net.sf.saxon.expr.XPathContext</code>
            </summary>
            <remarks>
            <para>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.</para> 
            <para>The internal methods follow
            Java naming conventions rather than .NET conventions.</para>
            <para>Information about the returned object (and the objects it provides access to)
            is included in the Saxon JavaDoc documentation, see <see cref="T:net.sf.saxon.expr.XPathContext"/>
            </para>
            </remarks>
        </member>
        <member name="T:Saxon.Api.ExtensionFunctionDefinition">
            <summary>
            <para>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.</para>
            <para>More precisely, a subclass of <c>ExtensionFunctionDefinition</c> identifies a family of extension functions
            with the same (namespace-qualified) name but potentially having different arity (number of arguments).</para>
            </summary>
            <remarks>
            <para>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.</para> 
            <para>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.</para>
            <para>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.</para>
            </remarks>
        </member>
        <member name="M:Saxon.Api.ExtensionFunctionDefinition.ResultType(Saxon.Api.XdmSequenceType[])">
            <summary>
            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.
            </summary>
            <remarks>
            This method must be implemented in every subclass.
            </remarks>
            <param name="ArgumentTypes">
            The static types of the arguments present in the function call
            </param>
            <returns>
            An <c>XdmSequenceType</c> representing the declared return type of the extension function
            </returns>
        </member>
        <member name="M:Saxon.Api.ExtensionFunctionDefinition.MakeFunctionCall">
            <summary>
            Factory method to create an <c>ExtensionFunctionCall</c> 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.
            </summary>
            <remarks>
            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.
            </remarks>
            <returns>
            An instance of the appropriate implementation of <code>ExtensionFunctionCall</code>
            </returns>
        </member>
        <member name="P:Saxon.Api.ExtensionFunctionDefinition.FunctionName">
            <summary>
            Read-only property returning the name of the extension function, as a <c>QName</c>.
            </summary>
            <remarks>
            A getter for this property must be implemented in every subclass.
            </remarks>
        </member>
        <member name="P:Saxon.Api.ExtensionFunctionDefinition.MinimumNumberOfArguments">
            <summary>
            Read-only property giving the minimum number of arguments in a call to this extension function.
            </summary>
            <remarks>
            A getter for this property must be implemented in every subclass.
            </remarks>
        </member>
        <member name="P:Saxon.Api.ExtensionFunctionDefinition.MaximumNumberOfArguments">
            <summary>
            Read-only property giving the maximum number of arguments in a call to this extension function.
            </summary>
            <remarks>
            A getter for this property must be implemented in every subclass.
            </remarks>
        </member>
        <member name="P:Saxon.Api.ExtensionFunctionDefinition.ArgumentTypes">
            <summary>
            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 <c>ArgumentTypes</c> is assumed to apply to all the rest; 
            if the returned array is empty, then all arguments are assumed to be of type <c>item()*</c>
            </summary>
            <remarks>
            A getter for this property must be implemented in every subclass.
            </remarks>
            <returns>
            An array of <c>XdmSequenceType</c> objects representing the required types of the arguments 
            to the extension function.
            </returns>
        </member>
        <member name="P:Saxon.Api.ExtensionFunctionDefinition.TrustResultType">
            <summary>
            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.
            </summary>
            <remarks>
            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.
            </remarks>
        </member>
        <member name="P:Saxon.Api.ExtensionFunctionDefinition.DependsOnFocus">
            <summary>
            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.
            </summary>
            <remarks>
            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.
            </remarks>
        </member>
        <member name="P:Saxon.Api.ExtensionFunctionDefinition.HasSideEffects">
            <summary>
            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.
            </summary>
            <remarks>
            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.
            </remarks>
        </member>
        <member name="T:Saxon.Api.ExtensionFunctionCall">
            <summary>
            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 <c>MakeFunctionCall()</c>
            of the corresponding <c>ExtensionFunctionDefinition</c>. 
            The implementation may therefore retain information about the static context of the
            call. Once compiled, however, the instance object must be immutable.
            </summary>
        </member>
        <member name="M:Saxon.Api.ExtensionFunctionCall.SupplyStaticContext(Saxon.Api.StaticContext)">
            <summary>
            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.
            </summary>
            <remarks>
            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.
            </remarks>
            <param name="context">Information about the static context in which the function is called</param>
        </member>
        <member name="M:Saxon.Api.ExtensionFunctionCall.CopyLocalData(Saxon.Api.ExtensionFunctionCall)">
            <summary>
            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 <c>ExtensionFunction</c> 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.
            </summary>
            <param name="destination">The new extension function object. This will always be an instance of the same
            class as the existing object.</param>
        </member>
        <member name="M:Saxon.Api.ExtensionFunctionCall.Call(System.Collections.Generic.IEnumerator{Saxon.Api.XdmItem}[],Saxon.Api.DynamicContext)">
            <summary>
            Method called at run time to evaluate the function.
            </summary>
            <param name="arguments">The values of the arguments to the function, supplied as iterators over XPath
            sequence values.</param>
            <param 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>
            <returns>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 <c>GetAnother()</c> method, 
            allowing the function results to be read more than once.</returns>
        </member>
        <member name="T:Saxon.Api.ICollectionFinder">
            <summary>
             An instance of CollectionFinder can be registered with the Saxon configuration; it is called in response
             to calls on the fn:collection() and fn:uri-collection() functions.
             When these functions are called, the <c>FindCollection(XPathContext, String)</c> method is
             called to get a <c>ResourceCollection</c>
             object representing the collection of resources identified by the supplied collection URI.
            </summary>
        </member>
        <member name="M:Saxon.Api.ICollectionFinder.FindCollection(Saxon.Api.DynamicContext,System.String)">
            <summary>
            Locate the collection of resources corresponding to a collection URI.
            </summary>
            <param name="context">The XPath dynamic evaluation context</param>
            <param name="collectionURI">The collection URI: an absolute URI, formed by resolving the argument
            supplied to the fn:collection or fn:uri-collection against the staticbase URI</param>
            <returns>a ResourceCollection object representing the resources in the collection identified
             by this collection URI. Result should not be null.</returns>
            public*
        </member>
        <member name="T:Saxon.Api.IResourceCollection">
            <summary>
            This interface defines a ResourceCollection. This class
            is used to map the URI of collection into a sequence of Resource objects.
            It is used to support the fn:collection() and fn:uri-collection() functions.
            </summary>
        </member>
        <member name="M:Saxon.Api.IResourceCollection.CollectionURI">
            <summary>
            Get the URI of the collection
            </summary>
            <returns> The URI as passed to the fn:collection() or fn:uri-collection()
            function, resolved if it is relative against the static base URI.
            If the collection() or uri-collection() function
            was called with no arguments(to get the "default collection") this
            will be the URI of the default collection registered with the Configuration.</returns>
            public*
        </member>
        <member name="M:Saxon.Api.IResourceCollection.GetResourceURIs(Saxon.Api.DynamicContext)">
            <summary>
            Get the URIs of the resources in the collection. This supports the fn:uri-collection()
            function.It is not required that all collections expose a list of URIs in this way, or
            that the URIs bear any particular relationship to the resources returned by the
            getResources() method for the same collection URI.The URIs that are returned should be
            suitable for passing to the registered URIResolver (in the case of XML resources),
            or the { @link UnparsedTextURIResolver }
            (in the case of unparsed text and JSON resources), etc.
            </summary>
            <param name="context">the XPath evaluation context</param>
            <returns>an iterator over the URIs of the resources in the collection. The URIs are represented
            as Strings.They should preferably be absolute URIs.</returns>
            public*
        </member>
        <member name="M:Saxon.Api.IResourceCollection.GetResources(Saxon.Api.DynamicContext)">
            <summary>
            Get the resources in the collection. This supports the fn:collection() function. It is not
            required that all collections expose a set of resources in this way, or that the resources
            returned bear any particular relationship to the URIs returned by the getResourceURIs() method
            for the same collection URI.
            </summary>
            <param name="context">the XPath evaluation context</param>
            <returns>a List over the resources in the collection. This returns objects of class
            <c>Riesource</c>.</returns>
            public*
        </member>
        <member name="T:Saxon.Api.DirectoryCollection">
            <summary>
            This class represents a resource collection containing all, or selected, files within a filestore directory
            </summary>
        </member>
        <member name="T:Saxon.Api.ResourceCollection">
            <summary>
            ResourceCollection class that implements the IResourceCollection interface.
            This class is used to map the URI of collection into a sequence of Resource objects.
            It is used to support the fn:collection() and fn:uri-collection() functions.
            </summary>
        </member>
        <member name="M:Saxon.Api.ResourceCollection.CollectionURI">
            <summary>
            Get the URI of the collection
            </summary>
            <returns>The URI as passed to the fn:collection() or fn:uri-collection() function, resolved if it is relative
            against the static base URI. If the collection() or uri-collection() function was called with no argument (to get the 
            'default collection') this will be the URI of the default collection registered with the Configuration</returns>
        </member>
        <member name="M:Saxon.Api.ResourceCollection.GetResourceURIs(Saxon.Api.DynamicContext)">
            <summary>
            Get the URIs of the resources in the collection.  It is
            not required that all collections expose a list of URIs in this way, or that the URIs bear any particular
            relationship to the resources returned by the getResources() method for the same collection URI.
            </summary>
            <param name="context">the XPath evaluation context</param>
            <returns>List over the URIs of the resources in the collection. The URIs are represented as strings.
            They should preferably be absolute URIs.</returns>
        </member>
        <member name="M:Saxon.Api.ResourceCollection.GetResources(Saxon.Api.DynamicContext)">
            <summary>
            Get the resources in the collection. This supports the fn:collection() function. It is not
            required that all collections expose a set of resources in this way, or that the resources
            returned bear any particular relationship to the URIs returned by the getResourceURIs() method
            for the same collection URI.
            </summary>
            <param name="context">the XPath evaluation context</param>
            <returns>a list over the resources in the collection. This returns objects of implementations of the interface <code>IResource</code></returns>
        </member>
        <member name="M:Saxon.Api.ResourceCollection.IsStable(Saxon.Api.DynamicContext)">
            <summary>
            Ask whether the collection is stable: in this case Saxon will retain the contents of the
            collection in memory, and will not make a second request on the CollectionFinder for the
            same collection URI.
            </summary>
            <param name="context">the XPath dynamic evaluation context (in case the decision is context dependent)</param>
        </member>
        <member name="M:Saxon.Api.DirectoryCollection.#ctor(Saxon.Api.Processor,System.String,System.String,Saxon.Api.URIQueryParameters)">
            <summary>
            Create a directory collection
            </summary>
            <param name="proc">Processor object for configuration properties</param>
            <param name="collectionURI">the collection URI</param>
            <param name="directoryName">the directory containing the files</param>
            <param name="parameters">query parameter supplied as part of the URI</param>
        </member>
        <member name="T:Saxon.Api.JarCollection">
            <summary>
            A JarCollection represents a collection of resources held in a JAR or ZIP archive, accessess typically
            using a URI using the "jar" URI scheme, or simply a "file" URI where the target file is a JAR or ZIP file.
            </summary>
        </member>
        <member name="M:Saxon.Api.JarCollection.#ctor(Saxon.Api.DynamicContext,System.String,Saxon.Api.URIQueryParameters)">
            <summary>
            Create a JarCollection
            </summary>
            <param name="context">The XPath dynamic context</param>
            <param name="collectionURI">the collection URI used to identify this collection 
            (typically but not necessarily the location of the JAR file)</param>
            <param name="parameters">URI query parameters appearing on the collection URI</param>
        </member>
        <member name="T:Saxon.Api.CatalogCollection">
            <summary>
            CatalogCollection
            </summary>
        </member>
        <member name="M:Saxon.Api.CatalogCollection.#ctor(Saxon.Api.Processor,System.String)">
            <summary>
            Constructor
            </summary>
            <param name="proc">Saxon Processor object</param>
            <param name="collectionURI">The URI for the collection</param>
        </member>
        <member name="T:Saxon.Api.StandardCollectionFinder">
            <summary>
            Default implementation of the CollectionFinder interface. 
            </summary>
        </member>
        <member name="M:Saxon.Api.StandardCollectionFinder.#ctor">
            <summary>
            Default constructor to create a wrapped Java StandardCollectionFinder
            </summary>
        </member>
        <member name="M:Saxon.Api.StandardCollectionFinder.FindCollection(Saxon.Api.DynamicContext,System.String)">
            <summary>
            Locate the collection of  resources corresponding to a collection URI
            </summary>
            <param name="context">The XPath dynamic evaluation context</param>
            <param name="collectionURI">The collection URI: an absolute URI, formed by resolving the argument
            supplied to the fn:collection or fn:uri-collection against the static base URI</param>
            <returns>a ResourceCollection object representing resources in the collection identified by this collection URI</returns>
        </member>
        <member name="M:Saxon.Api.StandardCollectionFinder.RegisterCollection(System.String,Saxon.Api.IResourceCollection)">
            <summary>
            Register a specific URI and bind it to a specific ResourceCollection
            </summary>
            <param name="collectionURI">collectionURI the collection URI to be registered. Must not be null.</param>
            <param name="collection">collection the ResourceCollection to be associated with this URI. Must not be null.</param>
        </member>
        <member name="P:Saxon.Api.StandardCollectionFinder.Implementation">
            <summary>
            The underlying java CollectionFinder object
            </summary>
        </member>
        <member name="T:Saxon.Api.IResource">
            <summary>
            This interface defines a Resource. The Resource objects belong to a collection.
            It is used to support the fn:collection() and fn:uri-collection() functions.
            <para>It is recommended (but is not universally the case) that fetching (and where necessary parsing)
            the content of a Resource should be delayed until the <c>getItem</c> method is called. This means
            that errors in fetching the resource or parsing its contents may go undetected until the resource
            is materialized in this way.</para>
            </summary>
        </member>
        <member name="M:Saxon.Api.IResource.GetResourceURI">
            <summary>
            Get a URI that identifies this resource
            </summary>
            <returns>a URI identifying the resource</returns>
            public*
        </member>
        <member name="M:Saxon.Api.IResource.GetXdmItem(Saxon.Api.DynamicContext)">
            <summary>
            Get an XDM Item holding the contents of this resource.
            </summary>
            <param name="context">the XPath evaluation context</param>
            <returns>an item holding the contents of the resource. The type of item will
            reflect the type of the resource: a document node for XML resources, a string
            for text resources, a map or array for JSON resources, a base64Binary value
            for binary resource.May also return null if the resource cannot be materialized
            and this is not to be treated as an error.</returns>
            public*
        </member>
        <member name="M:Saxon.Api.IResource.GetContentType">
            <summary> 
            Get the media type (MIME type) of the resource if known
            </summary>
            <returns>the media type if known; otherwise null</returns>
            public*
        </member>
        <member name="T:Saxon.Api.IResourceFactory">
            <summary>
            A ResourceFactory is used for constructing a particular type of resource
            </summary>
        </member>
        <member name="M:Saxon.Api.IResourceFactory.MakeResource(Saxon.Api.Processor)">
            <summary>
            Create a Resource with given content
            </summary>
            <param name="proc">the Saxon Processor</param>
            <returns>the resource</returns>
            public*
        </member>
        <member name="T:Saxon.Api.Resource">
            <summary>
            Resource Wrapper class for a Java Resource object
            </summary>
        </member>
        <member name="M:Saxon.Api.Resource.#ctor">
            <summary>
            Default constructor
            </summary>
        </member>
        <member name="M:Saxon.Api.Resource.#ctor(net.sf.saxon.lib.Resource)">
            <summary>
            Constructor to  wrap a Java Resource
            </summary>
            <param name="rc">Java Resource object</param>
        </member>
        <member name="M:Saxon.Api.Resource.GetContentType">
            <summary>
            Get the media type (MIME type) of the resource if known
            </summary>
            <returns>the media type if known; otherwise null</returns>
        </member>
        <member name="M:Saxon.Api.Resource.GetResourceURI">
            <summary>
            Get a URI that identifies this resource
            </summary>
            <returns>a URI identifying this resource</returns>
        </member>
        <member name="M:Saxon.Api.Resource.GetXdmItem(Saxon.Api.DynamicContext)">
            <summary>
            Get an XDM Item holding the contents of this resource.
            </summary>
            <param name="context">the XPath evaluation context</param>
            <returns>an item holding the contents of the resource. The type of item will
            reflect the type of the resource: a document node for XML resources, a string
            for text resources, a map or array for JSON resources, a base64Binary value
            for binary resource. May also return null if the resource cannot be materialized
            and this is not to be treated as an error.</returns>
        </member>
        <member name="T:Saxon.Api.BinaryResource">
            <summary>
            BinaryResource
            </summary>
        </member>
        <member name="M:Saxon.Api.BinaryResource.#ctor(System.String,System.String,System.Byte[])">
            <summary>
            Create a binary resource
            </summary>
            <param name="href">href of the resource</param>
            <param name="contentType">The MIME  type for the Binary resource</param>
            <param name="content">content given as byte array</param>
        </member>
        <member name="T:Saxon.Api.XmlResource">
            <summary>
            The class is an implementation of the generic Resource object (typically an item in a collection)
            representing an XML document
            </summary>
        </member>
        <member name="M:Saxon.Api.XmlResource.#ctor(Saxon.Api.XdmNode)">
            <summary>
            Constructor to create an  Xml resource using a specific node
            </summary>
            <param name="doc">the node in question (usually but not necessarily a document node)</param>
        </member>
        <member name="T:Saxon.Api.ExtensionFunction">
            <summary>
            This is an interface for simple external/extension functions.
            Users can implement this interface and register the implementation with the <see cref="T:Saxon.Api.Processor"/>;
            the function will then be available for calling from all queries, stylesheets, and XPath expressions compiled
            under this Processor.
            </summary>
            <remarks>
            <para>Extension functions implemented using this interface are expected to be free of side-effects,
            and to have no dependencies on the static or dynamic context. A richer interface for extension
            functions is provided via the <see cref="T:Saxon.Api.ExtensionFunctionDefinition"/> class.</para>
            </remarks>
        </member>
        <member name="M:Saxon.Api.ExtensionFunction.GetName">
            public*
        </member>
        <member name="M:Saxon.Api.ExtensionFunction.GetResultType">
            public*
        </member>
        <member name="M:Saxon.Api.ExtensionFunction.GetArgumentTypes">
            public*
        </member>
        <member name="M:Saxon.Api.ExtensionFunction.Call(Saxon.Api.XdmValue[])">
            public*
        </member>
        <member name="T:Saxon.Api.Feature`1">
            <summary>
            Feature defines a set of constants, representing the details of Saxon configuration
            options which can be supplied to the Saxon method <c>Processor.SetProperty()</c>,
            and to other interfaces.
            </summary>
        </member>
        <member name="M:Saxon.Api.Feature`1.byName(System.String)">
            <summary>
            Get the <c>Feature</c> object by string value name
            </summary>
            <param name="name">The feature name</param>
            <returns>The <c>Feature</c> object</returns>
        </member>
        <member name="F:Saxon.Api.Feature`1.ALLOW_EXTERNAL_FUNCTIONS">
            <summary>ALLOW_EXTERNAL_FUNCTIONS determines whether calls to reflexive external functions are
                           allowed.
            </summary>
            <remarks>
                       <para>More specifically, if set to <b>false</b> it disallows all of the
                           following:</para>
                       <list>
                           <item>Calls to reflexive Java extension functions</item>
                           <item>Use of the XSLT <code>system-property()</code> function to access Java system
                               properties</item>
                           <item>Use of a URI in the <code>href</code> attribute of an <code>xsl:result-document</code> instruction</item>
                           <item>Calls to XSLT extension instructions</item>
                       </list>
                       <para>The default value is <b>true</b>. The setting <b>false</b> is recommended in an
                           environment where untrusted stylesheets may be executed.</para>
                       <para>This option does not disable use of the <code>doc()</code> function or similar
                           functions to access the filestore of the machine where the transformation or query
                           is running. That should be done using a user-supplied <code>URIResolver</code>.</para>
                       <para>Note that integrated extension functions are trusted; calls to such functions are
                           allowed even if this configuration option is false. In cases where an integrated
                           extension function is used to load and execute untrusted code, it should check this
                           configuration option before doing so.</para>
                       <para>If the value of the property is false, then it will also be set to false on any new
                       Configuration created using the <code>fn:transform()</code> function.</para>
                   
            </remarks>
        </member>
        <member name="F:Saxon.Api.Feature`1.ALLOW_MULTITHREADING">
            <summary>ALLOW_MULTITHREADING determines whether multi-threading is allowed.
            </summary>
            <remarks>
                       <para>If true (the default), the presence of the attribute <code>saxon:threads="N"</code>
                           on an <code>xsl:for-each</code> instruction, when running under Saxon-EE, causes
                           multi-threaded execution. If set to false, the value of the
                               <code>saxon:threads</code> argument is ignored.</para>
                       <para>Setting the value to false also disables asynchronous processing of
                               <code>xsl:result-document</code> instructions.</para>
                       <para>The default value is true if Saxon-EE is in use, false otherwise.</para>
                   
            </remarks>
        </member>
        <member name="F:Saxon.Api.Feature`1.ALLOW_OLD_JAVA_URI_FORMAT">
            <summary>ALLOW_OLD_JAVA_URI_FORMAT determines whether extension function calls to
                           dynamically-loaded Java extension functions may use the URI format supported in
                           older Saxon releases.
            </summary>
            <remarks>
                       <para>If the value is false (the default), the only URI format accepted is (for example)
                           "java:java.util.Date" - that is, a URI consisting of the string "java:" followed by
                           the Java qualified class name of the class containing the implementation of the
                           extension function.</para>
                       <para>If the value is true, then in addition to this format, the following are accepted:
                           (a) the Java class name on its own ("java.util.Date"), and (b) any URI in which the
                           Java class name follows the last "/" character (for example
                           "http://my.com/extensions/java.util.Date"). This last format was originally provided
                           for compatibility with xt and xalan, but it causes problems because it leads to
                           unnecessary attempts to load spurious classes when the user did not intend the URI
                           to represent a dynamically-loaded Java class.</para>
                   
            </remarks>
        </member>
        <member name="F:Saxon.Api.Feature`1.ALLOW_SYNTAX_EXTENSIONS">
            <summary>This flag must be set to enable use of extensions to XPath, XQuery and XSLT
                           syntax that go beyond what is allowed by the extensibility mechanisms in the spec.
                           In some cases these extensions are experimental and may not be carried forward to future
                       Saxon releases.
            </summary>
            <remarks>
                       <para>Syntax extensions in Saxon 10 include the use of type aliases (<code>type(...)</code> where
                           an item type is expected, and <code>declare type NAME = item-type</code> in the XQuery Prolog); 
                           and simple inline functions (for example <code>.{. + 1}</code>).</para>
                   
            </remarks>
        </member>
        <member name="F:Saxon.Api.Feature`1.ASSERTIONS_CAN_SEE_COMMENTS">
            <summary>ASSERTIONS_CAN_SEE_COMMENTS determines whether comment and processing instructions in
                           a document being validated are visible to assertions in an XSD 1.1 schema.
            </summary>
            <remarks>
                       <para>If the value is false (the default), comments and processing instructions are
                           stripped from the view of the document that is made visible to the XPath expression
                           that implements the assertion. If this creates adjacent text nodes, they are
                           collapsed into a single text node.</para>
                       <para>If the value is true, then comments and processing instructions are visible to the
                           XPath assertion.</para>
                   
            </remarks>
        </member>
        <member name="F:Saxon.Api.Feature`1.COLLATION_URI_RESOLVER">
            <summary>The supplied <code>CollationURIResolver</code> is used to process any collation URIs
                           found in the query or stylesheet, returning an object of class
                               <see cref="T:net.sf.saxon.lib.StringCollator"/> that implements the requested
                           collation.
            </summary>
        </member>
        <member name="F:Saxon.Api.Feature`1.COLLATION_URI_RESOLVER_CLASS">
            <summary>The supplied class is instantiated and the resulting instance is used as the value of
                           the <see cref="F:Saxon.Api.Feature`1.COLLATION_URI_RESOLVER"/> property.
            </summary>
        </member>
        <member name="F:Saxon.Api.Feature`1.COLLECTION_FINDER">
            <summary>The supplied <code>CollectionFinder</code> is used to retrieve a <see cref="T:net.sf.saxon.lib.ResourceCollection"/> object given by any URI defined in
                           calls to the <code>collection()</code> or the <code>uri-collection()</code> function.
            </summary>
            <remarks>
                       <para>If the argument is not specified then a default <code>ResourceCollection</code> should be handled.
                           <code>CollectionFinder</code> returns a <see cref="T:net.sf.saxon.lib.ResourceCollection"/> which is used to map the URI of collection into a
                           sequence of <see cref="T:net.sf.saxon.lib.Resource"/> objects
                           (which are then resolved in the same way as URIs passed to the <code>doc()</code>
                           function), or it may return an item (typically a node but can handle JSON documents).</para>
                   
            </remarks>
        </member>
        <member name="F:Saxon.Api.Feature`1.COLLECTION_FINDER_CLASS">
            <summary>The supplied class is instantiated and the resulting instance is used as the value of
                           the <see cref="F:Saxon.Api.Feature`1.COLLECTION_FINDER"/> property.
            </summary>
        </member>
        <member name="F:Saxon.Api.Feature`1.COMPILE_WITH_TRACING">
            <summary>If run-time tracing of stylesheet or query execution is required, then the code must
                           be compiled with tracing enabled.
            </summary>
            <remarks>
                       <para>Default is false. This option causes code to be
                           compiled that makes calls to a <see cref="T:net.sf.saxon.lib.TraceListener"/>, but this
                           has no effect unless a <code>TraceListener</code> is registered at execution
                           time.</para>
                   
            </remarks>
        </member>
        <member name="F:Saxon.Api.Feature`1.CONFIGURATION">
            <summary>This attribute cannot be set on the <see cref="T:net.sf.saxon.Configuration"/> itself,
                           but it can be set on various JAXP factory objects such as a
                           <code>TransformerFactory</code> or <code>DocumentBuilderFactory</code>, to
                           ensure that several such factories use the same <code>Configuration</code>.
            </summary>
            <remarks>
                       <para>Note that other configuration options are held in the <code>Configuration</code> object,
                           so setting this attribute will cancel all others that have been set. Also, if two
                           factories share the same <code>Configuration</code>, then setting an attribute on
                           one affects all the others.</para>
                   
            </remarks>
        </member>
        <member name="F:Saxon.Api.Feature`1.CONFIGURATION_FILE">
            <summary>Defines a configuration file to be applied to the configuration.
            </summary>
            <remarks>
                       <para>This attribute cannot be set on the <see cref="T:net.sf.saxon.Configuration"/> itself, but it can be
                           set on various JAXP factory objects such as a <code>TransformerFactory</code> or
                               <code>DocumentBuilderFactory</code>. It is particularly useful when running
                           transformations via the Ant xslt task, where it can be set as follows to define all
                           configuration settings: </para>
                       <para><code>&lt;factory name="net.sf.saxon.TransformerFactoryImpl"&gt; &lt;attribute
                               name="http://saxon.sf.net/feature/configuration-file"
                               value="c:/saxon/config.xml"/&gt; &lt;/factory&gt;</code>
                       </para>
                   
            </remarks>
        </member>
        <member name="F:Saxon.Api.Feature`1.DEBUG_BYTE_CODE">
            <summary>This option is set to indicate that bytecode generation should be run in debugging
                           mode; it injects diagnostic tracing calls into the generated bytecode. This should
                           be used only if requested by Saxonica support to diagnose a problem related to
                           bytecode generation.
            </summary>
        </member>
        <member name="F:Saxon.Api.Feature`1.DEBUG_BYTE_CODE_DIR">
            <summary>This option is relevant only if <code>DISPLAY_BYTE_CODE</code> is set to true. It
                           defines a directory to which files containing bytecode in human-readable form will
                           be written. There will be one such file for each generated class, with a filename
                           designed to give some kind of clue as to its relationship to the source code.
            </summary>
            <remarks>
                       <para>The default value is the directory <code>saxonByteCode</code> within the current
                           working directory.</para>
                       <para>The named directory is created if it does not already exist.</para>
                       <para>Because the generation of class names involves random numbers, files will tend to
                           accumulate in the supplied directory, even when the same source code is compiled
                           repeatedly.</para>
                   
            </remarks>
        </member>
        <member name="F:Saxon.Api.Feature`1.DEFAULT_COLLATION">
            <summary>This option determines the collation that is used for comparing strings when no
                           explicit collation is requested. It is not necessary for this collation to exist (or
                           to have been registered) when setting this option; it only needs to exist by the
                           time it is used.
            </summary>
            <remarks>
                       <para>In XSLT it is possible to override this setting using the
                               <code>[xsl:]default-collation</code> attribute on any stylesheet element. In
                           XQuery, it can be overridden using the <code>declare default collation</code>
                           declaration in the query prolog, or via a setter method in class
                               <see cref="T:net.sf.saxon.query.StaticQueryContext"/>.</para>
                       <para>If no value is specified, the Unicode codepoint collation is used.</para>
                   
            </remarks>
        </member>
        <member name="F:Saxon.Api.Feature`1.DEFAULT_COLLECTION">
            <summary>This determines the collection that is used when the <code>fn:collection()</code>
                           function is called with no arguments; the effect is the same as if it were called
                           passing the URI that is the value of this configuration property.
            </summary>
        </member>
        <member name="F:Saxon.Api.Feature`1.DEFAULT_COUNTRY">
            <summary>This determines the country that is used by <code>format-date()</code> and similar
                           functions if no country code is supplied explicitly. If no value is given for this
                           property, the default is taken from the Java Locale, which in turn typically depends
                           on settings for the current user in the operating system.
            </summary>
        </member>
        <member name="F:Saxon.Api.Feature`1.DEFAULT_LANGUAGE">
            <summary>This option determines the language that is used by <code>format-date()</code>,
                               <code>xsl:number</code> and similar constructs if no language code is supplied
                           explicitly. If no value is given for this property, the default is taken from the
                           Java Locale, which in turn typically depends on settings for the current user in the
                           operating system.
            </summary>
        </member>
        <member name="F:Saxon.Api.Feature`1.DEFAULT_REGEX_ENGINE">
            <summary>Determines which regular expression engine should be used for evaluating regular expressions occuring in constructs
                       such as <code>fn:matches()</code>, <code>fn:replace</code>, and <code>xsl:analyze-string</code>, and also
                       in the pattern facet of a schema.
            </summary>
            <remarks>
                       <para>On the Java platform the permitted values are "S" (default), and "J". The value "J" selects the regex engine
                       provided in the JDK in preference to the Saxon regular expression engine. This means that regular expressions must
                       follow the Java syntax and semantics rather than the XPath syntax and semantics.</para>
                       <para>On the .NET platform the permitted values are "S" (default), "J", and "N". The value "J" selects the regex engine
                           provided in the IKVMC run-time, which is derived from OpenJDK. The value "N" selects the regex engine provided
                       in the Microsoft .NET platform. In each case, the regular expression must follow the syntax and semantics of the selected
                       regex engine.</para>
                       <para>The choice of regular expression may be overridden in a particular invocation by appending the value ";s",
                       ";j", or ";n" to the flags argument of the relevant call. (This does not apply to XSD patterns, where no flags argument is available)</para>
                       <para>Use of this feature is not conformant with W3C specifications. Use of the setting "N", however, can be useful
                       when schemas have been written with the Microsoft schema processor in mind, since this uses the Microsoft regular
                       expression dialect rather than the W3C dialect.</para>
                   
            </remarks>
        </member>
        <member name="F:Saxon.Api.Feature`1.DISABLE_XSL_EVALUATE">
            <summary>This option disables the <code>xsl:evaluate</code> instruction.
            </summary>
            <remarks>
                       <para>If set at stylesheet compile time, the feature is statically disabled. If set at 
                           run-time it is dynamically disabled. (These terms are defined in the XSLT 3.0 spec.)
                           By default, the feature is enabled.</para>
                       <para><i>The XSLT 3.0 specification requires conformant processors to provide a way of
                           disabling <code>xsl:evaluate</code>. This shouldn't be taken as meaning that 
                           <code>xsl:evaluate</code> poses particular security risks. The main reason for disabling it
                           is if you want to carry out static analysis or inspection of stylesheet code to see what 
                           features it uses. But if you're doing such inspection, it's not difficult to check that
                           <code>xsl:evaluate</code> is only being used to execute trusted code. Note also that
                           <code>fn:transform()</code> can similarly be used to execute dynamically-constructed code,
                           and there is no switch to disable that function.</i></para>
                   
            </remarks>
        </member>
        <member name="F:Saxon.Api.Feature`1.DISPLAY_BYTE_CODE">
            <summary>This option is set to indicate that bytecode generation should be run in display
                           mode. The effect is to output files (one per class) containing a human-readable
                           print of the generated bytecode. The files are placed in the directory identified by
                           the <code>DEBUG_BYTE_CODE_DIR</code> option.
            </summary>
        </member>
        <member name="F:Saxon.Api.Feature`1.DTD_VALIDATION">
            <summary>If true, the XML parser is requested to perform validation of source documents
                           against their DTD. Default is false.
            </summary>
            <remarks>
                       <para>This option establishes a default for use whenever source documents (not stylesheets
                           or schema documents) are parsed. The option can be overridden for individual
                           documents by setting the <see cref="T:net.sf.saxon.lib.ParseOptions"/> for that
                           individual document, for example from a <code>URIResolver</code>.</para>
                   
            </remarks>
        </member>
        <member name="F:Saxon.Api.Feature`1.DTD_VALIDATION_RECOVERABLE">
            <summary>This option determines whether DTD validation failures should be treated as
                           recoverable. If the option is set, a validation failure is reported as a warning
                           rather than an error. The default is false.
            </summary>
            <remarks>
                       <para>This option establishes a default for use whenever source documents (not stylesheets
                           or schema documents) are parsed. The option can be overridden for individual
                           documents by setting the <see cref="T:net.sf.saxon.lib.ParseOptions"/> for that
                           individual document, for example from a <code>URIResolver</code>.</para>
                   
            </remarks>
        </member>
        <member name="F:Saxon.Api.Feature`1.EAGER_EVALUATION">
            <summary>Forces Saxon to do eager evaluation of expressions in contexts where normally it would do lazy evaluation,
                           for example when evaluating variables and function results. This can make for easier debugging.
            </summary>
            <remarks>
                       <para>Note that this only applies to situations where Saxon would normally save a <code>Closure</code>
                       object as the result of an expression. It does not prevent Saxon from using pipelined evaluation of
                       intermediate expressions using iterators.</para>
                   
            </remarks>
        </member>
        <member name="F:Saxon.Api.Feature`1.ENTITY_RESOLVER_CLASS">
             <summary>The supplied class is instantiated and the resulting <code>EntityResolver</code> is
                            used whenever Saxon itself creates an <code>XMLReader</code> for parsing source
                            documents. It is not used with a user-supplied <code>XMLReader</code>.
             </summary>
             <remarks>
                        <para>The default value is <see cref="T:net.sf.saxon.lib.StandardEntityResolver"/>. This is an entity
                            resolver that recognizes the names of many standard W3C DTDs and external entity
                            files, and resolves them against local copies issued with the Saxon software, to
                            avoid the need to fetch them from the web.</para>
                        <para>The property can be set to a zero-length string, in which case no
                                <code>EntityResolver</code> will be used.</para>
            
                    
             </remarks>
        </member>
        <member name="F:Saxon.Api.Feature`1.ENVIRONMENT_VARIABLE_RESOLVER">
            <summary>Setting the <code>ENVIRONMENT_VARIABLE_RESOLVER</code> causes the supplied object to
                           be registered as the environment variable resolver for the
                               <code>Configuration</code>. The setting is global: it affects all queries and
                           transformations using this configuration.
            </summary>
            <remarks>
                       <para>The environment variable resolver is used when the XPath functions
                               <code>available-environment-variables()</code> or
                               <code>environment-variable()</code> are called. Saxon essentially delegates the
                           evaluation of the function to the external resolver.</para>
                   
            </remarks>
        </member>
        <member name="F:Saxon.Api.Feature`1.ENVIRONMENT_VARIABLE_RESOLVER_CLASS">
            <summary>Setting <code>ENVIRONMENT_VARIABLE_RESOLVER_CLASS</code> causes an instance of the
                           supplied class to be created, and registered as the environment variable resolver
                           for the <code>Configuration</code>. The setting is global: it affects all queries
                           and transformations using this configuration.
            </summary>
            <remarks>
                       <para>The environment variable resolver is used when the XPath functions
                               <code>available-environment-variables()</code> or
                               <code>environment-variable()</code> are called. Saxon essentially delegates the
                           evaluation of the function to the external resolver.</para>
                   
            </remarks>
        </member>
        <member name="F:Saxon.Api.Feature`1.ERROR_LISTENER_CLASS">
            <summary><code>ERROR_LISTENER_CLASS</code> is the name of the class used to implement the JAXP
                           <code>ErrorListener</code>. This is used both at compile time and at run-time.
            </summary>
            <remarks>
                       <para>Currently if this option is specified, the class is instantiated, and the same
                           instance is used for all processes running under this configuration. This may change
                           in future so that a new instance is created for each compilation or evaluation.</para>
                       <para>Finer control can be obtained by setting the <code>ErrorListener</code> for a
                           specific XSLT or XQuery compilation or evaluation.</para>
                   
            </remarks>
        </member>
        <member name="F:Saxon.Api.Feature`1.EXPAND_ATTRIBUTE_DEFAULTS">
            <summary><code>EXPAND_ATTRIBUTE_DEFAULTS</code> determines whether fixed and default values
                           defined in a schema or DTD will be expanded (both on input and on output documents,
                           if validation is requested).
            </summary>
            <remarks>
                       <para>By default (and for conformance with the specification)
                           validation against a DTD or schema will cause default values defined in the schema
                           or DTD to be inserted into the document. Setting this feature to false suppresses
                           this behavior. In the case of DTD-defined defaults this only works if the XML parser
                           reports whether each attribute was specified in the source or generated by expanding
                           a default value. Not all XML parsers report this information.</para>
                   
            </remarks>
        </member>
        <member name="F:Saxon.Api.Feature`1.EXPATH_FILE_DELETE_TEMPORARY_FILES">
            <summary><code>EXPATH_FILE_DELETE_TEMPORARY_FILES</code> determines whether temporary files
                           and directories created in the EXPath File module should be automatically deleted on
                           closure of the JVM.
            </summary>
            <remarks>
                       <para>The default value is <b>false</b>, to align with the standard. The setting
                               <b>false</b> is recommended when external 'sweep-up' features aren't
                           available.</para>
                   
            </remarks>
        </member>
        <member name="F:Saxon.Api.Feature`1.GENERATE_BYTE_CODE">
            <summary>By default, Saxon-EE attempts to generate Java bytecode for evaluation of parts of a
                           query or stylesheet that are amenable to such treatment. Setting this option to
                           false disables this.
            </summary>
            <remarks>
                       <para>For backwards compatibility, this option when used at the level of <code>Configuration.setConfigurationProperty()</code>
                       can also be used to set the value of <code>THRESHOLD_FOR_HOTSPOT_BYTECODE</code>. If the value on that interface is supplied
                       as an integer (or a string in the form of an integer) then a value of 1 or more sets the threshold for hotspot detection, while
                       a value of zero or less disables bytecode generation entirely. On other interfaces the value of the property must be a boolean.</para>
                   
            </remarks>
        </member>
        <member name="F:Saxon.Api.Feature`1.IGNORE_SAX_SOURCE_PARSER">
            <summary>If this option is set to true, then when a <code>SAXSource</code> is supplied as the
                           input to an XSLT transformation, Saxon will ignore the <code>XMLReader</code>
                           supplied in the <code>SAXSource</code> (in fact, it will modify the supplied
                               <code>SAXSource</code> setting the <code>XMLReader</code> to null) and use an
                               <code>XMLReader</code> created using the value of the
                               <code>SOURCE_PARSER_CLASS</code> option in preference.
            </summary>
            <remarks>
                       <para>The defining use case for this feature is when calling a Saxon transformation from
                           Ant. Ant always supplies the source document as a <code>SAXSource</code> using a
                           parser instantiated using the default JAXP mechanism. A different parser set using
                           the property <code>http://saxon.sf.net/feature/sourceParserClass</code> will
                           normally be ignored in this case; setting the <code>ignoreSAXSourceParser</code>
                           option overrides this. This is especially useful if the input format is not in fact
                           XML, but some other format converted to a SAX event stream by means of a custom
                           parser.</para>
                   
            </remarks>
        </member>
        <member name="F:Saxon.Api.Feature`1.IMPLICIT_SCHEMA_IMPORTS">
            <summary><code>IMPLICIT_SCHEMA_IMPORTS</code> allows reference to schema components without an <code>xs:import</code> for the relevant namespace being
                           present in the containing schema document. 
            </summary>
            <remarks>
                       <para>This only works if the referenced components are already present among the schema components known to the configuration, perhaps
                       because they were part of a different schema, or because there are cyclic references within a schema.</para>
                       <para>This option is not conformant with the XSD specification, which requires explicit <code>xs:import</code> declarations
                       for all cross-namespace component references. However, some "industry-standard" schemas are known to violate this rule,
                       and setting this option allows such schemas to be loaded by Saxon.</para>
                   
            </remarks>
        </member>
        <member name="F:Saxon.Api.Feature`1.LAZY_CONSTRUCTION_MODE">
            <summary><code>LAZY_CONSTRUCTION_MODE</code> determines whether temporary trees are
                           constructed lazily. The default setting is false; there are a few situations (but
                           not many) where setting this to true can give a performance benefit (especially a
                           memory saving).
            </summary>
            <remarks>
                       <para>The option is most likely to be effective when executing XQuery in "pull" mode, that
                           is, when the client calls the query processor to deliver the result as a stream of
                           nodes, rather than running the query and piping the results into a serializer.</para>
                   
            </remarks>
        </member>
        <member name="F:Saxon.Api.Feature`1.LICENSE_FILE_LOCATION">
            <summary><code>LICENSE_FILE_LOCATION</code> holds the filename in which the Saxon license file
                           is held.
            </summary>
            <remarks>
                       <para>This is the full file name, for example <code>c:/saxon/license/license.lic</code>. 
                           Setting this property causes Saxon to
                           immediately read the specified file and register the license data, assuming it can
                           be found at this location. The property is not recognized for reading, and it is not
                           recognized for writing except in Saxon-PE and Saxon-EE.</para>
                   
            </remarks>
        </member>
        <member name="F:Saxon.Api.Feature`1.LINE_NUMBERING">
            <summary>Default is false. If true, line and column number information is retained for all
                           source documents. This information is accessible using the
                               <code>saxon:line-number()</code> and <code>saxon:column-number()</code>
                           extension functions.
            </summary>
            <remarks>
                       <para>Note that the information is only as good as the XML parser supplies. SAX parsers
                           generally report the position of an element node using the line and column number of
                           the "&gt;" character that forms the last character of the start tag.</para>
                       <para>When this option is set, location information attached to a node (system ID, line
                       number, and column number) is retained when the node is copied. This has the side effect
                       that the base URI of a node is also copied, which in some cases runs contrary to the
                       XSLT or XQuery specification.</para>
                   
            </remarks>
        </member>
        <member name="F:Saxon.Api.Feature`1.MARK_DEFAULTED_ATTRIBUTES">
            <summary>Setting the <code>MARK_DEFAULTED_ATTRIBUTES</code> option causes Saxon to retain details of attributes
                       that were notified by the XML parser as being defaulted (that is, the attribute was not present in the instance
                       document but was defined by a default value in a DTD or schema). This information is available to applications
                       via the <code>saxon:is-defaulted()</code> extension function.
            </summary>
            <remarks>
                       <para>Note: information about defaulted attributes is retained automatically where the attribute is processed
                       using Saxon's schema processor; but in the case where the information comes from an external XML parser, it
                       is retained only if this option is set.</para>
                   
            </remarks>
        </member>
        <member name="F:Saxon.Api.Feature`1.MAX_COMPILED_CLASSES">
            <summary>Places a limit on the number of classes for which Saxon will generate bytecode.
            </summary>
            <remarks>
                       <para>If bytecode generation is enabled, Saxon will generate bytecode for frequently used constructs appearing
                           in stylesheets or queries. This can become problematic if a configuration uses a very large number
                           of different stylesheets and queries, because it creates memory pressure (in some environments classes
                           are never garbage collected). When this limit (which defaults to 10,000) is exceeded, no more bytecode
                       is generated, and queries/stylesheets are interpreted instead.</para>
                   
            </remarks>
        </member>
        <member name="F:Saxon.Api.Feature`1.MESSAGE_EMITTER_CLASS">
            <summary>Use the specified <code>Receiver</code> to process the output from
                               <code>xsl:message</code>. The class must implement the
                               <code>net.sf.saxon.event.Receiver</code> interface. This interface is similar to
                           a SAX <code>ContentHandler</code>, in that it takes a stream of events to generate
                           output.
            </summary>
            <remarks>
                       <para>By default the standard XML emitter is used, configured to write to the standard
                           error stream, and to include no XML declaration. </para>
                       <para>In general the content of a message is an XML fragment. Each message is output as a
                           new document. The sequence of calls to this <code>Receiver</code> is as follows:
                           there is a single <code>open()</code> call at the start of the transformation, and a
                           single <code>close()</code> call at the end; and each evaluation of an
                               <code>xsl:message</code> instruction starts with a <code>startDocument()</code>
                           call and ends with <code>endDocument()</code>. </para>
                       <para>The <code>startDocument()</code> event has a <code>properties</code> argument
                           indicating whether <code>terminate="yes"</code> was specified, and the
                               <code>locationId</code> on calls such as <code>startElement()</code> and
                               <code>characters()</code> can be used to identify the location in the stylesheet
                           where the message data originated (this is achieved by passing the supplied
                               <code>locationId</code> in a call to
                               <code>getPipelineConfiguration().getLocator().getSystemId(locationId)</code>, or
                           to <code>getLineNumber()</code> on the same object). </para>
                       <para>Select the class <code>net.sf.saxon.event.MessageWarner</code> to have
                               <code>xsl:message</code> output notified to the JAXP <code>ErrorListener</code>,
                           as described in the JAXP documentation.</para>
                   
            </remarks>
        </member>
        <member name="F:Saxon.Api.Feature`1.MODULE_URI_RESOLVER">
            <summary>Affects XQuery only. An instance of a user-written class implementing Saxon's
                               <see cref="T:net.sf.saxon.lib.ModuleURIResolver"/> interface. This is used to
                           process any URIs used in <code>import module</code> directives in XQuery.
            </summary>
        </member>
        <member name="F:Saxon.Api.Feature`1.MODULE_URI_RESOLVER_CLASS">
            <summary>Affects XQuery only. The name of a user-written class implementing Saxon's
                               <see cref="T:net.sf.saxon.lib.ModuleURIResolver"/> interface. This is used to
                           process any URIs used in <code>import module</code> directives in XQuery.
            </summary>
        </member>
        <member name="F:Saxon.Api.Feature`1.MONITOR_HOT_SPOT_BYTE_CODE">
            <summary>When set from the Transform or Query command line, a report on bytecode generation is
                           produced at the end of the transformation or query.
            </summary>
            <remarks>
                       <para>When set from an application, the bytecode report is produced only on request, by
                           calling <code>Configuration.createByteCodeReport(fileName)</code>.</para>
                       <para>The bytecode report is an XML file containing one entry for each expression that has
                           been compiled into bytecode. Each entry contains the following details, where
                           applicable:</para>
                           <list>
                           <item><code>text</code> Abbreviated text of the expression</item>
                           <item><code>intCount</code> Number of times the expression was evaluated in the interpreter</item>
                           <item><code>intTime</code> Cumulative time spent evaluating the expression (including subexpressions) in the interpreter</item>
                           <item><code>bcCount</code> Number of times the expression was evaluated as byte-code</item>
                           <item><code>bcTime</code> Cumulative time spent evaluating the expression (including subexpressions) as byte-code</item>
                           <item><code>compileTime</code> Time spent generating bytecode for the expression</item>
                           <item><code>ratio</code> Average byte-code execution time as a proportion of average interpreted execution time</item>
                           <item><code>ebv</code> Number of evaluations of the expressions <code>effectiveBooleanValue()</code> method</item>
                           <item><code>eval</code> Number of evaluations of the expressions <code>evaluateItem()</code> method</item>
                           <item><code>iterate</code> Number of evaluations of the expressions <code>iterate()</code> method</item>
                           <item><code>process</code> Number of evaluations of the expressions <code>process()</code> method</item>
                           <item><code>module</code> URI of the module containing the expression</item>
                           <item><code>line</code> Line number of the expression within this module</item>
                       </list>
                   
            </remarks>
        </member>
        <member name="F:Saxon.Api.Feature`1.MULTIPLE_SCHEMA_IMPORTS">
            <summary>Affects schema construction (whether for standalone validation, or in the context of
                           XSLT or XQuery).
            </summary>
            <remarks>
                       <para>If set to true, the schema processor attempts to fetch a schema
                           document appearing in an <code>xs:import</code> directive, whether or not a schema
                           for that namespace has already been loaded, unless the absolute URI formed from the
                               <code>schemaLocation</code> is the same as the absolute URI that was used to
                           load that namespace. If set to false, the schema processor ignores the
                               <code>schemaLocation</code> on an <code>xs:import</code> declaration if schema
                           components for the requested namespace are already available. Note that setting the
                           value to true might cause spurious errors due to like-named schema components being
                           loaded more than once. On the other hand, setting the value to false might result in
                           validation failing because schema components are missing.</para>
                       <para>Note: Both settings are conformant with the W3C recommendation, which leaves the
                           details implementation-defined. It is possible (and advisable) to write schemas in
                           such a way that this setting makes no difference, by ensuring that all imports for a
                           particular namespace go via a "home" schema document for that namespace, where the
                           home schema document contains <code>xs:include</code> declarations for all the
                           schema documents defining components in that namespace.</para>
                   
            </remarks>
        </member>
        <member name="F:Saxon.Api.Feature`1.NAME_POOL">
            <summary>Indicates that the supplied <code>NamePool</code> should be used as the target
                           (run-time) <code>NamePool</code> by all stylesheets compiled (using
                           <code>newTemplates()</code>) after this call on <code>setAttribute</code>.
            </summary>
            <remarks>
                       <para>Normally a single system-allocated <code>NamePool</code> is used for all stylesheets
                           compiled while the Java VM remains loaded; this attribute allows user control over
                           the allocation of name pools. Note that source trees used as input to a
                           transformation must be built using the same <code>NamePool</code> that is used when
                           the stylesheet is compiled: this will happen automatically if the input to a
                           transformation is supplied as a <code>SAXSource</code> or <code>StreamSource</code>
                           but it is under user control if you build the source tree yourself.</para>
                       <para>This option can be used to make two <code>Configuration</code> objects share a
                               <code>NamePool</code> even though they differ in other respects.</para>
                   
            </remarks>
        </member>
        <member name="F:Saxon.Api.Feature`1.OCCURRENCE_LIMITS">
            <summary><code>OCCURRENCE_LIMITS</code> determines the largest values of
                           <code>minOccurs</code> and <code>maxOccurs</code> that can be accommodated when
                           compiling an "expanded" finite state machine to represent an XSD content model
                           grammar.
            </summary>
            <remarks>
                       <para>These limits do not apply in the common cases where the grammar can be
                           implemented using a counting finite-state-machine, but in those cases where this is
                           not possible, any <code>minOccurs</code> value greater than the first integer is
                           reduced to the value of the first integer, and any <code>maxOccurs</code> value
                           greater than the second integer is treated as "unbounded".</para>
                       <para>Setting these values too high may cause an <code>OutOfMemoryException</code> since
                           the size of the finite state machine constructed by Saxon increases linearly with
                           the values of <code>minOccurs</code> and <code>maxOccurs</code>.</para>
                   
            </remarks>
        </member>
        <member name="F:Saxon.Api.Feature`1.OPTIMIZATION_LEVEL">
            <summary>Allows individual optimizations to be enabled or disabled selectively.
            </summary>
            <remarks>
                       <para>There is a set of single-letter flags identifying particular optimizations:</para>
                       <list>
                           <item>c: generate bytecode</item>
                           <item>e: cache regular expressions</item>
                           <item>f: inline functions</item>
                           <item>g: extract global variables</item>
                           <item>j: just-in-time compilation of template rules</item>
                           <item>k: create keys</item>
                           <item>l: loop lifting</item>
                           <item>m: miscellaneous</item>
                           <item>n: constant folding</item>
                           <item>r: template rule-sets</item>
                           <item>s: extract common subexpressions</item>
                           <item>v: inline variables</item>
                           <item>w: create switch statements</item>
                           <item>x: index predicates</item>
                       </list>
                       <para>A value such as <code>gs</code> runs with only the selected optimizations;
                           <code>-gs</code> runs with the selected optimizations disabled and all others enabled. The
                           value <code>0</code> suppresses all optimizations. The default is full optimization; this
                           feature allows optimization to be suppressed in cases where reducing compile time is
                           important, or where optimization gets in the way of debugging, or causes extension
                           functions with side-effects to behave unpredictably. (Note however, that even with
                           no optimization, lazy evaluation may still cause the evaluation order to be not as
                           expected.) </para>
                       <para><i>Note that disabling optimizations may prevent streamed execution. This is because
                       there are cases where streamed execution is only possible because the optimizer is able to detect
                       that sorting nodes into document order is unnecessary.</i></para>
                   
            </remarks>
        </member>
        <member name="F:Saxon.Api.Feature`1.OUTPUT_URI_RESOLVER">
            <summary>The supplied <code>OutputURIResolver</code> will be used to resolve URIs of secondary
                           result documents selected in the <code>href</code> attribute of the XSLT
                               <code>xsl:result-document</code> instruction.
            </summary>
        </member>
        <member name="F:Saxon.Api.Feature`1.OUTPUT_URI_RESOLVER_CLASS">
            <summary>The supplied class will be instantiated, and the resulting
                               <code>OutputURIResolver</code> will be used to resolve URIs of secondary result
                           documents selected in the <code>href</code> attribute of the XSLT
                               <code>xsl:result-document</code> instruction.
            </summary>
        </member>
        <member name="F:Saxon.Api.Feature`1.PRE_EVALUATE_DOC_FUNCTION">
            <summary>If true, calls on the <code>doc()</code> and <code>document()</code> functions, if
                           their arguments are known at compile time, will be evaluated at compile time, and
                           the resulting document will be stored as part of the Saxon
                           <see cref="T:net.sf.saxon.Configuration"/> and shared by all queries and
                           transformations running within that <code>Configuration</code>.
            </summary>
            <remarks>
                       <para>This is useful for reference documents that have stable content and are used by many different 
                           queries and transformations. The default is false, which means each query or transformation
                           will reload the document from disk.</para>
                       <para>In XSLT 3.0 a better way of having external documents pre-loaded at stylesheet
                           compile time is to use the new facility of static global variables.</para>
                   
            </remarks>
        </member>
        <member name="F:Saxon.Api.Feature`1.PREFER_JAXP_PARSER">
            <summary>Relevant only on .NET, determines whether the Java Classpath parser is used in
                           preference to the Microsoft .NET parser.
            </summary>
            <remarks>
                       <para>This option has no effect on the Java platform. The default is <b>true</b>. When
                           running on the .NET platform, if the option is true it causes the Apache Xerces
                           parser (cross-compiled using IKVMC) to be used in preference to the .NET XML parser.
                           If false the .NET XML parser (<code>System.Xml.XmlTextReader</code>) is used. One
                           reason for providing this option is that the .NET XML parser does not report ID
                           attributes, which means that the <code>id()</code> function does not work.</para>
                   
            </remarks>
        </member>
        <member name="F:Saxon.Api.Feature`1.RECOGNIZE_URI_QUERY_PARAMETERS">
            <summary>True if the standard URI resolver is to recognize query parameters included in the
                           URI (for example, <code>?validation=strict</code>). Such parameters can then be used
                           in URIs passed to the <code>doc()</code> or <code>document()</code> functions. The
                           default is false.
            </summary>
            <remarks>
                       <para>This option has no effect if a user-supplied <code>URIResolver</code> is in use,
                           unless the user-supplied <code>URIResolver</code> chooses to inherit this
                           functionality from the standard <code>URIResolver</code>.</para>
                       <para>The allowed parameters are: <code>validation=strict|lax|strip</code> to perform schema
                           validation (see <span class="link" data-href="/sourcedocs/validation">Validation of
                               Source Documents</span>); <code>strip-space=yes|ignorable|no</code> to control whitespace
                           stripping (see <span class="link" data-href="/sourcedocs/whitespace">Whitespace
                               Stripping in Source Documents</span>); <code>parser=full.class.name</code> to
                           determine the name of the parser (XMLReader) to be used (see <span class="link" data-href="/sourcedocs/controlling-parsing">Controlling Parsing of Source
                               Documents</span>); and <code>xinclude=yes|no</code> to control whether XInclude
                           processing takes place, assuming the XML parser supports it (see <span class="link" data-href="/sourcedocs/XInclude">XInclude processing</span>).</para>
                   
            </remarks>
        </member>
        <member name="F:Saxon.Api.Feature`1.RECOVERY_POLICY">
            <summary>At one time this property controlled how recoverable errors were handled
                           (fatal error, warning, or ignored). XSLT 3.0 has eliminated all recoverable errors from the
                           specification, so the property is now deprecated.
            </summary>
        </member>
        <member name="F:Saxon.Api.Feature`1.RECOVERY_POLICY_NAME">
            <summary>At one time this property controlled how recoverable errors were handled
                           (fatal error, warning, or ignored). XSLT 3.0 has eliminated all recoverable errors from the
                           specification, so the property is now deprecated.
            </summary>
        </member>
        <member name="F:Saxon.Api.Feature`1.RESULT_DOCUMENT_THREADS">
            <summary>Indicates the maximum number of threads to be used for processing
                               <code>xsl:result-document</code> instructions in parallel. If the maximum number
                           of threads are already in use, the <code>xsl:result-document</code> instruction will
                           be executed synchronously within its parent thread.
            </summary>
            <remarks>
                       <para>The default value is initialized to
                               <code>Runtime.getRuntime().availableProcessors()</code> which is intended to
                           represent the number of "processors" (under some definition) available from the
                           hardware.</para>
                       <para>The limit applies per <code>Configuration</code>. If multiple workloads are running
                           on the same server under separate Saxon <code>Configuration</code> objects, then it
                           may be desirable to lower the limit.</para>
                       <para>Setting a value of zero or one suppresses multithreading entirely. This can also be
                           achieved (for a specific <code>xsl:result-document</code> instruction) by setting
                           the attribute <code>saxon:asynchronous="no"</code> in the stylesheet. Suppressing
                           multithreading may be desirable in a stylesheet that calls extension functions with
                           side-effects.</para>
                   
            </remarks>
        </member>
        <member name="F:Saxon.Api.Feature`1.RETAIN_DTD_ATTRIBUTE_TYPES">
            <summary>If set to true, indicates that when input is obtained from a SAX parser, the
                           DTD-based attribute type notified by the XML parser should be used to set the type
                           annotation of the resulting node: for example a DTD type of NMTOKENS results in a
                           type annotation of xs:NMTOKENS. 
            </summary>
            <remarks>
                       <para>This option is retained for backwards compatibility (at some time in the past, it was
                           the default), but is deprecated.</para>
                   
            </remarks>
        </member>
        <member name="F:Saxon.Api.Feature`1.SCHEMA_URI_RESOLVER">
            <summary>The supplied <code>SchemaURIResolver</code> will be used to resolve URIs of schema
                           documents referenced in <code>xsl:import-schema</code> declarations in XSLT,
                               <code>import schema</code> in XQuery, references from one schema document to
                           another using <code>xs:include</code> or <code>xs:import</code>, and references from
                           an instance document to a schema using <code>xsi:schemaLocation</code>.
            </summary>
        </member>
        <member name="F:Saxon.Api.Feature`1.SCHEMA_URI_RESOLVER_CLASS">
            <summary>The name of a class that implements the interface <code>SchemaURIResolver</code>;
                           this class will be instantiated and the resulting instance will be used as the value
                           of the <see cref="F:Saxon.Api.Feature`1.SCHEMA_URI_RESOLVER"/> property.
            </summary>
        </member>
        <member name="F:Saxon.Api.Feature`1.SCHEMA_VALIDATION">
            <summary>Indicates whether and how schema validation should be applied to source
                           documents.
            </summary>
        </member>
        <member name="F:Saxon.Api.Feature`1.SCHEMA_VALIDATION_MODE">
            <summary>Indicates whether and how schema validation should be applied to source
                           documents.
            </summary>
        </member>
        <member name="F:Saxon.Api.Feature`1.SERIALIZER_FACTORY_CLASS">
            <summary>The class will be instantiated and the resulting <code>SerializerFactory</code> will
                           be used to create the serialization pipeline for XSLT and XQuery results.
            </summary>
            <remarks>
                       <para>By subclassing the standard <code>SerializerFactory</code> it is possible to customize
                           many aspects of the output produced by the Serializer, or to introduce new
                           serialization methods and parameters.</para>
                   
            </remarks>
        </member>
        <member name="F:Saxon.Api.Feature`1.SOURCE_PARSER_CLASS">
            <summary>XML parser used for source documents.
            </summary>
            <remarks>
                       <para>The class will be instantiated. If it is an <code>XMLReader</code> it is used
                           directly; if it is a <code>SAXParserFactory</code> it is used to instantiate an
                               <code>XMLReader</code>. The resulting <code>XMLReader</code> will be used to
                           parse source documents (that is, the principal source document plus any secondary
                           source documents read using the <code>doc()</code>, <code>document()</code>, or
                               <code>collection()</code> function).</para>
                       <para>Note that the selected parser is used only when the input is supplied in the form of
                           a <code>StreamSource</code>; it is ignored when a <code>SAXSource</code> with a
                           pre-initialized <code>XMLReader</code> is supplied. A consequence is that this
                           configuration option has no effect when running transformations from an Ant script,
                           since the Ant <code>xslt</code> task always supplies the input in the form of a
                               <code>SAXSource</code>.</para>
                   
            </remarks>
        </member>
        <member name="F:Saxon.Api.Feature`1.SOURCE_RESOLVER_CLASS">
            <summary>On interfaces that allow an <code>org.xml.sax.Source</code> to be supplied, if a kind
                           of <code>Source</code> is provided that Saxon does not recognize, it will be passed
                           to the user-supplied <code>SourceResolver</code>, which has the opportunity to
                           convert it to a kind of <code>Source</code> that Saxon does recognize. This allows
                           new kinds of input to be supplied as input to Saxon's query, transformation, and
                           validation engines.
            </summary>
        </member>
        <member name="F:Saxon.Api.Feature`1.STABLE_COLLECTION_URI">
            <summary><code>STABLE_COLLECTION_URI</code>, if set, indicates that collections returned by
                           the <code>fn:collection()</code> and <code>fn:uri-collection()</code> functions
                           should be <i>stable</i>, that is, repeated calls on these functions with the same
                           collection URI (within the scope of a single query or transformation) should return
                           identical results.
            </summary>
            <remarks>
                       <para>Setting this option may be expensive because it requires that the entire collection
                           be saved in memory; it is rarely necessary in practice, but is required for strict
                           conformance with the W3C specifications.</para>
                       <para>It is also possible to indicate that a collection is stable by means of the
                               <code>CollectionFinder</code> API.</para>
                   
            </remarks>
        </member>
        <member name="F:Saxon.Api.Feature`1.STABLE_UNPARSED_TEXT">
            <summary><code>STABLE_UNPARSED_TEXT</code>, if set, indicates that the results returned by
                           repeated calls of <code>unparsed-text()</code>, <code>unparsed-text-lines()</code>,
                           and <code>unparsed-text-available()</code> are consistent: calling these functions
                           twice during the evaluation of a stylesheet or query will return the same
                           results.
            </summary>
            <remarks>
                       <para>Setting this option may be expensive because it requires that the file contents be
                           saved in memory; it is rarely necessary in practice, but is required for strict
                           conformance with the W3C specifications.</para>
                   
            </remarks>
        </member>
        <member name="F:Saxon.Api.Feature`1.STANDARD_ERROR_OUTPUT_FILE">
            <summary><code>STANDARD_ERROR_OUTPUT_FILE</code> is the name of a file to which Saxon will
                           redirect output that would otherwise go to the operating system standard error
                           stream (System.err). This is the fallback destination for various tracing and
                           diagnostic output. In some cases a more specific mechanism exists to select the
                           destination for particular kinds of output.
            </summary>
            <remarks>
                       <para>Note that if the <code>Configuration</code> is used in more than one processing
                           thread, the messages from different threads will be interleaved in the output file.
                           A more selective approach is to use a different <code>ErrorListener</code> in
                           different processing threads, and arrange for each <code>ErrorListener</code> to
                           write to its own logging destination.</para>
                   
            </remarks>
        </member>
        <member name="F:Saxon.Api.Feature`1.STREAMABILITY">
            <summary>The <code>STREAMABILITY</code> option can be used to disable streaming.
            </summary>
            <remarks>
                       <para>In earlier Saxon releases a third value "extended" was supported, to enable Saxon
                           streaming extensions. Since nearly all these extensions found their way into the W3C
                           specification, the distinction between "standard" and "extended" became meaningless,
                           so the value "extended" has been dropped.</para>
                       <para>The value "off" causes Saxon to behave as a non-streaming processor; that is, it does
                           not analyze constructs that are declared streamable, and it processes them as if
                           streaming were not requested. This is the only option available when using a Saxon
                           version or license that does not enable streaming.</para>
                       <para>The value "standard" is a misnomer. For strict adherence to W3C streamability rules,
                           set the property <code>STRICT_STREAMABILITY</code>. The streamability rules applied
                           by default are (in nearly all cases) identical to the W3C rules, but by default they
                           are applied to the expression tree after type-checking and optimization, which makes
                           some constructs streamable that would not be so otherwise.</para>
                       <para>Whichever option is chosen, the <code>STREAMING_FALLBACK</code> option can be used to
                           control what happens when code is deemed non-streamable; it provides a choice
                           between throwing a static (compile-time) error, and falling back to a non-streaming
                           implementation.</para>
                   
            </remarks>
        </member>
        <member name="F:Saxon.Api.Feature`1.STRICT_STREAMABILITY">
            <summary>Causes the XSLT processor to verify that constructs that are declared streamable are
                           in fact "guaranteed streamable" according to the W3C rules.
            </summary>
            <remarks>
                       <para>Normally, Saxon performs a variety of simplifications and optimizations on the
                           expression tree before performing streamability analysis. Sometimes these tree
                           rewrites will turn a non-streamable expression into a streamable one. An obvious
                           example is variable inlining: the expression <code>let $x := ./item/price return
                               sum($x)</code> is not streamable, but the rewritten form
                               <code>sum(./item/price)</code> is.</para>
                       <para>The XSLT 3.0 specification requires conformant streaming processors to have a mode of
                           operation in which the streamability rules are enforced as they appear in the spec,
                           and this option enables this mode.</para>
                       <para>This analysis is expensive, and should only be used during development when testing
                           stylesheet code for portability. When this mode is enabled, Saxon applies the
                           streamability rules at the earliest possible stage of processing; it then performs
                           its normal type checking and optimization phases, before doing a second stage of
                           streamability analysis to construct a streamed execution plan.</para>
                   
            </remarks>
        </member>
        <member name="F:Saxon.Api.Feature`1.STREAMING_FALLBACK">
            <summary>If the <code>STREAMING_FALLBACK</code> option is set, then constructs for which
                           streaming is requested (such as templates in a streaming mode, the
                               <code>xsl:source-document</code> instruction with attribute
                               <code>streamable="yes"</code>, and streamable accumulators) will be executed in
                           non-streaming mode if the code is not actually streamable. A compile-time warning
                           will always be given when the fallback option is taken.
            </summary>
        </member>
        <member name="F:Saxon.Api.Feature`1.STRIP_WHITESPACE">
            <summary>Indicates whether all whitespace, no whitespace, or whitespace in elements defined in
                           a DTD or schema as having element-only content should be stripped from source
                           documents.
            </summary>
            <remarks>
                       <para>The default is "ignorable". This whitespace stripping is additional to
                           any stripping done as a result of the <code>xsl:strip-space</code> declaration in an
                           XSLT stylesheet.</para>
                   
            </remarks>
        </member>
        <member name="F:Saxon.Api.Feature`1.STYLE_PARSER_CLASS">
            <summary>XML parser used for stylesheets and schema documents.
            </summary>
            <remarks>
                       <para>The class will be instantiated. If it is an <code>XMLReader</code> it is used
                           directly; if it is a <code>SAXParserFactory</code> it is used to instantiate an
                               <code>XMLReader</code>. The resulting <code>XMLReader</code> will be used to
                           parse stylesheet documents (that is, the principal stylesheet module plus any
                           secondary source documents read using <code>xsl:include</code> or
                               <code>xsl:import</code>) and also schema documents.</para>
                   
            </remarks>
        </member>
        <member name="F:Saxon.Api.Feature`1.SUPPRESS_EVALUATION_EXPIRY_WARNING">
            <summary>This is set to true to suppress the warning otherwise issued by command-line
                           interfaces indicating that an evaluation license is in use and is due to expire in a
                           set number of days.
            </summary>
        </member>
        <member name="F:Saxon.Api.Feature`1.SUPPRESS_XPATH_WARNINGS">
            <summary>Suppresses all warnings issued by the XPath and XQuery parsers.
            </summary>
            <remarks>
                       <para>Examples of warnings that are suppressed are the warning produced when keywords such
                           as <code>true</code> and <code>return</code> are interpreted as element names.</para>
                   
            </remarks>
        </member>
        <member name="F:Saxon.Api.Feature`1.SUPPRESS_XSLT_NAMESPACE_CHECK">
            <summary>This is set to true to suppress the warning when there is no commonality between the
                           namespaces used in stylesheet match patterns and the namespaces used in the source
                           document.
            </summary>
        </member>
        <member name="F:Saxon.Api.Feature`1.THRESHOLD_FOR_COMPILING_TYPES">
            <summary>Indicates how often an XSD simple type definition must be used before Saxon generates
                           bytecode to implement validation of input data against that type.
            </summary>
            <remarks>
                       <para>By default, Saxon-EE generates Java bytecode to speed up the validation of input
                           strings against user-defined simple types after the type has been used 100 times
                           (during the life of a Saxon Configuration). This threshold may be changed using this
                           configuration option. It may be useful to raise the threshold if the number of
                           user-defined types is large, and the bytecode is creating memory pressure.</para>
                   
            </remarks>
        </member>
        <member name="F:Saxon.Api.Feature`1.TIMING">
            <summary>This is set to true to cause basic timing and tracing information to be output to the
                           standard error output stream.
            </summary>
            <remarks>
                       <para>The name of the feature is poorly chosen, since much
                           of the information that is output has nothing to do with timing, for example the
                           names of output files for <code>xsl:result-document</code> are traced, as are the
                           names of schema documents loaded.</para>
                   
            </remarks>
        </member>
        <member name="F:Saxon.Api.Feature`1.TRACE_EXTERNAL_FUNCTIONS">
            <summary>If this option is set, Saxon will output (to the standard error output) progress
                           information about its attempts to locate and disambiguate references to reflexive
                           Java extension functions. This is useful for diagnostics if the XQuery or XSLT
                           compiler is failing to locate user-written extension functions.
            </summary>
        </member>
        <member name="F:Saxon.Api.Feature`1.TRACE_LISTENER">
            <summary>The <code>TraceListener</code> will be notified of significant events occurring
                           during a query or transformation, for tracing or debugging purposes.
            </summary>
            <remarks>
                       <para>Setting a <code>TraceListener</code> automatically sets the
                               <see cref="F:Saxon.Api.Feature`1.COMPILE_WITH_TRACING"/> option.</para>
                       <para>Avoid this option if more than one transformation or query is running concurrently:
                           use the feature <see cref="F:Saxon.Api.Feature`1.TRACE_LISTENER_CLASS"/>
                           instead. Alternatively, it is possible to set a <code>TraceListener</code> for an
                           individual query or transformation.</para>
                   
            </remarks>
        </member>
        <member name="F:Saxon.Api.Feature`1.TRACE_LISTENER_CLASS">
            <summary>The class will be instantiated once for each query or transformation, and the
                           resulting <code>TraceListener</code> will be notified of significant events
                           occurring during that query or transformation, for tracing or debugging
                           purposes.
            </summary>
            <remarks>
                       <para>Setting a <code>TraceListener</code> automatically sets the
                               <see cref="F:Saxon.Api.Feature`1.COMPILE_WITH_TRACING"/> option.</para>
                   
            </remarks>
        </member>
        <member name="F:Saxon.Api.Feature`1.TRACE_LISTENER_OUTPUT_FILE">
            <summary>When trace listening is switched on (for example by using -T on the command line),
                           this file will be supplied to the trace listener to use as the output destination.
                           If the option is not supplied, trace listener output is sent to the standard error
                           stream.
            </summary>
        </member>
        <member name="F:Saxon.Api.Feature`1.TRACE_OPTIMIZER_DECISIONS">
            <summary>If this option is set, Saxon will output (to the standard error output) detailed
                           information about the rewrites to the expression tree made by the optimizer. This
                           information is mainly useful for internal system debugging, but it is also possible
                           to digest it to analyze the ways in which the expression has been optimized for the
                           purpose of performance analysis and tuning.
            </summary>
        </member>
        <member name="F:Saxon.Api.Feature`1.TREE_MODEL">
            <summary>Selects an implementation of the Saxon tree model. The default is
                               <code>TINY_TREE</code>.
            </summary>
            <remarks>
                       <para>For running XQuery Update, use the linked tree, because it is the only implementation
                           that is updateable.</para>
                   
            </remarks>
        </member>
        <member name="F:Saxon.Api.Feature`1.TREE_MODEL_NAME">
            <summary>Selects an implementation of the Saxon tree model. The default is
                               <code>tinyTree</code>.
            </summary>
            <remarks>
                       <para>For running XQuery Update, use the linked tree, because it is the only implementation
                           that is updateable.</para>
                   
            </remarks>
        </member>
        <member name="F:Saxon.Api.Feature`1.UNPARSED_TEXT_URI_RESOLVER">
            <summary>The supplied <code>UnparsedTextURIResolver</code> will be used to resolve
                           (dereference) all URIs specifed in calls to the <code>unparsed-text()</code>,
                               <code>unparsed-text-lines()</code>, and <code>unparsed-text-available()</code>
                           functions.
            </summary>
        </member>
        <member name="F:Saxon.Api.Feature`1.UNPARSED_TEXT_URI_RESOLVER_CLASS">
            <summary>An instance of the specified <code>UnparsedTextURIResolver</code> class will be
                           created, and used to resolve (dereference) all URIs specifed in calls to the
                               <code>unparsed-text()</code>, <code>unparsed-text-lines()</code>, and
                               <code>unparsed-text-available()</code> functions.
            </summary>
        </member>
        <member name="F:Saxon.Api.Feature`1.URI_RESOLVER_CLASS">
            <summary>An instance of the specified <code>URIResolver</code> class will be created, and used
                           to resolve (dereference) all URIs specifed in calls to the <code>doc()</code> and
                               <code>document()</code> functions, as well as URIs used in
                               <code>xsl:include</code> and <code>xsl:import</code> and location hints for
                           XQuery modules and XSD schema documents.
            </summary>
        </member>
        <member name="F:Saxon.Api.Feature`1.USE_PI_DISABLE_OUTPUT_ESCAPING">
            <summary>This option determines whether a <code>TransformerHandler</code> created with this
                               <code>TransformerFactory</code> or <code>Configuration</code> recognizes the
                           JAXP-defined processing instructions <code>Result.PI_DISABLE_OUTPUT_ESCAPING</code>
                           and <code>Result.PI_ENABLE_OUTPUT_ESCAPING</code> in the input stream as
                           instructions to disable or to re-enable output escaping. The default value is
                               <b>false</b>.
            </summary>
        </member>
        <member name="F:Saxon.Api.Feature`1.USE_TYPED_VALUE_CACHE">
            <summary>This option is relevant only when the TinyTree is used; it determines whether (for a
                           validated document) a cache will be maintained containing the typed values of nodes.
            </summary>
            <remarks>
                       <para>Typed values are held in the cache only for elements and attributes whose type is
                           other than string, untypedAtomic, or anyURI. The default value is true. Setting this
                           value to false can reduce memory requirements at the cost of requiring recomputation
                           of typed values on each access.</para>
                   
            </remarks>
        </member>
        <member name="F:Saxon.Api.Feature`1.USE_XSI_SCHEMA_LOCATION">
            <summary>This option determines whether or not to use the <code>xsi:schemaLocation</code>
                               and<code> xsi:noNamespaceSchemaLocation</code> attributes in an instance
                           document to locate a schema for validation.
            </summary>
            <remarks>
                       <para>Note, these attribute are only consulted if validation is requested; the presence of
                           one of these attributes never by itself triggers validation.</para>
                   
            </remarks>
        </member>
        <member name="F:Saxon.Api.Feature`1.VALIDATION_COMMENTS">
            <summary>This option determines whether non-fatal validation errors in XQuery or XSLT result
                           documents should result in comments being inserted into the result tree. The
                           command-line flag <code>-outval:recover</code> sets both this option and the
                               <see cref="F:Saxon.Api.Feature`1.VALIDATION_WARNINGS"/> option.
            </summary>
        </member>
        <member name="F:Saxon.Api.Feature`1.VALIDATION_WARNINGS">
            <summary>This option indicates (if true) that errors occuring while validating a final result
                           tree are not to be treated as fatal.
            </summary>
            <remarks>
                       <para>Regardless of the setting of this option, all validation errors are reported to the
                               <code>error()</code> method of the <code>ErrorListener</code>, and validation is
                           terminated if the <code>error()</code> method throws an exception, or if the error
                           limit set in the <code>ParseOptions</code> object is reached.</para>
                       <para>This option primarily controls what happens at the end of a validation episode. If
                           the validation episode detected one or more validation errors, then when this option
                           is off, an exception is thrown, which will normally result in any query or
                           stylesheet failing with a dynamic error, and no output file being written. If the
                           option is on, no exception is thrown, and the output is written as if validation had
                           been successful. Note in this case that any type annotations present in a result
                           document are unreliable.</para>
                       <para>If this option is set when running XSLT or XQuery, it is ignored as far as input
                           files are concerned: validation errors in input files are still fatal. However, if
                           the option is set and a validation error occurs in a final output file, the output
                           file is still written and the process terminates as if successful.</para>
                       <para>The detailed interpretation of this option changed in Saxon 9.5.</para>
                   
            </remarks>
        </member>
        <member name="F:Saxon.Api.Feature`1.VERSION_WARNING">
            <summary>Indicates whether a warning message should be notified (to the
                           <code>ErrorListener</code>) if running Saxon against an XSLT stylesheet that
                           specifies <code>version="1.0"</code>.
            </summary>
            <remarks>
                       <para>From Saxon 9.8, the warning is no longer output (since XSLT 3.0 does not require
                           it), so this option is ignored.</para>
                       
                   
            </remarks>
        </member>
        <member name="F:Saxon.Api.Feature`1.XINCLUDE">
            <summary>Indicates whether source documents should have any XInclude directives expanded.
            </summary>
            <remarks>
                       <para>The default is false. The option applies to all input XML documents, including
                           stylesheets and schema documents. It can be overridden for individual documents
                           using the <see cref="T:net.sf.saxon.lib.ParseOptions"/> class.</para>
                       <para>This option relies on support in the underlying XML parser. If the XML parser does
                           not support XInclude processing, setting this option results in a parsing failure.</para>
                   
            </remarks>
        </member>
        <member name="F:Saxon.Api.Feature`1.XML_VERSION">
            <summary>This determines the XML version used by the <code>Configuration</code>.
            </summary>
            <remarks>
                       <para>Note that source documents specifying <code>xml version="1.0"</code> or
                               <code>"1.1"</code> are accepted regardless of this setting. The effect of this
                           switch is to change the validation rules for types such as <code>xs:Name</code> and
                               <code>xs:NCName</code>, to change the characters allowed in names within XPath
                           expressions (etc.), to change the meaning of <code>\i</code> and <code>\c</code> in
                           regular expressions, and to determine whether the serializer allows XML 1.1
                           documents to be constructed. </para>
                       <para>The default is currently 1.0, but may change.</para>
                   
            </remarks>
        </member>
        <member name="F:Saxon.Api.Feature`1.XML_PARSER_FEATURE">
            <summary>Sets the value of a parser feature flag. The feature name is any fully-qualified
                           URI.
            </summary>
            <remarks>
                       <para>For example if the parser supports a feature
                               <code>http://xml.org/sax/features/external-parameter-entities</code> then this
                           can be set by setting the value of the Configuration property:
                               <code>http://saxon.sf.net/feature/parserFeature?uri=http%3A//xml.org/sax/features/external-parameter-entities</code>
                           to true.</para>
                   
            </remarks>
        </member>
        <member name="F:Saxon.Api.Feature`1.XML_PARSER_PROPERTY">
            <summary>Sets the value of a parser property flag. The property name is any fully-qualified
                           URI.
            </summary>
            <remarks>
                       <para>For example if the parser supports a property
                               <code>http://apache.org/xml/properties/schema/external-schemaLocation</code>
                           then this can be set using the value of the Configuration property:
                               <code>http://saxon.sf.net/feature/parserProperty?uri=http%3A//apache.org/xml/properties/schema/external-schemaLocation</code>
                           to the required value.</para>
                   
            </remarks>
        </member>
        <member name="F:Saxon.Api.Feature`1.XQUERY_ALLOW_UPDATE">
            <summary>Determines whether XQuery Update syntax is accepted.
            </summary>
            <remarks>
                       <para>If true, update syntax is accepted, if false, it is not accepted. Setting the value to 
                           true does not mean that the query has to use update syntax, only that it may do so.</para>
                       <para>From Saxon 9.6, XQuery Update syntax and XQuery 3.0 syntax can be mixed, although
                           this combination is not defined by any W3C specification at the time of writing.</para>
                       <para>This option can be set for a particular XQuery compilation. When the option is set at
                           the <code>Configuration</code> level, it acts as a default.</para>
                       <para>On the command line, this option is combined with the option "discard" which
                           indicates that updates are allowed, but the updates are not written back to
                           filestore. This does not correspond to any option in the Java API, where writing an
                           updated document back to filestore only happens if explicitly requested.</para>
                   
            </remarks>
        </member>
        <member name="F:Saxon.Api.Feature`1.XQUERY_CONSTRUCTION_MODE">
            <summary>This option defines the default value of the construction mode in the XQuery static
                           context (overridable in the query prolog).
            </summary>
            <remarks>
                       <para>This option can be set for a particular XQuery compilation. When the option is set at
                           the <code>Configuration</code> level, it acts as a default.</para>
                   
            </remarks>
        </member>
        <member name="F:Saxon.Api.Feature`1.XQUERY_DEFAULT_ELEMENT_NAMESPACE">
            <summary>This property defines the default namespace for elements and types that are not
                           qualified by a namespace prefix.
            </summary>
            <remarks>
                       <para>This option can be set for a particular XQuery compilation. When the option is set at
                           the <code>Configuration</code> level, it acts as a default.</para>
                   
            </remarks>
        </member>
        <member name="F:Saxon.Api.Feature`1.XQUERY_DEFAULT_FUNCTION_NAMESPACE">
            <summary>This property defines the default namespace for function names that are not qualified
                           by a namespace prefix.
            </summary>
            <remarks>
                       <para>This option can be set for a particular XQuery compilation. When the option is set at
                           the <code>Configuration</code> level, it acts as a default.</para>
                   
            </remarks>
        </member>
        <member name="F:Saxon.Api.Feature`1.XQUERY_EMPTY_LEAST">
            <summary>This property defines how the empty sequence is handled in XQuery sorting (the "order
                           by" clause). If true, <code>()</code> comes at the start of the sorted sequence; if
                           false, it comes last.
            </summary>
            <remarks>
                       <para>This option can be set for a particular XQuery compilation. When the option is set at
                           the <code>Configuration</code> level, it acts as a default.</para>
                   
            </remarks>
        </member>
        <member name="F:Saxon.Api.Feature`1.XQUERY_INHERIT_NAMESPACES">
            <summary>This property defines the default value of the <code>inherit-namespaces</code>
                           property in the XQuery static context.
            </summary>
            <remarks>
                       <para>This option can be set for a particular XQuery compilation. When the option is set at
                           the <code>Configuration</code> level, it acts as a default.</para>
                   
            </remarks>
        </member>
        <member name="F:Saxon.Api.Feature`1.XQUERY_MULTIPLE_MODULE_IMPORTS">
            <summary>If the value is false, then when an <code>import module</code> declaration is
                           encountered for a module URI that is already among the known loaded modules (or
                           modules in the process of being compiled), the <code>import module</code> is treated
                           as a reference to the existing module. If the value is true, the system first checks
                           whether the supplied "location hints" match the known location of the existing
                           module, and the existing module is used only if there is a match.
            </summary>
        </member>
        <member name="F:Saxon.Api.Feature`1.XQUERY_PRESERVE_BOUNDARY_SPACE">
            <summary>This property defines whether "boundary space" (insignificant space in direct element
                           constructors) should be retained or not.
            </summary>
            <remarks>
                       <para>This option can be set for a particular XQuery compilation. When the option is set at
                           the <code>Configuration</code> level, it acts as a default.</para>
                   
            </remarks>
        </member>
        <member name="F:Saxon.Api.Feature`1.XQUERY_PRESERVE_NAMESPACES">
            <summary>This property defines whether unused namespace declarations are retained by XQuery
                           element copy operations.
            </summary>
            <remarks>
                       <para>This option can be set for a particular XQuery compilation. When the option is set at
                           the <code>Configuration</code> level, it acts as a default.</para>
                   
            </remarks>
        </member>
        <member name="F:Saxon.Api.Feature`1.XQUERY_REQUIRED_CONTEXT_ITEM_TYPE">
            <summary>This property defines the default expected context item type for a query.
            </summary>
            <remarks>
                       <para>This option can be set for a particular XQuery compilation. When the option is set at
                           the <code>Configuration</code> level, it acts as a default.</para>
                   
            </remarks>
        </member>
        <member name="F:Saxon.Api.Feature`1.XQUERY_SCHEMA_AWARE">
            <summary>A query will automatically be schema-aware if it contains an <code>import
                               schema</code> declaration. This property allows a query to be marked as
                           schema-aware even if it contains no <code>import schema</code> declaration. It is
                           necessary for a query to be compiled as schema-aware if it is to handle typed
                           (validated) input documents in which nodes have type annotations based on their
                           schema-defined type.
            </summary>
            <remarks>
                       <para>This option can be set for a particular XQuery compilation. When the option is set at
                           the <code>Configuration</code> level, it acts as a default.</para>
                   
            </remarks>
        </member>
        <member name="F:Saxon.Api.Feature`1.XQUERY_STATIC_ERROR_LISTENER_CLASS">
            <summary>The specified class is instantiated to create an <code>ErrorListener</code>, and all
                           reports of static errors in a query will go to this <code>ErrorListener</code>.
            </summary>
            <remarks>
                       <para>This option can be set for a particular XQuery compilation. When the option is set at
                           the <code>Configuration</code> level, it acts as a default.</para>
                       <para>In the absence of this property, the global <code>ErrorListener</code> specified as
                           the value of the <see cref="F:Saxon.Api.Feature`1.ERROR_LISTENER_CLASS"/>
                           property is used.</para>
                   
            </remarks>
        </member>
        <member name="F:Saxon.Api.Feature`1.XQUERY_VERSION">
            <summary>This property determines the version of XQuery used by the
                           <code>Configuration</code>.
            </summary>
            <remarks>
                       <para>From Saxon 9.8, an XQuery 3.1 processor is always used by default. So setting this
                           property has no effect.</para>
                       
                   
            </remarks>
        </member>
        <member name="F:Saxon.Api.Feature`1.XSD_VERSION">
            <summary>This property determines the version of XML Schema used by the
                           <code>Configuration</code>.
            </summary>
            <remarks>
                       <para>From Saxon 9.8, the default is XSD 1.1. If XSD 1.0 is
                           selected, XSD 1.1 features will be rejected, with the exception of the version
                           control attributes that allow sections of the schema to be marked as requiring XSD
                           1.0 or XSD 1.1.</para>
                   
            </remarks>
        </member>
        <member name="F:Saxon.Api.Feature`1.XSLT_ENABLE_ASSERTIONS">
            <summary>This property indicates whether assertions (XSLT 3.0 xsl:assert instructions) are
                           enabled or disabled. They are disabled by default. Setting this property on causes
                           assertions to be enabled at compile time for all XSLT packages compiled using the
                           default configuration options.
            </summary>
            <remarks>
                       <para>This option can be set for a particular XSLT compilation. When the option is set at
                           the <code>Configuration</code> level (or on a <code>TransformerFactory</code>), it
                           acts as a default.</para>
                       <para>If assertions have been enabled at compile time for a particular package, they can
                           still be disabled at run-time (for all packages) by setting an option on the
                               <code>Xslt30Transformer</code>. But if assertions were disabled at compile time,
                           enabling them at run-time has no effect.</para>
                   
            </remarks>
        </member>
        <member name="F:Saxon.Api.Feature`1.XSLT_INITIAL_MODE">
            <summary>This property indicates the name of a mode within a stylesheet in which execution
                           (using template rules) should begin.
            </summary>
            <remarks>
                       <para>This option can be set for a particular XSLT transformation. When the option is set
                           at the <code>Configuration</code> (or on a <code>TransformerFactory</code>), it acts
                           as a default.</para>
                   
            </remarks>
        </member>
        <member name="F:Saxon.Api.Feature`1.XSLT_INITIAL_TEMPLATE">
            <summary>This property indicates the name of a named template within a stylesheet where
                           execution should begin.
            </summary>
            <remarks>
                       <para>This option can be set for a particular XSLT transformation. When the option is set
                           at the <code>Configuration</code> level (or on a <code>TransformerFactory</code>),
                           it acts as a default.</para>
                       <para>Specifically, if the transformation is performed using the <code>transform()</code>
                           method of class <code>net.sf.saxon.s9api.XsltTransformer</code>, then the transformation
                           will proceed by calling the relevant named template, rather than by applying templates
                           to the supplied source node. It will also affect other APIs built on top of the 
                           <code>XsltTransformer</code>, notably the JAXP transformation interface, which in turn
                           is used by many higher-level interfaces such as Ant. Indeed, the main purpose of this
                           configuration option is to allow named-template stylesheet invocation using the JAXP 
                           interface, which was designed without this feature in mind.</para>
                       <para>This configuration option is ignored when using an <code>net.sf.saxon.s9api.Xslt30Transformer</code>,
                           or other interfaces built on top of an <code>Xslt30Transformer</code>, for example the
                           <code>net.sf.saxon.Transform</code> command line interface.</para>
                   
            </remarks>
        </member>
        <member name="F:Saxon.Api.Feature`1.XSLT_SCHEMA_AWARE">
            <summary>This property indicates whether stylesheets should be compiled with the ability to
                           handle schema-typed input documents. By default a stylesheet is compiled to handle
                           such input if it contains an <code>xsl:import-schema</code> instruction, and not
                           otherwise. It is necessary for a stylesheet to be compiled as schema-aware if it is
                           to handle typed (validated) input documents in which nodes have type annotations
                           based on their schema-defined type.
            </summary>
            <remarks>
                       <para>This option can be set for a particular XSLT compilation. When the option is set at
                           the <code>Configuration</code> level (or on a <code>TransformerFactory</code>), it
                           acts as a default.</para>
                   
            </remarks>
        </member>
        <member name="F:Saxon.Api.Feature`1.XSLT_STATIC_ERROR_LISTENER_CLASS">
            <summary>The specified class is instantiated to create an <code>ErrorListener</code>, and all
                           reports of static errors in a stylesheet will go to this
                           <code>ErrorListener</code>.
            </summary>
            <remarks>
                       <para>This option can be set for a particular XSLT compilation. When the option is set at
                           the <code>Configuration</code> level (or on a <code>TransformerFactory</code>), it
                           acts as a default.</para>
                       <para>In the absence of this property, the global <code>ErrorListener</code> specified as
                           the value of the <see cref="F:Saxon.Api.Feature`1.ERROR_LISTENER_CLASS"/>
                           property is used.</para>
                   
            </remarks>
        </member>
        <member name="F:Saxon.Api.Feature`1.XSLT_STATIC_URI_RESOLVER_CLASS">
            <summary>This property defines a <code>URIResolver</code> used when dereferencing the URIs
                           that appear in the <code>href</code> attributes of the <code>xsl:include</code> and
                               <code>xsl:import</code> declarations. Note that this defaults to the setting of
                           the global <code>URI_RESOLVER</code> property.
            </summary>
            <remarks>
                       <para>This option can be set for a particular XSLT compilation. When the option is set at
                           the <code>Configuration</code> level (or on a <code>TransformerFactory</code>), it
                           acts as a default.</para>
                       <para>In the absence of this property, the global <code>URIResolver</code> specified as the
                           value of the <see cref="F:Saxon.Api.Feature`1.URI_RESOLVER_CLASS"/> property
                           is used.</para>
                   
            </remarks>
        </member>
        <member name="F:Saxon.Api.Feature`1.XSLT_VERSION">
            <summary>This property determines the version of XSLT to be supported by default.
            </summary>
            <remarks>
                       <para>From Saxon 9.8, an XSLT 3.0 processor is always used by default. So setting this
                           property has no effect.</para>
                       
                   
            </remarks>
        </member>
        <member name="F:Saxon.Api.Feature`1.REGEX_BACKTRACKING_LIMIT">
            <summary>This property sets a limit on the amount of backtracking performed during regular expression evaluation.
            </summary>
            <remarks>
                       <para>The default is 10000000 (ten million) which typically represents an evaluation time of about ten seconds.
                       After this time, evaluation of the regular expression will fail rather than making further attempts to find a
                       match. If this limit is reached, it often suggests that there might be a better way of writing the regular expression.
                       The value can be set to -1 (minus one) to mean "unlimited".</para>
                       <para>Excessive backtracking is usually caused by nested loops in the regular expression, combined with processing
                       of long input strings. Try to ensure that when nested loops are used, there is an unambiguous condition that causes
                       the inner loop to terminate. For example <code>(/[^/]*)+</code> is fine (it matches a sequence of path segments separated
                           by <code>/</code> characters), because the presence of <code>/</code> forces the inner loop to terminate. By contrast,
                           <code>(/.*)+</code> matches the same input, but in many different ways, which could lead to excessive backtracking
                       to no useful purpose.</para>
                   
            </remarks>
        </member>
        <member name="F:Saxon.Api.Feature`1.XPATH_VERSION_FOR_XSD">
            <summary>The XSD 1.1 specification states that XPath version 2.0 is used for expressions appearing in assertions and type
                           alternatives. This option allows XPath 3.0 or 3.1 to be used instead.
            </summary>
            <remarks>
                       <para>The recognized values are the integers 20, 30, and 31 representing versions 2.0, 3.0, and 3.1 respectively.</para>           
                   
            </remarks>
        </member>
        <member name="F:Saxon.Api.Feature`1.XPATH_VERSION_FOR_XSLT">
            <summary>The XSLT 3.0 specification states that processors are required to support XPath 3.0 expressions within stylesheets, together
                           with some extensions (maps) selected from the XPath 3.1 specification. Support for the full syntax of XPath 3.1 is
                           optional, but it is the default in Saxon. This option allows a different XPath language level to be selected.
            </summary>
            <remarks>
                       <para>The integer values 20, 30, and 31 denote XPath 2.0, 3.0, and 3.1 respectively, while the value 305 denotes XPath 3.0
                           with the extensions defined in the XSLT 3.0 specification.</para>
                   
            </remarks>
        </member>
        <member name="F:Saxon.Api.Feature`1.THRESHOLD_FOR_FUNCTION_INLINING">
            <summary>Saxon-EE performs inlining of user-defined functions that are sufficiently simple: they must not be recursive,
                           and they must be below a certain size. This option defines the size.
            </summary>
            <remarks>
                       <para>The value is (roughly) the number of nodes in the expression tree representing the function body. This
                           includes both explicit subexpressions, and subexpressions added by Saxon itself to perform implicit
                           operations such as type checking or conversion of function arguments. The default value is 100.</para>
                   
            </remarks>
        </member>
        <member name="F:Saxon.Api.Feature`1.THRESHOLD_FOR_HOTSPOT_BYTE_CODE">
            <summary>Saxon-EE generates bytecode to give faster execution of frequently-evaluated subexpressions.
                           Bytecode is generated when a candidate expression has been evaluated a certain number of
                           times, controlled by this parameter.
                       
            </summary>
            <remarks>
                       <para>Setting this parameter to 0 (or any negative value) has the effect of disabling bytecode
                           generation completely. Setting the parameter to a positive value has the effect of enabling
                           bytecode generation if it is not already enabled. Setting the value to 1 (one) causes bytecode
                           to be generated for candidate expressions the first time it is executed.</para>
                   
            </remarks>
        </member>
        <member name="F:Saxon.Api.Feature`1.ALLOWED_PROTOCOLS">
            <summary>The value is a comma-separated list of permitted protocols. A protocol is the 
                           scheme portion of a URI, or in the case of the JAR protocol, "jar" 
                           plus the scheme portion separated by colon. The value "all" gives access
                           to all protocols (which is the default). The value "" (empty string) disallows
                           all external resource access. (The format is thus the same as for 
                           <code>XMLConstants.ACCESS_EXTERNAL_SCHEMA</code> and similar attributes.)
                       
            </summary>
            <remarks>
                       <para>The value constrains access by Saxon (but not by underlying software, such
                           as the XML parser) to resources including the following:</para>
                       
                       <list>
                           <item>Stylesheet modules</item>
                           <item>Schema documents</item>
                           <item>Query modules</item>
                           <item>Documents referenced from a stylesheet or query using functions such
                               as <code>fn:doc</code>, <code>fn:document</code>, <code>fn:unparsed-text</code>,
                               <code>fn:collection</code>, <code>fn:json-doc</code>, <code>fn:transform</code>, or by the
                               <code>xsl:source-document</code> instruction.</item>
                           <item>Resources obtained using Saxon-supplied extension functions such as
                               those in the EXPath file library (but it does not affect user-supplied
                               extension functions).</item>
                       </list>
                       <para>The constraint applies to the URI used to request
                           the resource; the constraint is applied by the standard URI resolvers, but if 
                           user-supplied resolvers are used (such as a <code>URIResolver</code>), they can decide
                           whether to apply the restrictions or not.</para>
                       <para>The constraint applies to URIs used as locations or location hints, not to URIs used as names. So
                       for XSD it applies to a schemaLocation, not a targetNamespace; for XQuery it applies to module
                       location hints, not to module URIs. In the case of XSLT packages, resolution from a package name
                       to a location is always under user/application control, so Saxon imposes no restrictions.</para>
                       <para>The format is the same as for <code>XMLConstants.ACCESS_EXTERNAL_SCHEMA</code>: either <code>"all"</code> to allow
                           all schemes/protocols, or a comma-separated list of scheme names such as <code>"http"</code>, <code>"file"</code>, <code>"ftp"</code>.
                           For a JAR file scheme, use the format <code>"jar:<i>scheme</i>"</code>, for example <code>"jar:file"</code>. A zero-length
                           string disallows all schemes.</para>
                   
            </remarks>
        </member>
        <member name="F:Saxon.Api.Feature`1.RETAIN_NODE_FOR_DIAGNOSTICS">
            <summary>By default, Saxon attempts to ensure that the run-time code contains no links to the original source stylesheet tree.
                           This allows the garbage collector to free memory.
                       
            </summary>
            <remarks>
                       <para>If this option is set, then <code>Location</code> objects held in the run-time expression tree may contain a link
                           to an element node in the source stylesheet, enabling a user-written <code>ErrorListener</code> to produce
                           improved diagnostics. This may be an appropriate setting to use, for example, in an IDE.</para>
                       <para>Links to source nodes are not retained in an exported SEF file, regardless of this setting.</para>
                   
            </remarks>
        </member>
        <member name="F:Saxon.Api.Feature`1.ALLOW_UNRESOLVED_SCHEMA_COMPONENTS">
            <summary>The W3C XSD specification (both 1.0 and 1.1) states that an unresolved
                   reference to an absent schema component does not automatically make the schema
                   invalid; the schema should be usable for validation provided that the missing
                   components are not actually needed in a particular validation episode.
                 
            </summary>
            <remarks>
                 <para>However, the W3C XSD conformance tests treat such an unresolved reference
                 as an error; the test is expected to report the schema as invalid. And this
                 is the way most schema processors actually operate, and probably what most
                 users would expect.</para>
                 <para>By default, the Saxon schema processor reports an unresolved reference
                 as an error in the schema.</para>
                 <para>If this option is set, then Saxon attempts to repair the schema so that
                 it is usable for validation, by substituting the missing components with default
                 components: for example if an attribute declaration refers to a type that has
                 not been defined, then <code>xs:error</code> is substituted, making any instance
                 of the attribute invalid.</para>
                 
            </remarks>
        </member>
        <member name="F:Saxon.Api.Feature`1.ZIP_URI_PATTERN">
            <summary>This is used by the standard Collection Finder and may not be relevant
                           if a custom Collection Finder is in use.
                       
            </summary>
            <remarks>
                       <para>If the absolutized URI passed to the collection() function matches
                       this pattern, then the URI will be treated as a reference to a ZIP file
                       (and will therefore fail if the URI does not resolve to a resource that can
                       be opened as a ZIP file).</para>
                       
                   
            </remarks>
        </member>
        <member name="P:Saxon.Api.Feature`1.JFeature">
            <summary>
            The underlying <c>net.sf.saxon.lib.Feature</c> object in the Java implementation
            </summary>
            <remarks>
            <para>This property provides access to the internal Java <c>Feature</c> object in the 
            Saxon engine that is wrapped in the .NET API.</para> 
            <para>Information about the returned <see cref="T:net.sf.saxon.lib.Feature"/> object 
            is included in the Saxon JavaDoc docmentation.
            </para>
            </remarks>
        </member>
        <member name="T:Saxon.Api.FeatureKeys">
            <summary>
            <c>FeatureKeys</c> defines a set of constants, representing the names of Saxon configuration
            options which can be supplied to the Saxon implementations of the JAXP
            interfaces <c>TransformerFactory</c>, <c>SchemaFactory</c>, <c>Validator</c>, and <c>ValidationHandler</c>,
            and to other interfaces such as the s9api <c>net.sf.saxon.s9api.Processor</c> 
            </summary>
        </member>
        <member name="F:Saxon.Api.FeatureKeys.ALLOW_EXTERNAL_FUNCTIONS">
            <summary>ALLOW_EXTERNAL_FUNCTIONS determines whether calls to reflexive external functions are
                           allowed.
            </summary>
            <remarks>
                       <para>More specifically, if set to <b>false</b> it disallows all of the
                           following:</para>
                       <list>
                           <item>Calls to reflexive Java extension functions</item>
                           <item>Use of the XSLT <code>system-property()</code> function to access Java system
                               properties</item>
                           <item>Use of a URI in the <code>href</code> attribute of an <code>xsl:result-document</code> instruction</item>
                           <item>Calls to XSLT extension instructions</item>
                       </list>
                       <para>The default value is <b>true</b>. The setting <b>false</b> is recommended in an
                           environment where untrusted stylesheets may be executed.</para>
                       <para>This option does not disable use of the <code>doc()</code> function or similar
                           functions to access the filestore of the machine where the transformation or query
                           is running. That should be done using a user-supplied <code>URIResolver</code>.</para>
                       <para>Note that integrated extension functions are trusted; calls to such functions are
                           allowed even if this configuration option is false. In cases where an integrated
                           extension function is used to load and execute untrusted code, it should check this
                           configuration option before doing so.</para>
                       <para>If the value of the property is false, then it will also be set to false on any new
                       Configuration created using the <code>fn:transform()</code> function.</para>
                   
            </remarks>
        </member>
        <member name="F:Saxon.Api.FeatureKeys.ALLOW_MULTITHREADING">
            <summary>ALLOW_MULTITHREADING determines whether multi-threading is allowed.
            </summary>
            <remarks>
                       <para>If true (the default), the presence of the attribute <code>saxon:threads="N"</code>
                           on an <code>xsl:for-each</code> instruction, when running under Saxon-EE, causes
                           multi-threaded execution. If set to false, the value of the
                               <code>saxon:threads</code> argument is ignored.</para>
                       <para>Setting the value to false also disables asynchronous processing of
                               <code>xsl:result-document</code> instructions.</para>
                       <para>The default value is true if Saxon-EE is in use, false otherwise.</para>
                   
            </remarks>
        </member>
        <member name="F:Saxon.Api.FeatureKeys.ALLOW_OLD_JAVA_URI_FORMAT">
            <summary>ALLOW_OLD_JAVA_URI_FORMAT determines whether extension function calls to
                           dynamically-loaded Java extension functions may use the URI format supported in
                           older Saxon releases.
            </summary>
            <remarks>
                       <para>If the value is false (the default), the only URI format accepted is (for example)
                           "java:java.util.Date" - that is, a URI consisting of the string "java:" followed by
                           the Java qualified class name of the class containing the implementation of the
                           extension function.</para>
                       <para>If the value is true, then in addition to this format, the following are accepted:
                           (a) the Java class name on its own ("java.util.Date"), and (b) any URI in which the
                           Java class name follows the last "/" character (for example
                           "http://my.com/extensions/java.util.Date"). This last format was originally provided
                           for compatibility with xt and xalan, but it causes problems because it leads to
                           unnecessary attempts to load spurious classes when the user did not intend the URI
                           to represent a dynamically-loaded Java class.</para>
                   
            </remarks>
        </member>
        <member name="F:Saxon.Api.FeatureKeys.ALLOW_SYNTAX_EXTENSIONS">
            <summary>This flag must be set to enable use of extensions to XPath, XQuery and XSLT
                           syntax that go beyond what is allowed by the extensibility mechanisms in the spec.
                           In some cases these extensions are experimental and may not be carried forward to future
                       Saxon releases.
            </summary>
            <remarks>
                       <para>Syntax extensions in Saxon 10 include the use of type aliases (<code>type(...)</code> where
                           an item type is expected, and <code>declare type NAME = item-type</code> in the XQuery Prolog); 
                           and simple inline functions (for example <code>.{. + 1}</code>).</para>
                   
            </remarks>
        </member>
        <member name="F:Saxon.Api.FeatureKeys.ASSERTIONS_CAN_SEE_COMMENTS">
            <summary>ASSERTIONS_CAN_SEE_COMMENTS determines whether comment and processing instructions in
                           a document being validated are visible to assertions in an XSD 1.1 schema.
            </summary>
            <remarks>
                       <para>If the value is false (the default), comments and processing instructions are
                           stripped from the view of the document that is made visible to the XPath expression
                           that implements the assertion. If this creates adjacent text nodes, they are
                           collapsed into a single text node.</para>
                       <para>If the value is true, then comments and processing instructions are visible to the
                           XPath assertion.</para>
                   
            </remarks>
        </member>
        <member name="F:Saxon.Api.FeatureKeys.COLLATION_URI_RESOLVER">
            <summary>The supplied <code>CollationURIResolver</code> is used to process any collation URIs
                           found in the query or stylesheet, returning an object of class
                               <see cref="T:net.sf.saxon.lib.StringCollator"/> that implements the requested
                           collation.
            </summary>
        </member>
        <member name="F:Saxon.Api.FeatureKeys.COLLATION_URI_RESOLVER_CLASS">
            <summary>The supplied class is instantiated and the resulting instance is used as the value of
                           the <see cref="F:Saxon.Api.FeatureKeys.COLLATION_URI_RESOLVER"/> property.
            </summary>
        </member>
        <member name="F:Saxon.Api.FeatureKeys.COLLECTION_FINDER">
            <summary>The supplied <code>CollectionFinder</code> is used to retrieve a <see cref="T:net.sf.saxon.lib.ResourceCollection"/> object given by any URI defined in
                           calls to the <code>collection()</code> or the <code>uri-collection()</code> function.
            </summary>
            <remarks>
                       <para>If the argument is not specified then a default <code>ResourceCollection</code> should be handled.
                           <code>CollectionFinder</code> returns a <see cref="T:net.sf.saxon.lib.ResourceCollection"/> which is used to map the URI of collection into a
                           sequence of <see cref="T:net.sf.saxon.lib.Resource"/> objects
                           (which are then resolved in the same way as URIs passed to the <code>doc()</code>
                           function), or it may return an item (typically a node but can handle JSON documents).</para>
                   
            </remarks>
        </member>
        <member name="F:Saxon.Api.FeatureKeys.COLLECTION_FINDER_CLASS">
            <summary>The supplied class is instantiated and the resulting instance is used as the value of
                           the <see cref="F:Saxon.Api.FeatureKeys.COLLECTION_FINDER"/> property.
            </summary>
        </member>
        <member name="F:Saxon.Api.FeatureKeys.COMPILE_WITH_TRACING">
            <summary>If run-time tracing of stylesheet or query execution is required, then the code must
                           be compiled with tracing enabled.
            </summary>
            <remarks>
                       <para>Default is false. This option causes code to be
                           compiled that makes calls to a <see cref="T:net.sf.saxon.lib.TraceListener"/>, but this
                           has no effect unless a <code>TraceListener</code> is registered at execution
                           time.</para>
                   
            </remarks>
        </member>
        <member name="F:Saxon.Api.FeatureKeys.CONFIGURATION">
            <summary>This attribute cannot be set on the <see cref="T:net.sf.saxon.Configuration"/> itself,
                           but it can be set on various JAXP factory objects such as a
                           <code>TransformerFactory</code> or <code>DocumentBuilderFactory</code>, to
                           ensure that several such factories use the same <code>Configuration</code>.
            </summary>
            <remarks>
                       <para>Note that other configuration options are held in the <code>Configuration</code> object,
                           so setting this attribute will cancel all others that have been set. Also, if two
                           factories share the same <code>Configuration</code>, then setting an attribute on
                           one affects all the others.</para>
                   
            </remarks>
        </member>
        <member name="F:Saxon.Api.FeatureKeys.CONFIGURATION_FILE">
            <summary>Defines a configuration file to be applied to the configuration.
            </summary>
            <remarks>
                       <para>This attribute cannot be set on the <see cref="T:net.sf.saxon.Configuration"/> itself, but it can be
                           set on various JAXP factory objects such as a <code>TransformerFactory</code> or
                               <code>DocumentBuilderFactory</code>. It is particularly useful when running
                           transformations via the Ant xslt task, where it can be set as follows to define all
                           configuration settings: </para>
                       <para><code>&lt;factory name="net.sf.saxon.TransformerFactoryImpl"&gt; &lt;attribute
                               name="http://saxon.sf.net/feature/configuration-file"
                               value="c:/saxon/config.xml"/&gt; &lt;/factory&gt;</code>
                       </para>
                   
            </remarks>
        </member>
        <member name="F:Saxon.Api.FeatureKeys.DEBUG_BYTE_CODE">
            <summary>This option is set to indicate that bytecode generation should be run in debugging
                           mode; it injects diagnostic tracing calls into the generated bytecode. This should
                           be used only if requested by Saxonica support to diagnose a problem related to
                           bytecode generation.
            </summary>
        </member>
        <member name="F:Saxon.Api.FeatureKeys.DEBUG_BYTE_CODE_DIR">
            <summary>This option is relevant only if <code>DISPLAY_BYTE_CODE</code> is set to true. It
                           defines a directory to which files containing bytecode in human-readable form will
                           be written. There will be one such file for each generated class, with a filename
                           designed to give some kind of clue as to its relationship to the source code.
            </summary>
            <remarks>
                       <para>The default value is the directory <code>saxonByteCode</code> within the current
                           working directory.</para>
                       <para>The named directory is created if it does not already exist.</para>
                       <para>Because the generation of class names involves random numbers, files will tend to
                           accumulate in the supplied directory, even when the same source code is compiled
                           repeatedly.</para>
                   
            </remarks>
        </member>
        <member name="F:Saxon.Api.FeatureKeys.DEFAULT_COLLATION">
            <summary>This option determines the collation that is used for comparing strings when no
                           explicit collation is requested. It is not necessary for this collation to exist (or
                           to have been registered) when setting this option; it only needs to exist by the
                           time it is used.
            </summary>
            <remarks>
                       <para>In XSLT it is possible to override this setting using the
                               <code>[xsl:]default-collation</code> attribute on any stylesheet element. In
                           XQuery, it can be overridden using the <code>declare default collation</code>
                           declaration in the query prolog, or via a setter method in class
                               <see cref="T:net.sf.saxon.query.StaticQueryContext"/>.</para>
                       <para>If no value is specified, the Unicode codepoint collation is used.</para>
                   
            </remarks>
        </member>
        <member name="F:Saxon.Api.FeatureKeys.DEFAULT_COLLECTION">
            <summary>This determines the collection that is used when the <code>fn:collection()</code>
                           function is called with no arguments; the effect is the same as if it were called
                           passing the URI that is the value of this configuration property.
            </summary>
        </member>
        <member name="F:Saxon.Api.FeatureKeys.DEFAULT_COUNTRY">
            <summary>This determines the country that is used by <code>format-date()</code> and similar
                           functions if no country code is supplied explicitly. If no value is given for this
                           property, the default is taken from the Java Locale, which in turn typically depends
                           on settings for the current user in the operating system.
            </summary>
        </member>
        <member name="F:Saxon.Api.FeatureKeys.DEFAULT_LANGUAGE">
            <summary>This option determines the language that is used by <code>format-date()</code>,
                               <code>xsl:number</code> and similar constructs if no language code is supplied
                           explicitly. If no value is given for this property, the default is taken from the
                           Java Locale, which in turn typically depends on settings for the current user in the
                           operating system.
            </summary>
        </member>
        <member name="F:Saxon.Api.FeatureKeys.DEFAULT_REGEX_ENGINE">
            <summary>Determines which regular expression engine should be used for evaluating regular expressions occuring in constructs
                       such as <code>fn:matches()</code>, <code>fn:replace</code>, and <code>xsl:analyze-string</code>, and also
                       in the pattern facet of a schema.
            </summary>
            <remarks>
                       <para>On the Java platform the permitted values are "S" (default), and "J". The value "J" selects the regex engine
                       provided in the JDK in preference to the Saxon regular expression engine. This means that regular expressions must
                       follow the Java syntax and semantics rather than the XPath syntax and semantics.</para>
                       <para>On the .NET platform the permitted values are "S" (default), "J", and "N". The value "J" selects the regex engine
                           provided in the IKVMC run-time, which is derived from OpenJDK. The value "N" selects the regex engine provided
                       in the Microsoft .NET platform. In each case, the regular expression must follow the syntax and semantics of the selected
                       regex engine.</para>
                       <para>The choice of regular expression may be overridden in a particular invocation by appending the value ";s",
                       ";j", or ";n" to the flags argument of the relevant call. (This does not apply to XSD patterns, where no flags argument is available)</para>
                       <para>Use of this feature is not conformant with W3C specifications. Use of the setting "N", however, can be useful
                       when schemas have been written with the Microsoft schema processor in mind, since this uses the Microsoft regular
                       expression dialect rather than the W3C dialect.</para>
                   
            </remarks>
        </member>
        <member name="F:Saxon.Api.FeatureKeys.DISABLE_XSL_EVALUATE">
            <summary>This option disables the <code>xsl:evaluate</code> instruction.
            </summary>
            <remarks>
                       <para>If set at stylesheet compile time, the feature is statically disabled. If set at 
                           run-time it is dynamically disabled. (These terms are defined in the XSLT 3.0 spec.)
                           By default, the feature is enabled.</para>
                       <para><i>The XSLT 3.0 specification requires conformant processors to provide a way of
                           disabling <code>xsl:evaluate</code>. This shouldn't be taken as meaning that 
                           <code>xsl:evaluate</code> poses particular security risks. The main reason for disabling it
                           is if you want to carry out static analysis or inspection of stylesheet code to see what 
                           features it uses. But if you're doing such inspection, it's not difficult to check that
                           <code>xsl:evaluate</code> is only being used to execute trusted code. Note also that
                           <code>fn:transform()</code> can similarly be used to execute dynamically-constructed code,
                           and there is no switch to disable that function.</i></para>
                   
            </remarks>
        </member>
        <member name="F:Saxon.Api.FeatureKeys.DISPLAY_BYTE_CODE">
            <summary>This option is set to indicate that bytecode generation should be run in display
                           mode. The effect is to output files (one per class) containing a human-readable
                           print of the generated bytecode. The files are placed in the directory identified by
                           the <code>DEBUG_BYTE_CODE_DIR</code> option.
            </summary>
        </member>
        <member name="F:Saxon.Api.FeatureKeys.DTD_VALIDATION">
            <summary>If true, the XML parser is requested to perform validation of source documents
                           against their DTD. Default is false.
            </summary>
            <remarks>
                       <para>This option establishes a default for use whenever source documents (not stylesheets
                           or schema documents) are parsed. The option can be overridden for individual
                           documents by setting the <see cref="T:net.sf.saxon.lib.ParseOptions"/> for that
                           individual document, for example from a <code>URIResolver</code>.</para>
                   
            </remarks>
        </member>
        <member name="F:Saxon.Api.FeatureKeys.DTD_VALIDATION_RECOVERABLE">
            <summary>This option determines whether DTD validation failures should be treated as
                           recoverable. If the option is set, a validation failure is reported as a warning
                           rather than an error. The default is false.
            </summary>
            <remarks>
                       <para>This option establishes a default for use whenever source documents (not stylesheets
                           or schema documents) are parsed. The option can be overridden for individual
                           documents by setting the <see cref="T:net.sf.saxon.lib.ParseOptions"/> for that
                           individual document, for example from a <code>URIResolver</code>.</para>
                   
            </remarks>
        </member>
        <member name="F:Saxon.Api.FeatureKeys.EAGER_EVALUATION">
            <summary>Forces Saxon to do eager evaluation of expressions in contexts where normally it would do lazy evaluation,
                           for example when evaluating variables and function results. This can make for easier debugging.
            </summary>
            <remarks>
                       <para>Note that this only applies to situations where Saxon would normally save a <code>Closure</code>
                       object as the result of an expression. It does not prevent Saxon from using pipelined evaluation of
                       intermediate expressions using iterators.</para>
                   
            </remarks>
        </member>
        <member name="F:Saxon.Api.FeatureKeys.ENTITY_RESOLVER_CLASS">
             <summary>The supplied class is instantiated and the resulting <code>EntityResolver</code> is
                            used whenever Saxon itself creates an <code>XMLReader</code> for parsing source
                            documents. It is not used with a user-supplied <code>XMLReader</code>.
             </summary>
             <remarks>
                        <para>The default value is <see cref="T:net.sf.saxon.lib.StandardEntityResolver"/>. This is an entity
                            resolver that recognizes the names of many standard W3C DTDs and external entity
                            files, and resolves them against local copies issued with the Saxon software, to
                            avoid the need to fetch them from the web.</para>
                        <para>The property can be set to a zero-length string, in which case no
                                <code>EntityResolver</code> will be used.</para>
            
                    
             </remarks>
        </member>
        <member name="F:Saxon.Api.FeatureKeys.ENVIRONMENT_VARIABLE_RESOLVER">
            <summary>Setting the <code>ENVIRONMENT_VARIABLE_RESOLVER</code> causes the supplied object to
                           be registered as the environment variable resolver for the
                               <code>Configuration</code>. The setting is global: it affects all queries and
                           transformations using this configuration.
            </summary>
            <remarks>
                       <para>The environment variable resolver is used when the XPath functions
                               <code>available-environment-variables()</code> or
                               <code>environment-variable()</code> are called. Saxon essentially delegates the
                           evaluation of the function to the external resolver.</para>
                   
            </remarks>
        </member>
        <member name="F:Saxon.Api.FeatureKeys.ENVIRONMENT_VARIABLE_RESOLVER_CLASS">
            <summary>Setting <code>ENVIRONMENT_VARIABLE_RESOLVER_CLASS</code> causes an instance of the
                           supplied class to be created, and registered as the environment variable resolver
                           for the <code>Configuration</code>. The setting is global: it affects all queries
                           and transformations using this configuration.
            </summary>
            <remarks>
                       <para>The environment variable resolver is used when the XPath functions
                               <code>available-environment-variables()</code> or
                               <code>environment-variable()</code> are called. Saxon essentially delegates the
                           evaluation of the function to the external resolver.</para>
                   
            </remarks>
        </member>
        <member name="F:Saxon.Api.FeatureKeys.ERROR_LISTENER_CLASS">
            <summary><code>ERROR_LISTENER_CLASS</code> is the name of the class used to implement the JAXP
                           <code>ErrorListener</code>. This is used both at compile time and at run-time.
            </summary>
            <remarks>
                       <para>Currently if this option is specified, the class is instantiated, and the same
                           instance is used for all processes running under this configuration. This may change
                           in future so that a new instance is created for each compilation or evaluation.</para>
                       <para>Finer control can be obtained by setting the <code>ErrorListener</code> for a
                           specific XSLT or XQuery compilation or evaluation.</para>
                   
            </remarks>
        </member>
        <member name="F:Saxon.Api.FeatureKeys.EXPAND_ATTRIBUTE_DEFAULTS">
            <summary><code>EXPAND_ATTRIBUTE_DEFAULTS</code> determines whether fixed and default values
                           defined in a schema or DTD will be expanded (both on input and on output documents,
                           if validation is requested).
            </summary>
            <remarks>
                       <para>By default (and for conformance with the specification)
                           validation against a DTD or schema will cause default values defined in the schema
                           or DTD to be inserted into the document. Setting this feature to false suppresses
                           this behavior. In the case of DTD-defined defaults this only works if the XML parser
                           reports whether each attribute was specified in the source or generated by expanding
                           a default value. Not all XML parsers report this information.</para>
                   
            </remarks>
        </member>
        <member name="F:Saxon.Api.FeatureKeys.EXPATH_FILE_DELETE_TEMPORARY_FILES">
            <summary><code>EXPATH_FILE_DELETE_TEMPORARY_FILES</code> determines whether temporary files
                           and directories created in the EXPath File module should be automatically deleted on
                           closure of the JVM.
            </summary>
            <remarks>
                       <para>The default value is <b>false</b>, to align with the standard. The setting
                               <b>false</b> is recommended when external 'sweep-up' features aren't
                           available.</para>
                   
            </remarks>
        </member>
        <member name="F:Saxon.Api.FeatureKeys.GENERATE_BYTE_CODE">
            <summary>By default, Saxon-EE attempts to generate Java bytecode for evaluation of parts of a
                           query or stylesheet that are amenable to such treatment. Setting this option to
                           false disables this.
            </summary>
            <remarks>
                       <para>For backwards compatibility, this option when used at the level of <code>Configuration.setConfigurationProperty()</code>
                       can also be used to set the value of <code>THRESHOLD_FOR_HOTSPOT_BYTECODE</code>. If the value on that interface is supplied
                       as an integer (or a string in the form of an integer) then a value of 1 or more sets the threshold for hotspot detection, while
                       a value of zero or less disables bytecode generation entirely. On other interfaces the value of the property must be a boolean.</para>
                   
            </remarks>
        </member>
        <member name="F:Saxon.Api.FeatureKeys.IGNORE_SAX_SOURCE_PARSER">
            <summary>If this option is set to true, then when a <code>SAXSource</code> is supplied as the
                           input to an XSLT transformation, Saxon will ignore the <code>XMLReader</code>
                           supplied in the <code>SAXSource</code> (in fact, it will modify the supplied
                               <code>SAXSource</code> setting the <code>XMLReader</code> to null) and use an
                               <code>XMLReader</code> created using the value of the
                               <code>SOURCE_PARSER_CLASS</code> option in preference.
            </summary>
            <remarks>
                       <para>The defining use case for this feature is when calling a Saxon transformation from
                           Ant. Ant always supplies the source document as a <code>SAXSource</code> using a
                           parser instantiated using the default JAXP mechanism. A different parser set using
                           the property <code>http://saxon.sf.net/feature/sourceParserClass</code> will
                           normally be ignored in this case; setting the <code>ignoreSAXSourceParser</code>
                           option overrides this. This is especially useful if the input format is not in fact
                           XML, but some other format converted to a SAX event stream by means of a custom
                           parser.</para>
                   
            </remarks>
        </member>
        <member name="F:Saxon.Api.FeatureKeys.IMPLICIT_SCHEMA_IMPORTS">
            <summary><code>IMPLICIT_SCHEMA_IMPORTS</code> allows reference to schema components without an <code>xs:import</code> for the relevant namespace being
                           present in the containing schema document. 
            </summary>
            <remarks>
                       <para>This only works if the referenced components are already present among the schema components known to the configuration, perhaps
                       because they were part of a different schema, or because there are cyclic references within a schema.</para>
                       <para>This option is not conformant with the XSD specification, which requires explicit <code>xs:import</code> declarations
                       for all cross-namespace component references. However, some "industry-standard" schemas are known to violate this rule,
                       and setting this option allows such schemas to be loaded by Saxon.</para>
                   
            </remarks>
        </member>
        <member name="F:Saxon.Api.FeatureKeys.LAZY_CONSTRUCTION_MODE">
            <summary><code>LAZY_CONSTRUCTION_MODE</code> determines whether temporary trees are
                           constructed lazily. The default setting is false; there are a few situations (but
                           not many) where setting this to true can give a performance benefit (especially a
                           memory saving).
            </summary>
            <remarks>
                       <para>The option is most likely to be effective when executing XQuery in "pull" mode, that
                           is, when the client calls the query processor to deliver the result as a stream of
                           nodes, rather than running the query and piping the results into a serializer.</para>
                   
            </remarks>
        </member>
        <member name="F:Saxon.Api.FeatureKeys.LICENSE_FILE_LOCATION">
            <summary><code>LICENSE_FILE_LOCATION</code> holds the filename in which the Saxon license file
                           is held.
            </summary>
            <remarks>
                       <para>This is the full file name, for example <code>c:/saxon/license/license.lic</code>. 
                           Setting this property causes Saxon to
                           immediately read the specified file and register the license data, assuming it can
                           be found at this location. The property is not recognized for reading, and it is not
                           recognized for writing except in Saxon-PE and Saxon-EE.</para>
                   
            </remarks>
        </member>
        <member name="F:Saxon.Api.FeatureKeys.LINE_NUMBERING">
            <summary>Default is false. If true, line and column number information is retained for all
                           source documents. This information is accessible using the
                               <code>saxon:line-number()</code> and <code>saxon:column-number()</code>
                           extension functions.
            </summary>
            <remarks>
                       <para>Note that the information is only as good as the XML parser supplies. SAX parsers
                           generally report the position of an element node using the line and column number of
                           the "&gt;" character that forms the last character of the start tag.</para>
                       <para>When this option is set, location information attached to a node (system ID, line
                       number, and column number) is retained when the node is copied. This has the side effect
                       that the base URI of a node is also copied, which in some cases runs contrary to the
                       XSLT or XQuery specification.</para>
                   
            </remarks>
        </member>
        <member name="F:Saxon.Api.FeatureKeys.MARK_DEFAULTED_ATTRIBUTES">
            <summary>Setting the <code>MARK_DEFAULTED_ATTRIBUTES</code> option causes Saxon to retain details of attributes
                       that were notified by the XML parser as being defaulted (that is, the attribute was not present in the instance
                       document but was defined by a default value in a DTD or schema). This information is available to applications
                       via the <code>saxon:is-defaulted()</code> extension function.
            </summary>
            <remarks>
                       <para>Note: information about defaulted attributes is retained automatically where the attribute is processed
                       using Saxon's schema processor; but in the case where the information comes from an external XML parser, it
                       is retained only if this option is set.</para>
                   
            </remarks>
        </member>
        <member name="F:Saxon.Api.FeatureKeys.MAX_COMPILED_CLASSES">
            <summary>Places a limit on the number of classes for which Saxon will generate bytecode.
            </summary>
            <remarks>
                       <para>If bytecode generation is enabled, Saxon will generate bytecode for frequently used constructs appearing
                           in stylesheets or queries. This can become problematic if a configuration uses a very large number
                           of different stylesheets and queries, because it creates memory pressure (in some environments classes
                           are never garbage collected). When this limit (which defaults to 10,000) is exceeded, no more bytecode
                       is generated, and queries/stylesheets are interpreted instead.</para>
                   
            </remarks>
        </member>
        <member name="F:Saxon.Api.FeatureKeys.MESSAGE_EMITTER_CLASS">
            <summary>Use the specified <code>Receiver</code> to process the output from
                               <code>xsl:message</code>. The class must implement the
                               <code>net.sf.saxon.event.Receiver</code> interface. This interface is similar to
                           a SAX <code>ContentHandler</code>, in that it takes a stream of events to generate
                           output.
            </summary>
            <remarks>
                       <para>By default the standard XML emitter is used, configured to write to the standard
                           error stream, and to include no XML declaration. </para>
                       <para>In general the content of a message is an XML fragment. Each message is output as a
                           new document. The sequence of calls to this <code>Receiver</code> is as follows:
                           there is a single <code>open()</code> call at the start of the transformation, and a
                           single <code>close()</code> call at the end; and each evaluation of an
                               <code>xsl:message</code> instruction starts with a <code>startDocument()</code>
                           call and ends with <code>endDocument()</code>. </para>
                       <para>The <code>startDocument()</code> event has a <code>properties</code> argument
                           indicating whether <code>terminate="yes"</code> was specified, and the
                               <code>locationId</code> on calls such as <code>startElement()</code> and
                               <code>characters()</code> can be used to identify the location in the stylesheet
                           where the message data originated (this is achieved by passing the supplied
                               <code>locationId</code> in a call to
                               <code>getPipelineConfiguration().getLocator().getSystemId(locationId)</code>, or
                           to <code>getLineNumber()</code> on the same object). </para>
                       <para>Select the class <code>net.sf.saxon.event.MessageWarner</code> to have
                               <code>xsl:message</code> output notified to the JAXP <code>ErrorListener</code>,
                           as described in the JAXP documentation.</para>
                   
            </remarks>
        </member>
        <member name="F:Saxon.Api.FeatureKeys.MODULE_URI_RESOLVER">
            <summary>Affects XQuery only. An instance of a user-written class implementing Saxon's
                               <see cref="T:net.sf.saxon.lib.ModuleURIResolver"/> interface. This is used to
                           process any URIs used in <code>import module</code> directives in XQuery.
            </summary>
        </member>
        <member name="F:Saxon.Api.FeatureKeys.MODULE_URI_RESOLVER_CLASS">
            <summary>Affects XQuery only. The name of a user-written class implementing Saxon's
                               <see cref="T:net.sf.saxon.lib.ModuleURIResolver"/> interface. This is used to
                           process any URIs used in <code>import module</code> directives in XQuery.
            </summary>
        </member>
        <member name="F:Saxon.Api.FeatureKeys.MONITOR_HOT_SPOT_BYTE_CODE">
            <summary>When set from the Transform or Query command line, a report on bytecode generation is
                           produced at the end of the transformation or query.
            </summary>
            <remarks>
                       <para>When set from an application, the bytecode report is produced only on request, by
                           calling <code>Configuration.createByteCodeReport(fileName)</code>.</para>
                       <para>The bytecode report is an XML file containing one entry for each expression that has
                           been compiled into bytecode. Each entry contains the following details, where
                           applicable:</para>
                           <list>
                           <item><code>text</code> Abbreviated text of the expression</item>
                           <item><code>intCount</code> Number of times the expression was evaluated in the interpreter</item>
                           <item><code>intTime</code> Cumulative time spent evaluating the expression (including subexpressions) in the interpreter</item>
                           <item><code>bcCount</code> Number of times the expression was evaluated as byte-code</item>
                           <item><code>bcTime</code> Cumulative time spent evaluating the expression (including subexpressions) as byte-code</item>
                           <item><code>compileTime</code> Time spent generating bytecode for the expression</item>
                           <item><code>ratio</code> Average byte-code execution time as a proportion of average interpreted execution time</item>
                           <item><code>ebv</code> Number of evaluations of the expressions <code>effectiveBooleanValue()</code> method</item>
                           <item><code>eval</code> Number of evaluations of the expressions <code>evaluateItem()</code> method</item>
                           <item><code>iterate</code> Number of evaluations of the expressions <code>iterate()</code> method</item>
                           <item><code>process</code> Number of evaluations of the expressions <code>process()</code> method</item>
                           <item><code>module</code> URI of the module containing the expression</item>
                           <item><code>line</code> Line number of the expression within this module</item>
                       </list>
                   
            </remarks>
        </member>
        <member name="F:Saxon.Api.FeatureKeys.MULTIPLE_SCHEMA_IMPORTS">
            <summary>Affects schema construction (whether for standalone validation, or in the context of
                           XSLT or XQuery).
            </summary>
            <remarks>
                       <para>If set to true, the schema processor attempts to fetch a schema
                           document appearing in an <code>xs:import</code> directive, whether or not a schema
                           for that namespace has already been loaded, unless the absolute URI formed from the
                               <code>schemaLocation</code> is the same as the absolute URI that was used to
                           load that namespace. If set to false, the schema processor ignores the
                               <code>schemaLocation</code> on an <code>xs:import</code> declaration if schema
                           components for the requested namespace are already available. Note that setting the
                           value to true might cause spurious errors due to like-named schema components being
                           loaded more than once. On the other hand, setting the value to false might result in
                           validation failing because schema components are missing.</para>
                       <para>Note: Both settings are conformant with the W3C recommendation, which leaves the
                           details implementation-defined. It is possible (and advisable) to write schemas in
                           such a way that this setting makes no difference, by ensuring that all imports for a
                           particular namespace go via a "home" schema document for that namespace, where the
                           home schema document contains <code>xs:include</code> declarations for all the
                           schema documents defining components in that namespace.</para>
                   
            </remarks>
        </member>
        <member name="F:Saxon.Api.FeatureKeys.NAME_POOL">
            <summary>Indicates that the supplied <code>NamePool</code> should be used as the target
                           (run-time) <code>NamePool</code> by all stylesheets compiled (using
                           <code>newTemplates()</code>) after this call on <code>setAttribute</code>.
            </summary>
            <remarks>
                       <para>Normally a single system-allocated <code>NamePool</code> is used for all stylesheets
                           compiled while the Java VM remains loaded; this attribute allows user control over
                           the allocation of name pools. Note that source trees used as input to a
                           transformation must be built using the same <code>NamePool</code> that is used when
                           the stylesheet is compiled: this will happen automatically if the input to a
                           transformation is supplied as a <code>SAXSource</code> or <code>StreamSource</code>
                           but it is under user control if you build the source tree yourself.</para>
                       <para>This option can be used to make two <code>Configuration</code> objects share a
                               <code>NamePool</code> even though they differ in other respects.</para>
                   
            </remarks>
        </member>
        <member name="F:Saxon.Api.FeatureKeys.OCCURRENCE_LIMITS">
            <summary><code>OCCURRENCE_LIMITS</code> determines the largest values of
                           <code>minOccurs</code> and <code>maxOccurs</code> that can be accommodated when
                           compiling an "expanded" finite state machine to represent an XSD content model
                           grammar.
            </summary>
            <remarks>
                       <para>These limits do not apply in the common cases where the grammar can be
                           implemented using a counting finite-state-machine, but in those cases where this is
                           not possible, any <code>minOccurs</code> value greater than the first integer is
                           reduced to the value of the first integer, and any <code>maxOccurs</code> value
                           greater than the second integer is treated as "unbounded".</para>
                       <para>Setting these values too high may cause an <code>OutOfMemoryException</code> since
                           the size of the finite state machine constructed by Saxon increases linearly with
                           the values of <code>minOccurs</code> and <code>maxOccurs</code>.</para>
                   
            </remarks>
        </member>
        <member name="F:Saxon.Api.FeatureKeys.OPTIMIZATION_LEVEL">
            <summary>Allows individual optimizations to be enabled or disabled selectively.
            </summary>
            <remarks>
                       <para>There is a set of single-letter flags identifying particular optimizations:</para>
                       <list>
                           <item>c: generate bytecode</item>
                           <item>e: cache regular expressions</item>
                           <item>f: inline functions</item>
                           <item>g: extract global variables</item>
                           <item>j: just-in-time compilation of template rules</item>
                           <item>k: create keys</item>
                           <item>l: loop lifting</item>
                           <item>m: miscellaneous</item>
                           <item>n: constant folding</item>
                           <item>r: template rule-sets</item>
                           <item>s: extract common subexpressions</item>
                           <item>v: inline variables</item>
                           <item>w: create switch statements</item>
                           <item>x: index predicates</item>
                       </list>
                       <para>A value such as <code>gs</code> runs with only the selected optimizations;
                           <code>-gs</code> runs with the selected optimizations disabled and all others enabled. The
                           value <code>0</code> suppresses all optimizations. The default is full optimization; this
                           feature allows optimization to be suppressed in cases where reducing compile time is
                           important, or where optimization gets in the way of debugging, or causes extension
                           functions with side-effects to behave unpredictably. (Note however, that even with
                           no optimization, lazy evaluation may still cause the evaluation order to be not as
                           expected.) </para>
                       <para><i>Note that disabling optimizations may prevent streamed execution. This is because
                       there are cases where streamed execution is only possible because the optimizer is able to detect
                       that sorting nodes into document order is unnecessary.</i></para>
                   
            </remarks>
        </member>
        <member name="F:Saxon.Api.FeatureKeys.OUTPUT_URI_RESOLVER">
            <summary>The supplied <code>OutputURIResolver</code> will be used to resolve URIs of secondary
                           result documents selected in the <code>href</code> attribute of the XSLT
                               <code>xsl:result-document</code> instruction.
            </summary>
        </member>
        <member name="F:Saxon.Api.FeatureKeys.OUTPUT_URI_RESOLVER_CLASS">
            <summary>The supplied class will be instantiated, and the resulting
                               <code>OutputURIResolver</code> will be used to resolve URIs of secondary result
                           documents selected in the <code>href</code> attribute of the XSLT
                               <code>xsl:result-document</code> instruction.
            </summary>
        </member>
        <member name="F:Saxon.Api.FeatureKeys.PRE_EVALUATE_DOC_FUNCTION">
            <summary>If true, calls on the <code>doc()</code> and <code>document()</code> functions, if
                           their arguments are known at compile time, will be evaluated at compile time, and
                           the resulting document will be stored as part of the Saxon
                           <see cref="T:net.sf.saxon.Configuration"/> and shared by all queries and
                           transformations running within that <code>Configuration</code>.
            </summary>
            <remarks>
                       <para>This is useful for reference documents that have stable content and are used by many different 
                           queries and transformations. The default is false, which means each query or transformation
                           will reload the document from disk.</para>
                       <para>In XSLT 3.0 a better way of having external documents pre-loaded at stylesheet
                           compile time is to use the new facility of static global variables.</para>
                   
            </remarks>
        </member>
        <member name="F:Saxon.Api.FeatureKeys.PREFER_JAXP_PARSER">
            <summary>Relevant only on .NET, determines whether the Java Classpath parser is used in
                           preference to the Microsoft .NET parser.
            </summary>
            <remarks>
                       <para>This option has no effect on the Java platform. The default is <b>true</b>. When
                           running on the .NET platform, if the option is true it causes the Apache Xerces
                           parser (cross-compiled using IKVMC) to be used in preference to the .NET XML parser.
                           If false the .NET XML parser (<code>System.Xml.XmlTextReader</code>) is used. One
                           reason for providing this option is that the .NET XML parser does not report ID
                           attributes, which means that the <code>id()</code> function does not work.</para>
                   
            </remarks>
        </member>
        <member name="F:Saxon.Api.FeatureKeys.RECOGNIZE_URI_QUERY_PARAMETERS">
            <summary>True if the standard URI resolver is to recognize query parameters included in the
                           URI (for example, <code>?validation=strict</code>). Such parameters can then be used
                           in URIs passed to the <code>doc()</code> or <code>document()</code> functions. The
                           default is false.
            </summary>
            <remarks>
                       <para>This option has no effect if a user-supplied <code>URIResolver</code> is in use,
                           unless the user-supplied <code>URIResolver</code> chooses to inherit this
                           functionality from the standard <code>URIResolver</code>.</para>
                       <para>The allowed parameters are: <code>validation=strict|lax|strip</code> to perform schema
                           validation (see <span class="link" data-href="/sourcedocs/validation">Validation of
                               Source Documents</span>); <code>strip-space=yes|ignorable|no</code> to control whitespace
                           stripping (see <span class="link" data-href="/sourcedocs/whitespace">Whitespace
                               Stripping in Source Documents</span>); <code>parser=full.class.name</code> to
                           determine the name of the parser (XMLReader) to be used (see <span class="link" data-href="/sourcedocs/controlling-parsing">Controlling Parsing of Source
                               Documents</span>); and <code>xinclude=yes|no</code> to control whether XInclude
                           processing takes place, assuming the XML parser supports it (see <span class="link" data-href="/sourcedocs/XInclude">XInclude processing</span>).</para>
                   
            </remarks>
        </member>
        <member name="F:Saxon.Api.FeatureKeys.RECOVERY_POLICY">
            <summary>At one time this property controlled how recoverable errors were handled
                           (fatal error, warning, or ignored). XSLT 3.0 has eliminated all recoverable errors from the
                           specification, so the property is now deprecated.
            </summary>
        </member>
        <member name="F:Saxon.Api.FeatureKeys.RECOVERY_POLICY_NAME">
            <summary>At one time this property controlled how recoverable errors were handled
                           (fatal error, warning, or ignored). XSLT 3.0 has eliminated all recoverable errors from the
                           specification, so the property is now deprecated.
            </summary>
        </member>
        <member name="F:Saxon.Api.FeatureKeys.RESULT_DOCUMENT_THREADS">
            <summary>Indicates the maximum number of threads to be used for processing
                               <code>xsl:result-document</code> instructions in parallel. If the maximum number
                           of threads are already in use, the <code>xsl:result-document</code> instruction will
                           be executed synchronously within its parent thread.
            </summary>
            <remarks>
                       <para>The default value is initialized to
                               <code>Runtime.getRuntime().availableProcessors()</code> which is intended to
                           represent the number of "processors" (under some definition) available from the
                           hardware.</para>
                       <para>The limit applies per <code>Configuration</code>. If multiple workloads are running
                           on the same server under separate Saxon <code>Configuration</code> objects, then it
                           may be desirable to lower the limit.</para>
                       <para>Setting a value of zero or one suppresses multithreading entirely. This can also be
                           achieved (for a specific <code>xsl:result-document</code> instruction) by setting
                           the attribute <code>saxon:asynchronous="no"</code> in the stylesheet. Suppressing
                           multithreading may be desirable in a stylesheet that calls extension functions with
                           side-effects.</para>
                   
            </remarks>
        </member>
        <member name="F:Saxon.Api.FeatureKeys.RETAIN_DTD_ATTRIBUTE_TYPES">
            <summary>If set to true, indicates that when input is obtained from a SAX parser, the
                           DTD-based attribute type notified by the XML parser should be used to set the type
                           annotation of the resulting node: for example a DTD type of NMTOKENS results in a
                           type annotation of xs:NMTOKENS. 
            </summary>
            <remarks>
                       <para>This option is retained for backwards compatibility (at some time in the past, it was
                           the default), but is deprecated.</para>
                   
            </remarks>
        </member>
        <member name="F:Saxon.Api.FeatureKeys.SCHEMA_URI_RESOLVER">
            <summary>The supplied <code>SchemaURIResolver</code> will be used to resolve URIs of schema
                           documents referenced in <code>xsl:import-schema</code> declarations in XSLT,
                               <code>import schema</code> in XQuery, references from one schema document to
                           another using <code>xs:include</code> or <code>xs:import</code>, and references from
                           an instance document to a schema using <code>xsi:schemaLocation</code>.
            </summary>
        </member>
        <member name="F:Saxon.Api.FeatureKeys.SCHEMA_URI_RESOLVER_CLASS">
            <summary>The name of a class that implements the interface <code>SchemaURIResolver</code>;
                           this class will be instantiated and the resulting instance will be used as the value
                           of the <see cref="F:Saxon.Api.FeatureKeys.SCHEMA_URI_RESOLVER"/> property.
            </summary>
        </member>
        <member name="F:Saxon.Api.FeatureKeys.SCHEMA_VALIDATION">
            <summary>Indicates whether and how schema validation should be applied to source
                           documents.
            </summary>
        </member>
        <member name="F:Saxon.Api.FeatureKeys.SCHEMA_VALIDATION_MODE">
            <summary>Indicates whether and how schema validation should be applied to source
                           documents.
            </summary>
        </member>
        <member name="F:Saxon.Api.FeatureKeys.SERIALIZER_FACTORY_CLASS">
            <summary>The class will be instantiated and the resulting <code>SerializerFactory</code> will
                           be used to create the serialization pipeline for XSLT and XQuery results.
            </summary>
            <remarks>
                       <para>By subclassing the standard <code>SerializerFactory</code> it is possible to customize
                           many aspects of the output produced by the Serializer, or to introduce new
                           serialization methods and parameters.</para>
                   
            </remarks>
        </member>
        <member name="F:Saxon.Api.FeatureKeys.SOURCE_PARSER_CLASS">
            <summary>XML parser used for source documents.
            </summary>
            <remarks>
                       <para>The class will be instantiated. If it is an <code>XMLReader</code> it is used
                           directly; if it is a <code>SAXParserFactory</code> it is used to instantiate an
                               <code>XMLReader</code>. The resulting <code>XMLReader</code> will be used to
                           parse source documents (that is, the principal source document plus any secondary
                           source documents read using the <code>doc()</code>, <code>document()</code>, or
                               <code>collection()</code> function).</para>
                       <para>Note that the selected parser is used only when the input is supplied in the form of
                           a <code>StreamSource</code>; it is ignored when a <code>SAXSource</code> with a
                           pre-initialized <code>XMLReader</code> is supplied. A consequence is that this
                           configuration option has no effect when running transformations from an Ant script,
                           since the Ant <code>xslt</code> task always supplies the input in the form of a
                               <code>SAXSource</code>.</para>
                   
            </remarks>
        </member>
        <member name="F:Saxon.Api.FeatureKeys.SOURCE_RESOLVER_CLASS">
            <summary>On interfaces that allow an <code>org.xml.sax.Source</code> to be supplied, if a kind
                           of <code>Source</code> is provided that Saxon does not recognize, it will be passed
                           to the user-supplied <code>SourceResolver</code>, which has the opportunity to
                           convert it to a kind of <code>Source</code> that Saxon does recognize. This allows
                           new kinds of input to be supplied as input to Saxon's query, transformation, and
                           validation engines.
            </summary>
        </member>
        <member name="F:Saxon.Api.FeatureKeys.STABLE_COLLECTION_URI">
            <summary><code>STABLE_COLLECTION_URI</code>, if set, indicates that collections returned by
                           the <code>fn:collection()</code> and <code>fn:uri-collection()</code> functions
                           should be <i>stable</i>, that is, repeated calls on these functions with the same
                           collection URI (within the scope of a single query or transformation) should return
                           identical results.
            </summary>
            <remarks>
                       <para>Setting this option may be expensive because it requires that the entire collection
                           be saved in memory; it is rarely necessary in practice, but is required for strict
                           conformance with the W3C specifications.</para>
                       <para>It is also possible to indicate that a collection is stable by means of the
                               <code>CollectionFinder</code> API.</para>
                   
            </remarks>
        </member>
        <member name="F:Saxon.Api.FeatureKeys.STABLE_UNPARSED_TEXT">
            <summary><code>STABLE_UNPARSED_TEXT</code>, if set, indicates that the results returned by
                           repeated calls of <code>unparsed-text()</code>, <code>unparsed-text-lines()</code>,
                           and <code>unparsed-text-available()</code> are consistent: calling these functions
                           twice during the evaluation of a stylesheet or query will return the same
                           results.
            </summary>
            <remarks>
                       <para>Setting this option may be expensive because it requires that the file contents be
                           saved in memory; it is rarely necessary in practice, but is required for strict
                           conformance with the W3C specifications.</para>
                   
            </remarks>
        </member>
        <member name="F:Saxon.Api.FeatureKeys.STANDARD_ERROR_OUTPUT_FILE">
            <summary><code>STANDARD_ERROR_OUTPUT_FILE</code> is the name of a file to which Saxon will
                           redirect output that would otherwise go to the operating system standard error
                           stream (System.err). This is the fallback destination for various tracing and
                           diagnostic output. In some cases a more specific mechanism exists to select the
                           destination for particular kinds of output.
            </summary>
            <remarks>
                       <para>Note that if the <code>Configuration</code> is used in more than one processing
                           thread, the messages from different threads will be interleaved in the output file.
                           A more selective approach is to use a different <code>ErrorListener</code> in
                           different processing threads, and arrange for each <code>ErrorListener</code> to
                           write to its own logging destination.</para>
                   
            </remarks>
        </member>
        <member name="F:Saxon.Api.FeatureKeys.STREAMABILITY">
            <summary>The <code>STREAMABILITY</code> option can be used to disable streaming.
            </summary>
            <remarks>
                       <para>In earlier Saxon releases a third value "extended" was supported, to enable Saxon
                           streaming extensions. Since nearly all these extensions found their way into the W3C
                           specification, the distinction between "standard" and "extended" became meaningless,
                           so the value "extended" has been dropped.</para>
                       <para>The value "off" causes Saxon to behave as a non-streaming processor; that is, it does
                           not analyze constructs that are declared streamable, and it processes them as if
                           streaming were not requested. This is the only option available when using a Saxon
                           version or license that does not enable streaming.</para>
                       <para>The value "standard" is a misnomer. For strict adherence to W3C streamability rules,
                           set the property <code>STRICT_STREAMABILITY</code>. The streamability rules applied
                           by default are (in nearly all cases) identical to the W3C rules, but by default they
                           are applied to the expression tree after type-checking and optimization, which makes
                           some constructs streamable that would not be so otherwise.</para>
                       <para>Whichever option is chosen, the <code>STREAMING_FALLBACK</code> option can be used to
                           control what happens when code is deemed non-streamable; it provides a choice
                           between throwing a static (compile-time) error, and falling back to a non-streaming
                           implementation.</para>
                   
            </remarks>
        </member>
        <member name="F:Saxon.Api.FeatureKeys.STRICT_STREAMABILITY">
            <summary>Causes the XSLT processor to verify that constructs that are declared streamable are
                           in fact "guaranteed streamable" according to the W3C rules.
            </summary>
            <remarks>
                       <para>Normally, Saxon performs a variety of simplifications and optimizations on the
                           expression tree before performing streamability analysis. Sometimes these tree
                           rewrites will turn a non-streamable expression into a streamable one. An obvious
                           example is variable inlining: the expression <code>let $x := ./item/price return
                               sum($x)</code> is not streamable, but the rewritten form
                               <code>sum(./item/price)</code> is.</para>
                       <para>The XSLT 3.0 specification requires conformant streaming processors to have a mode of
                           operation in which the streamability rules are enforced as they appear in the spec,
                           and this option enables this mode.</para>
                       <para>This analysis is expensive, and should only be used during development when testing
                           stylesheet code for portability. When this mode is enabled, Saxon applies the
                           streamability rules at the earliest possible stage of processing; it then performs
                           its normal type checking and optimization phases, before doing a second stage of
                           streamability analysis to construct a streamed execution plan.</para>
                   
            </remarks>
        </member>
        <member name="F:Saxon.Api.FeatureKeys.STREAMING_FALLBACK">
            <summary>If the <code>STREAMING_FALLBACK</code> option is set, then constructs for which
                           streaming is requested (such as templates in a streaming mode, the
                               <code>xsl:source-document</code> instruction with attribute
                               <code>streamable="yes"</code>, and streamable accumulators) will be executed in
                           non-streaming mode if the code is not actually streamable. A compile-time warning
                           will always be given when the fallback option is taken.
            </summary>
        </member>
        <member name="F:Saxon.Api.FeatureKeys.STRIP_WHITESPACE">
            <summary>Indicates whether all whitespace, no whitespace, or whitespace in elements defined in
                           a DTD or schema as having element-only content should be stripped from source
                           documents.
            </summary>
            <remarks>
                       <para>The default is "ignorable". This whitespace stripping is additional to
                           any stripping done as a result of the <code>xsl:strip-space</code> declaration in an
                           XSLT stylesheet.</para>
                   
            </remarks>
        </member>
        <member name="F:Saxon.Api.FeatureKeys.STYLE_PARSER_CLASS">
            <summary>XML parser used for stylesheets and schema documents.
            </summary>
            <remarks>
                       <para>The class will be instantiated. If it is an <code>XMLReader</code> it is used
                           directly; if it is a <code>SAXParserFactory</code> it is used to instantiate an
                               <code>XMLReader</code>. The resulting <code>XMLReader</code> will be used to
                           parse stylesheet documents (that is, the principal stylesheet module plus any
                           secondary source documents read using <code>xsl:include</code> or
                               <code>xsl:import</code>) and also schema documents.</para>
                   
            </remarks>
        </member>
        <member name="F:Saxon.Api.FeatureKeys.SUPPRESS_EVALUATION_EXPIRY_WARNING">
            <summary>This is set to true to suppress the warning otherwise issued by command-line
                           interfaces indicating that an evaluation license is in use and is due to expire in a
                           set number of days.
            </summary>
        </member>
        <member name="F:Saxon.Api.FeatureKeys.SUPPRESS_XPATH_WARNINGS">
            <summary>Suppresses all warnings issued by the XPath and XQuery parsers.
            </summary>
            <remarks>
                       <para>Examples of warnings that are suppressed are the warning produced when keywords such
                           as <code>true</code> and <code>return</code> are interpreted as element names.</para>
                   
            </remarks>
        </member>
        <member name="F:Saxon.Api.FeatureKeys.SUPPRESS_XSLT_NAMESPACE_CHECK">
            <summary>This is set to true to suppress the warning when there is no commonality between the
                           namespaces used in stylesheet match patterns and the namespaces used in the source
                           document.
            </summary>
        </member>
        <member name="F:Saxon.Api.FeatureKeys.THRESHOLD_FOR_COMPILING_TYPES">
            <summary>Indicates how often an XSD simple type definition must be used before Saxon generates
                           bytecode to implement validation of input data against that type.
            </summary>
            <remarks>
                       <para>By default, Saxon-EE generates Java bytecode to speed up the validation of input
                           strings against user-defined simple types after the type has been used 100 times
                           (during the life of a Saxon Configuration). This threshold may be changed using this
                           configuration option. It may be useful to raise the threshold if the number of
                           user-defined types is large, and the bytecode is creating memory pressure.</para>
                   
            </remarks>
        </member>
        <member name="F:Saxon.Api.FeatureKeys.TIMING">
            <summary>This is set to true to cause basic timing and tracing information to be output to the
                           standard error output stream.
            </summary>
            <remarks>
                       <para>The name of the feature is poorly chosen, since much
                           of the information that is output has nothing to do with timing, for example the
                           names of output files for <code>xsl:result-document</code> are traced, as are the
                           names of schema documents loaded.</para>
                   
            </remarks>
        </member>
        <member name="F:Saxon.Api.FeatureKeys.TRACE_EXTERNAL_FUNCTIONS">
            <summary>If this option is set, Saxon will output (to the standard error output) progress
                           information about its attempts to locate and disambiguate references to reflexive
                           Java extension functions. This is useful for diagnostics if the XQuery or XSLT
                           compiler is failing to locate user-written extension functions.
            </summary>
        </member>
        <member name="F:Saxon.Api.FeatureKeys.TRACE_LISTENER">
            <summary>The <code>TraceListener</code> will be notified of significant events occurring
                           during a query or transformation, for tracing or debugging purposes.
            </summary>
            <remarks>
                       <para>Setting a <code>TraceListener</code> automatically sets the
                               <see cref="F:Saxon.Api.FeatureKeys.COMPILE_WITH_TRACING"/> option.</para>
                       <para>Avoid this option if more than one transformation or query is running concurrently:
                           use the feature <see cref="F:Saxon.Api.FeatureKeys.TRACE_LISTENER_CLASS"/>
                           instead. Alternatively, it is possible to set a <code>TraceListener</code> for an
                           individual query or transformation.</para>
                   
            </remarks>
        </member>
        <member name="F:Saxon.Api.FeatureKeys.TRACE_LISTENER_CLASS">
            <summary>The class will be instantiated once for each query or transformation, and the
                           resulting <code>TraceListener</code> will be notified of significant events
                           occurring during that query or transformation, for tracing or debugging
                           purposes.
            </summary>
            <remarks>
                       <para>Setting a <code>TraceListener</code> automatically sets the
                               <see cref="F:Saxon.Api.FeatureKeys.COMPILE_WITH_TRACING"/> option.</para>
                   
            </remarks>
        </member>
        <member name="F:Saxon.Api.FeatureKeys.TRACE_LISTENER_OUTPUT_FILE">
            <summary>When trace listening is switched on (for example by using -T on the command line),
                           this file will be supplied to the trace listener to use as the output destination.
                           If the option is not supplied, trace listener output is sent to the standard error
                           stream.
            </summary>
        </member>
        <member name="F:Saxon.Api.FeatureKeys.TRACE_OPTIMIZER_DECISIONS">
            <summary>If this option is set, Saxon will output (to the standard error output) detailed
                           information about the rewrites to the expression tree made by the optimizer. This
                           information is mainly useful for internal system debugging, but it is also possible
                           to digest it to analyze the ways in which the expression has been optimized for the
                           purpose of performance analysis and tuning.
            </summary>
        </member>
        <member name="F:Saxon.Api.FeatureKeys.TREE_MODEL">
            <summary>Selects an implementation of the Saxon tree model. The default is
                               <code>TINY_TREE</code>.
            </summary>
            <remarks>
                       <para>For running XQuery Update, use the linked tree, because it is the only implementation
                           that is updateable.</para>
                   
            </remarks>
        </member>
        <member name="F:Saxon.Api.FeatureKeys.TREE_MODEL_NAME">
            <summary>Selects an implementation of the Saxon tree model. The default is
                               <code>tinyTree</code>.
            </summary>
            <remarks>
                       <para>For running XQuery Update, use the linked tree, because it is the only implementation
                           that is updateable.</para>
                   
            </remarks>
        </member>
        <member name="F:Saxon.Api.FeatureKeys.UNPARSED_TEXT_URI_RESOLVER">
            <summary>The supplied <code>UnparsedTextURIResolver</code> will be used to resolve
                           (dereference) all URIs specifed in calls to the <code>unparsed-text()</code>,
                               <code>unparsed-text-lines()</code>, and <code>unparsed-text-available()</code>
                           functions.
            </summary>
        </member>
        <member name="F:Saxon.Api.FeatureKeys.UNPARSED_TEXT_URI_RESOLVER_CLASS">
            <summary>An instance of the specified <code>UnparsedTextURIResolver</code> class will be
                           created, and used to resolve (dereference) all URIs specifed in calls to the
                               <code>unparsed-text()</code>, <code>unparsed-text-lines()</code>, and
                               <code>unparsed-text-available()</code> functions.
            </summary>
        </member>
        <member name="F:Saxon.Api.FeatureKeys.URI_RESOLVER_CLASS">
            <summary>An instance of the specified <code>URIResolver</code> class will be created, and used
                           to resolve (dereference) all URIs specifed in calls to the <code>doc()</code> and
                               <code>document()</code> functions, as well as URIs used in
                               <code>xsl:include</code> and <code>xsl:import</code> and location hints for
                           XQuery modules and XSD schema documents.
            </summary>
        </member>
        <member name="F:Saxon.Api.FeatureKeys.USE_PI_DISABLE_OUTPUT_ESCAPING">
            <summary>This option determines whether a <code>TransformerHandler</code> created with this
                               <code>TransformerFactory</code> or <code>Configuration</code> recognizes the
                           JAXP-defined processing instructions <code>Result.PI_DISABLE_OUTPUT_ESCAPING</code>
                           and <code>Result.PI_ENABLE_OUTPUT_ESCAPING</code> in the input stream as
                           instructions to disable or to re-enable output escaping. The default value is
                               <b>false</b>.
            </summary>
        </member>
        <member name="F:Saxon.Api.FeatureKeys.USE_TYPED_VALUE_CACHE">
            <summary>This option is relevant only when the TinyTree is used; it determines whether (for a
                           validated document) a cache will be maintained containing the typed values of nodes.
            </summary>
            <remarks>
                       <para>Typed values are held in the cache only for elements and attributes whose type is
                           other than string, untypedAtomic, or anyURI. The default value is true. Setting this
                           value to false can reduce memory requirements at the cost of requiring recomputation
                           of typed values on each access.</para>
                   
            </remarks>
        </member>
        <member name="F:Saxon.Api.FeatureKeys.USE_XSI_SCHEMA_LOCATION">
            <summary>This option determines whether or not to use the <code>xsi:schemaLocation</code>
                               and<code> xsi:noNamespaceSchemaLocation</code> attributes in an instance
                           document to locate a schema for validation.
            </summary>
            <remarks>
                       <para>Note, these attribute are only consulted if validation is requested; the presence of
                           one of these attributes never by itself triggers validation.</para>
                   
            </remarks>
        </member>
        <member name="F:Saxon.Api.FeatureKeys.VALIDATION_COMMENTS">
            <summary>This option determines whether non-fatal validation errors in XQuery or XSLT result
                           documents should result in comments being inserted into the result tree. The
                           command-line flag <code>-outval:recover</code> sets both this option and the
                               <see cref="F:Saxon.Api.FeatureKeys.VALIDATION_WARNINGS"/> option.
            </summary>
        </member>
        <member name="F:Saxon.Api.FeatureKeys.VALIDATION_WARNINGS">
            <summary>This option indicates (if true) that errors occuring while validating a final result
                           tree are not to be treated as fatal.
            </summary>
            <remarks>
                       <para>Regardless of the setting of this option, all validation errors are reported to the
                               <code>error()</code> method of the <code>ErrorListener</code>, and validation is
                           terminated if the <code>error()</code> method throws an exception, or if the error
                           limit set in the <code>ParseOptions</code> object is reached.</para>
                       <para>This option primarily controls what happens at the end of a validation episode. If
                           the validation episode detected one or more validation errors, then when this option
                           is off, an exception is thrown, which will normally result in any query or
                           stylesheet failing with a dynamic error, and no output file being written. If the
                           option is on, no exception is thrown, and the output is written as if validation had
                           been successful. Note in this case that any type annotations present in a result
                           document are unreliable.</para>
                       <para>If this option is set when running XSLT or XQuery, it is ignored as far as input
                           files are concerned: validation errors in input files are still fatal. However, if
                           the option is set and a validation error occurs in a final output file, the output
                           file is still written and the process terminates as if successful.</para>
                       <para>The detailed interpretation of this option changed in Saxon 9.5.</para>
                   
            </remarks>
        </member>
        <member name="F:Saxon.Api.FeatureKeys.VERSION_WARNING">
            <summary>Indicates whether a warning message should be notified (to the
                           <code>ErrorListener</code>) if running Saxon against an XSLT stylesheet that
                           specifies <code>version="1.0"</code>.
            </summary>
            <remarks>
                       <para>From Saxon 9.8, the warning is no longer output (since XSLT 3.0 does not require
                           it), so this option is ignored.</para>
                       
                   
            </remarks>
        </member>
        <member name="F:Saxon.Api.FeatureKeys.XINCLUDE">
            <summary>Indicates whether source documents should have any XInclude directives expanded.
            </summary>
            <remarks>
                       <para>The default is false. The option applies to all input XML documents, including
                           stylesheets and schema documents. It can be overridden for individual documents
                           using the <see cref="T:net.sf.saxon.lib.ParseOptions"/> class.</para>
                       <para>This option relies on support in the underlying XML parser. If the XML parser does
                           not support XInclude processing, setting this option results in a parsing failure.</para>
                   
            </remarks>
        </member>
        <member name="F:Saxon.Api.FeatureKeys.XML_VERSION">
            <summary>This determines the XML version used by the <code>Configuration</code>.
            </summary>
            <remarks>
                       <para>Note that source documents specifying <code>xml version="1.0"</code> or
                               <code>"1.1"</code> are accepted regardless of this setting. The effect of this
                           switch is to change the validation rules for types such as <code>xs:Name</code> and
                               <code>xs:NCName</code>, to change the characters allowed in names within XPath
                           expressions (etc.), to change the meaning of <code>\i</code> and <code>\c</code> in
                           regular expressions, and to determine whether the serializer allows XML 1.1
                           documents to be constructed. </para>
                       <para>The default is currently 1.0, but may change.</para>
                   
            </remarks>
        </member>
        <member name="F:Saxon.Api.FeatureKeys.XML_PARSER_FEATURE">
            <summary>Sets the value of a parser feature flag. The feature name is any fully-qualified
                           URI.
            </summary>
            <remarks>
                       <para>For example if the parser supports a feature
                               <code>http://xml.org/sax/features/external-parameter-entities</code> then this
                           can be set by setting the value of the Configuration property:
                               <code>http://saxon.sf.net/feature/parserFeature?uri=http%3A//xml.org/sax/features/external-parameter-entities</code>
                           to true.</para>
                   
            </remarks>
        </member>
        <member name="F:Saxon.Api.FeatureKeys.XML_PARSER_PROPERTY">
            <summary>Sets the value of a parser property flag. The property name is any fully-qualified
                           URI.
            </summary>
            <remarks>
                       <para>For example if the parser supports a property
                               <code>http://apache.org/xml/properties/schema/external-schemaLocation</code>
                           then this can be set using the value of the Configuration property:
                               <code>http://saxon.sf.net/feature/parserProperty?uri=http%3A//apache.org/xml/properties/schema/external-schemaLocation</code>
                           to the required value.</para>
                   
            </remarks>
        </member>
        <member name="F:Saxon.Api.FeatureKeys.XQUERY_ALLOW_UPDATE">
            <summary>Determines whether XQuery Update syntax is accepted.
            </summary>
            <remarks>
                       <para>If true, update syntax is accepted, if false, it is not accepted. Setting the value to 
                           true does not mean that the query has to use update syntax, only that it may do so.</para>
                       <para>From Saxon 9.6, XQuery Update syntax and XQuery 3.0 syntax can be mixed, although
                           this combination is not defined by any W3C specification at the time of writing.</para>
                       <para>This option can be set for a particular XQuery compilation. When the option is set at
                           the <code>Configuration</code> level, it acts as a default.</para>
                       <para>On the command line, this option is combined with the option "discard" which
                           indicates that updates are allowed, but the updates are not written back to
                           filestore. This does not correspond to any option in the Java API, where writing an
                           updated document back to filestore only happens if explicitly requested.</para>
                   
            </remarks>
        </member>
        <member name="F:Saxon.Api.FeatureKeys.XQUERY_CONSTRUCTION_MODE">
            <summary>This option defines the default value of the construction mode in the XQuery static
                           context (overridable in the query prolog).
            </summary>
            <remarks>
                       <para>This option can be set for a particular XQuery compilation. When the option is set at
                           the <code>Configuration</code> level, it acts as a default.</para>
                   
            </remarks>
        </member>
        <member name="F:Saxon.Api.FeatureKeys.XQUERY_DEFAULT_ELEMENT_NAMESPACE">
            <summary>This property defines the default namespace for elements and types that are not
                           qualified by a namespace prefix.
            </summary>
            <remarks>
                       <para>This option can be set for a particular XQuery compilation. When the option is set at
                           the <code>Configuration</code> level, it acts as a default.</para>
                   
            </remarks>
        </member>
        <member name="F:Saxon.Api.FeatureKeys.XQUERY_DEFAULT_FUNCTION_NAMESPACE">
            <summary>This property defines the default namespace for function names that are not qualified
                           by a namespace prefix.
            </summary>
            <remarks>
                       <para>This option can be set for a particular XQuery compilation. When the option is set at
                           the <code>Configuration</code> level, it acts as a default.</para>
                   
            </remarks>
        </member>
        <member name="F:Saxon.Api.FeatureKeys.XQUERY_EMPTY_LEAST">
            <summary>This property defines how the empty sequence is handled in XQuery sorting (the "order
                           by" clause). If true, <code>()</code> comes at the start of the sorted sequence; if
                           false, it comes last.
            </summary>
            <remarks>
                       <para>This option can be set for a particular XQuery compilation. When the option is set at
                           the <code>Configuration</code> level, it acts as a default.</para>
                   
            </remarks>
        </member>
        <member name="F:Saxon.Api.FeatureKeys.XQUERY_INHERIT_NAMESPACES">
            <summary>This property defines the default value of the <code>inherit-namespaces</code>
                           property in the XQuery static context.
            </summary>
            <remarks>
                       <para>This option can be set for a particular XQuery compilation. When the option is set at
                           the <code>Configuration</code> level, it acts as a default.</para>
                   
            </remarks>
        </member>
        <member name="F:Saxon.Api.FeatureKeys.XQUERY_MULTIPLE_MODULE_IMPORTS">
            <summary>If the value is false, then when an <code>import module</code> declaration is
                           encountered for a module URI that is already among the known loaded modules (or
                           modules in the process of being compiled), the <code>import module</code> is treated
                           as a reference to the existing module. If the value is true, the system first checks
                           whether the supplied "location hints" match the known location of the existing
                           module, and the existing module is used only if there is a match.
            </summary>
        </member>
        <member name="F:Saxon.Api.FeatureKeys.XQUERY_PRESERVE_BOUNDARY_SPACE">
            <summary>This property defines whether "boundary space" (insignificant space in direct element
                           constructors) should be retained or not.
            </summary>
            <remarks>
                       <para>This option can be set for a particular XQuery compilation. When the option is set at
                           the <code>Configuration</code> level, it acts as a default.</para>
                   
            </remarks>
        </member>
        <member name="F:Saxon.Api.FeatureKeys.XQUERY_PRESERVE_NAMESPACES">
            <summary>This property defines whether unused namespace declarations are retained by XQuery
                           element copy operations.
            </summary>
            <remarks>
                       <para>This option can be set for a particular XQuery compilation. When the option is set at
                           the <code>Configuration</code> level, it acts as a default.</para>
                   
            </remarks>
        </member>
        <member name="F:Saxon.Api.FeatureKeys.XQUERY_REQUIRED_CONTEXT_ITEM_TYPE">
            <summary>This property defines the default expected context item type for a query.
            </summary>
            <remarks>
                       <para>This option can be set for a particular XQuery compilation. When the option is set at
                           the <code>Configuration</code> level, it acts as a default.</para>
                   
            </remarks>
        </member>
        <member name="F:Saxon.Api.FeatureKeys.XQUERY_SCHEMA_AWARE">
            <summary>A query will automatically be schema-aware if it contains an <code>import
                               schema</code> declaration. This property allows a query to be marked as
                           schema-aware even if it contains no <code>import schema</code> declaration. It is
                           necessary for a query to be compiled as schema-aware if it is to handle typed
                           (validated) input documents in which nodes have type annotations based on their
                           schema-defined type.
            </summary>
            <remarks>
                       <para>This option can be set for a particular XQuery compilation. When the option is set at
                           the <code>Configuration</code> level, it acts as a default.</para>
                   
            </remarks>
        </member>
        <member name="F:Saxon.Api.FeatureKeys.XQUERY_STATIC_ERROR_LISTENER_CLASS">
            <summary>The specified class is instantiated to create an <code>ErrorListener</code>, and all
                           reports of static errors in a query will go to this <code>ErrorListener</code>.
            </summary>
            <remarks>
                       <para>This option can be set for a particular XQuery compilation. When the option is set at
                           the <code>Configuration</code> level, it acts as a default.</para>
                       <para>In the absence of this property, the global <code>ErrorListener</code> specified as
                           the value of the <see cref="F:Saxon.Api.FeatureKeys.ERROR_LISTENER_CLASS"/>
                           property is used.</para>
                   
            </remarks>
        </member>
        <member name="F:Saxon.Api.FeatureKeys.XQUERY_VERSION">
            <summary>This property determines the version of XQuery used by the
                           <code>Configuration</code>.
            </summary>
            <remarks>
                       <para>From Saxon 9.8, an XQuery 3.1 processor is always used by default. So setting this
                           property has no effect.</para>
                       
                   
            </remarks>
        </member>
        <member name="F:Saxon.Api.FeatureKeys.XSD_VERSION">
            <summary>This property determines the version of XML Schema used by the
                           <code>Configuration</code>.
            </summary>
            <remarks>
                       <para>From Saxon 9.8, the default is XSD 1.1. If XSD 1.0 is
                           selected, XSD 1.1 features will be rejected, with the exception of the version
                           control attributes that allow sections of the schema to be marked as requiring XSD
                           1.0 or XSD 1.1.</para>
                   
            </remarks>
        </member>
        <member name="F:Saxon.Api.FeatureKeys.XSLT_ENABLE_ASSERTIONS">
            <summary>This property indicates whether assertions (XSLT 3.0 xsl:assert instructions) are
                           enabled or disabled. They are disabled by default. Setting this property on causes
                           assertions to be enabled at compile time for all XSLT packages compiled using the
                           default configuration options.
            </summary>
            <remarks>
                       <para>This option can be set for a particular XSLT compilation. When the option is set at
                           the <code>Configuration</code> level (or on a <code>TransformerFactory</code>), it
                           acts as a default.</para>
                       <para>If assertions have been enabled at compile time for a particular package, they can
                           still be disabled at run-time (for all packages) by setting an option on the
                               <code>Xslt30Transformer</code>. But if assertions were disabled at compile time,
                           enabling them at run-time has no effect.</para>
                   
            </remarks>
        </member>
        <member name="F:Saxon.Api.FeatureKeys.XSLT_INITIAL_MODE">
            <summary>This property indicates the name of a mode within a stylesheet in which execution
                           (using template rules) should begin.
            </summary>
            <remarks>
                       <para>This option can be set for a particular XSLT transformation. When the option is set
                           at the <code>Configuration</code> (or on a <code>TransformerFactory</code>), it acts
                           as a default.</para>
                   
            </remarks>
        </member>
        <member name="F:Saxon.Api.FeatureKeys.XSLT_INITIAL_TEMPLATE">
            <summary>This property indicates the name of a named template within a stylesheet where
                           execution should begin.
            </summary>
            <remarks>
                       <para>This option can be set for a particular XSLT transformation. When the option is set
                           at the <code>Configuration</code> level (or on a <code>TransformerFactory</code>),
                           it acts as a default.</para>
                       <para>Specifically, if the transformation is performed using the <code>transform()</code>
                           method of class <code>net.sf.saxon.s9api.XsltTransformer</code>, then the transformation
                           will proceed by calling the relevant named template, rather than by applying templates
                           to the supplied source node. It will also affect other APIs built on top of the 
                           <code>XsltTransformer</code>, notably the JAXP transformation interface, which in turn
                           is used by many higher-level interfaces such as Ant. Indeed, the main purpose of this
                           configuration option is to allow named-template stylesheet invocation using the JAXP 
                           interface, which was designed without this feature in mind.</para>
                       <para>This configuration option is ignored when using an <code>net.sf.saxon.s9api.Xslt30Transformer</code>,
                           or other interfaces built on top of an <code>Xslt30Transformer</code>, for example the
                           <code>net.sf.saxon.Transform</code> command line interface.</para>
                   
            </remarks>
        </member>
        <member name="F:Saxon.Api.FeatureKeys.XSLT_SCHEMA_AWARE">
            <summary>This property indicates whether stylesheets should be compiled with the ability to
                           handle schema-typed input documents. By default a stylesheet is compiled to handle
                           such input if it contains an <code>xsl:import-schema</code> instruction, and not
                           otherwise. It is necessary for a stylesheet to be compiled as schema-aware if it is
                           to handle typed (validated) input documents in which nodes have type annotations
                           based on their schema-defined type.
            </summary>
            <remarks>
                       <para>This option can be set for a particular XSLT compilation. When the option is set at
                           the <code>Configuration</code> level (or on a <code>TransformerFactory</code>), it
                           acts as a default.</para>
                   
            </remarks>
        </member>
        <member name="F:Saxon.Api.FeatureKeys.XSLT_STATIC_ERROR_LISTENER_CLASS">
            <summary>The specified class is instantiated to create an <code>ErrorListener</code>, and all
                           reports of static errors in a stylesheet will go to this
                           <code>ErrorListener</code>.
            </summary>
            <remarks>
                       <para>This option can be set for a particular XSLT compilation. When the option is set at
                           the <code>Configuration</code> level (or on a <code>TransformerFactory</code>), it
                           acts as a default.</para>
                       <para>In the absence of this property, the global <code>ErrorListener</code> specified as
                           the value of the <see cref="F:Saxon.Api.FeatureKeys.ERROR_LISTENER_CLASS"/>
                           property is used.</para>
                   
            </remarks>
        </member>
        <member name="F:Saxon.Api.FeatureKeys.XSLT_STATIC_URI_RESOLVER_CLASS">
            <summary>This property defines a <code>URIResolver</code> used when dereferencing the URIs
                           that appear in the <code>href</code> attributes of the <code>xsl:include</code> and
                               <code>xsl:import</code> declarations. Note that this defaults to the setting of
                           the global <code>URI_RESOLVER</code> property.
            </summary>
            <remarks>
                       <para>This option can be set for a particular XSLT compilation. When the option is set at
                           the <code>Configuration</code> level (or on a <code>TransformerFactory</code>), it
                           acts as a default.</para>
                       <para>In the absence of this property, the global <code>URIResolver</code> specified as the
                           value of the <see cref="F:Saxon.Api.FeatureKeys.URI_RESOLVER_CLASS"/> property
                           is used.</para>
                   
            </remarks>
        </member>
        <member name="F:Saxon.Api.FeatureKeys.XSLT_VERSION">
            <summary>This property determines the version of XSLT to be supported by default.
            </summary>
            <remarks>
                       <para>From Saxon 9.8, an XSLT 3.0 processor is always used by default. So setting this
                           property has no effect.</para>
                       
                   
            </remarks>
        </member>
        <member name="F:Saxon.Api.FeatureKeys.REGEX_BACKTRACKING_LIMIT">
            <summary>This property sets a limit on the amount of backtracking performed during regular expression evaluation.
            </summary>
            <remarks>
                       <para>The default is 10000000 (ten million) which typically represents an evaluation time of about ten seconds.
                       After this time, evaluation of the regular expression will fail rather than making further attempts to find a
                       match. If this limit is reached, it often suggests that there might be a better way of writing the regular expression.
                       The value can be set to -1 (minus one) to mean "unlimited".</para>
                       <para>Excessive backtracking is usually caused by nested loops in the regular expression, combined with processing
                       of long input strings. Try to ensure that when nested loops are used, there is an unambiguous condition that causes
                       the inner loop to terminate. For example <code>(/[^/]*)+</code> is fine (it matches a sequence of path segments separated
                           by <code>/</code> characters), because the presence of <code>/</code> forces the inner loop to terminate. By contrast,
                           <code>(/.*)+</code> matches the same input, but in many different ways, which could lead to excessive backtracking
                       to no useful purpose.</para>
                   
            </remarks>
        </member>
        <member name="F:Saxon.Api.FeatureKeys.XPATH_VERSION_FOR_XSD">
            <summary>The XSD 1.1 specification states that XPath version 2.0 is used for expressions appearing in assertions and type
                           alternatives. This option allows XPath 3.0 or 3.1 to be used instead.
            </summary>
            <remarks>
                       <para>The recognized values are the integers 20, 30, and 31 representing versions 2.0, 3.0, and 3.1 respectively.</para>           
                   
            </remarks>
        </member>
        <member name="F:Saxon.Api.FeatureKeys.XPATH_VERSION_FOR_XSLT">
            <summary>The XSLT 3.0 specification states that processors are required to support XPath 3.0 expressions within stylesheets, together
                           with some extensions (maps) selected from the XPath 3.1 specification. Support for the full syntax of XPath 3.1 is
                           optional, but it is the default in Saxon. This option allows a different XPath language level to be selected.
            </summary>
            <remarks>
                       <para>The integer values 20, 30, and 31 denote XPath 2.0, 3.0, and 3.1 respectively, while the value 305 denotes XPath 3.0
                           with the extensions defined in the XSLT 3.0 specification.</para>
                   
            </remarks>
        </member>
        <member name="F:Saxon.Api.FeatureKeys.THRESHOLD_FOR_FUNCTION_INLINING">
            <summary>Saxon-EE performs inlining of user-defined functions that are sufficiently simple: they must not be recursive,
                           and they must be below a certain size. This option defines the size.
            </summary>
            <remarks>
                       <para>The value is (roughly) the number of nodes in the expression tree representing the function body. This
                           includes both explicit subexpressions, and subexpressions added by Saxon itself to perform implicit
                           operations such as type checking or conversion of function arguments. The default value is 100.</para>
                   
            </remarks>
        </member>
        <member name="F:Saxon.Api.FeatureKeys.THRESHOLD_FOR_HOTSPOT_BYTE_CODE">
            <summary>Saxon-EE generates bytecode to give faster execution of frequently-evaluated subexpressions.
                           Bytecode is generated when a candidate expression has been evaluated a certain number of
                           times, controlled by this parameter.
                       
            </summary>
            <remarks>
                       <para>Setting this parameter to 0 (or any negative value) has the effect of disabling bytecode
                           generation completely. Setting the parameter to a positive value has the effect of enabling
                           bytecode generation if it is not already enabled. Setting the value to 1 (one) causes bytecode
                           to be generated for candidate expressions the first time it is executed.</para>
                   
            </remarks>
        </member>
        <member name="F:Saxon.Api.FeatureKeys.ALLOWED_PROTOCOLS">
            <summary>The value is a comma-separated list of permitted protocols. A protocol is the 
                           scheme portion of a URI, or in the case of the JAR protocol, "jar" 
                           plus the scheme portion separated by colon. The value "all" gives access
                           to all protocols (which is the default). The value "" (empty string) disallows
                           all external resource access. (The format is thus the same as for 
                           <code>XMLConstants.ACCESS_EXTERNAL_SCHEMA</code> and similar attributes.)
                       
            </summary>
            <remarks>
                       <para>The value constrains access by Saxon (but not by underlying software, such
                           as the XML parser) to resources including the following:</para>
                       
                       <list>
                           <item>Stylesheet modules</item>
                           <item>Schema documents</item>
                           <item>Query modules</item>
                           <item>Documents referenced from a stylesheet or query using functions such
                               as <code>fn:doc</code>, <code>fn:document</code>, <code>fn:unparsed-text</code>,
                               <code>fn:collection</code>, <code>fn:json-doc</code>, <code>fn:transform</code>, or by the
                               <code>xsl:source-document</code> instruction.</item>
                           <item>Resources obtained using Saxon-supplied extension functions such as
                               those in the EXPath file library (but it does not affect user-supplied
                               extension functions).</item>
                       </list>
                       <para>The constraint applies to the URI used to request
                           the resource; the constraint is applied by the standard URI resolvers, but if 
                           user-supplied resolvers are used (such as a <code>URIResolver</code>), they can decide
                           whether to apply the restrictions or not.</para>
                       <para>The constraint applies to URIs used as locations or location hints, not to URIs used as names. So
                       for XSD it applies to a schemaLocation, not a targetNamespace; for XQuery it applies to module
                       location hints, not to module URIs. In the case of XSLT packages, resolution from a package name
                       to a location is always under user/application control, so Saxon imposes no restrictions.</para>
                       <para>The format is the same as for <code>XMLConstants.ACCESS_EXTERNAL_SCHEMA</code>: either <code>"all"</code> to allow
                           all schemes/protocols, or a comma-separated list of scheme names such as <code>"http"</code>, <code>"file"</code>, <code>"ftp"</code>.
                           For a JAR file scheme, use the format <code>"jar:<i>scheme</i>"</code>, for example <code>"jar:file"</code>. A zero-length
                           string disallows all schemes.</para>
                   
            </remarks>
        </member>
        <member name="F:Saxon.Api.FeatureKeys.RETAIN_NODE_FOR_DIAGNOSTICS">
            <summary>By default, Saxon attempts to ensure that the run-time code contains no links to the original source stylesheet tree.
                           This allows the garbage collector to free memory.
                       
            </summary>
            <remarks>
                       <para>If this option is set, then <code>Location</code> objects held in the run-time expression tree may contain a link
                           to an element node in the source stylesheet, enabling a user-written <code>ErrorListener</code> to produce
                           improved diagnostics. This may be an appropriate setting to use, for example, in an IDE.</para>
                       <para>Links to source nodes are not retained in an exported SEF file, regardless of this setting.</para>
                   
            </remarks>
        </member>
        <member name="F:Saxon.Api.FeatureKeys.ALLOW_UNRESOLVED_SCHEMA_COMPONENTS">
            <summary>The W3C XSD specification (both 1.0 and 1.1) states that an unresolved
                   reference to an absent schema component does not automatically make the schema
                   invalid; the schema should be usable for validation provided that the missing
                   components are not actually needed in a particular validation episode.
                 
            </summary>
            <remarks>
                 <para>However, the W3C XSD conformance tests treat such an unresolved reference
                 as an error; the test is expected to report the schema as invalid. And this
                 is the way most schema processors actually operate, and probably what most
                 users would expect.</para>
                 <para>By default, the Saxon schema processor reports an unresolved reference
                 as an error in the schema.</para>
                 <para>If this option is set, then Saxon attempts to repair the schema so that
                 it is usable for validation, by substituting the missing components with default
                 components: for example if an attribute declaration refers to a type that has
                 not been defined, then <code>xs:error</code> is substituted, making any instance
                 of the attribute invalid.</para>
                 
            </remarks>
        </member>
        <member name="F:Saxon.Api.FeatureKeys.ZIP_URI_PATTERN">
            <summary>This is used by the standard Collection Finder and may not be relevant
                           if a custom Collection Finder is in use.
                       
            </summary>
            <remarks>
                       <para>If the absolutized URI passed to the collection() function matches
                       this pattern, then the URI will be treated as a reference to a ZIP file
                       (and will therefore fail if the URI does not resolve to a resource that can
                       be opened as a ZIP file).</para>
                       
                   
            </remarks>
        </member>
        <member name="T:Saxon.Api.XdmValue">
            <summary>
            A value in the XDM data model. A value is a sequence of zero or more
            items, each item being an atomic value, a node, or a function item.
            </summary>
            <remarks>
            <para>An <c>XdmValue</c> is immutable.</para>
            <para>A sequence consisting of a single item <i>may</i> be represented
            as an instance of <see cref="T:Saxon.Api.XdmItem"/>, which is a subtype of <c>XdmValue</c>. However,
            there is no guarantee that all single-item sequences will be instances of
            <c>XdmItem</c>: if you want to ensure this, use the <see cref="P:Saxon.Api.XdmValue.Simplify"/> property.</para>
            <para>There are various ways of creating an <c>XdmValue</c>. To create an atomic
            value, use one of the constructors on <see cref="T:Saxon.Api.XdmAtomicValue"/> (which is a subtype of <c>XdmValue</c>).
            To construct an <see cref="T:Saxon.Api.XdmNode"/> (another subtype) by parsing an XML document, or by wrapping a DOM document,
            use a <see cref="T:Saxon.Api.DocumentBuilder"/>. To create a sequence of values, use the <see cref="M:Saxon.Api.XdmValue.Append(Saxon.Api.XdmValue)"/>
            method on this class to form a list from individual items or sublists.</para>
            <para>An <c>XdmValue</c> is also returned as the result of evaluating a query
            using the XQuery and XPath interfaces.</para>
            <para>The subtype <see cref="T:Saxon.Api.XdmEmptySequence"/> represents an empty sequence: an
            <c>XdmValue</c> of length zero. Again, there is no guarantee that every empty sequence
            will be represented as an instance of <c>XdmEmptySequence</c>, unless you use
            the <c>Simplify</c> property.</para>
            </remarks>
        </member>
        <member name="M:Saxon.Api.XdmValue.#ctor(System.Collections.Generic.IEnumerable{Saxon.Api.XdmItem})">
            <summary>
            Create a value from a collection of items.
            </summary>
            <param 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>
        </member>
        <member name="M:Saxon.Api.XdmValue.Select``2(Saxon.Api.Step{``0,``1})">
            <summary>
            Get an <c>IEnumerable</c> by applying a <c>Step</c> to the items in this value. This operation
            is analogous to the <c>SelectMany</c> operation in C#, or to the "!" operator
            in XPath.
            </summary>
            <typeparam name="TInput">Input items to the <c>Step</c> function, which can be subclass of <c>XdmItem</c></typeparam>
            <typeparam name="TResult">Result items to the <c>Step</c> function, which can be subclass of <c>XdmItem</c></typeparam>
            <param name="step">The <c>Step</c> to be applied to the items in this value.</param>
            <returns>An <c>IEnumerable</c> of items obtained by replacing each item X in this value by the items obtained
            by applying the <c>Step</c> function to X.</returns>
        </member>
        <member name="M:Saxon.Api.XdmValue.Concat``1(System.Collections.Generic.IEnumerable{``0},System.Collections.Generic.IEnumerable{``0})">
            <summary>
            Concatenate two <c>IEnumerable</c> objects of <c>XdmItem</c> objects or items of its subclass.
            </summary>
            <typeparam name="TInput">The types of object to enumerate. The object must be an <c>XdmItem</c> or a derived type.</typeparam>
            <param name="first">The first enumerable object</param>
            <param name="second">The second enumerable object</param>
            <returns>The enumerable object as a result of the concatenation.</returns>
        </member>
        <member name="M:Saxon.Api.XdmValue.Where``1(Saxon.Api.IPredicate{``0})">
            <summary>
            Get the enumerable object of items that satisfy a supplied <c>Predicate</c>.
            </summary>
            <typeparam name="T">The types of object to enumerate. The object must be an <c>XdmItem</c> or a derived type.</typeparam>
            <param name="predicate">The predicate to be applied</param>
            <returns>An enumerable of items that satisfy the suppplied <c>Predicate</c>.</returns>
        </member>
        <member name="M:Saxon.Api.XdmValue.AnyMatch``1(Saxon.Api.IPredicate{``0})">
            <summary>
            Returns whether any items of this <c>XdmValue</c> match the provided predicate.
            May not evaluate the predicate on all items if not necessary for 
            determining the result. 
            </summary>
            <typeparam name="T">The types of object in the enumerable. The object must be an <c>XdmItem</c> or a derived type.</typeparam>
            <param name="predicate">The predicate to apply to items of this <c>XdmValue</c></param>
            <returns>True if any items of the <c>XdmValue</c> match the provided predicate, otherwise false.</returns>
        </member>
        <member name="M:Saxon.Api.XdmValue.AllMatch``1(Saxon.Api.IPredicate{``0})">
            <summary>
            Returns whether all items of this <c>XdmValue</c> match the provided predicate.
            May not evaluate the predicate on all items if not necessary for determining the result.
            </summary>
            <typeparam name="T">The types of object in the enumerable. The object must be an <c>XdmItem</c> or a derived type.</typeparam>
            <param name="predicate">The predicate to apply to items of this <c>XdmValue</c></param>
            <returns><c>true</c> if either all items of the <c>XdmValue</c> match the provided predicate or the <c>XdmValue</c> is empty, otherwise <c>false</c></returns>
        </member>
        <member name="M:Saxon.Api.XdmValue.#ctor(System.Collections.Generic.IEnumerator{Saxon.Api.XdmItem})">
            <summary>
            Create an <c>XdmValue</c> from an enumerator of <c>XdmItem</c> objects.
            </summary>
            <param name="items">An enumerator of <c>XdmItem</c> objects</param>
        </member>
        <member name="M:Saxon.Api.XdmValue.Append(Saxon.Api.XdmValue)">
            <summary>
            Create a new <c>XdmValue</c> by concatenating the sequences of items in 
            this <c>XdmValue</c> and another <c>XdmValue</c>.
            </summary>
            <remarks>
            Neither of the input <c>XdmValue</c> objects is modified by this operation.
            </remarks>
            <param name="otherValue">
            The other <c>XdmValue</c>, whose items are to be appended to the items from this <c>XdmValue</c>.
            </param>
        </member>
        <member name="M:Saxon.Api.XdmValue.Wrap(net.sf.saxon.om.Sequence)">
            <summary>
            Create an <c>XdmValue</c> from an underlying Saxon <c>Sequence</c> 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.
            </summary>
            <param name="value">An object representing an XDM value in the
            underlying Saxon implementation. If the parameter is null,
            the method returns null.</param>
            <returns>An <c>XdmValue</c> that wraps the underlying Saxon XDM value
            representation.</returns>
        </member>
        <member name="M:Saxon.Api.XdmValue.MakeValue(System.Object)">
            <summary>
            Make an XDM value from a .NET object. 
            </summary>
            <remarks>
            The supplied object may be any of the following:
            <list>
            <item>An instance of <c>XdmValue</c> (for example an <c>XdmAtomicValue</c>, 
            <c>XdmMap</c>, <c>XdmArray</c> or <c>XdmNode</c>), which is returned unchanged</item>
            <item>An instance of Saxon's Java class <c>net.sf.saxon.om.Sequence</c>, which is wrapped
            as an <c>XdmValue</c></item>
            <item>An instance of <c>IDictionary</c> (which is wrapped as an <c>XdmMap</c> using the method <see cref="M:Saxon.Api.XdmMap.MakeMap(System.Collections.IDictionary)"/>)</item>
            <item>An array of objects, which are converted by applying these rules recursively,
            and then wrapped as an <c>XdmArray</c>.</item>
            </list>
            </remarks>
            <param name="o">The supplied object</param>
            <returns>The result of conversion if successful.</returns>
        </member>
        <member name="M:Saxon.Api.XdmValue.Unwrap">
            <summary>
            Extract the underlying Saxon <c>Sequence</c> object from an <c>XdmValue</c>.
            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.
            </summary>
            <returns>An object representing the XDM value in the
            underlying Saxon implementation.</returns>
        </member>
        <member name="M:Saxon.Api.XdmValue.GetList">
            <summary>
            Get the sequence of items in the form of an <c>IList</c>.
            </summary>
            <returns>
            The list of items making up this XDM value. Each item in the list
            will be an object of type <c>XdmItem</c>.
            </returns>        
        </member>
        <member name="M:Saxon.Api.XdmValue.System#Collections#Generic#IEnumerable{Saxon#Api#XdmItem}#GetEnumerator">
            <summary>
            Get the sequence of items in the form of an <c>IEnumerator</c>.
            </summary>
            <returns>
            An enumeration over the list of items making up this XDM value. Each item in the list
            will be an object of type <c>XdmItem</c>.
            </returns>    
        </member>
        <member name="M:Saxon.Api.XdmValue.GetEnumerator">
            <summary>
            Get the sequence of items in the form of an <c>IEnumerator</c>.
            </summary>
            <returns>
            An enumeration over the list of items making up this XDM value. Each item in the list
            will be an object of type <c>XdmItem</c>.
            </returns>    
        </member>
        <member name="M:Saxon.Api.XdmValue.ItemAt(System.Int32)">
            <summary>
            Get the i'th item in the value, counting from zero.
            </summary>
            <param name="i">The item that is required, counting the first item in the sequence as item zero.</param>
            <returns>The i'th item in the sequence making up the value, counting from zero.</returns>
        </member>
        <member name="M:Saxon.Api.XdmValue.ToString">
            <summary>
            Create a string representation of the value. The is the result of serializing
            the value using the adaptive serialization method.
            </summary>
            <returns>A string representation of the value.</returns>
        </member>
        <member name="M:Saxon.Api.XdmValue.DocumentOrder">
            <summary>
            Return a new <c>XdmValue</c> containing the nodes present in this <c>XdmValue</c>,
            with duplicates eliminated, and sorted into document order.
            </summary>
            <returns>The same nodes, sorted into document order, with duplicates eliminated.</returns>
        </member>
        <member name="P:Saxon.Api.XdmValue.Count">
            <summary>
            Get the number of items in the sequence.
            </summary>
            <returns>
            The number of items in the sequence. Note that for a single item (including
            a map or an array) this always returns 1 (one).
            </returns> 
        </member>
        <member name="P:Saxon.Api.XdmValue.Simplify">
            <summary>
            Simplify an XDM value: that is, reduce it to the simplest possible form.
            </summary>
            <remarks>
            <list>
            <item>If the sequence is empty, the result will be an instance of <c>XdmEmptySequence</c></item>
            <item>If the sequence is a single node, the result will be an instance of <c>XdmNode</c></item>
            <item>If it is a single atomic value, it will be an instance of <c>XdmAtomicValue</c></item>
            <item>If it is a map, it will be an instance of <c>XdmMap</c></item>
            <item>If it is an array, it will be an instance of <c>XdmArray</c></item>
            <item>If it is any other kind of function, it will be an instance of <c>XdmFunctionItem</c></item>
            <item>If it is a wrapper around a .NET object, it will be an instance of <c>XdmExternalObjectValue</c></item>
            </list>
            </remarks>
            <returns>The XDM value reduced to the simplest possible form.</returns>
        </member>
        <member name="T:Saxon.Api.XdmExternalObjectValue">
            <summary inherits="XdmItem">
            The class <c>XdmExternalObjectValue</c> represents an XDM item that wraps an external .NET object.
            As such, it is outside the scope of the W3C XDM specification (but permitted as an extension).
            </summary>
        </member>
        <member name="T:Saxon.Api.XdmItem">
            <summary inherits="XdmValue">
            The class <c>XdmItem</c> represents an item in a sequence, as defined
            by the XDM data model. An item may be an atomic value, a node, a function (including maps
            and arrays), or an external object.
            </summary>
            <remarks>
            <para>An item is a member of a sequence, but it can also be considered as
            a sequence (of length one) in its own right. <c>XdmItem</c> is a subtype
            of <c>XdmValue</c> because every item in the XDM data model is also a
            value.</para>
            <para>It cannot be assumed that every sequence of length one will always be 
            represented by an <c>XdmItem</c>. It is quite possible for an <c>XdmValue</c>
            that is not an <c>XdmItem</c> to hold a singleton sequence. Use <see cref="P:Saxon.Api.XdmValue.Simplify"/> 
            to ensure that a singleton is represented as an <c>XdmItem</c>.</para>
            </remarks> 
        </member>
        <member name="M:Saxon.Api.XdmItem.IsAtomic">
            <summary>
            Determine whether the item is an atomic value.
            </summary>
            <returns>
            True if the item is an atomic value, false if it is a node, function, or external object.
            </returns>
        </member>
        <member name="M:Saxon.Api.XdmItem.IsNode">
            <summary>
            Determine whether the item is a node or some other type of item.
            </summary>
            <returns>True if the item is a node, false if it is an atomic value or a function (including maps and arrays).</returns>
        </member>
        <member name="M:Saxon.Api.XdmItem.GetStringValue">
            <summary>
            Get the string value of the item. 
            </summary>
            <remarks>
            <list>
            <item>For an atomic value, the result is the same as casting the value to a string.</item>
            <item>For a node, the method returns the string
            value of the node. This is not the same as the result of <see cref="M:Saxon.Api.XdmNode.ToString"/>, which
            returns the result of serializing the node.</item>
            <item>For a function, including a map or array, the result is an error.</item>
            <item>For an external object, the result is the same as the result of calling <c>ToString()</c>
            on the external object.</item>
            </list>
            <para>In all cases the result is the same as applying the XPath <c>string()</c> function.</para>
            </remarks>
            <returns>The result of converting the item to a string.</returns>
        </member>
        <member name="M:Saxon.Api.XdmItem.Matches(Saxon.Api.XdmItemType)">
            <summary>
            Determine whether this item matches a given item type.
            </summary>
            <param name="typei">The item type to be tested against this item</param>
            <returns>True if the item matches this item type, false if it does not match.</returns>
        </member>
        <member name="M:Saxon.Api.XdmExternalObjectValue.#ctor(System.Object)">
            <summary>
            Constructor to create an <c>XdmExternalObjectValue</c> that wraps a supplied .NET object.
            </summary>
            <param name="o">The supplied .NET object.</param>
        </member>
        <member name="M:Saxon.Api.XdmExternalObjectValue.IsAtomic">
            <summary>
            Determine whether the item is an atomic value.
            </summary>
            <returns>
            False (the item is not an atomic value).
            </returns>
        </member>
        <member name="M:Saxon.Api.XdmExternalObjectValue.Equals(Saxon.Api.XdmExternalObjectValue)">
            <summary>
            Compare two external objects for equality. Two instances of <c>XdmExternalObjectValue</c> are equal
            if the .NET objects that they wrap are equal.
            </summary>
            <param name="other">The object to be compared</param>
            <returns>True if the other object is an <c>XdmExternalObjectValue</c> and the two wrapped objects are 
            equal under the equals method.</returns>
        </member>
        <member name="M:Saxon.Api.XdmExternalObjectValue.GetHashCode">
            <summary>
            Return a hash code for the object. This respects the semantics of <c>equals(Object)</c>.
            </summary>
            <returns>A suitable hash code.</returns>
        </member>
        <member name="M:Saxon.Api.XdmExternalObjectValue.GetExternalObject">
            <summary>
            Get the wrapped .NET object.
            </summary>
            <returns>The wrapped object.</returns>
        </member>
        <member name="M:Saxon.Api.XdmExternalObjectValue.ToString">
            <summary>
            Get the result of converting the external value to a string.
            </summary>
            <returns>The result of applying <c>ToString()</c> to the wrapped external object.</returns>
        </member>
        <member name="T:Saxon.Api.XdmAtomicValue">
            <summary inherits="XdmItem">
            The class <c>XdmAtomicValue</c> represents an item in an XDM 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 XDM-specific type <c>xs:untypedAtomic</c>.
            </summary>
            <remarks>
            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>.
            </remarks>
        </member>
        <member name="M:Saxon.Api.XdmAtomicValue.IsAtomic">
            <summary>
            Determine whether the item is an atomic value
            </summary>
            <returns>
            True (the item is an atomic value).
            </returns>
        </member>
        <member name="M:Saxon.Api.XdmAtomicValue.#ctor(System.String)">
            <summary>
            Construct an atomic value of type <c>xs:string</c>
            </summary>
            <param name="str">The string value</param>
        </member>
        <member name="M:Saxon.Api.XdmAtomicValue.#ctor(System.Int64)">
            <summary>
            Construct an atomic value of type <c>xs:integer</c> from a supplied <c>long</c>
            </summary>
            <param name="i">The integer value</param>
        </member>
        <member name="M:Saxon.Api.XdmAtomicValue.#ctor(System.Int32)">
            <summary>
            Construct an atomic value of type <c>xs:integer</c> from a supplied <c>long</c>
            </summary>
            <param name="i">The integer value</param>
        </member>
        <member name="M:Saxon.Api.XdmAtomicValue.#ctor(System.Byte)">
            <summary>
            Construct an atomic value of type <c>xs:integer</c> from a supplied <c>byte</c>
            </summary>
            <param name="i">The integer value, in the range -128 to +127</param>
        </member>
        <member name="M:Saxon.Api.XdmAtomicValue.#ctor(System.Decimal)">
            <summary>
            Construct an atomic value of type <c>xs:decimal</c>
            </summary>
            <param name="d">The decimal value</param>
        </member>
        <member name="M:Saxon.Api.XdmAtomicValue.#ctor(System.Single)">
            <summary>
            Construct an atomic value of type <c>xs:float</c>
            </summary>
            <param name="f">The float value</param>        
        </member>
        <member name="M:Saxon.Api.XdmAtomicValue.#ctor(System.DateTime)">
            <summary>
            Construct an atomic value of type <c>xs:dateTime</c> from a .NET DateTime object
            Here we probe the object for timezone offset information to create the resulting value. 
            </summary>
            <param name="dt">The DateTime object value</param>
        </member>
        <member name="M:Saxon.Api.XdmAtomicValue.#ctor(System.DateTimeOffset)">
            <summary>
            Construct an atomic value of type <c>xs:dateTime</c> with a specific timezone offset from a DateTimeOffset object.
            </summary>
            <param name="offset">The DateTimeOffset value</param>
        </member>
        <member name="M:Saxon.Api.XdmAtomicValue.#ctor(System.Double)">
            <summary>
            Construct an atomic value of type <c>xs:double</c>
            </summary>
            <param name="d">The double value</param>
        </member>
        <member name="M:Saxon.Api.XdmAtomicValue.#ctor(System.Boolean)">
            <summary>
            Construct an atomic value of type <c>xs:boolean</c>
            </summary>
            <param name="b">The boolean value</param>
        </member>
        <member name="M:Saxon.Api.XdmAtomicValue.#ctor(System.Uri)">
            <summary>
            Construct an atomic value of type <c>xs:anyURI</c>
            </summary>
            <param name="u">The uri value</param>
        </member>
        <member name="M:Saxon.Api.XdmAtomicValue.#ctor(Saxon.Api.QName)">
            <summary>
            Construct an atomic value of type <c>xs:QName</c>
            </summary>
            <param name="q">The QName value</param>                
        </member>
        <member name="M:Saxon.Api.XdmAtomicValue.#ctor(System.String,Saxon.Api.XdmAtomicType)">
            <summary>
            Construct an atomic value of a given type
            </summary>
            <param 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 name="type">The type given as an <c>XdmAtomicType</c></param>
        </member>
        <member name="M:Saxon.Api.XdmAtomicValue.#ctor(System.String,Saxon.Api.QName,Saxon.Api.Processor)">
            <summary>
            Construct an atomic value of a given built-in or user-defined type
            </summary>
            <example>
              <code>XdmAtomicValue("abcd", QName.XDT_UNTYPED_ATOMIC, processor)</code>
              <para>creates an untyped atomic value containing the string "abcd"</para>
            </example>
            <param 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 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 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>
            <exception cref="T:System.ArgumentException">Thrown if the type is unknown or unsuitable, or if the supplied string is not
            a valid lexical representation of a value of the given type.</exception>
        </member>
        <member name="M:Saxon.Api.XdmAtomicValue.MakeAtomicValue(System.Object)">
            <summary>
            Create an atomic value of a type appropriate to the supplied value. 
            </summary>
            <remarks>
            The supplied value must be one of the following:
            <list>
            <item>An instance of the Saxon Java class <c>net.sf.saxon.value.AtomicValue</c></item>
            <item>A <c>Boolean</c> - returns an instance of <c>xs:boolean</c></item>
            <item>A (signed) <c>int</c>, <c>long</c>, <c>short</c>, or <c>byte</c> - returns an instance of <c>xs:integer</c></item>
            <item>A <c>Char</c> - TODO ???????</item>
            <item>A <c>String</c> - returns an instance of <c>xs:string</c></item>
            <item>A <c>Double</c> - returns an instance of <c>xs:double</c></item>
            <item>A <c>Float</c> - returns an instance of <c>xs:float</c></item>
            <item>A <c>decimal</c> - returns an instance of <c>xs:decimal</c></item>
            <item>A <c>URI</c> - returns an instance of <c>xs:anyURI</c></item>
            <item>A <c>QName</c> - returns an instance of <c>xs:QName</c></item>
            </list>
            </remarks>
            <param name="value">The value to be converted.</param>
            <returns>The converted value</returns>
        </member>
        <member name="M:Saxon.Api.XdmAtomicValue.GetBooleanValue">
            <summary>
            Get the value converted to a boolean using the XPath casting rules.
            </summary>
            <returns>The result of converting to a boolean (Note: this is not the same as the
            effective boolean value).</returns> 
        </member>
        <member name="M:Saxon.Api.XdmAtomicValue.GetLongValue">
            <summary>
            Get the value converted to a long using the XPath casting rules.
            </summary>
            <returns>The result of converting to a long</returns>
        </member>
        <member name="M:Saxon.Api.XdmAtomicValue.GetDoubleValue">
            <summary>
            Get the value converted to a double using the XPath casting rules.
            </summary>
            <remarks>If the value is a string, the XSD 1.1 rules are used, which means that the string
            "+INF" is recognised.</remarks>
            <returns>The result of converting to a double</returns>
        </member>
        <member name="M:Saxon.Api.XdmAtomicValue.GetDecimalValue">
            <summary>
            Get the value converted to a decimal using the XPath casting rules.
            </summary>
            <returns>The result of converting to a decimal</returns>
        </member>
        <member name="M:Saxon.Api.XdmAtomicValue.ToString">
            <summary>
            Convert the atomic value to a string
            </summary>
            <returns>The value converted to a string, according to the rules
            of the XPath cast expression</returns>        
        </member>
        <member name="M:Saxon.Api.XdmAtomicValue.Equals(System.Object)">
            <summary>
            Compare two atomic values for equality
            </summary>
            <param name="other">The object to be compared</param>
            <returns>The result of the equality comparison, using the rules of the
            <c>op:is-same-key()</c> comparison used for comparing key values in maps.</returns>
        </member>
        <member name="M:Saxon.Api.XdmAtomicValue.GetHashCode">
            <summary>
            Get a hash code to support equality comparison
            </summary>
            <returns>A suitable hash code</returns>
        </member>
        <member name="M:Saxon.Api.XdmAtomicValue.GetTypeName">
            <summary>
            Get the name of the value's XDM type
            </summary>
            <returns>The type of the value, as a QName.</returns>
        </member>
        <member name="M:Saxon.Api.XdmAtomicValue.GetTypeName(Saxon.Api.Processor)">
            <summary>
            Get the name of the value's XDM type
            </summary>
            <param name="processor">The <code>Processor</code> object. 
            This parameter is no longer used, but is accepted for backwards compatibility.</param>
            <returns>The type of the value, as a QName.</returns>
        </member>
        <member name="M:Saxon.Api.XdmAtomicValue.GetPrimitiveTypeName">
            <summary>
            Get the name of the primitive type of the value
            </summary>
            <returns>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 <c>xs:untypedAtomic</c>. For the purposes of this method, <c>xs:integer</c> is considered
            to be a primitive type.
            </returns>
        </member>
        <member name="P:Saxon.Api.XdmAtomicValue.Value">
            <summary>Get the value as a CLI object of the nearest equivalent type.</summary>
            <remarks>
            <para>The return type is as follows:</para>
            <list>
            <item><c>xs:string</c> - String</item>
            <item><c>xs:integer</c> - Long</item>
            <item><c>xs:decimal</c> - Decimal</item>
            <item><c>xs:double</c> - Double</item>
            <item><c>xs:float</c> - Float</item>
            <item><c>xs:boolean</c> - Bool</item>
            <item><c>xs:QName</c> - QName</item>
            <item><c>xs:anyURI</c> - Uri</item>
            <item><c>xs:untypedAtomic</c> - String</item>
            <item>wrapped external object - the original external object</item>
            <item>Other types - currently String, but this may change in the future</item>
            </list>
            </remarks>
            <returns>The value converted to the most appropriate CLI type</returns>
        </member>
        <member name="T:Saxon.Api.XdmFunctionItem">
            <summary inherits="XdmItem">
            The class <c>XdmFunctionItem</c> represents an item in an XDM sequence
            that holds a function.
            </summary>
            <remarks>
            <para>Note that there is no guarantee that every <c>XdmValue</c> comprising a single
            function item will be an instance of this class. To force this, use the <c>Simplify</c>
            property of the <c>XdmValue</c>.</para>
            <para>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.</para>
            </remarks>
        </member>
        <member name="M:Saxon.Api.XdmFunctionItem.IsAtomic">
            <summary>
            Determine whether the item is an atomic value
            </summary>
            <returns>
            false (a function item is not an atomic value)
            </returns>
        </member>
        <member name="M:Saxon.Api.XdmFunctionItem.Invoke(Saxon.Api.XdmValue[],Saxon.Api.Processor)">
            <summary>
            Invoke the function
            </summary>
            <param name="arguments">The arguments to the function</param>
            <param name="processor">The Saxon processor, used to provide context information</param>
            <returns>The result of calling the function</returns>
            
        </member>
        <member name="P:Saxon.Api.XdmFunctionItem.FunctionName">
            <summary>
            The name of the function, as a QName
            </summary>
            <returns>The name of the function. The result will be null if the function is anonymous.</returns>
        </member>
        <member name="P:Saxon.Api.XdmFunctionItem.Arity">
            <summary>
            The arity of the function, that is, the number of arguments it expects
            </summary>
            <returns>The number of arguments that the function takes</returns>
        </member>
        <member name="T:Saxon.Api.XdmArray">
            <summary inherits="XdmFunctionItem">
            The class <c>XdmArray</c> represents an array item in an XDM 3.1 sequence:
            this is a new kind of item in the XDM data model. An array is a list of zero or 
            more members, each of which is an arbitrary XDM value. An array is also a function:
            it maps a positive integer to the array member found at that position in the array.
            </summary>
        </member>
        <member name="M:Saxon.Api.XdmArray.#ctor">
            <summary> Constructor to create an empty <c>XdmArray</c></summary>
        </member>
        <member name="M:Saxon.Api.XdmArray.#ctor(Saxon.Api.XdmValue)">
            <summary>Create an <c>XdmArray</c> whose members are single items, corresponding
            one-to-one with the items making up a supplied sequence.</summary>
            <param name="value">A sequence of items; each item becomes a member of the array.</param>
        </member>
        <member name="M:Saxon.Api.XdmArray.#ctor(Saxon.Api.XdmValue[])">
            <summary> Create an <c>XdmArray</c> supplying the members as an array of <c>XdmValue</c> objects.</summary>
             <param name="members">An array of <c>XdmValue</c> objects. Note that subsequent changes 
             to the array will have no effect on the <c>XdmArray</c>.</param>
        </member>
        <member name="M:Saxon.Api.XdmArray.#ctor(System.Collections.Generic.List{Saxon.Api.XdmValue})">
            <summary>Create an <c>XdmArray</c> supplying the members as a list of <c>XdmValue</c> objects</summary>
            <param name="members">A sequence of <c>XdmValue</c> objects. Note that if this is supplied as 
            a list or similar collection, subsequent changes to the list/collection will have no effect on 
            the <c>XdmValue</c>.</param>
            <remarks>Note that the argument can be a single <c>XdmValue</c> representing a sequence, in which case the
             constructed array will have one member for each item in the supplied sequence.</remarks>
        </member>
        <member name="M:Saxon.Api.XdmArray.ArrayLength">
            <summary>
            Get the number of members in the array
            </summary>
            <returns>the number of members in the array.</returns> 
            <remarks>(Note that the <see cref="P:Saxon.Api.XdmValue.Count"/> property returns 1 (one),
            because an XDM array is an item.)</remarks>
        </member>
        <member name="M:Saxon.Api.XdmArray.Get(System.Int32)">
            <summary>
            Get the n'th member in the array, counting from zero.
            </summary>
            <param name="n">the position of the member that is required, counting the first member in 
            the array as member zero</param>
            <returns>the n'th member in the sequence making up the array, counting from zero</returns>
        </member>
        <member name="M:Saxon.Api.XdmArray.Put(System.Int32,Saxon.Api.XdmValue)">
            <summary>
            Create a new array in which one member is replaced with a new value.
            </summary>
            <param name="n">the position of the member that is to be replaced, counting the first member
            in the array as member zero</param>
            <param name="valuei">the new value</param>
            <returns>the new array</returns>
        </member>
        <member name="M:Saxon.Api.XdmArray.AppendMember(Saxon.Api.XdmValue)">
            <summary>
            Append a new member to an array
            </summary>
            <param name="value">the new member</param>
            <returns>a new array, one item longer than the original</returns>
        </member>
        <member name="M:Saxon.Api.XdmArray.Concat(Saxon.Api.XdmArray)">
            <summary>
            Concatenate another array
            </summary>
            <param name="value">the other array</param>
            <returns>a new array, containing the members of this array followed by the members 
            of the other array</returns>
        </member>
        <member name="M:Saxon.Api.XdmArray.AsList">
            <summary>
            Get the members of the array in the form of a list.
            </summary>
            <returns>A list of the members of this array.</returns>
        </member>
        <member name="M:Saxon.Api.XdmArray.MakeArray(System.Object[])">
            <summary>
            Make an XDM array from an object array. Each member of the supplied array
            is converted to a single member in the result array using the method
            <see cref="M:Saxon.Api.XdmValue.MakeValue(System.Object)"/>        
            </summary>
            <param name="o">the array of objects</param>
            <returns>the result of the conversion if successful</returns>
        </member>
        <member name="M:Saxon.Api.XdmArray.MakeArray(System.Boolean[])">
            <summary>
            Make an <c>XdmArray</c> whose members are <c>xs:boolean</c> values       
            </summary>
            <param name="o">the input array of booleans</param>
            <returns>an <c>XdmArray</c> whose members are <c>xs:boolean</c> values corresponding one-to-one with the input</returns>
        </member>
        <member name="M:Saxon.Api.XdmArray.MakeArray(System.Int64[])">
            <summary>
            Make an <c>XdmArray</c> whose members are <c>xs:integer</c> values      
            </summary>
            <param name="o">the input array of long values</param>
            <returns>an <c>XdmArray</c> whose members are <c>xs:integer</c> values corresponding one-to-one with the input</returns>
        </member>
        <member name="M:Saxon.Api.XdmArray.MakeArray(System.Int32[])">
            <summary>
            Make an <c>XdmArray</c> whose members are <c>xs:integer</c> values      
            </summary>
            <param name="o">the input array of int values</param>
            <returns>an <c>XdmArray</c> whose members are <c>xs:integer</c> values corresponding one-to-one with the input</returns>
        </member>
        <member name="M:Saxon.Api.XdmArray.MakeArray(System.Byte[])">
            <summary>
            Make an <c>XdmArray</c> whose members are <c>xs:integer</c> values      
            </summary>
            <param name="o">the input array of byte values</param>
            <returns>an <c>XdmArray</c> whose members are <c>xs:integer</c> values corresponding one-to-one with the input</returns>
        </member>
        <member name="T:Saxon.Api.XdmMap">
            <summary inherits="XdmFunctionItem">
            The class <c>XdmMap</c> represents a map item in an XPath 3.1 sequence:
            this is a new kind of item in the XDM data model. A map is a list of zero or more entries, each of which
            is a pair comprising a key (which is an atomic value) and a value (which is an arbitrary value).
            </summary>
        </member>
        <member name="M:Saxon.Api.XdmMap.#ctor">
            <summary>
            Create an empty <c>XdmMap</c>
            </summary>
        </member>
        <member name="M:Saxon.Api.XdmMap.IsEmpty">
            <summary>
            Ask whether the <c>XdmMap</c> is empty
            </summary>
            <returns>Returns <code>true</code> if this map contains no key-value pairs, that is
            if the <c>Size</c> property is zero.</returns>
        </member>
        <member name="M:Saxon.Api.XdmMap.Put(Saxon.Api.XdmAtomicValue,Saxon.Api.XdmValue)">
            <summary>
            Create a new map containing an additional (key, value) pair.
            If there is an existing entry with the same key, it is removed.
            </summary>
            <param name="key">The key of the new entry.</param>
            <param name="value">The value part of the new entry.</param>
            <returns>A new map containing the additional entry (or replaced entry). The original map is unchanged.</returns>
        </member>
        <member name="M:Saxon.Api.XdmMap.Remove(Saxon.Api.XdmAtomicValue)">
            <summary>
            Create a new map in which the entry for a given key has been removed.
            If there is no entry with the same key, the new map has the same content as the old (it may or may not
            be the same .NET object)
            </summary>
            <param name="key">The key of the entry that is to be removed</param>
            <returns>A map without the specified entry. The original map is unchanged.</returns>
        </member>
        <member name="M:Saxon.Api.XdmMap.AsDictionary">
            <summary>
            Return a corresponding .NET Dictionary collection of keys and values.
            </summary>
            <returns>A mutable Dictionary from atomic values to (sequence) values, containing the
            same entries as this map</returns>
        </member>
        <member name="M:Saxon.Api.XdmMap.KeySet">
            <summary>
            Get the keys present in the map in the form of a set.
            </summary>
            <returns>a set of the keys present in this map, with no defined ordering.</returns>
        </member>
        <member name="M:Saxon.Api.XdmMap.ContainsKey(Saxon.Api.XdmAtomicValue)">
            <summary>
            Returns <code>true</code> if this map contains a mapping for the specified
            key. More formally, returns <code>true</code> if and only if
            this map contains a mapping for a key <code>k</code> such that
            <code>(key==null ? k==null : key.Equals(k))</code>.  (There can be
            at most one such mapping.)
            </summary>
            <param name="key">the key whose presence in this map is to be tested</param>
            <returns><c>true</c> if this map contains a mapping for the specified key</returns>
        </member>
        <member name="M:Saxon.Api.XdmMap.Get(Saxon.Api.XdmAtomicValue)">
            <summary>
            Returns the value to which the specified key is mapped,
            or <c>null</c> if this map contains no mapping for the key.
            </summary>
            <param name="key">the key whose associated value is to be returned. If this is
            not an <c>XdmAtomicValue</c>, the method attempts to construct an
            <c>XdmAtomicValue</c> using the method <see cref="M:Saxon.Api.XdmAtomicValue.MakeAtomicValue(System.Object)"/>;
            it is therefore possible to pass a simple key such as a string or integer.</param>
            <returns>the value to which the specified key is mapped, or
            <c>null</c> if this map contains no mapping for the key</returns>
        </member>
        <member name="M:Saxon.Api.XdmMap.Get(System.String)">
            <summary>
            Returns the value to which the specified key is mapped,
            or <c>null</c> if this map contains no mapping for the key.
            </summary>
            <param name="key">the key whose associated value is to be returned.</param>
            <returns>the value to which the specified key is mapped, or
            <c>null</c> if this map contains no mapping for the key</returns>
        </member>
        <member name="M:Saxon.Api.XdmMap.Get(System.Int64)">
            <summary>
            Returns the value to which the specified key is mapped,
            or <c>null</c> if this map contains no mapping for the key.
            </summary>
            <param name="key">the key whose associated value is to be returned.</param>
            <returns>the value to which the specified key is mapped, or
            <c>null</c> if this map contains no mapping for the key</returns>
        </member>
        <member name="M:Saxon.Api.XdmMap.Values">
            <summary>
            Returns a <c>Collection</c> containing the values found in this map.
            </summary>
            <returns>A collection of the values found in this map, that is, the value
            parts of the key-value pairs. The result may contain duplicates, and the
            order of results is unpredictable.</returns>
        </member>
        <member name="M:Saxon.Api.XdmMap.EntrySet">
            <summary>
            Returns a <c>HashSet</c> view of the mappings contained in this map.
            </summary>
            <returns>a set view of the mappings contained in this map</returns>
        </member>
        <member name="M:Saxon.Api.XdmMap.MakeMap(System.Collections.IDictionary)">
            <summary>
            Static factory method to construct an XDM map by converting each entry
            in a supplied generic collection of key/value pairs; <code>IDictionary</code>. The keys in the 
            Dictionary must be convertible to XDM atomic values using the 
            <see cref="M:Saxon.Api.XdmAtomicValue.MakeAtomicValue(System.Object)"/> method. The associated values 
            must be convertible to XDM sequences
            using the <see cref="M:Saxon.Api.XdmValue.MakeValue(System.Object)"/> method.
            </summary>
            <param name="input">the supplied map</param>
            <returns>the resulting <c>XdmMap</c></returns>
        </member>
        <member name="P:Saxon.Api.XdmMap.Size">
            <summary>
            Get the number of entries in the map
            </summary>
            <remarks>(Note that the <see cref="P:Saxon.Api.XdmValue.Count"/> method returns 1 (one),
            because an XDM map is an item.)</remarks>
        </member>
        <member name="T:Saxon.Api.XdmNode">
            <summary inherits="XdmItem">
            The class <c>XdmNode</c> represents a Node in the XDM Data Model. A Node
            is an <c>XdmItem</c>, and is therefore an <c>XdmValue</c> in its own right, and may also participate
            as one item within a sequence value.
            </summary>
            <remarks>
            <para>An <c>XdmNode</c> is implemented as a wrapper around an object
            of type <c>net.sf.saxon.NodeInfo</c>. 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.</para>
            <para>The <c>XdmNode</c> 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, <c>EnumerateAxis</c>, which allows
            other nodes to be retrieved by following any of the XPath axes.</para>
            </remarks>
        </member>
        <member name="M:Saxon.Api.XdmNode.IsAtomic">
            <summary>
            Determine whether the item is an atomic value
            </summary>
            <returns>
            false (the item is not an atomic value)
            </returns>
        </member>
        <member name="M:Saxon.Api.XdmNode.getUnderlyingXmlNode">
            <summary>
            Unwraps the underlying <c>XmlNode</c> object from the <c>XdmValue</c>.
            If the method does not wrap a <c>XmlNode</c> then a null is returned
            </summary>
            <returns>The underlying <c>XmlNode</c></returns>
        </member>
        <member name="M:Saxon.Api.XdmNode.GetAttributeValue(Saxon.Api.QName)">
            <summary>
            Get a the string value of a named attribute of this element. 
            </summary>
            <remarks>
            Returns null if this node is not an element, or if this element has no
            attribute with the specified name.
            </remarks>
            <param name="name">The name of the attribute whose value is required</param>
        </member>
        <member name="M:Saxon.Api.XdmNode.GetAttributeValue(System.String)">
            <summary>
            Get a the string value of a named attribute (in no namespace) of this element. 
            </summary>
            <remarks>
            Returns null if this node is not an element, or if this element has no
            attribute with the specified name.
            </remarks>
            <param name="name">The name of the attribute whose value is required, interpreted as no-namespace name</param>
        </member>
        <member name="M:Saxon.Api.XdmNode.Select(Saxon.Api.Step{Saxon.Api.XdmNode,Saxon.Api.XdmNode})">
            <summary>
            Get a IEnumerable of XdmNodes by applying a <c>Step</c> to this
            XdmNode value.
            </summary>
            <param name="step">the <c>Step</c> to be applied to this node</param>
            <returns>an IEnumerable of nodes obtained by applying the <c>Step</c> function to this node</returns>
        </member>
        <member name="M:Saxon.Api.XdmNode.Children(Saxon.Api.IPredicate{Saxon.Api.XdmNode})">
            <summary>
            Get the nodes found on the child axis that satisfy a supplied <c>Predicate</c>.
            </summary>
            <param name="filter">the predicate to be applied</param>
            <returns> an <c>Iterable</c> containing those nodes found on the child axis that satisfy the supplied predicate.</returns>
        </member>
        <member name="M:Saxon.Api.XdmNode.Children">
            <summary>
            Get the element children of this node
            </summary>
            <returns> an <c>Iterable</c> containing all nodes on the child axis.</returns>
        </member>
        <member name="M:Saxon.Api.XdmNode.Children(System.String)">
            <summary>
            Get the element children of this node having a specified local name, irrespective of the namespace
            </summary>
            <param name="localName">the local name of the child elements to be selected, or "*" to select all children that are element nodes</param>
            <returns> an <c>Iterable</c> containing the element children of this node that have the required local name.</returns>
        </member>
        <member name="M:Saxon.Api.XdmNode.Children(System.String,System.String)">
            <summary>
            Get the element children having a specified namespace URI and local name
            </summary>
            <param name="uri">the namespace URI of the child elements to be selected: 
            supply a zero-length string to indicate the null namespace</param>
            <param name="localName">the local name of the child elements to be selected</param>
            <returns> an <c>Iterable</c> containing the element children of this node that have the required local name and namespace URI.</returns>
        </member>
        <member name="M:Saxon.Api.XdmNode.EnumerableOverAxis(Saxon.Api.XdmAxis)">
            <summary>
            Get an enumerable that supplies all the nodes on one of the XPath
            axes, starting with this node.
            </summary>
            <param name="axis">
            The axis to be navigated, for example <c>XdmAxis.Child</c> for the child axis.
            </param>
            <remarks>
            The nodes are returned in axis order: that is, document order for a forwards
            axis, reverse document order for a reverse axis.
            </remarks>
        </member>
        <member name="M:Saxon.Api.XdmNode.EnumerateAxis(Saxon.Api.XdmAxis)">
            <summary>
            Get an enumerator that supplies all the nodes on one of the XPath
            axes, starting with this node.
            </summary>
            <param name="axis">
            The axis to be navigated, for example <c>XdmAxis.Child</c> for the child axis.
            </param>
            <remarks>
            The nodes are returned in axis order: that is, document order for a forwards
            axis, reverse document order for a reverse axis.
            </remarks>
        </member>
        <member name="M:Saxon.Api.XdmNode.EnumerateAxis(Saxon.Api.XdmAxis,Saxon.Api.QName)">
            <summary>
            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.
            </summary>
            <param name="axis">
            The axis to be navigated, for example <c>XdmAxis.Child</c> for the child axis.
            </param>
            <param 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>
            <remarks>
            The nodes are returned in axis order: that is, document order for a forwards
            axis, reverse document order for a reverse axis.
            </remarks>
        </member>
        <member name="M:Saxon.Api.XdmNode.WriteTo(System.Xml.XmlWriter)">
            <summary>
            Send the node (that is, the subtree rooted at this node) to an <c>XmlWriter</c>
            </summary>
            <remarks>
            Note that an <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.
            </remarks>
            <param name="writer">
            The <c>XmlWriter</c> to which the node is to be written
            </param>
        </member>
        <member name="M:Saxon.Api.XdmNode.Equals(System.Object)">
            <summary>
            Two instances of <c>XdmNode</c> are equal if they represent the same node. That is, the <c>Equals()</c>
            method returns the same result as the XPath "is" operator.
            </summary>
            <param name="obj">The object node to be compared</param>
        </member>
        <member name="M:Saxon.Api.XdmNode.GetHashCode">
            <summary>
            The hash code of a node reflects the equality relationship: if two <c>XdmNode</c> instances
            represent the same node, then they have the same hash code
            </summary>
        </member>
        <member name="M:Saxon.Api.XdmNode.ToString">
            <summary>
            Return a string representation of the node.
            </summary>
            <remarks>
            This method returns the value of the <see cref="P:Saxon.Api.XdmNode.OuterXml"/> property.
            To get the string value of a node as defined in XPath, use the <see cref="P:Saxon.Api.XdmNode.StringValue"/> property.
            </remarks>
        </member>
        <member name="P:Saxon.Api.XdmNode.NodeName">
            <summary>
            The name of the node, as a <c>QName</c>. Returns null in the case of unnamed nodes.
            </summary>
        </member>
        <member name="P:Saxon.Api.XdmNode.NodeKind">
            <summary>
            The kind of node, as an instance of <c>System.Xml.XmlNodeType</c>.
            </summary>
            <remarks>For a namespace node in the XDM model, the value <c>XmlNodeType.None</c> 
            is returned.
            </remarks>
        </member>
        <member name="P:Saxon.Api.XdmNode.LineNumber">
            <summary>
            Get the line number of the node in a source document. 
            </summary>
            <remarks>
            For a document constructed using the document
            builder, this is available only if the line numbering option was set when the document was built (and
            then only for element nodes). If the line number is not available, the value -1 is returned.
            Line numbers will typically be as reported by a SAX parser; this means that the line number for an element
            node is the line number containing the closing ">" of the start tag.
            </remarks>
        </member>
        <member name="P:Saxon.Api.XdmNode.ColumnNumber">
            <summary>
            Get the column number of the node in a source document. 
            </summary>
            <remarks>
            For a document constructed using the document
            builder, this is available only if the line numbering option was set when the document was built (and
            then only for element nodes). If the column number is not available, the value -1 is returned.
            Line numbers will typically be as reported by a SAX parser; this means that the column number for an element
            node is the column number containing the closing ">" of the start tag.
            </remarks>
        </member>
        <member name="P:Saxon.Api.XdmNode.TypedValue">
            <summary>
            The typed value of the node, as an instance of <c>XdmValue</c>.
            </summary>
            <remarks>
            A <c>DynamicError</c> is thrown if the node has no typed value, as will be the case for
            an element with element-only content.
            </remarks>
        </member>
        <member name="P:Saxon.Api.XdmNode.Processor">
            <summary>
            Get a <see cref="P:Saxon.Api.XdmNode.Processor"/> suitable for use with this <see cref="T:Saxon.Api.XdmNode"/>.
            </summary>
            <remarks>
            <para>In most cases this will be the original <see cref="P:Saxon.Api.XdmNode.Processor"/>
            object used to create the <see cref="T:Saxon.Api.DocumentBuilder"/> that built the document that 
            contains this node. If that <see cref="P:Saxon.Api.XdmNode.Processor"/> is not available, it will be a 
            compatible <c>Processor</c>, one that shares the same underlying <see cref="T:net.sf.saxon.Configuration"/>, 
            and hence is initialized with the same configuration settings, schema components, license features,
            and so on.</para>
            <para><i>Note: the only case where the original <c>Processor</c> is not available is when
            the same <c>Configuration</c> is used with multiple APIs, for example mixing s9api
            and JAXP or XQJ in the same application.</i></para>
            </remarks>
            <returns>Returns a <c>Processor</c> suitable for performing further operations on this node, for example
            for creating a <see cref="T:Saxon.Api.Serializer"/> or an <see cref="T:Saxon.Api.XPathCompiler"/>.</returns>
        </member>
        <member name="P:Saxon.Api.XdmNode.StringValue">
            <summary>
            Get the string value of the node.
            </summary>
        </member>
        <member name="P:Saxon.Api.XdmNode.Parent">
            <summary>
            Get the parent of this node.
            </summary>
            <remarks>
            Returns either a document node, an element node, or null in the case where
            this node has no parent. 
            </remarks>
        </member>
        <member name="P:Saxon.Api.XdmNode.Root">
            <summary>
            Get the root of the tree containing this node.
            </summary>
            <remarks>
            Returns the root of the tree containing this node (which might be this node itself).
            </remarks>
        </member>
        <member name="P:Saxon.Api.XdmNode.BaseUri">
            <summary>
            Get the base URI of the node.
            </summary>
        </member>
        <member name="P:Saxon.Api.XdmNode.DocumentUri">
            <summary>
            Get the document URI of the node.
            </summary>
        </member>
        <member name="P:Saxon.Api.XdmNode.OuterXml">
            <summary>
            Return a serialization of this node as lexical XML
            </summary>
            <remarks>
            <para>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 <c>method="xml"</c>, <c>indent="yes"</c>, <c>omit-xml-declaration="yes"</c>.</para>
            <para>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.</para>
            <para>In the case of an attribute node, the output is a string in the form
            <c>name="value"</c>. The name will use the original namespace prefix.</para>
            <para>Other nodes, such as text nodes, comments, and processing instructions, are
            represented as they would appear in lexical XML.</para>
            </remarks>
        </member>
        <member name="P:Saxon.Api.XdmNode.Implementation">
            <summary>
            Escape hatch to the underlying class in the Java implementation
            </summary>
        </member>
        <member name="T:Saxon.Api.XdmEmptySequence">
            <summary inherits="XdmValue">
            The class <c>XdmEmptySequence</c> represents an empty sequence in the XDM Data Model.
            </summary>
            <remarks>
            <para>An empty sequence <i>may</i> also be represented by an <c>XdmValue</c> 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.</para>
            <para>In interfaces that expect an <c>XdmItem</c>, an empty sequence is represented
            by a CLI <c>null</c> value.</para> 
            </remarks>
        </member>
        <member name="F:Saxon.Api.XdmEmptySequence.INSTANCE">
            <summary>The singular instance of this class</summary>
        </member>
        <member name="T:Saxon.Api.QName">
            <summary>
            The <c>QName</c> class represents an instance of <c>xs:QName</c>, 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.
            </summary>
            <remarks>
            Note that a <c>QName</c> is not itself an <c>XdmItem</c> in this model; however it can
            be converted to an <c>XdmAtomicValue</c>.
            </remarks>    
        </member>
        <member name="F:Saxon.Api.QName.XS_STRING">
            <summary>QName constant for the name xs:string</summary>
        </member>
        <member name="F:Saxon.Api.QName.XS_INTEGER">
            <summary>QName constant for the name xs:integer</summary>
        </member>
        <member name="F:Saxon.Api.QName.XS_DOUBLE">
            <summary>QName constant for the name xs:double</summary>
        </member>
        <member name="F:Saxon.Api.QName.XS_FLOAT">
            <summary>QName constant for the name xs:float</summary>
        </member>
        <member name="F:Saxon.Api.QName.XS_DECIMAL">
            <summary>QName constant for the name xs:decimal</summary>
        </member>
        <member name="F:Saxon.Api.QName.XS_BOOLEAN">
            <summary>QName constant for the name xs:boolean</summary>
        </member>
        <member name="F:Saxon.Api.QName.XS_ANYURI">
            <summary>QName constant for the name xs:anyURI</summary>
        </member>
        <member name="F:Saxon.Api.QName.XS_QNAME">
            <summary>QName constant for the name xs:QName</summary>
        </member>
        <member name="F:Saxon.Api.QName.XS_UNTYPED_ATOMIC">
            <summary>QName constant for the name xs:untypedAtomic</summary>
        </member>
        <member name="F:Saxon.Api.QName.XDT_UNTYPED_ATOMIC">
            <summary>QName constant for the name xs:untypedAtomic (for backwards compatibility)</summary>
        </member>
        <member name="M:Saxon.Api.QName.#ctor(System.String)">
            <summary>
            Construct a <c>QName</c> representing a name in no namespace
            </summary>
            <remarks>
            This constructor does not check that the components of the QName are
            lexically valid.
            </remarks>
            <param name="local">The local part of the name
            </param>
        </member>
        <member name="M:Saxon.Api.QName.#ctor(System.String,System.String)">
            <summary>
            Construct a <c>QName</c> 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 <c>prefix:local-name</c>
            </summary>
            <remarks>
            This constructor does not check that the components of the QName are
            lexically valid.
            </remarks>
            <param name="uri">The namespace URI. Use either the string "" or null
            for names that are not in any namespace.
            </param>
            <param name="lexical">Either the local part of the name, or the prefix
            and local part in the format <c>prefix:local</c>
            </param>
        </member>
        <member name="M:Saxon.Api.QName.#ctor(System.String,System.String,System.String)">
            <summary>
            Construct a <c>QName</c> using a namespace prefix, a namespace URI, and a local name
            (in that order).
            </summary>
            <remarks>
            This constructor does not check that the components of the QName are
            lexically valid.
            </remarks>
            <param 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 name="uri">The namespace URI. Use either the string "" or null
            for names that are not in any namespace.
            </param>
            <param name="local">The local part of the name</param>
        </member>
        <member name="M:Saxon.Api.QName.#ctor(System.String,Saxon.Api.XdmNode)">
            <summary>
            Construct a <c>QName</c> from a lexical QName, supplying an element node whose
            in-scope namespaces are to be used to resolve any prefix contained in the QName.
            </summary>
            <remarks>
            <para>This constructor checks that the components of the QName are
            lexically valid.</para>
            <para>If the lexical QName has no prefix, the name is considered to be in the
            default namespace, as defined by <c>xmlns="..."</c>.</para>
            </remarks>
            <param name="lexicalQName">The lexical QName, in the form <code>prefix:local</code>
            or simply <c>local</c>.</param>
            <param name="element">The element node whose in-scope namespaces are to be used
            to resolve the prefix part of the lexical QName.</param>
            <exception cref="T:System.ArgumentException">If the prefix of the lexical QName is not in scope</exception>
            <exception cref="T:System.ArgumentException">If the lexical QName is invalid 
            (for example, if it contains invalid characters)</exception>
            
        </member>
        <member name="M:Saxon.Api.QName.#ctor(System.Xml.XmlQualifiedName)">
            <summary>
            Construct a <c>QName</c> from an <c>XmlQualifiedName</c> (as defined in the
            <c>System.Xml</c> package).
            </summary>
            <remarks>
            Note that an <c>XmlQualifiedName</c> does not contain any prefix, so the result
            will always have a prefix of ""
            </remarks>
            <param name="qualifiedName">The <c>XmlQualifiedName</c></param>
        </member>
        <member name="M:Saxon.Api.QName.FromClarkName(System.String)">
            <summary>
            Factory method to construct a <c>QName</c> from a string containing the expanded
            QName in Clark notation, that is, <c>{uri}local</c>
            </summary>
            <remarks>
            The prefix part of the <c>QName</c> will be set to an empty string.
            </remarks>
            <param 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> 
        </member>
        <member name="M:Saxon.Api.QName.FromEQName(System.String)">
            <summary>
            Factory method to construct a <c>QName</c> from a string containing the expanded
            QName in EQName notation, that is, <c>Q{uri}local</c>
            </summary>
            <remarks>
            The prefix part of the <c>QName</c> will be set to an empty string.
            </remarks>
            <param name="expandedName">The QName in EQName notation: <c>Q{uri}local</c>. 
            For a name in no namespace, either of the
            forms <c>Q{}local</c> or simply <c>local</c> are accepted.</param>
            <returns> the QName corresponding to the supplied name in EQName notation. This will always
            have an empty prefix.</returns>
        </member>
        <member name="M:Saxon.Api.QName.Register(Saxon.Api.Processor)">
            <summary>
            Register a <c>QName</c> with the <c>Processor</c>. This makes comparison faster
            when the QName is compared with others that are also registered with the <c>Processor</c>.
            Depreacted method.
            </summary>
            <remarks>
            A given <c>QName</c> object can only be registered with one <c>Processor</c>.
            </remarks>
            <param name="processor">The <c>Processor</c> in which the name is to be registered.</param>
        </member>
        <member name="M:Saxon.Api.QName.IsValid(Saxon.Api.Processor)">
            <summary>
            Validate the <c>QName</c> against the XML 1.0 or XML 1.1 rules for valid names.
            </summary>
            <param name="processor">This argument is no longer used (at one time it was used
            to establish whether XML 1.0 or XML 1.1 rules should be used for validation, but the
            two versions of the XML specification have since been aligned).</param>
            <returns>true if the name is valid, false if not</returns>
        </member>
        <member name="M:Saxon.Api.QName.IsValid">
            <summary>
            Validate the <c>QName</c> against the XML rules for valid names.
            </summary>
            <returns>true if the name is valid, false if not</returns>
        </member>
        <member name="M:Saxon.Api.QName.ToString">
            <summary>
            Convert the value to a string. The resulting string is the lexical form of the QName,
            using the original prefix if there was one.
            </summary>
        </member>
        <member name="M:Saxon.Api.QName.GetHashCode">
            <summary>
            Get a hash code for the <c>QName</c>, to support equality matching. This supports the
            semantics of equality, which considers only the namespace URI and local name, and
            not the prefix.
            </summary>
            <remarks>
            The algorithm for allocating a hash code does not depend on registering the QName 
            with the <c>Processor</c>.
            </remarks>
        </member>
        <member name="M:Saxon.Api.QName.Equals(System.Object)">
            <summary>
            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.
            </summary>
            <param name="other">The value to be compared with this <c>QName</c>. If this value is not a <c>QName</c>, the
            result is always false. Otherwise, it is true if the namespace URI and local name both match.</param>
        </member>
        <member name="M:Saxon.Api.QName.ToXmlQualifiedName">
            <summary>
            Convert the value to an <c>XmlQualifiedName</c> (as defined in the
            <c>System.Xml</c> package)
            </summary>
            <remarks>
            Note that this loses the prefix.
            </remarks>
        </member>
        <member name="P:Saxon.Api.QName.Prefix">
            <summary>Get the prefix of the <c>QName</c>. 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.
            </summary>
            <remarks>
            Returns the zero-length string in the case of a QName that has no prefix.
            </remarks>
        </member>
        <member name="P:Saxon.Api.QName.Uri">
            <summary>Get the namespace URI of the <c>QName</c>. Returns "" (the zero-length string) if the
            QName is not in a namespace.
            </summary>
        </member>
        <member name="P:Saxon.Api.QName.LocalName">
            <summary>Get the local part of the <c>QName</c></summary>
        </member>
        <member name="P:Saxon.Api.QName.ClarkName">
            <summary>Get 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 <c>{uri}local</c>.
            Otherwise, the value is the local part of the name.
            </summary>
        </member>
        <member name="P:Saxon.Api.QName.EQName">
            <summary>Get the expanded name in EQName format, that is <c>Q{uri}local</c>. A no namespace name is returned as <c>Q{}local</c>.
            </summary>
        </member>
        <member name="T:Saxon.Api.IPredicate`1">
            <summary>
            Interface that represents a predicate (boolean-valued <c>Func</c>) of one argument.
            </summary>
            <remarks>This is a functional interface whose functional method is <c>Invoke(object)</c>.</remarks>
            <typeparam name="XdmItem">The type of the input to the predicate.</typeparam>
        </member>
        <member name="M:Saxon.Api.IPredicate`1.Or``1(Saxon.Api.IPredicate{``0})">
            <summary>
            Returns a composed predicate that represents a short-circuiting logical
            OR of this predicate and another. When evaluating the composed
            predicate, if this predicate is <c>true</c>, then the <c>other</c>
            predicate is not evaluated.
            </summary>
            <typeparam name="T">The type of the input argument</typeparam>
            <param name="other">A predicate that will be logically-ORed with this predicate</param>
            <returns>A composed predicate that represents the short-circuiting logical OR of this predicate and the <c>other</c>
            predicate.</returns>
            public*
        </member>
        <member name="M:Saxon.Api.IPredicate`1.And``1(Saxon.Api.IPredicate{``0})">
            <summary>
            Returns a composed predicate that represents a short-circuiting logical
            AND of this predicate and another. When evaluating the composed
            predicate, if this predicate is <c>false</c>, then the <c>other</c>
            predicate is not evaluated.
            </summary>
            <typeparam name="T">The type of the input argument</typeparam>
            <param name="other">A predicate that will be logically-ANDed with this predicate</param>
            <returns>A composed predicate that represents the short-circuiting logical AND of this predicate the <c>other</c>
            predicate.</returns>
            public*
        </member>
        <member name="M:Saxon.Api.IPredicate`1.Negate">
            <summary>
            Returns a predicate that represents the logical negation of this predicate.
            </summary>
            <returns>A predicate that represents the logical negation of this predicate.</returns>
            public*
        </member>
        <member name="M:Saxon.Api.IPredicate`1.Invoke``1(``0)">
            <summary>
            Evaluates this predicate on the given argument.
            </summary>
            <typeparam name="T">The type of the input argument</typeparam>
            <param name="item">The input item</param>
            <returns><c>true</c> if the input argument matches the predicate, otherwise <c>false</c>.</returns>
            public*
        </member>
        <member name="P:Saxon.Api.IPredicate`1.Func">
            <summary>
            Unwrapped Func property which evaluates to boolean.
            </summary>
            public*
        </member>
        <member name="T:Saxon.Api.Predicate`1">
            <summary>
            This class implements the <c>IPredicate</c> interface which represents a predicate (boolean-valued <c>Func</c>) of one argument.
            </summary>
            <typeparam name="T">The type of the input to the predicate, which must be of type <c>XdmItem</c> or one of its subclasses.</typeparam>
        </member>
        <member name="M:Saxon.Api.Predicate`1.#ctor(System.Func{`0,System.Boolean})">
            <summary>
            Predicate constructor method to wrap the <c>Func</c> object.
            </summary>
            <param name="f">boolean-valued <c>Func</c> object</param>
        </member>
        <member name="M:Saxon.Api.Predicate`1.Invoke``1(``0)">
            <summary>
            Evaluates this predicate on the given argument.
            </summary>
            <typeparam name="T1">The type of the input argument</typeparam>
            <param name="item">The input item</param>
            <returns><c>true</c> if the input argument matches the predicate, otherwise <c>false</c>.</returns>
        </member>
        <member name="M:Saxon.Api.Predicate`1.Saxon#Api#IPredicate{T}#And``1(Saxon.Api.IPredicate{``0})">
            <summary>
            Returns a compose predicate that represents a short-circuiting logical
            AND of this predicate and another. When evaluating the composed predicate,
            if this predicate is <c>false</c>, then the other predicate is not evaluated.
            </summary>
            <param name="other">A predicate that will be logically-ANDed with this predicate</param>
            <returns>A composed predicate that represents the short-circuiting logical 
            AND of this predicate and the <c>other</c> predicate.</returns>
            public*
        </member>
        <member name="M:Saxon.Api.Predicate`1.Saxon#Api#IPredicate{T}#Or``1(Saxon.Api.IPredicate{``0})">
            <summary>
            Returns a composed predicate that represents a short-circuiting logical
            OR of this predicate and another. When evaluating the composed
            predicate, if this predicate is <c>true</c>, then the <c>other</c>
            predicate is not evaluated.
            </summary>
            <param name="other">A predicate that will be logically-ORed with this predicate.</param>
            <returns>A composed predicate that represents the short-circuiting logical
            OR of this predicate and the <c>other</c> predicate.</returns>
            public*
        </member>
        <member name="M:Saxon.Api.Predicate`1.Saxon#Api#IPredicate{T}#Negate">
            <summary>
            Return a predicate that represents the logical negation of this predicate.
            </summary>
            <returns>A predicate that represents the logical negation of this predicate.</returns>
            public*
        </member>
        <member name="P:Saxon.Api.Predicate`1.Func">
            <summary>
            The <c>Func</c> Property represents the wrapped delegate method which can be invoked.
            </summary>
        </member>
        <member name="T:Saxon.Api.Predicates">
            <summary>
            This non-instantiable class provides a number of useful implementations of the <c>Predicate</c>
            interface, designed for use when navigating streams of XDM items.
            </summary>
        </member>
        <member name="M:Saxon.Api.Predicates.IsAttribute">
            <summary>
            A predicate to test whether an item is an attribute node.
            </summary>
            <returns>A predicate that returns true if given an item that is an attribute node.</returns>
        </member>
        <member name="M:Saxon.Api.Predicates.IsNode">
            <summary>
            A predicate to test whether an item is a node.
            </summary>
            <returns>A predicate that returns true if given an item that is a node.</returns>
        </member>
        <member name="M:Saxon.Api.Predicates.IsElement">
            <summary>
            A predicate to test whether an item is an element node.
            </summary>
            <returns>A predicate that returns true if given an item that is an element node.</returns>
        </member>
        <member name="M:Saxon.Api.Predicates.IsText">
            <summary>
            A predicate to test whether an item is a text node.
            </summary>
            <returns>A predicate that returns true if given an item that is a text node.</returns>
        </member>
        <member name="M:Saxon.Api.Predicates.IsComment">
            <summary>
            A predicate to test whether an item is a comment node.
            </summary>
            <returns>A predicate that returns true if given an item that is a comment node.</returns>
        </member>
        <member name="M:Saxon.Api.Predicates.IsProcessingInstruction">
            <summary>
            A predicate to test whether an item is a processing instruction node.
            </summary>
            <returns>A predicate that returns true if given an item that is a processing instruction node.</returns>
        </member>
        <member name="M:Saxon.Api.Predicates.IsDocument">
            <summary>
            A predicate to test whether an item is a document node.
            </summary>
            <returns>A predicate that returns true if given an item that is a document node.</returns>
        </member>
        <member name="M:Saxon.Api.Predicates.IsNamespace">
            <summary>
            A predicate to test whether an item is a namespace node.
            </summary>
            <returns>A predicate that returns true if given an item that is a namespace node.</returns>
        </member>
        <member name="M:Saxon.Api.Predicates.IsAtomic">
            <summary>
            A predicate to test whether an item is an atomic value.
            </summary>
            <returns>A predicate that returns true if given an item that is an atomic value.</returns>
        </member>
        <member name="M:Saxon.Api.Predicates.IsFunction">
            <summary>
            A predicate to test whether an item is a function value (this includes maps and arrays).
            </summary>
            <returns>A predicate that returns true if given an item that is a function, including
            maps and arrays.</returns>
        </member>
        <member name="M:Saxon.Api.Predicates.IsMap">
            <summary>
            A predicate to test whether an item is an XDM map.
            </summary>
            <returns>A predicate that returns true if given an item that is a map.</returns>
        </member>
        <member name="M:Saxon.Api.Predicates.IsArray">
            <summary>
            A predicate to test whether an item is an XDM array.
            </summary>
            <returns>A predicate that returns true if given an item that is an array.</returns>
        </member>
        <member name="M:Saxon.Api.Predicates.Empty``2(Saxon.Api.Step{``0,``1})">
            <summary>
            Obtain a predicate that tests whether a supplied <c>Step</c> delivers an empty result.
            </summary>
            <param name="step">A step to be applied to the item being tested</param>
            <returns>A predicate that returns true if the supplied step returns an empty result.</returns>
        </member>
        <member name="M:Saxon.Api.Predicates.Not``1(Saxon.Api.IPredicate{``0})">
            <summary>
            Return an <c>IPredicate</c> that is the negation of a supplied <c>IPredicate</c>.
            </summary>
            <typeparam name="TInput">The type of object to which the predicate is applicable</typeparam>
            <param name="condition">The supplied predicate</param>
            <returns>A predicate that matches an item if and only if the supplied predicate does not match the item.</returns>
        </member>
        <member name="M:Saxon.Api.Predicates.Exists(Saxon.Api.Step{Saxon.Api.XdmItem,Saxon.Api.XdmItem})">
            <summary>
            Obtain a predicate that tests whether a supplied <c>Step</c> delivers a non-empty result.
            </summary>
            <param name="step">A step to be applied to the item being tested</param>
            <returns>A predicate that returns true if the step returns a non-empty result.</returns>
        </member>
        <member name="M:Saxon.Api.Predicates.HasName(System.String,System.String)">
            <summary>
            Obtain a predicate that tests whether an item is a node with a given namespace URI and local name.
            </summary>
            <param name="uri">The required namespace URI: supply a zero-length string to indicate the null namespace</param>
            <param name="localName">The required local name</param>
            <returns>A predicate that returns true if and only if the supplied item is a node with the given namespace URI and local name.</returns>
        </member>
        <member name="M:Saxon.Api.Predicates.HasLocalName(System.String)">
            <summary>
            Obtain a predicate that tests whether an item is a node with a given local name, irrespective of the namespace.
            </summary>
            <param name="localName">The required local name</param>
            <returns>A predicate that returns true if and only if the supplied item is a node with the given namespace URI and local name.</returns>
        </member>
        <member name="M:Saxon.Api.Predicates.HasNamespace(System.String)">
            <summary>
            Obtain a predicate that tests whether an item is a node with a given namespace URI.
            </summary>
            <param name="uri">The required namespace URI: supply a zero-length string to identify the null namespace</param>
            <returns>A predicate that returns true if and only if the supplied item is a node with the given
            namespace URI. If a zero-length string is supplied, the predicate will also match nodes having no name,
            such as text and comment nodes, and nodes having a local name only, such as namespace and processing-instruction
            nodes.</returns>
        </member>
        <member name="M:Saxon.Api.Predicates.HasAttribute(System.String)">
            <summary>
            Obtain a predicate that tests whether an item is an element node with a given attribute (whose name is in no namespace).
            </summary>
            <param name="local">The required attribute name</param>
            <returns>A predicate that returns true if and only if the supplied item is an element having an attribute
            with the given local name, in no namespace.</returns>
        </member>
        <member name="M:Saxon.Api.Predicates.AttributeEq(System.String,System.String)">
            <summary>
            Obtain a predicate that tests whether an item is an element node with a given attribute (whose
            name is in no namespace) whose string value is equal to a given value.
            </summary>
            <param name="local">The required attribute name</param>
            <param name="value">The required attribute value</param>
            <returns>A predicate that returns true if and only if the supplied item is an element having an attribute
            with the given local name, in no namespace, whose string value is equal to the given value.</returns>
        </member>
        <member name="M:Saxon.Api.Predicates.Eq(Saxon.Api.XdmAtomicValue)">
            <summary>
            Obtain a predicate that tests whether an atomic value compares equal to a supplied atomic value of
            a comparable type.
            </summary>
            <param name="value2">The atomic value to be compared with</param>
            <returns>A predicate which returns true when applied to a value that is equal to the supplied
            value under the "is-same-key" comparison rules. (These are the rules used to compare key values
            in an XDM map. The rules are chosen to be context-free, error-free, and transitive.)</returns>
        </member>
        <member name="M:Saxon.Api.Predicates.Eq(System.String)">
            <summary>
            Obtain a predicate that tests whether the result of applying the XPath <c>string()</c> function to an item
            is equal to a given string.
            </summary>
            <param name="value">The string being tested</param>
            <returns>A predicate which returns true if the string value of the item being tested
            is equal to the given string under Java comparison rules for comparing strings.</returns>
        </member>
        <member name="M:Saxon.Api.Predicates.Eq``2(Saxon.Api.Step{``0,``1},System.String)">
            <summary>
            Obtain a predicate that tests whether there is some item in the result of applying a step,
            whose string value is equal to a given string. For example, <c>Eq(attribute("id"), "foo")</c>
            matches an element if it has an "id" attribute whose value is "foo".
            </summary>
            <typeparam name="TInput">The type of the input object to the <c>Step</c> function</typeparam>
            <typeparam name="TResult">The result type after invoking the function</typeparam>
            <param name="step">The step to be evaluated</param>
            <param name="value">The string to be compared against the items returned by the step</param>
            <returns>A predicate which returns true if some item selected by the step has as string value
            equal to the given string.</returns>
        </member>
        <member name="M:Saxon.Api.Predicates.MatchesRegex(System.String)">
            <summary>
            Obtain a predicate that tests whether the result of applying the XPath <c>string()</c> function to an item
            matches a given regular expression.
            </summary>
            <param name="regex">The regular expression (this is a Java regular expression, not an XPath regular expression)</param>
            <returns>A predicate which returns true if the string value of the item being tested
            contains a substring that matches the given regular expression. To test the string in its entirety,
            use anchors "^" and "$" in the regular expression.</returns>
        </member>
        <member name="M:Saxon.Api.Predicates.Some``2(Saxon.Api.Step{``0,``1},Saxon.Api.IPredicate{``1})">
            <summary>
            Obtain a predicate that tests whether there is some item in the result of applying a step that
            satisfies the supplied condition.
            </summary>
            <remarks><para>For example, <c>some(CHILD, exists(attribute("foo"))</c> matches an element if it has a child
            element with an attribute whose local name is "foo".</para>
            <para>If the step returns an empty sequence the result will always be false.</para></remarks>
            <typeparam name="TInput">The type of the input object to the <c>Step</c> function</typeparam>
            <typeparam name="TResult">The expected result type after invoking the function. The predicate must also be of this type.</typeparam>
            <param name="step">The step to be evaluated</param>
            <param name="condition">The predicate to be applied to the items returned by the step</param>
            <returns>A predicate which returns true if some item selected by the step satisfies the supplied condition.</returns>
        </member>
        <member name="M:Saxon.Api.Predicates.Every``2(Saxon.Api.Step{``0,``1},Saxon.Api.IPredicate{``1})">
            <summary>
            Obtain a predicate that tests whether every item in the result of applying a step
            satisfies the supplied condition.
            </summary>
            <remarks> <para>For example, <c>every(CHILD, exists(attribute("foo"))</c> matches an element if each of its child
            elements has an attribute whose local name is "foo".</para>
            <para>If the step returns an empty sequence the result will always be true.</para></remarks>
            <typeparam name="TInput">the type of the input object to the <c>Step</c> function</typeparam>
            <typeparam name="TResult">The expected result type after invoking the function. The predicate must also be of this type.</typeparam>
            <param name="step">The step to be evaluated</param>
            <param name="condition">The predicate to be applied to the items returned by the step</param>
            <returns>A predicate which returns true if every item selected by the step satisfies the supplied condition.</returns>
        </member>
        <member name="T:Saxon.Api.Step`2">
            <summary>
            A <c>Step</c> class wraps a delegate method that can be applied to an item
            to return a <c>XdmValue</c> of items.
            </summary>
        </member>
        <member name="M:Saxon.Api.Step`2.#ctor(System.Func{`0,System.Collections.Generic.IEnumerable{`1}})">
            <summary>
            Constructor method to wrap a delegate method.
            </summary>
            <param name="f">Passes a delegate as a <c>Func</c> with encapsulated type <c>XdmItem</c> and the return value <c>IEnumerable</c> of items.</param>
        </member>
        <member name="M:Saxon.Api.Step`2.Where(Saxon.Api.IPredicate{`1})">
            <summary>
            Obtain a <c>Step</c> that filters the results of this <c>Step</c> using a supplied <c>Func</c> predicate.
            <p>For example, <c>Child.Where(Predicate.IsText())</c>
            returns a <c>Step</c> whose effect is to select the text node children 
            of a supplied element or document node.</p>
            </summary>
            <param name="predicate">The predicate is a <c>Func</c> delegate enapsulating the filter which will be applied to the results of this <c>Step</c></param>
            <returns>A new <c>Step</c> (that is, a wrapped delegate from one <c>Step</c> of items to another) that
            filters the results of this step by selecting only the items that satisfy the predicate.</returns>
        </member>
        <member name="M:Saxon.Api.Step`2.Then(Saxon.Api.Step{`1,`1})">
            <summary>
            Obtain a <c>Step</c> that combines the results of this step with the results of another step.
            </summary>
            <param name="next">The step which will be applied to the results of this step</param>
            <returns>A new <c>Step</c> (that is, a function from one <c>IEnumerable</c> of items to another) that
            performs this step and the next step in turn. The result is equivalent to the <c>IEnumerable</c> method <c>SelectMany()</c>
            function or the XPath <c>!</c> operator: there is no sorting of nodes into document order, and
            no elimination of duplicates.</returns>
        </member>
        <member name="M:Saxon.Api.Step`2.At(System.Int32)">
            <summary>
            Obtain a <c>Step</c> that selects the Nth item in the results of this step.
            </summary>
            <param name="index">The zero-based index of the item to be selected</param>
            <returns>A new <c>Step</c> (that is, a function from one <c>IEnumerable</c> of items to another) that
            filters the results of this step by selecting only the items that satisfy the predicate.</returns>
        </member>
        <member name="M:Saxon.Api.Step`2.Cat(Saxon.Api.Step{`0,`1})">
            <summary>
            Obtain a <c>Step</c> that concatenates the results of this <c>Step</c> with the result of another
            <c>Step</c> applied to the same input item.
            </summary>
            <remarks><p>For example, <c>Attribute().Cat(Child())</c> returns a step whose effect is
            to select the attributes of a supplied element followed by its children.</p></remarks>
            <param name="other">The step whose results will be concatenated with the results of this step</param>
            <returns>A new <c>Step</c> (that is, a function from one <c>IEnumerable</c> of items to another) that
            concatenates the results of applying this step to the input item, followed by the
            results of applying the other step to the input item.</returns>
        </member>
        <member name="M:Saxon.Api.Step`2.Invoke(`0)">
            <summary>
            Invokes this function to the given argument.
            </summary>
            <param name="item">The function argument</param>
            <returns>The function result.</returns>
        </member>
        <member name="P:Saxon.Api.Step`2.Func">
            <summary>
            The <c>Func</c> property that represents the wrapped delegate method which can be invoked.
            </summary>
        </member>
        <member name="T:Saxon.Api.Steps">
            <summary>
            This non-instantiable class provides a number of useful implementations of the <c>Step</c>
            class which wraps a <c>Func</c> object, used to navigate XDM trees, typically getting the <c>Func</c> property 
            and used as an argument to <c>XdmValue#Select</c> and <c>XdmValue#SelectMany</c>.
            </summary>
        </member>
        <member name="M:Saxon.Api.Steps.Root">
            <summary>
            Obtain a <c>Step</c> that selects the root node of the containing document (which may or may not
            be a document node). If not a node a wrapped empty sequence is returned.
            </summary>
            <returns>A <c>Step</c> that selects the root node of the containing document.</returns>
        </member>
        <member name="M:Saxon.Api.Steps.Ancestor">
            <summary>
            Obtain a <c>Step</c> to navigate from a node to its ancestors, in reverse document
            order (that is, nearest ancestor first, root node last).
            </summary>
            <returns>A <c>Step</c> that selects all nodes on the ancestor axis.</returns>
        </member>
        <member name="M:Saxon.Api.Steps.Ancestor(System.String)">
            <summary>
            Obtain a <c>Step</c> that navigates from a node to its ancestor elements having a specified
            local name, irrespective of the namespace. The nodes are returned in reverse document
            order (that is, nearest ancestor first, root node last).
            </summary>
            <param name="localName">The local name of the ancestors to be selected by the <c>Step</c>,
            or "*" to select all ancestors that are element nodes</param>
            <returns>A <c>Step</c>, which selects the ancestors of a supplied node that have the
            required local name.</returns>
        </member>
        <member name="M:Saxon.Api.Steps.Ancestor(System.String,System.String)">
            <summary>
            Return a <c>Step</c> that navigates from a node to its ancestors having a specified
            namespace URI and local name, in reverse document order (that is, nearest ancestor first,
            root node last).
            </summary>
            <param name="uri">The namespace URI of the ancestors to be selected by the <c>Step</c></param>
            <param name="localName">The local name of the ancestors to be selected by the <c>Step</c></param>
            <returns>A <c>Step</c>, which selects the ancestors (at most one) of a supplied node that have the
            required local name and namespace URI.</returns>
        </member>
        <member name="M:Saxon.Api.Steps.Ancestor(Saxon.Api.Predicate{Saxon.Api.XdmItem})">
            <summary>
            Obtain a <c>Step</c> that filters the nodes found on the ancestor axis using a supplied <c>Predicate</c>.
            Nodes are returned in reverse document order (that is, nearest ancestor first, root node last).
            </summary>
            <remarks>The function call <c>Ancestor(predicate)</c> is equivalent to <c>Ancestor.Where(predicate)</c>.</remarks>
            <param name="filter">The predicate to be applied</param>
            <returns>A <c>Step</c> that filters the nodes found on the ancestor-or-self axis using the supplied predicate.</returns>
        </member>
        <member name="M:Saxon.Api.Steps.AncestorOrSelf">
            <summary>
            Obtain a <c>Step</c> to navigate from a node to its ancestors, in reverse document
            order, with the node itself returned at the start of the sequence (that is, origin node first,
            root node last).
            </summary>
            <returns>A <c>Step</c> that selects all nodes on the ancestor-or-self axis.</returns>
        </member>
        <member name="M:Saxon.Api.Steps.AncestorOrSelf(System.String)">
            <summary>
            Obtain a <c>Step</c> that navigates from a node to its ancestor elements having a specified
            local name, irrespective of the namespace. The nodes are returned in reverse document
            order (that is, nearest ancestor first, root node last), and include the node itself.
            </summary>
            <param name="localName">The local name of the ancestors to be selected by the <c>Step</c>,
            or "*" to select all ancestor-or-self nodes that are element nodes</param>
            <returns>A <c>Step</c>, which selects the ancestors-or-self of a supplied node that have 
            the required local name.</returns>
        </member>
        <member name="M:Saxon.Api.Steps.AncestorOrSelf(System.String,System.String)">
            <summary>
            Obtain a <c>Step</c> that navigates from a node to its ancestors-or-self having a specified
            namespace URI and local name, in reverse document order (that is, nearest ancestor first, root node last).
            </summary>
            <param name="uri">The namespace URI of the ancestors to be selected by the <c>Step</c>:
            supply a zero-length string to indicate the null namespace</param>
            <param name="localName">The local name of the ancestors to be selected by the <c>Step</c></param>
            <returns>A <c>Step</c>, which selects the ancestors-or-self of a supplied node that have the
            required local name and namespace URI.</returns>
        </member>
        <member name="M:Saxon.Api.Steps.AncestorOrSelf(Saxon.Api.Predicate{Saxon.Api.XdmItem})">
            <summary>
            Obtain a <c>Step</c> that filters the nodes found on the ancestor-or-self axis using a supplied <c>Predicate</c>.
            Nodes are returned in reverse document order (that is, origin node first, root node last).
            </summary>
            <remarks>The function call <c>AncestorOrSelf(predicate)</c> is equivalent to <c>AncestorOrSelf.Where(predicate)</c>.</remarks>
            <param name="filter">The predicate to be applied</param>
            <returns>A <c>Step</c> that filters the nodes found on the ancestor-or-self axis using a supplied predicate.</returns>
        </member>
        <member name="M:Saxon.Api.Steps.Attribute">
            <summary>
            Obtain a <c>Step</c> to navigate from a node to its attributes.
            </summary>
            <returns>A <c>Step</c> that selects all attribute nodes.</returns>
        </member>
        <member name="M:Saxon.Api.Steps.Attribute(System.String)">
            <summary>
            Obtain a <c>Step</c> that navigates from a node to its attributes having a specified
            local name, irrespective of the namespace.
            </summary>
            <param name="localName">The local name of the attributes to be selected by the <c>Step</c>, or
            "*" to select all attributes</param>
            <returns>A <c>Step</c>, which selects the attributes of a supplied node that have the
            required local name.</returns>
        </member>
        <member name="M:Saxon.Api.Steps.Attribute(System.String,System.String)">
            <summary>
            Return a <c>Step</c> that navigates from a node to its attribute having a specified
            namespace URI and local name.
            </summary>
            <param name="uri">The namespace URI of the attributes to be selected by the <c>Step</c>:
            supply a zero-length string to indicate the null namespace</param>
            <param name="localName">The local name of the attributes to be selected by the <c>Step</c></param>
            <returns>A <c>Step</c>, which selects the attributes (at most one) of a supplied node that have the
            required local name and namespace URI.</returns>
        </member>
        <member name="M:Saxon.Api.Steps.Attribute(Saxon.Api.IPredicate{Saxon.Api.XdmNode})">
            <summary>
            Obtain a <c>Step</c> that filters the nodes found on the attribute axis using a supplied <c>Predicate</c>.
            The function call <c>Attribute(predicate)</c> is equivalent to <c>Attribute.Where(predicate)</c>.
            </summary>
            <param name="filter">The predicate to be applied</param>
            <returns>A <c>Step</c> that filters the nodes found on the attribute axis using the supplied predicate.</returns>
        </member>
        <member name="M:Saxon.Api.Steps.Child">
            <summary>
            Obtain a <c>Step</c> to navigate from a node to its children
            </summary>
            <returns>A <c>Step</c> that selects all nodes on the child axis</returns>
        </member>
        <member name="M:Saxon.Api.Steps.Child(System.String)">
            <summary>
            Obtain a <c>Step</c> that navigates from a node to the element children having a specified
            local name, irrespective of the namespace.
            </summary>
            <param name="localName">The local name of the child elements to be selected by the <c>Step</c>,
            or "*" to select all children that are element nodes</param>
            <returns>A <c>Step</c>, which selects the element children of a supplied node that have the required local name.</returns>
        </member>
        <member name="M:Saxon.Api.Steps.Child(System.String,System.String)">
            <summary>
            Obtain a <c>Step</c> that navigates from a node to the element children having a specified
            namespace URI and local name.
            </summary>
            <param name="uri">The namespace URI of the child elements to be selected by the <c>Step</c>:
            supply a zero-length string to indicate the null namespace</param>
            <param name="localName">The local name of the child elements to be selected by the <c>Step</c></param>
            <returns>A <c>Step</c>, which selects the element children of a supplied node that have the
            required local name and namespace URI.</returns>
        </member>
        <member name="M:Saxon.Api.Steps.Child(Saxon.Api.IPredicate{Saxon.Api.XdmNode})">
            <summary>
            Obtain a <c>Step</c> that filters the nodes found on the child axis using a supplied <c>Predicate</c>.
            The function call <c>Child(predicate)</c> is equivalent to <c>Child.Where(predicate)</c>.
            For example, <c>Child(IsElement())</c> returns a <c>Step</c> that selects the element node children
            of a given node.
            </summary>
            <param name="filter">The predicate to be applied</param>
            <returns>A <c>Step</c> that filters the nodes found on the child axis using the supplied predicate.</returns>
        </member>
        <member name="M:Saxon.Api.Steps.Descendant">
            <summary>
            Obtain a <c>Step</c> to navigate from a node to its descendants, which are returned in document order.
            </summary>
            <returns>A <c>Step</c> that selects all nodes on the descendant axis.</returns>
        </member>
        <member name="M:Saxon.Api.Steps.Descendant(System.String)">
            <summary>
            Obtain a <c>Step</c> that navigates from a node to the descendant elements having a specified
            local name, irrespective of the namespace. These are returned in document order.
            </summary>
            <param name="localname">The local name of the descendant elements to be selected by the <c>Step</c>,
            or "*" to select all descendants that are element nodes</param>
            <returns>A <c>Step</c>, which selects the element descendants of a supplied node that have the
            required local name.</returns>
        </member>
        <member name="M:Saxon.Api.Steps.Descendant(System.String,System.String)">
            <summary>
            Obtain a <c>Step</c> that navigates from a node to the descendant elements having a specified
            namespace URI and local name.
            </summary>
            <param name="uri">The namespace URI of the elements to be selected by the <c>Step</c>:
            supply a zero-length string to indicate the null namespace</param>
            <param name="localName">The local name of the elements to be selected by the <c>Step</c></param>
            <returns>A <c>Step</c>, which selects the element descendants of a supplied node that have the required
            local name and namespace URI.</returns>
        </member>
        <member name="M:Saxon.Api.Steps.Descendant(Saxon.Api.IPredicate{Saxon.Api.XdmNode})">
            <summary>
            Obtain a <c>Step</c> that filters the nodes found on the descendant axis using a supplied <c>Predicate</c>.
            The function call <c>Descendant(predicate)</c> is equivalent to <c>Descendant.Where(predicate)</c>.
            For example, <c>Steps.Descendant(Predicates.IsElement())</c>
            returns a <c>Step</c> that selects the element node descendants
            of a given node, while <c>Descendant(Predicate.Exists(attribute("id")))</c> selects those that have an attribute
            named "id". These are returned in document order.
            </summary>
            <param name="filter">The predicate to be applied</param>
            <returns>A <c>Step</c> that filters the nodes found on the descendant axis using the supplied predicate.</returns>
        </member>
        <member name="M:Saxon.Api.Steps.DescendantOrSelf">
            <summary>
            Obtain a <c>Step</c> to navigate from a node to its descendants, which are returned in document order,
            preceded by the origin node itself.
            </summary>
            <returns>A <c>Step</c> that selects all nodes on the descendant-or-self axis.</returns>
        </member>
        <member name="M:Saxon.Api.Steps.DescendantOrSelf(System.String)">
            <summary>
            Obtain a <c>Step</c> that navigates from a node to the descendant-or-self elements having a specified
            local name, irrespective of the namespace. These are returned in document order.
            </summary>
            <param name="localname">The local name of the descendant-or-self elements to be selected by the <c>Step</c>,
            or "*" to select all descendant-or-self that are element nodes</param>
            <returns>A <c>Step</c>, which selects the descendant-or-self elements of a supplied node that have the
            required local name.</returns>
        </member>
        <member name="M:Saxon.Api.Steps.DescendantOrSelf(System.String,System.String)">
            <summary>
            Obtain a <c>Step</c> that navigates from a node to the descendant-or-self elements having a specified
            namespace URI and local name.
            </summary>
            <param name="uri">The namespace URI of the elements to be selected by the <c>Step</c>:
            supply a zero-length string to indicate the null namespace</param>
            <param name="localName">The local name of the elements to be selected by the <c>Step</c></param>
            <returns>A <c>Step</c>, which selects the descendant-or-self elements of a supplied node that have the required
            local name and namespace URI.</returns>
        </member>
        <member name="M:Saxon.Api.Steps.DescendantOrSelf(Saxon.Api.IPredicate{Saxon.Api.XdmNode})">
            <summary>
            Obtain a <c>Step</c> that filters the nodes found on the descendant-or-self axis using a supplied <c>Predicate</c>.
            The function call <c>DescendantOrSelf(predicate)</c> is equivalent to <c>DescendantOrSelf.Where(predicate)</c>.
            For example, <c>Steps.DescendantOrSelf(Predicates.IsElement())</c>
            returns a <c>Step</c> that selects the descendant-or-self element nodes
            of a given node, while <c>DescendantOrSelf(Predicate.Exists(attribute("id")))</c> selects those that have an attribute
            named "id". These are returned in document order.
            </summary>
            <param name="filter">The predicate to be applied</param>
            <returns>A <c>Step</c> that filters the nodes found on the descendant-or-self axis using the supplied predicate.</returns>
        </member>
        <member name="M:Saxon.Api.Steps.Following">
            <summary>
            Obtain a <c>Step</c> to navigate from a node to its following nodes
            (excluding descendants), which are returned in document order.
            </summary>
            <returns>A <c>Step</c> that selects all nodes on the following axis.</returns>
        </member>
        <member name="M:Saxon.Api.Steps.Following(System.String)">
            <summary>
            Obtain a <c>Step</c> that navigates from a node to the following elements having a specified
            local name, irrespective of the namespace. These are returned in document order.
            </summary>
            <param name="localName">The local name of the following elements to be selected by the <c>Step</c>,
            or "*" to select all following nodes that are elements</param>
            <returns>A <c>Step</c>, which selects the following elements of a supplied node that have the
            required local name.</returns>
        </member>
        <member name="M:Saxon.Api.Steps.Following(System.String,System.String)">
            <summary>
            Obtain a <c>Step</c> that navigates from a node to the following elements having a specified
            namespace URI and local name. These are returned in document order.
            </summary>
            <param name="uri">The namespace URI of the following elements to be selected by the <c>Step</c>:
            supply a zero-length string to indicate the null namespace</param>
            <param name="localName">The local name of the following elements to be selected by the <c>Step</c></param>
            <returns>A <c>Step</c>, which selects the following elements of a supplied node that have the
            required local name and namespace URI.</returns>
        </member>
        <member name="M:Saxon.Api.Steps.Following(Saxon.Api.Predicate{Saxon.Api.XdmItem})">
            <summary>
            Obtain a <c>Step</c> that filters the nodes found on the following axis using a supplied <c>Predicate</c>.
            The function call <c>Following(predicate)</c> is equivalent to <c>Following().Where(predicate)</c>.
            For example, <c>Following(IsElement())</c> returns a <c>Step</c> that selects the following elements
            of a given node, while <c>Following(Exists(Attribute("id")))</c> selects those that have an attribute
            named "id". These are returned in document order.
            </summary>
            <param name="filter">The predicate to be applied</param>
            <returns>A <c>Step</c> that filters the nodes found on the following axis using the supplied predicate.</returns>
        </member>
        <member name="M:Saxon.Api.Steps.FollowingSibling">
            <summary>
            Obtain a <c>Step</c> to navigate from a node to its following siblings, which are returned in document order.
            </summary>
            <returns>A <c>Step</c> that selects all nodes on the following-sibling axis.</returns>
        </member>
        <member name="M:Saxon.Api.Steps.FollowingSibling(System.String)">
            <summary>
             Obtain a <c>Step</c> that navigates from a node to the following sibling elements having a specified
             local name, irrespective of the namespace. These are returned in document order.
            </summary>
            <param name="localName">The local name of the following sibling elements to be selected by the <c>Step</c>,
            or "*" to select all following siblings that are element nodes</param>
            <returns>A <c>Step</c>, which selects the following sibling elements of a supplied node that have the
            required local name.</returns>
        </member>
        <member name="M:Saxon.Api.Steps.FollowingSibling(System.String,System.String)">
            <summary>
            Obtain a <c>Step</c> that navigates from a node to the following sibling elements having a specified
            namespace URI and local name. These are returned in document order.
            </summary>
            <param name="uri">The namespace URI of the following sibling elements to be selected by the <c>Step</c>:
            supply a zero-length string to indicate the null namespace</param>
            <param name="localName">The local name of the following sibling elements to be selected by the <c>Step</c></param>
            <returns>A <c>Step</c>, which selects the following sibling elements of a supplied node that have the
            required local name and namespace URI.</returns>
        </member>
        <member name="M:Saxon.Api.Steps.FollowingSibling(Saxon.Api.Predicate{Saxon.Api.XdmItem})">
            <summary>
            Obtain a <c>Step</c> that filters the nodes found on the following sibling axis using a supplied <c>Predicate</c>.
            The function call <c>FollowingSibling(predicate)</c> is equivalent to <c>FollowingSibling.Where(predicate)</c>.
            For example, <c>FollowingSibling(IsElement())</c> returns a <c>Step</c> that selects the following sibling 
            elements of a given node, while <c>FollowingSibling(Exists(Attribute("id")))</c> 
            selects those that have an attribute named "id". These are returned in document order.
            </summary>
            <param name="filter">The predicate to be applied</param>
            <returns>A <c>Step</c> that filters the nodes found on the following sibling axis using the supplied predicate.</returns>
        </member>
        <member name="M:Saxon.Api.Steps.Namespace">
            <summary>
            Obtain a <c>Step</c> to navigate from a node to its namespace nodes.
            </summary>
            <returns>A <c>Step</c> that selects all nodes on the namespace axis.</returns>
        </member>
        <member name="M:Saxon.Api.Steps.Namespace(System.String)">
            <summary>
            Obtain a <c>Step</c> that navigates from a node to its namespaces having a specified
            local name. The local name of a namespace node corresponds to the prefix used in the
            namespace binding.
            </summary>
            <param name="localName">The local name (representing the namespace prefix) of the namespace nodes
            to be selected by the <c>Step</c>, or "*" to select all namespaces</param>
            <returns>A <c>Step</c>, which selects the namespaces of a supplied node that have a
            given local name (prefix).</returns>
        </member>
        <member name="M:Saxon.Api.Steps.Namespace(Saxon.Api.Predicate{Saxon.Api.XdmItem})">
            <summary>
            Obtain a <c>Step</c> that filters the nodes found on the namespace axis using a supplied <c>Predicate</c>.
            The function call <c>Namespace(predicate)</c> is equivalent to <c>Namespace().Where(predicate)</c>.
            For example, <c>Namespace(Eq("http://www.w3.org/1999/XSL/Transform")</c>
            selects a namespace node that binds a prefix to the XSLT namespace.
            </summary>
            <param name="filter">The predicate to be applied</param>
            <returns>A <c>Step</c> that filters the nodes found on the namespace axis using the supplied predicate.</returns>
        </member>
        <member name="M:Saxon.Api.Steps.Parent">
            <summary>
            Obtain a <c>Step</c> to navigate from a node to its parent.
            </summary>
            <returns>A <c>Step</c> that selects all nodes on the parent axis (of which there is at most one).</returns>
        </member>
        <member name="M:Saxon.Api.Steps.Parent(System.String)">
            <summary>
            Obtain a <c>Step</c> that navigates from a node to the parent element provided it has a specified
            local name, irrespective of the namespace.
            </summary>
            <param name="localName">The local name of the parent element to be selected by the <c>Step</c>,
             or "*" to select the parent node provided it is an element</param>
            <returns>A <c>Step</c>, which selects the parent of a supplied node provided it is an element with the
            required local name.</returns>
        </member>
        <member name="M:Saxon.Api.Steps.Parent(System.String,System.String)">
            <summary>
            Obtain a <c>Step</c> that navigates from a node to the parent element provided it has a specified
            namespace URI and local name.
            </summary>
            <param name="uri">The namespace URI of the parent element to be selected by the <c>Step</c>:
            supply a zero-length string to indicate the null namespace</param>
            <param name="localName">The local name of the parent element to be selected by the <c>Step</c></param>
            <returns>A <c>Step</c>, which selects the parent element of a supplied node provided it is an 
            element with the required local name and namespace URI.</returns>
        </member>
        <member name="M:Saxon.Api.Steps.Parent(Saxon.Api.Predicate{Saxon.Api.XdmItem})">
            <summary>
            Obtain a <c>Step</c> that filters the node found on the parent axis using a supplied <c>Predicate</c>.
            The function call <c>Parent(filter)</c> is equivalent to <c>Parent(filter).where(Predicate)</c>.
            For example, <c>Parent(Predicate.IsElement()).GetFunc</c> returns a <c>Step</c> that selects the parent node provided it is an element
            </summary>
            <param name="filter">The predicate to be applied</param>
            <returns>A <c>Step</c> that filters the nodes found on the parent axis using the supplied predicate.</returns>
        </member>
        <member name="M:Saxon.Api.Steps.PrecedingSibling">
            <summary>
            Obtain a <c>Step</c> to navigate from a node to its preceding siblings, which are returned
            in reverse document order.
            </summary>
            <returns>A <c>Step</c> that selects all nodes on the preceding-sibling axis.</returns>
        </member>
        <member name="M:Saxon.Api.Steps.PrecedingSibling(System.String)">
            <summary>
            Obtain a <c>Step</c> that navigates from a node to the preceding sibling elements having a specified
            local name. These are returned in reverse document order.
            </summary>
            <param name="localName">The local name of the preceding sibling elements to be selected by the <c>Step</c>,
            or "*" to select all descendants that are element nodes</param>
            <returns>A <c>Step</c>, which selects the preceding sibling elements of a supplied node that have the
            required local name.</returns>
        </member>
        <member name="M:Saxon.Api.Steps.PrecedingSibling(System.String,System.String)">
            <summary>
            Obtain a <c>Step</c> that navigates from a node to the preceding sibling elements having a specified
            namespace URI and local name. These are returned in reverse document order.
            </summary>
            <param name="uri">The namespace URI of the preceding sibling elements to be selected by the <c>Step</c>:
            supply a zero-length string to indicate the null namespace</param>
            <param name="localName">The local name of the preceding sibling elements to be selected by the <c>Step</c></param>
            <returns>A <c>Step</c>, which selects the preceding sibling elements of a supplied node that have the
            required local name and namespace URI.</returns>
        </member>
        <member name="M:Saxon.Api.Steps.PrecedingSibling(Saxon.Api.Predicate{Saxon.Api.XdmItem})">
            <summary>
            Obtain a <c>Step</c> that filters the nodes found on the preceding sibling axis using a supplied <c>Predicate</c>.
            The function call <c>PrecedingSibling(predicate)</c> is equivalent to <c>PrecedingSibling().Where(predicate)</c>.
            For example, <c>PrecedingSibling(isElement())</c> returns a <c>Step</c> that selects the preceding sibling elements 
            of a given node, while <c>PrecedingSibling(Predicate.Exists(attribute("id")))</c> selects those that have an attribute named "id". 
            These are returned in reverse document order.
            </summary>
            <param name="filter">The predicate to be applied</param>
            <returns>A <c>Step</c> that filters the nodes found on the following sibling axis using the supplied predicate.</returns>
        </member>
        <member name="M:Saxon.Api.Steps.Preceding">
            <summary>
            Obtain a <c>Step</c> to navigate from a node to its preceding nodes (excluding ancestors),
            which are returned in reverse document order.
            </summary>
            <returns>A <c>Step</c> that selects all nodes on the preceding axis.</returns>
        </member>
        <member name="M:Saxon.Api.Steps.Preceding(System.String)">
            <summary>
            Obtain a <c>Step</c> that navigates from a node to the preceding elements having a specified
            local name. These are returned in reverse document order.
            </summary>
            <param name="localName">The local name of the preceding elements to be selected by the <c>Step</c>,
            or "*" to select all descendants that are element nodes</param>
            <returns>A <c>Step</c>, which selects the preceding elements of a supplied node that have the
            required local name.</returns>
        </member>
        <member name="M:Saxon.Api.Steps.Preceding(System.String,System.String)">
            <summary>
            Obtain a <c>Step</c> that navigates from a node to the preceding elements having a specified
            namespace URI and local name. These are returned in reverse document order.
            </summary>
            <param name="uri">The namespace URI of the preceding elements to be selected by the <c>Step</c>:
            supply a zero-length string to indicate the null namespace</param>
            <param name="localName">The local name of the preceding elements to be selected by the <c>Step</c></param>
            <returns>A <c>Step</c>, which selects the preceding elements of a supplied node that have the
            required local name and namespace URI.</returns>
        </member>
        <member name="M:Saxon.Api.Steps.Preceding(Saxon.Api.Predicate{Saxon.Api.XdmItem})">
            <summary>
            Obtain a Step that filters the nodes found on the preceding axis using a supplied <c>Predicate</c> .
            The function call <c>Preceding(predicate)</c> is equivalent to <c>Preceding().Where(predicate)</c>.
            For example, <c>Preceding(isElement())</c> returns a <c>Step</c> that selects the preceding elements 
            of a given node, while <c>Preceding(Predicate.Exists(attribute("id")))</c> selects those that have an attribute named "id". 
            These are returned in reverse document order.
            </summary>
            <param name="filter">The predicate to be applied</param>
            <returns>A <c>Step</c> that filters the nodes found on the following axis using the supplied predicate.</returns>
        </member>
        <member name="M:Saxon.Api.Steps.Self">
            <summary>
            Obtain a <c>Step</c> to navigate from a node to itself (useful only if applying a predicate).
            </summary>
            <returns>A <c>Step</c> that selects all nodes on the self axis (that is, the node itself).</returns>
        </member>
        <member name="M:Saxon.Api.Steps.Self(System.String)">
            <summary>
            Obtain a <c>Step</c> that navigates from a node to itself provided it is an element with a specified
            local name, irrespective of the namespace.
            </summary>
            <param name="localName">The local name of the element to be selected by the <c>Step</c>,
            or "*" to select the node provided that it is an element node</param>
            <returns>A <c>Step</c>, which selects the supplied node provided it has a given local name.</returns>
        </member>
        <member name="M:Saxon.Api.Steps.Self(System.String,System.String)">
            <summary>
            Obtain a <c>Step</c> that navigates from a node to itself provided it has a specified
            namespace URI and local name.
            </summary>
            <param name="uri">The namespace URI of the element to be selected by the <c>Step</c>:
            supply a zero-length string to indicate the null namespace</param>
            <param name="localName">The local name of the element to be selected by the <c>Step</c></param>
            <returns>A <c>Step</c>, which selects the supplied node provided it is an element with a given local name and namespace URI.</returns>
        </member>
        <member name="M:Saxon.Api.Steps.Self(Saxon.Api.Predicate{Saxon.Api.XdmNode})">
            <summary>
            Obtain a <c>Step</c> that filters the node found on the self axis using a supplied <c>Predicate</c> filter.
            The function call <c>Self(predicate)</c> is equivalent to <c>Self().Where(predicate)</c>.
            For example, <c>self(isElement())</c> returns a <c>Step</c> that selects the supplied node provided it is an element.
            </summary>
            <param name="filter">The predicate to be applied</param>
            <returns>A <c>Step</c> that filters the nodes found on the self axis using the supplied predicate.</returns>
        </member>
        <member name="M:Saxon.Api.Steps.Atomize">
            <summary>
            Obtain an selector that atomizes an item to produce a <c>XdmValue</c> of atomic values. Atomizing a node will
            usually produce a single atomic value, but in the case of schema-typed nodes using a list type, there may
            be more than one atomic value. Atomizing an array also returns multiple atomic values.
            </summary>
        </member>
        <member name="M:Saxon.Api.Steps.Text">
            <summary>
            Obtain a <c>Step</c> that returns text nodes found on the child axis.
            The function call <c>Text()</c> is equivalent to <c>Child().Where(Predicate.IsText)</c>.
            </summary>
            <returns>A <c>Step</c> that returns the text nodes found on the child axis.</returns>
        </member>
        <member name="M:Saxon.Api.Steps.Tokenize">
            <summary>
            Obtain a <c>Step</c> whose effect is to tokenize the supplied item on whitespace
            boundaries, returning a sequence of strings as <c>XdmAtomicValue</c> instances.
            </summary>
            <remarks><p>Note: the tokenize step, when applied to a string with leading and trailing whitespace,
            has the effect of removing this whitespace. In addition to its primary role, the function
            can therefore be useful for trimming the content of a single string.</p></remarks>
            <returns>A <c>Step</c> whose effect is to take a supplied item and split its string
            value into a sequence of <c>xs:string</c> instances</returns>
        </member>
        <member name="M:Saxon.Api.Steps.id(Saxon.Api.XdmNode)">
            <summary>
            Obtain a Step whose effect is to interpret the supplied item as an <c>xs:ID</c> value
            and return the nodes (in a given document) that have that string as their ID.
            </summary>
            <param name="doc">The root node (document node) of the document within which the ID
            value should be sought</param>
            <returns>A <c>Step</c> whose effect is to return the nodes that have the given string as their ID.</returns>
        </member>
        <member name="M:Saxon.Api.Steps.Path(System.String[])">
            <summary>
            Construct a path as a composite <c>Step</c> from a sequence of steps composed together.
            </summary>
            <param name="steps">The constituent steps in the path</param>
            <returns>A composite step.</returns>
        </member>
        <member name="M:Saxon.Api.Steps.PathFromList(System.Collections.Generic.List{Saxon.Api.Step{Saxon.Api.XdmNode,Saxon.Api.XdmNode}})">
            <summary>
            Construct a path as a composite <c>Step</c> from a list of steps composed together.
            </summary>
            <param name="steps">The constituent steps in the path</param>
            <returns>A composite step.</returns>
        </member>
        <member name="T:Saxon.Api.SequenceEnumerable`1">
            <summary>
            This class is an implementation of <c>IEnumerator</c> that wraps
            a (Java) <c>SequenceIterator</c>.
            </summary>
            <remarks>
            Because the underlying value can be evaluated lazily, it is possible
            for exceptions to occur as the sequence is being read.
            </remarks>
        </member>
        <member name="T:Saxon.Api.SequenceEnumerator`1">
            <summary>
            This class is an implementation of <c>IEnumerator</c> that wraps
            a (Java) <c>SequenceIterator</c>.
            </summary>
            <remarks>
            Because the underlying value can be evaluated lazily, it is possible
            for exceptions to occur as the sequence is being read.
            </remarks>
        </member>
        <member name="M:Saxon.Api.SequenceEnumerator`1.MoveNext">
            <summary>Move to the next item in the sequence</summary>
            <returns>true if there are more items in the sequence</returns>
        </member>
        <member name="M:Saxon.Api.SequenceEnumerator`1.Reset">
            <summary>Deprecated. Reset the enumeration so that the next call of
            <c>MoveNext</c> will position the enumeration at the
            first item in the sequence</summary>
        </member>
        <member name="M:Saxon.Api.SequenceEnumerator`1.Dispose">
            <summary>
            The Dispose method does not have any effect on this Enumerator
            </summary>
        </member>
        <member name="P:Saxon.Api.SequenceEnumerator`1.Current">
            <summary>Return the current item in the sequence</summary>
            <returns>An object which will always be an instance of <c>XdmItem</c></returns>
            
        </member>
        <member name="T:Saxon.Api.XdmAxis">
            <summary>
            Enumeration identifying the thirteen XPath axes
            </summary>
        </member>
        <member name="F:Saxon.Api.XdmAxis.Ancestor">
            <summary>The XPath ancestor axis</summary> 
        </member>
        <member name="F:Saxon.Api.XdmAxis.AncestorOrSelf">
            <summary>The XPath ancestor-or-self axis</summary> 
        </member>
        <member name="F:Saxon.Api.XdmAxis.Attribute">
            <summary>The XPath attribute axis</summary> 
        </member>
        <member name="F:Saxon.Api.XdmAxis.Child">
            <summary>The XPath child axis</summary> 
        </member>
        <member name="F:Saxon.Api.XdmAxis.Descendant">
            <summary>The XPath descendant axis</summary> 
        </member>
        <member name="F:Saxon.Api.XdmAxis.DescendantOrSelf">
            <summary>The XPath descandant-or-self axis</summary> 
        </member>
        <member name="F:Saxon.Api.XdmAxis.Following">
            <summary>The XPath following axis</summary> 
        </member>
        <member name="F:Saxon.Api.XdmAxis.FollowingSibling">
            <summary>The XPath following-sibling axis</summary> 
        </member>
        <member name="F:Saxon.Api.XdmAxis.Namespace">
            <summary>The XPath namespace axis</summary> 
        </member>
        <member name="F:Saxon.Api.XdmAxis.Parent">
            <summary>The XPath parent axis</summary> 
        </member>
        <member name="F:Saxon.Api.XdmAxis.Preceding">
            <summary>The XPath preceding axis</summary> 
        </member>
        <member name="F:Saxon.Api.XdmAxis.PrecedingSibling">
            <summary>The XPath preceding-sibling axis</summary> 
        </member>
        <member name="F:Saxon.Api.XdmAxis.Self">
            <summary>The XPath self axis</summary> 
        </member>
        <member name="T:Saxon.Api.EmptyEnumerator`1">
            <summary>
            An implementation of <code>IEnumerator</code> that iterates over an empty sequence.
            </summary>
        </member>
        <member name="F:Saxon.Api.EmptyEnumerator`1.INSTANCE">
            <summary>
            Create an instance of the enumerator with the <c>XdmItem</c> as the generic type
            </summary>
        </member>
        <member name="F:Saxon.Api.EmptyEnumerator`1.NODE_INSTANCE">
            <summary>
            Create an instance of the enumerator with the <c>XdmNode</c> as the generic type
            </summary>
        </member>
        <member name="M:Saxon.Api.EmptyEnumerator`1.Reset">
            <summary>
            Reset the enumerator
            </summary>
        </member>
        <member name="M:Saxon.Api.EmptyEnumerator`1.MoveNext">
            <summary>
            Move to the next item in the enumerator..
            </summary>
            <returns>true if successful move, false otherwise.</returns>
        </member>
        <member name="M:Saxon.Api.EmptyEnumerator`1.Dispose">
            <summary>
            The Dispose method is not implemented on this Enumerator
            </summary>
        </member>
        <member name="P:Saxon.Api.EmptyEnumerator`1.System#Collections#Generic#IEnumerator{T}#Current">
            <summary>
            The current item in the enumerator
            </summary>
        </member>
        <member name="T:Saxon.Api.NamespaceConstant">
            <summary> 
            Holds a set of constants representing known namespaces.
            </summary>
        </member>
        <member name="F:Saxon.Api.NamespaceConstant.NULL">
            <summary>
            A URI representing the null namespace (actually, an empty string)
            </summary>
        </member>
        <member name="F:Saxon.Api.NamespaceConstant.XML">
            <summary>
            Fixed namespace name for XML: "http://www.w3.org/XML/1998/namespace".
            </summary>
        </member>
        <member name="F:Saxon.Api.NamespaceConstant.XSLT">
            <summary>
            Fixed namespace name for XSLT: "http://www.w3.org/1999/XSL/Transform"
            </summary>
        </member>
        <member name="F:Saxon.Api.NamespaceConstant.SAXON">
            <summary>
            Fixed namespace name for Saxon: "http://saxon.sf.net/"
            </summary>
        </member>
        <member name="F:Saxon.Api.NamespaceConstant.SAXON_XSLT_EXPORT">
            <summary>
            Fixed namespace name for the export of a Saxon stylesheet package: "http://ns.saxonica.com/xslt/export"
            </summary>
        </member>
        <member name="F:Saxon.Api.NamespaceConstant.SCHEMA">
            <summary>
            Namespace name for XML Schema: "http://www.w3.org/2001/XMLSchema"
            </summary>
        </member>
        <member name="F:Saxon.Api.NamespaceConstant.SCHEMA_INSTANCE">
            <summary>
            XML-schema-defined namespace for use in instance documents ("xsi"): "http://www.w3.org/2001/XMLSchema-instance"
            </summary>
        </member>
        <member name="F:Saxon.Api.NamespaceConstant.SCHEMA_VERSIONING">
            <summary>
            Namespace defined in XSD 1.1 for schema versioning: "http://www.w3.org/2007/XMLSchema-versioning"
            </summary>
        </member>
        <member name="F:Saxon.Api.NamespaceConstant.SQL">
            <summary>
            Fixed namespace name for Saxon SQL extension: "http://saxon.sf.net/sql"
            </summary>
        </member>
        <member name="F:Saxon.Api.NamespaceConstant.EXSLT_COMMON">
            <summary>
            Fixed namespace name for EXSLT/Common: "http://exslt.org/common"
            </summary>
        </member>
        <member name="F:Saxon.Api.NamespaceConstant.EXSLT_MATH">
            <summary>
            Fixed namespace name for EXSLT/math: "http://exslt.org/math"
            </summary>
        </member>
        <member name="F:Saxon.Api.NamespaceConstant.EXSLT_SETS">
            <summary>
            Fixed namespace name for EXSLT/sets: "http://exslt.org/sets"
            </summary>
        </member>
        <member name="F:Saxon.Api.NamespaceConstant.EXSLT_DATES_AND_TIMES">
            <summary>
            Fixed namespace name for EXSLT/date: "http://exslt.org/dates-and-times"
            </summary>
        </member>
        <member name="F:Saxon.Api.NamespaceConstant.EXSLT_RANDOM">
            <summary>
            Fixed namespace name for EXSLT/random: "http://exslt.org/random"
            </summary>
        </member>
        <member name="F:Saxon.Api.NamespaceConstant.FN">
            <summary>
            The standard namespace for functions and operators: "http://www.w3.org/2005/xpath-functions"
            </summary>
        </member>
        <member name="F:Saxon.Api.NamespaceConstant.OUTPUT">
            <summary>
            The standard namespace for XQuery output declarations: "http://www.w3.org/2010/xslt-xquery-serialization"
            </summary>
        </member>
        <member name="F:Saxon.Api.NamespaceConstant.ERR">
            <summary>
            The standard namespace for system error codes: "http://www.w3.org/2005/xqt-errors"
            </summary>
        </member>
        <member name="F:Saxon.Api.NamespaceConstant.LOCAL">
            <summary>
            Predefined XQuery namespace for local functions: "http://www.w3.org/2005/xquery-local-functions"
            </summary>
        </member>
        <member name="F:Saxon.Api.NamespaceConstant.MATH">
            <summary>
            Namespace name for the XPath 3.0 math functions: "http://www.w3.org/2005/xpath-functions/math"
            </summary>
        </member>
        <member name="F:Saxon.Api.NamespaceConstant.MAP_FUNCTIONS">
            <summary>
            Namespace name for XPath 3.0 functions associated with maps: "http://www.w3.org/2005/xpath-functions/map"
            </summary>
        </member>
        <member name="F:Saxon.Api.NamespaceConstant.ARRAY_FUNCTIONS">
            <summary>
            Namespace name for XPath 3.0 functions associated with arrays: "http://www.w3.org/2005/xpath-functions/array"
            </summary>
        </member>
        <member name="F:Saxon.Api.NamespaceConstant.XHTML">
            <summary>
            The XHTML namespace: "http://www.w3.org/1999/xhtml"
            </summary>
        </member>
        <member name="F:Saxon.Api.NamespaceConstant.SVG">
            <summary>
            The SVG namespace: "http://www.w3.org/2000/svg"
            </summary>
        </member>
        <member name="F:Saxon.Api.NamespaceConstant.MATHML">
            <summary>
            The MathML namespace: "http://www.w3.org/1998/Math/MathML"
            </summary>
        </member>
        <member name="F:Saxon.Api.NamespaceConstant.XMLNS">
            <summary>
            The XMLNS namespace (used in DOM): "http://www.w3.org/2000/xmlns/"
            </summary>
        </member>
        <member name="F:Saxon.Api.NamespaceConstant.XLINK">
            <summary>
            The XLink namespace: "http://www.w3.org/1999/xlink"
            </summary>
        </member>
        <member name="F:Saxon.Api.NamespaceConstant.XQUERY_OPTIONS">
            <summary>
            The xquery-option namespace for the XQuery 3.0 feature names: "http://www.w3.org/2011/xquery-options"
            </summary>
        </member>
        <member name="F:Saxon.Api.NamespaceConstant.XQUERY">
            <summary>
            The xquery namespace for the XQuery 3.0 declare option: "http://www.w3.org/2012/xquery"
            </summary>
        </member>
        <member name="F:Saxon.Api.NamespaceConstant.JAVA_TYPE">
            <summary>
            Namespace for types representing external Java objects: "http://saxon.sf.net/java-type"
            </summary>
        </member>
        <member name="F:Saxon.Api.NamespaceConstant.DOT_NET_TYPE">
            <summary>
            Namespace for types representing external .NET objects: "http://saxon.sf.net/clitype"
            </summary>
        </member>
        <member name="F:Saxon.Api.NamespaceConstant.ANONYMOUS">
            <summary>
            Namespace for names allocated to anonymous types: "http://ns.saxonica.com/anonymous-type". 
            This exists so that a name fingerprint can be allocated for use as a type annotation.
            </summary>
        </member>
        <member name="F:Saxon.Api.NamespaceConstant.SCM">
            <summary>
            Namespace for the Saxon serialization of the schema component model: "http://ns.saxonica.com/schema-component-model"
            </summary>
        </member>
        <member name="F:Saxon.Api.NamespaceConstant.OBJECT_MODEL_SAXON">
            <summary>
            URI identifying the Saxon object model for use in the JAXP 1.3 XPath API: "http://saxon.sf.net/jaxp/xpath/om"
            </summary>
        </member>
        <member name="F:Saxon.Api.NamespaceConstant.CODEPOINT_COLLATION_URI">
            <summary>
            URI identifying the Unicode codepoint collation
            </summary>
        </member>
        <member name="F:Saxon.Api.NamespaceConstant.HTML5_CASE_BLIND_COLLATION_URI">
            <summary>
            URI identifying the HML5 ascii-case-blind collation
            </summary>
        </member>
        <member name="F:Saxon.Api.NamespaceConstant.SAXON_GENERATED_GLOBAL">
            <summary>
            Namespace for the names of generated global variables: "http://saxon.sf.net/generated-global-variable"
            </summary>
        </member>
        <member name="F:Saxon.Api.NamespaceConstant.SAXON_CONFIGURATION">
            <summary>
            Namespace for the Saxon configuration file: "http://saxon.sf.net/ns/configuration"
            </summary>
        </member>
        <member name="F:Saxon.Api.NamespaceConstant.EXPATH_ZIP">
            <summary>
            Namespace for the EXPath zip module: "http://expath.org/ns/zip" 
            </summary>
        </member>
        <member name="M:Saxon.Api.NamespaceConstant.isReserved(System.String)">
            <summary>
            Determine whether a namespace is a reserved namespace
            </summary>
            <returns><c>true</c>, if this namespace URI is a reserved namespace, <c>false</c> otherwise.</returns>
            <param name="uri">the namespace URI to be tested</param>
        </member>
        <member name="M:Saxon.Api.NamespaceConstant.isReservedInQuery31(System.String)">
            <summary>
            Determine whether a namespace is a reserved namespace in XQuery 3.1
            </summary>
            <returns><c>true</c>, if this namespace URI is reserved in XQuery 3.1, <c>false</c> otherwise.</returns>
            <param name="uri">the namespace URI to be tested</param>
        </member>
        <member name="M:Saxon.Api.NamespaceConstant.findSimilarNamespace(System.String)">
            <summary>
            Find a similar namespace to one that is a possible mis-spelling
            </summary>
            <returns>the correct spelling of the namespace</returns>
            <param name="candidate">the possibly mis-spelt namespace</param>
        </member>
        <member name="T:Saxon.Api.SchemaManager">
            <summary>
            A <c>SchemaManager</c> is responsible for compiling schemas and
            maintaining a cache of compiled schemas that can be used for validating
            instance documents.
            </summary>
            <remarks>
            <para>To obtain a <c>SchemaManager</c>, use the 
            <c>SchemaManager</c> property of the <c>Processor</c> object.</para>
            <para>In a schema-aware <c>Processor</c> there is exactly one
            <c>SchemaManager</c> (in a non-schema-aware <c>Processor</c> there is none).</para>
            <para>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.</para>
            <para>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 <c>&lt;xs:redefine&gt;</c>.</para>
            </remarks>
        </member>
        <member name="M:Saxon.Api.SchemaManager.SetErrorList(System.Collections.Generic.IList{Saxon.Api.XmlProcessingError})">
            <summary>
            List of errors. The caller may supply an empty list before calling <c>Compile</c>;
            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 <c>StaticError</c>.
            If no error list is supplied by the caller, error information will be written to
            the standard error stream.
            </summary>
            <remarks>
            <para>By supplying a custom <c>List</c> with a user-written <c>add()</c> method, it is possible to
            intercept error conditions as they occur.</para>
            <para>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.</para>
            </remarks>
            <param name="value">Supplied list.</param>
        </member>
        <member name="M:Saxon.Api.SchemaManager.GetErrorList">
            <summary>
            Get list of errors as <code>IList&lt;XmlProcessingError&gt;</code>
            </summary>
        </member>
        <member name="M:Saxon.Api.SchemaManager.Compile(System.IO.Stream,System.Uri)">
            <summary>
            Compile a schema supplied as a <c>Stream</c>. The resulting schema components are added
            to the cache.
            </summary>
            <param 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 name="baseUri">The base URI of the schema document, for resolving any references to other
            schema documents</param>        
        </member>
        <member name="M:Saxon.Api.SchemaManager.Compile(System.Uri)">
            <summary>
            Compile a schema, retrieving the source using a URI. The resulting schema components are added
            to the cache.
            </summary>
            <remarks>
            The document located via the URI is parsed using the <c>System.Xml</c> parser.
            </remarks>
            <param name="uri">The URI identifying the location where the schema document can be
            found</param>
        </member>
        <member name="M:Saxon.Api.SchemaManager.Compile(System.Xml.XmlReader)">
            <summary>
            Compile a schema, delivered using an <c>XmlReader</c>. The resulting schema components are added
            to the cache.
            </summary>
            <remarks>
            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).
            </remarks>
            <param name="reader">The <c>XmlReader</c> (that is, the XML parser) used to supply the source schema document</param>
        </member>
        <member name="M:Saxon.Api.SchemaManager.Compile(Saxon.Api.XdmNode)">
            <summary>
            Compile a schema document, located at an <c>XdmNode</c>. This may be a document node whose
            child is an <c>xs:schema</c> element, or it may be
            the <c>xs:schema</c> element itself. The resulting schema components are added
            to the cache.
            </summary>
            <param name="node">The document node or the outermost element node of a schema document.</param>
        </member>
        <member name="M:Saxon.Api.SchemaManager.NewSchemaValidator">
            <summary>
            Create a new <c>SchemaValidator</c>, which may be used for validating instance
            documents.
            </summary>
            <remarks>
            <para>The <c>SchemaValidator</c> uses the cache of schema components held by the
            <c>SchemaManager</c>. It may also add new components to this cache (for example,
            when the instance document references a schema using <c>xsi:schemaLocation</c>).
            It is also affected by changes to the schema cache that occur after the 
            <c>SchemaValidator</c> is created.</para>
            <para>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 <c>&lt;xs:redefine&gt;</c>.</para>
            </remarks>
        </member>
        <member name="M:Saxon.Api.SchemaManager.GetAtomicType(Saxon.Api.QName)">
            <summary>
            Factory method to get an <c>AtomicType</c> object representing the atomic type with a given <c>QName</c>.
            </summary>
            <remarks>
            It is undefined whether two calls on this method supplying the same <c>QName</c> will return the same
            <c>XdmAtomicType</c> object instance.
            </remarks>
            <param name="qname">The <c>QName</c> of the required type</param>
            <returns>An <c>AtomicType</c> object representing this type if it is present in this schema (and is an
            atomic type); otherwise, null. </returns>
        </member>
        <member name="P:Saxon.Api.SchemaManager.XsdVersion">
            <summary>
            The version of the W3C XML Schema Specification handled by this <c>SchemaManager</c>.
            </summary>
            <remarks>
            <para>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.
            </para>
            </remarks>
            
        </member>
        <member name="P:Saxon.Api.SchemaManager.Catalog">
            <summary>
            This property provides a way to set the catalog file which will be used by the Apache catalog resolver.
            </summary>
        </member>
        <member name="P:Saxon.Api.SchemaManager.SchemaResolver">
            <summary>
            The <c>SchemaResolver</c> is a user-supplied class used for resolving references to
            schema documents. It applies to references from one schema document to another
            appearing in <c>xs:import</c>, <c>xs:include</c>, and <c>xs:redefine</c>; to
            references from an instance document to a schema in <c>xsi:schemaLocation</c> and
            <c>xsi:noNamespaceSchemaLocation</c>, to <c>xsl:import-schema</c> in XSLT, and to
            the <c>import schema</c> declaration in XQuery.
            </summary>
        </member>
        <member name="P:Saxon.Api.SchemaManager.ErrorList">
            <summary>
            List of errors. The caller may supply an empty list before calling <c>Compile</c>;
            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 <c>StaticError</c>.
            If no error list is supplied by the caller, error information will be written to
            the standard error stream.
            </summary>
            <remarks>
            <para>By supplying a custom <c>List</c> with a user-written <c>add()</c> method, it is possible to
            intercept error conditions as they occur.</para>
            <para>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.</para>
            </remarks>
        </member>
        <member name="P:Saxon.Api.SchemaManager.ErrorReporter">
            <summary>Set the <c>ErrorReporter</c> to be used when validating instance documents as a user defined ErrorReporter.
            If this property is used then the ErrorList property and SetErrorList method is overriden </summary>
            <remarks>The <c>IErrorReporter</c> to be used</remarks>
        </member>
        <member name="T:Saxon.Api.SchemaValidator">
            <summary>
            A <c>SchemaValidator</c> 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 <c>SchemaManager</c>, together with
            any additional schema components located during the course of validation by means of an
            <c>xsl:schemaLocation</c> or <c>xsi:noNamespaceSchemaLocation</c> attribute within the
            instance document.
            </summary>
            <remarks>
            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.
            </remarks>    
        </member>
        <member name="M:Saxon.Api.SchemaValidator.SetValidityReporting(Saxon.Api.XmlDestination)">
            <summary>Set the validation reporting feature, which saves the validation errors in an XML file</summary>
            <param name="destination"> destination where XML will be sent</param>
        </member>
        <member name="M:Saxon.Api.SchemaValidator.SetInvalidityHandler(Saxon.Api.IInvalidityHandler)">
            <summary>Set the <c>InvalidityHandler</c> to be used when validating instance documents</summary>
            <param name="inHandler">the <c>InvalidityHandler</c> to be used</param>
        </member>
        <member name="M:Saxon.Api.SchemaValidator.AddSource(System.IO.Stream,System.Uri)">
            <summary>
            Add an instance document to the list of documents to be validated.
            </summary>
            <param name="source">Source document supplied as a <c>Stream</c></param>
            <param name="baseUri">Base URI of the source document</param>
        </member>
        <member name="M:Saxon.Api.SchemaValidator.AddSource(System.Uri)">
            <summary>
            Add an instance document to the list of documents to be validated
            </summary>
            <param name="uri">URI of the source document</param>
        </member>
        <member name="M:Saxon.Api.SchemaValidator.AddSource(System.Xml.XmlReader)">
            <summary>
            Add an instance document to the list of documents to be validated
            </summary>
            <param name="reader">Source document supplied as an <c>XmlReader</c></param>
        </member>
        <member name="M:Saxon.Api.SchemaValidator.AddSource(Saxon.Api.XdmNode)">
            <summary>
            Add an instance document to the list of documents to be validated.
            </summary>
            <param name="source">Source document supplied as an <c>XdmNode</c> value</param>
        </member>
        <member name="M:Saxon.Api.SchemaValidator.SetSource(System.IO.Stream,System.Uri)">
            <summary>
            Supply the instance document to be validated in the form of a <c>Stream</c>
            </summary>
            <param 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 name="baseUri">The base URI to be used for resolving any relative
            references, for example a reference to an <c>xsi:schemaLocation</c></param>                  
        </member>
        <member name="M:Saxon.Api.SchemaValidator.SetSource(System.Uri)">
            <summary>
            Supply the instance document to be validated in the form of a <c>Uri</c> reference
            </summary>
            <param name="uri">URI of the document to be validated</param>                  
        </member>
        <member name="M:Saxon.Api.SchemaValidator.SetSource(System.Xml.XmlReader)">
            <summary>
            Supply the instance document to be validated, in the form of an <c>XmlReader</c>.
            </summary>
            <remarks>
            The <c>XmlReader</c> is responsible for parsing the document; this method validates it.
            </remarks>
            <param 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>
        </member>
        <member name="M:Saxon.Api.SchemaValidator.SetSource(Saxon.Api.XdmNode)">
            <summary>
            Supply the instance document to be validated in the form of an <c>XdmNode</c>.
            </summary>
            <remarks>
            <para>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.
            </para>
            </remarks>
            <param name="source">The document or element node at the root of the tree
            to be validated</param>        
        </member>
        <member name="M:Saxon.Api.SchemaValidator.SetDestination(Saxon.Api.XmlDestination)">
            <summary>
            Supply the destination to hold the validated document. If no destination
            is supplied, the validated document is discarded.
            </summary>
            <remarks>
            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 <c>XdmDestination</c>.
            </remarks>
            <param name="destination">
            The destination to hold the validated document.
            </param>
        </member>
        <member name="M:Saxon.Api.SchemaValidator.Close">
            <summary>
            Close the destination, allowing resources to be released. Saxon calls this method
            when it has finished writing to the destination
            </summary>
        </member>
        <member name="M:Saxon.Api.SchemaValidator.SetParameter(Saxon.Api.QName,Saxon.Api.XdmValue)">
            <summary>
            Set the value of a schema parameter (a parameter defined in the schema using the <c>saxon:param</c> extension)
            </summary>
            <param name="name">the name of the schema parameter, as a QName</param>
            <param name="value">the value of the schema  parameter, or null to clear a previously set value</param>
        </member>
        <member name="M:Saxon.Api.SchemaValidator.GetParameter(Saxon.Api.QName)">
            <summary>
            Get the value that has set for a schema processor (a parameter defined in the schema using the <c>saxon:param</c>
            extension)
            </summary>
            <param name="name">the parameter whose name is required</param>
            <returns>the value that has been set for the parameter, or the EmptySequence if no value has been set</returns>
        </member>
        <member name="M:Saxon.Api.SchemaValidator.Run">
            <summary>
            Run the validation of the supplied source document, optionally
            writing the validated document to the supplied destination.
            </summary>
        </member>
        <member name="P:Saxon.Api.SchemaValidator.IsLax">
            <summary>
            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.
            </summary>
        </member>
        <member name="P:Saxon.Api.SchemaValidator.UseXsiSchemaLocation">
            <summary>
            This property defines whether the schema processor will recognize, and attempt to
            dereference, any <c>xsi:schemaLocation</c> and <c>xsi:noNamespaceSchemaLocation</c>
            attributes encountered in the instance document. The default value is true.
            </summary>
        </member>
        <member name="P:Saxon.Api.SchemaValidator.DocumentElementName">
            <summary>
            The name of the required top-level element of the document to be validated (that is, the
            name of the outermost element of the document).
            if no value is supplied, there is no constraint on the required type
            </summary>
        </member>
        <member name="P:Saxon.Api.SchemaValidator.DocumentElementTypeName">
            <summary>
            The name of the required type of the top-level element of the document to be validated.
            QName of the name of the required type of the document element, or null if no value has been set.
            If no value is supplied, there is no constrin on the required type
            </summary>
        </member>
        <member name="P:Saxon.Api.SchemaValidator.ExpendAttributeDefaults">
            <summary>
            Ask and set whether attribute defaults defined in a schema are to be expanded or not
            (by default, fixed and default attribute values are expaned, that is, they are inserted) into
            the document during validation as if they were present in the instance being validated)
            </summary>
        </member>
        <member name="P:Saxon.Api.SchemaValidator.ErrorList">
            <summary>
            List of errors. The caller may supply an empty list before calling <c>Compile</c>;
            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 <c>StaticError</c>.
            If no error list is supplied by the caller, error information will be written to
            the standard error stream.
            </summary>
            <remarks>
            <para>By supplying a custom <c>List</c> with a user-written <c>add()</c> method, it is possible to
            intercept error conditions as they occur.</para>
            <para>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.</para>
            </remarks>
        </member>
        <member name="T:Saxon.Api.SchemaResolver">
            <summary>
            The <c>SchemaResolver</c> is a user-supplied class used for resolving references to
            schema documents. It applies to references from one schema document to another
            appearing in <c>xs:import</c>, <c>xs:include</c>, and <c>xs:redefine</c>; to
            references from an instance document to a schema in <c>xsi:schemaLocation</c> and
            <c>xsi:noNamespaceSchemaLocation</c>, to <c>xsl:import-schema</c> in XSLT, and to
            the <c>import schema</c> declaration in XQuery.
            </summary>
        </member>
        <member name="M:Saxon.Api.SchemaResolver.GetSchemaDocuments(System.String,System.Uri,System.String[])">
            public*
        </member>
        <member name="M:Saxon.Api.SchemaResolver.GetEntity(System.Uri)">
            public*
        </member>
        <member name="T:Saxon.Api.DotNetSchemaURIResolver">
            <summary>
            internal class that wraps a (.NET) QueryResolver to create a (Java) SchemaURIResolver
            </summary>
        </member>
        <member name="M:Saxon.Api.DotNetSchemaURIResolver.#ctor(Saxon.Api.SchemaResolver)">
            <summary>
            Initializes a new instance of the <see cref="T:Saxon.Api.DotNetSchemaURIResolver"/> class.
            </summary>
            <param name="resolver">Resolver.</param>
        </member>
        <member name="M:Saxon.Api.DotNetSchemaURIResolver.resolve(System.String,System.String,System.String[])">
            <summary>
            Resolve the specified targetNamespace, baseURI and locations.
            </summary>
            <param name="targetNamespace">Target namespace.</param>
            <param name="baseURI">BaseURI.</param>
            <param name="locations">Locations.</param>
        </member>
        <member name="T:Saxon.Api.XdmItemType">
            <summary>
            Abstract class representing an item type. This may be the generic item type <c>item()</c>,
            an atomic type, the generic node type <code>node()</code>, a specific node kind such as
            <c>element()</c> or <c>text()</c>, or the generic function type <code>function()</code>.
            </summary>
            <remarks>
            More specific node types (such as <c>element(E)</c> or <c>schema-element(E)</c>) cannot currently
            be instantiated in this API.
            </remarks>
        </member>
        <member name="M:Saxon.Api.XdmItemType.Matches(Saxon.Api.XdmItem)">
            <summary>
            Determine whether this item type matches a given item.
            </summary>
            <param name="item">the item to be tested against this item type</param>
            <returns>true if the item matches this item type, false if it does not match.</returns>
        </member>
        <member name="M:Saxon.Api.XdmItemType.Subsumes(Saxon.Api.XdmItemType)">
            <summary>
            Determine whether this ItemType subsumes another ItemType. Specifically,
            <code>A.subsumes(B)</code> is true if every value that matches the ItemType B also matches
            the ItemType A.
            </summary>
            <param name="other">the other ItemType</param>
            <returns>true if this ItemType subsumes the other ItemType. This includes the case where A and B
                    represent the same ItemType.</returns>
        </member>
        <member name="M:Saxon.Api.XdmItemType.ToString">
            <summary>
            Get a string representation of the type. This will be a string that confirms to
            XPath ItemType production, for example a QName (always in 'Q{uri}local' format, or a
            construct such as 'node()' or 'map(*)'). If the type is an anonymous schema type, the 
            name of the nearest named base type will be given, preceded by the character '&lt;'
            </summary>
            <returns>a string representation of the type</returns>
        </member>
        <member name="T:Saxon.Api.XdmAnyItemType">
            <summary>
            Singleton class representing the item type <c>item()</c>, which matches any item.
            </summary>
        </member>
        <member name="F:Saxon.Api.XdmAnyItemType.Instance">
            <summary>
            The singleton instance of this class: an <c>XdmItemType</c> corresponding to the
            item type <c>item()</c>, which matches any item.
            </summary>
        </member>
        <member name="M:Saxon.Api.XdmAnyItemType.Matches(Saxon.Api.XdmItem)">
            <summary>
            Determine whether this item type matches a given item.
            </summary>
            <param name="item">the item to be tested against this item type</param>
            <returns>true if the item matches this item type, false if it does not match.</returns>
        </member>
        <member name="M:Saxon.Api.XdmAnyItemType.Subsumes(Saxon.Api.XdmItemType)">
            <summary>
            Determine whether this ItemType subsumes another ItemType. Specifically,
            <code>A.subsumes(B)</code> is true if every value that matches the ItemType B also matches
            the ItemType A.
            </summary>
            <param name="other">the other ItemType</param>
            <returns>true if this ItemType subsumes the other ItemType. This includes the case where A and B
                    represent the same ItemType.</returns>
        </member>
        <member name="T:Saxon.Api.XdmAnyMapType">
            <summary>
            Singleton class representing the item type <c>map(*)</c>, which matches any map.
            </summary>
        </member>
        <member name="F:Saxon.Api.XdmAnyMapType.Instance">
            <summary>
            The singleton instance of this class: an <c>XdmMapType</c> corresponding to the
            item type <c>map(*)</c>, which matches any map.
            </summary>
        </member>
        <member name="T:Saxon.Api.XdmAnyArrayType">
            <summary>
            Singleton class representing the item type <c>array(*)</c>, which matches any array.
            </summary>
        </member>
        <member name="F:Saxon.Api.XdmAnyArrayType.Instance">
            <summary>
            The singleton instance of this class: an <c>XdmArrayType</c> corresponding to the
            item type <c>array(*)</c>, which matches any array.
            </summary>
        </member>
        <member name="T:Saxon.Api.XdmAnyNodeType">
            <summary>
            Singleton class representing the item type <c>node()</c>, which matches any node.
            </summary>
        </member>
        <member name="F:Saxon.Api.XdmAnyNodeType.Instance">
            <summary>
            The singleton instance of this class: an <c>XdmItemType</c> corresponding to the
            item type <c>node()</c>, which matches any node.
            </summary>
        </member>
        <member name="M:Saxon.Api.XdmAnyNodeType.Matches(Saxon.Api.XdmItem)">
            <summary>
            Determine whether this item type matches a given item.
            </summary>
            <param name="item">the item to be tested against this item type</param>
            <returns>true if the item matches this item type, false if it does not match.</returns>
        </member>
        <member name="M:Saxon.Api.XdmAnyNodeType.Subsumes(Saxon.Api.XdmItemType)">
            <summary>
             Determine whether this ItemType subsumes another ItemType. Specifically,
            <code>A.subsumes(B)</code> is true if every value that matches the ItemType B also matches
            the ItemType A.
            </summary>
            <param name="other">the other ItemType</param>
            <returns>true if this ItemType subsumes the other ItemType. This includes the case where A and B
                    represent the same ItemType.</returns>
        </member>
        <member name="T:Saxon.Api.XdmAnyFunctionType">
            <summary>
            Singleton class representing the item type <c>function(*)</c>, which matches any function item.
            </summary>
        </member>
        <member name="F:Saxon.Api.XdmAnyFunctionType.Instance">
            <summary>
            The singleton instance of this class: an <c>XdmItemType</c> corresponding to the
            item type <c>function(*)</c>, which matches any function item.
            </summary>
        </member>
        <member name="T:Saxon.Api.XdmAtomicType">
            <summary>
            An instance of class <c>XdmAtomicType</c> represents a specific atomic type, for example
            <c>xs:double</c>, <c>xs:integer</c>, or <c>xs:anyAtomicType</c>. This may be either a built-in
            atomic type or a type defined in a user-written schema.
            </summary>
            <remarks>
            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.
            </remarks>
        </member>
        <member name="F:Saxon.Api.XdmAtomicType.Instance">
            <summary>
            Instance object of the <c>XdmAtomicType</c> class
            </summary>
        </member>
        <member name="F:Saxon.Api.XdmAtomicType.SHORT">
            <summary>
             ItemType representing the built-in (but non-primitive) type xs:short
            </summary>
        </member>
        <member name="F:Saxon.Api.XdmAtomicType.STRING">
            <summary>
            ItemType representing the primitive type xs:string
            </summary>
        </member>
        <member name="F:Saxon.Api.XdmAtomicType.BOOLEAN">
            <summary>
            ItemType representing the primitive type xs:boolean
            </summary>
        </member>
        <member name="F:Saxon.Api.XdmAtomicType.DURATION">
            <summary>
            ItemType representing the primitive type xs:duration
            </summary>
        </member>
        <member name="F:Saxon.Api.XdmAtomicType.DATE_TIME">
            <summary>
            ItemType representing the primitive type xs:dateTime
            </summary>
        </member>
        <member name="F:Saxon.Api.XdmAtomicType.DATE">
            <summary>
            ItemType representing the primitive type xs:date
            </summary>
        </member>
        <member name="F:Saxon.Api.XdmAtomicType.TIME">
            <summary>
            ItemType representing the primitive type xs:time
            </summary>
        </member>
        <member name="F:Saxon.Api.XdmAtomicType.G_YEAR_MONTH">
            <summary>
            ItemType representing the primitive type xs:gYearMonth
            </summary>
        </member>
        <member name="F:Saxon.Api.XdmAtomicType.G_MONTH">
            <summary>
             ItemType representing the primitive type xs:gMonth
            </summary>
        </member>
        <member name="F:Saxon.Api.XdmAtomicType.G_MONTH_DAY">
            <summary>
            ItemType representing the primitive type xs:gMonthDay
            </summary>
        </member>
        <member name="F:Saxon.Api.XdmAtomicType.G_YEAR">
            <summary>
            ItemType representing the primitive type xs:gYear
            </summary>
        </member>
        <member name="F:Saxon.Api.XdmAtomicType.G_DAY">
            <summary>
            ItemType representing the primitive type xs:gDay
            </summary>
        </member>
        <member name="F:Saxon.Api.XdmAtomicType.HEX_BINARY">
            <summary>
            ItemType representing the primitive type xs:hexBinary
            </summary>
        </member>
        <member name="F:Saxon.Api.XdmAtomicType.BASE64_BINARY">
            <summary>
             ItemType representing the primitive type xs:base64Binary
            </summary>
        </member>
        <member name="F:Saxon.Api.XdmAtomicType.ANY_URI">
            <summary>
            ItemType representing the primitive type xs:anyURI
            </summary>
        </member>
        <member name="F:Saxon.Api.XdmAtomicType.QNAME">
            <summary>
            ItemType representing the primitive type xs:QName
            </summary>
        </member>
        <member name="F:Saxon.Api.XdmAtomicType.NOTATION">
            <summary>
            ItemType representing the primitive type xs:NOTATION
            </summary>
        </member>
        <member name="F:Saxon.Api.XdmAtomicType.UNTYPED_ATOMIC">
            <summary>
             ItemType representing the XPath-defined type xs:untypedAtomic
            </summary>
        </member>
        <member name="F:Saxon.Api.XdmAtomicType.DECIMAL">
            <summary>
            ItemType representing the primitive type xs:decimal
            </summary>
        </member>
        <member name="F:Saxon.Api.XdmAtomicType.FLOAT">
            <summary>
            ItemType representing the primitive type xs:float
            </summary>
        </member>
        <member name="F:Saxon.Api.XdmAtomicType.DOUBLE">
            <summary>
            ItemType representing the primitive type xs:double
            </summary>
        </member>
        <member name="F:Saxon.Api.XdmAtomicType.INTEGER">
            <summary>
            ItemType representing the built-in (but non-primitive) type xs:integer
            </summary>
        </member>
        <member name="F:Saxon.Api.XdmAtomicType.NON_POSITIVE_INTEGER">
            <summary>
            
            </summary>
        </member>
        <member name="F:Saxon.Api.XdmAtomicType.NEGATIVE_INTEGER">
            <summary>
            ItemType representing the built-in (but non-primitive) type xs:negativeInteger
            </summary>
        </member>
        <member name="F:Saxon.Api.XdmAtomicType.LONG">
            <summary>
            ItemType representing the built-in (but non-primitive) type xs:long
            </summary>
        </member>
        <member name="F:Saxon.Api.XdmAtomicType.INT">
            <summary>
            ItemType representing the built-in (but non-primitive) type xs:int
            </summary>
        </member>
        <member name="F:Saxon.Api.XdmAtomicType.BYTE">
            <summary>
            ItemType representing the built-in (but non-primitive) type xs:byte
            </summary>
        </member>
        <member name="F:Saxon.Api.XdmAtomicType.NON_NEGATIVE_INTEGER">
            <summary>
            ItemType representing the built-in (but non-primitive) type xs:nonNegativeInteger
            </summary>
        </member>
        <member name="F:Saxon.Api.XdmAtomicType.POSITIVE_INTEGER">
            <summary>
            ItemType representing the built-in (but non-primitive) type xs:positiveInteger
            </summary>
        </member>
        <member name="F:Saxon.Api.XdmAtomicType.UNSIGNED_LONG">
            <summary>
            ItemType representing the built-in (but non-primitive) type xs:unsignedLong
            </summary>
        </member>
        <member name="F:Saxon.Api.XdmAtomicType.UNSIGNED_INT">
            <summary>
            ItemType representing the built-in (but non-primitive) type xs:unsignedInt
            </summary>
        </member>
        <member name="F:Saxon.Api.XdmAtomicType.UNSIGNED_SHORT">
            <summary>
            ItemType representing the built-in (but non-primitive) type xs:unsignedShort
            </summary>
        </member>
        <member name="F:Saxon.Api.XdmAtomicType.UNSIGNED_BYTE">
            <summary>
            ItemType representing the built-in (but non-primitive) type xs:unsignedByte
            </summary>
        </member>
        <member name="F:Saxon.Api.XdmAtomicType.YEAR_MONTH_DURATION">
            <summary>
            ItemType representing the built-in (but non-primitive) type xs:yearMonthDuration
            </summary>
        </member>
        <member name="F:Saxon.Api.XdmAtomicType.DAY_TIME_DURATION">
            <summary>
            ItemType representing the built-in (but non-primitive) type xs:dayTimeDuration
            </summary>
        </member>
        <member name="F:Saxon.Api.XdmAtomicType.NORMALIZED_STRING">
            <summary>
            ItemType representing the built-in (but non-primitive) type xs:normalizedString
            </summary>
        </member>
        <member name="F:Saxon.Api.XdmAtomicType.TOKEN">
            <summary>
            ItemType representing the built-in (but non-primitive) type xs:token
            </summary>
        </member>
        <member name="F:Saxon.Api.XdmAtomicType.LANGUAGE">
            <summary>
            ItemType representing the built-in (but non-primitive) type xs:language
            </summary>
        </member>
        <member name="F:Saxon.Api.XdmAtomicType.NAME">
            <summary>
            ItemType representing the built-in (but non-primitive) type xs:Name
            </summary>
        </member>
        <member name="F:Saxon.Api.XdmAtomicType.NMTOKEN">
            <summary>
            ItemType representing the built-in (but non-primitive) type xs:NMTOKEN
            </summary>
        </member>
        <member name="F:Saxon.Api.XdmAtomicType.NCNAME">
            <summary>
            ItemType representing the built-in (but non-primitive) type xs:NCName
            </summary>
        </member>
        <member name="F:Saxon.Api.XdmAtomicType.ID">
            <summary>
            ItemType representing the built-in (but non-primitive) type xs:ID
            </summary>
        </member>
        <member name="F:Saxon.Api.XdmAtomicType.IDREF">
            <summary>
            ItemType representing the built-in (but non-primitive) type xs:IDREF
            </summary>
        </member>
        <member name="F:Saxon.Api.XdmAtomicType.ENTITY">
            <summary>
            ItemType representing the built-in (but non-primitive) type xs:ENTITY
            </summary>
        </member>
        <member name="F:Saxon.Api.XdmAtomicType.DATE_TIME_STAMP">
            <summary>
            ItemType representing the built-in (but non-primitive) type xs:dateTimeStamp
            (introduced in XSD 1.1)
            </summary>
        </member>
        <member name="M:Saxon.Api.XdmAtomicType.BuiltInAtomicType(Saxon.Api.QName)">
            <summary>
            Get an <c>XdmAtomicType</c> object representing a built-in atomic type with a given name.
            </summary>
            <param name="name">The name of the required built-in atomic type</param>
            <returns>An <c>XdmAtomicType</c> 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.</returns>
        </member>
        <member name="M:Saxon.Api.XdmAtomicType.Matches(Saxon.Api.XdmItem)">
            <summary>
            Determine whether this item type matches a given item
            </summary>
            <param name="item">the item to be tested against this item type</param>
            <returns>true if the item matches this item type, false if it does not match</returns>
        </member>
        <member name="M:Saxon.Api.XdmAtomicType.Subsumes(Saxon.Api.XdmItemType)">
            <summary>
            Determine whether this ItemType subsumes another ItemType. Specifically
            <code>A.Sumsumes(B)</code> is true if every value that matches the ItemType B also
            matches the ItemType A.
            </summary>
            <param name="other">the other ItemType</param>
            <returns>true if this ItemType subsumes the other ItemType. This includes the case where A and B
            represent the same ItemType.</returns>
        </member>
        <member name="P:Saxon.Api.XdmAtomicType.Name">
            <summary>
            The name of the atomic type, or null if the type is anonymous.
            </summary>
        </member>
        <member name="T:Saxon.Api.XdmNodeKind">
            <summary>
            Instances of <c>XdmNodeKind</c> represent the item types denoted in XPath as <c>document-node()</c>,
            <c>element()</c>, <c>attribute()</c>, <c>text()</c>, and so on. These are all represented by singular named instances.
            </summary>
        </member>
        <member name="F:Saxon.Api.XdmNodeKind.Document">
            <summary>
            The item type <c>document-node()</c>
            </summary>
        </member>
        <member name="F:Saxon.Api.XdmNodeKind.Element">
            <summary>
            The item type <c>element()</c>
            </summary>
        </member>
        <member name="F:Saxon.Api.XdmNodeKind.Attribute">
            <summary>
            The item type <c>attribute()</c>
            </summary>
        </member>
        <member name="F:Saxon.Api.XdmNodeKind.Text">
            <summary>
            The item type <c>text()</c>
            </summary>
        </member>
        <member name="F:Saxon.Api.XdmNodeKind.Comment">
            <summary>
            The item type <c>comment()</c>
            </summary>
        </member>
        <member name="F:Saxon.Api.XdmNodeKind.ProcessingInstruction">
            <summary>
            The item type <c>processing-instruction()</c>
            </summary>
        </member>
        <member name="F:Saxon.Api.XdmNodeKind.Namespace">
            <summary>
            The item type <c>namespace-node()</c>
            </summary>
        </member>
        <member name="M:Saxon.Api.XdmNodeKind.ForNode(Saxon.Api.XdmNode)">
            <summary>
            Get the item type representing the node kind of a supplied node
            </summary>
            <param name="node">The node whose node kind is required</param>
            <returns>The relevant node kind</returns>
        </member>
        <member name="M:Saxon.Api.XdmNodeKind.Matches(Saxon.Api.XdmItem)">
            <summary>
            Determine whether this item type matches a given item.
            </summary>
            <param name="item">item the item to be tested against this item type</param>
            <returns>true if the item matches this item type, false if it does not match.</returns>
        </member>
        <member name="M:Saxon.Api.XdmNodeKind.Subsumes(Saxon.Api.XdmItemType)">
            <summary>
             Determine whether this ItemType subsumes another ItemType. Specifically,
            <code>A.subsumes(B)</code> is true if every value that matches the ItemType B also matches
            the ItemType A.
            </summary>
            <param name="other">the other ItemType</param>
            <returns>true if this ItemType subsumes the other ItemType. This includes the case where A and B
                    represent the same ItemType.</returns>
        </member>
        <member name="M:Saxon.Api.XdmNodeKind.ForNodeType(System.Xml.XmlNodeType)">
            <summary>
            Get the item type corresponding to an <c>XmlNodeType</c> as defined in the <c>System.Xml</c> package
            </summary>
            <param name="type">The <c>XmlNodeType</c> to be converted</param>
            <returns>The corresponding <c>XdmNodeKind</c></returns>
        </member>
        <member name="T:Saxon.Api.XdmSequenceType">
            <summary>
            An instance of class <c>XdmSequenceType</c> represents a sequence type, that is, the combination
            of an item type and an occurrence indicator.
            </summary>
        </member>
        <member name="F:Saxon.Api.XdmSequenceType.ZERO_OR_MORE">
            <summary>
            Occurrence indicator representing zero or more occurrences ("*")
            </summary>
        </member>
        <member name="F:Saxon.Api.XdmSequenceType.ONE_OR_MORE">
            <summary>
            Occurrence indicator representing one or more occurrences ("+")
            </summary>
        </member>
        <member name="F:Saxon.Api.XdmSequenceType.ZERO_OR_ONE">
            <summary>
            Occurrence indicator representing zero or one occurrences ("?")
            </summary>
        </member>
        <member name="F:Saxon.Api.XdmSequenceType.ZERO">
            <summary>
            Occurrence indicator representing exactly zero occurrences ("0")
            </summary>
        </member>
        <member name="F:Saxon.Api.XdmSequenceType.ONE">
            <summary>
            Occurrence indicator representing zero or more occurrences (space character, " ")
            </summary>
        </member>
        <member name="M:Saxon.Api.XdmSequenceType.#ctor(Saxon.Api.XdmItemType,System.Char)">
            <summary>
            Create an <c>XdmSequenceType</c> corresponding to a given <c>XdmItemType</c> and occurrence indicator
            </summary>
            <param name="itemType">The item type</param>
            <param name="occurrenceIndicator">The occurrence indicator, one of '?' (zero-or-one), 
            '*' (zero-or-more), '+' (one-or-more), ' ' (a single space) (exactly one),
            or '0' (exactly zero). The type <c>empty-sequence()</c>
            can be represented by an occurrence indicator of 'º' with any item type.</param>
        </member>
        <member name="T:Saxon.Api.XPathCompiler">
            <summary>
            An <c>XPathCompiler</c> object allows XPath queries to be compiled.
            The compiler holds information that represents the static context
            for the expression.
            </summary>
            <remarks>
            <para>To construct an <c>XPathCompiler</c>, use the factory method
            <c>NewXPathCompiler</c> on the <see cref="P:Saxon.Api.XPathCompiler.Processor"/> object.</para>
            <para>An <c>XPathCompiler</c> may be used repeatedly to compile multiple
            queries. Any changes made to the <c>XPathCompiler</c> (that is, to the
            static context) do not affect queries that have already been compiled.
            An <c>XPathCompiler</c> may be used concurrently in multiple threads, but
            it should not then be modified once initialized.</para>
            <para> The <code>XPathCompiler</code> has the ability to maintain a cache of compiled
            expressions. This is active only if enabled by setting the <c>Caching</c> 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 <c>BaseUri</c> property. Unless the cache is emptied,
            it grows indefinitely: compiled expressions are never discarded.</para>
            </remarks>
        </member>
        <member name="M:Saxon.Api.XPathCompiler.DeclareDefaultCollation(System.String)">
            <summary>
            Declare the default collation
            </summary>
            <param name="uri">the absolute URI of the default collation. This URI must identify a known collation;
            either one that has been explicitly declared, or one that is recognized implicitly, such as a UCA collation</param>
        </member>
        <member name="M:Saxon.Api.XPathCompiler.DeclareNamespace(System.String,System.String)">
            <summary>
            Declare a namespace for use by the XPath expression.
            </summary>
            <param 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 name="uri">The namespace URI. It is possible to specify
            a zero-length string to "undeclare" a namespace.</param>
        </member>
        <member name="M:Saxon.Api.XPathCompiler.AddXsltFunctionLibrary(Saxon.Api.XsltPackage)">
            <summary>
            Make available a set of functions defined in an XSLT 3.0 package. All functions
            defined with <c>visibility="public"</c>
            (or exposed as public using <c>xsl:expose</c>
            become part of the static context for an XPath expression created using this
            <c>XPathCompiler</c>. The functions are added to the search path after all existing
            functions, including functions added using a previous call on this method.
            <p>Note that if the library package includes functions that reference stylesheet parameters
            (or global variables that depend on the context item), then there is no way of supplying
            values for such parameters; calling such functions will cause a run-time error.</p>
            </summary>
            <param name="libraryPackage">the XSLT compiled library package whose functions are to be made available</param>
        </member>
        <member name="M:Saxon.Api.XPathCompiler.GetNamespaceURI(System.String,System.Boolean)">
            <summary>
            Get the namespace URI part of a QName provided in lexical form (<c>prefix:localname</c>)
            </summary>
            <param name="lexicalName">The lexical QName. This may either be a plain <c>NCName</c> (a local name
            with no prefix or colon) or a lexical name using a prefix that is bound to a namespace.</param>
            <param name="useDefault">Set to true if the default namespace for elements and types is to be used
            in the case where there is no prefix. If false, no prefix means no namespace.</param>
            <returns>The namespace URI associated with the prefix (or absence thereof) in the supplied
            lexical QName. The "null namespace" is represented by a zero length string. The method returns null
            if there is no known binding for the prefix used in the lexical QName.</returns>
        </member>
        <member name="M:Saxon.Api.XPathCompiler.ImportSchemaNamespace(System.String)">
            <summary>
            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.
            </summary>
            <remarks>
            <para>This method will not cause the schema to be loaded. That must be done separately, using the
            <c>SchemaManager</c>. 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.
            </para>
            <para>
            This method does not bind a prefix to the namespace. That must be done separately, using the
            <c>DeclareNamespace</c> method.
            </para>
            </remarks>
            <param name="uri">The namespace URI whose declarations and type definitions are to
            be made available for use within the XPath expression.</param>
        </member>
        <member name="M:Saxon.Api.XPathCompiler.SetDecimalFormatProperty(Saxon.Api.QName,System.String,System.String)">
            <summary>
            Sets a property of a selected decimal format, for use by the <c>format-number()</c> function.
            </summary>
            <remarks>
            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.
            </remarks>
            <param name="format">The name of the decimal format whose property is to be set.
             It is not possible to set the properties for the default (unnamed) decimal format.
             This correponds to a name used in the third argument of <c>format-number()</c>.</param>
            <param 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 name="value">The new value for the property.</param>
        </member>
        <member name="M:Saxon.Api.XPathCompiler.DeclareVariable(Saxon.Api.QName)">
            <summary>
            Declare a variable for use by the XPath expression. If the expression
            refers to any variables, then they must be declared here, unless the
            <c>AllowUndeclaredVariables</c> property has been set to true.
            </summary>
            <param name="name">The name of the variable, as a <c>QName</c></param>
        </member>
        <member name="M:Saxon.Api.XPathCompiler.Compile(System.String)">
            <summary>
            Compile an expression supplied as a <c>String</c>.
            </summary>
            <example>
            <code>
            XPathExecutable q = compiler.Compile("distinct-values(//*/node-name()");
            </code>
            </example>
            <param name="source">A string containing the source text of the XPath expression</param>
            <returns>An <c>XPathExecutable</c> which represents the compiled XPath expression object.
            The <c>XPathExecutable</c> may be run as many times as required, in the same or a different
            thread. The <c>XPathExecutable</c> is not affected by any changes made to the <c>XPathCompiler</c>
            once it has been compiled.</returns>
            <exception cref="T:Saxon.Api.StaticError">
            Throws a <c>Saxon.Api.StaticError</c> if there is any static error in the XPath expression.
            This includes both syntax errors, semantic errors such as references to undeclared functions or
            variables, and statically-detected type errors.
            </exception>
        </member>
        <member name="M:Saxon.Api.XPathCompiler.Evaluate(System.String,Saxon.Api.XdmItem)">
            <summary>
            Compile and execute an expression supplied as a <c>String</c>, with a given context item.
            </summary>
            <param name="expression">A string containing the source text of the XPath expression</param>
            <param 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>
            <returns>An <c>XdmValue</c> which is the result of evaluating the XPath expression.</returns>
            <exception cref="T:Saxon.Api.StaticError">
            Throws a <c>Saxon.Api.StaticError</c> if there is any static error in the XPath expression.
            This includes both syntax errors, semantic errors such as references to undeclared functions or
            variables, and statically-detected type errors.
            </exception>
            <exception cref="T:Saxon.Api.DynamicError">
            Throws a <c>Saxon.Api.DynamicError</c> if there is any dynamic error during evaluation of the XPath expression.
            This includes, for example, referring to the context item if no context item was supplied.
            </exception>
        </member>
        <member name="M:Saxon.Api.XPathCompiler.EvaluateSingle(System.String,Saxon.Api.XdmItem)">
            <summary>
            Compile and execute an expression supplied as a <c>String</c>, with a given context item, where
            the expression is expected to return a single item as its result.
            </summary>
            <param name="expression">A string containing the source text of the XPath expression</param>
            <param 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>
            <returns>If the XPath expression returns a singleton, then the the <c>XdmItem</c> 
            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.</returns>
            <exception cref="T:Saxon.Api.StaticError">
            Throws a <c>Saxon.Api.StaticError</c> if there is any static error in the XPath expression.
            This includes both syntax errors, semantic errors such as references to undeclared functions or
            variables, and statically-detected type errors.
            </exception>
            <exception cref="T:Saxon.Api.DynamicError">
            Throws a <c>Saxon.Api.DynamicError</c> if there is any dynamic error during evaluation of the XPath expression.
            This includes, for example, referring to the context item if no context item was supplied.
            </exception>
        </member>
        <member name="P:Saxon.Api.XPathCompiler.WarningHandler">
            <summary>
            Set the error reporter to be used for reporting static warnings during compilation.
            By default, the <see cref="T:Saxon.Api.ErrorReporter"/> associated with the Saxon Configuration is used.
            Note that fatal static errors are always reported in the form
            of an exception thrown by the <see cref="M:Saxon.Api.XPathCompiler.Compile(System.String)"/> method, so this method only controls
            the handling of warnings
            </summary>
            <remarks>The property IErrorReporter to which warnings will be notified</remarks>
        </member>
        <member name="P:Saxon.Api.XPathCompiler.Processor">
            <summary>
            Get the <c>Processor</c> from which this <c>XPathCompiler</c> was constructed
            </summary>
        </member>
        <member name="P:Saxon.Api.XPathCompiler.Implementation">
            <summary>
            Escape hatch to the <c>net.sf.saxon.s9api.XPathCompiler</c> object in the underlying Java implementation
            </summary>
        </member>
        <member name="P:Saxon.Api.XPathCompiler.AllowUndeclaredVariables">
            <summary>
            This property indicates whether the XPath expression may contain references to variables that have not been
            explicitly declared by calling <c>DeclareVariable</c>. The property is false by default (that is, variables
            must be declared).
            </summary>
            <remarks>
            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.
            </remarks>
        </member>
        <member name="P:Saxon.Api.XPathCompiler.SchemaAware">
            <summary>
            Say whether XPath expressions compiled using this <c>XPathCompiler</c> are
            schema-aware. They will automatically be schema-aware if the method
            <see cref="M:Saxon.Api.XPathCompiler.ImportSchemaNamespace(System.String)"/> is called. An XPath expression
            must be marked as schema-aware if it is to handle typed (validated)
            input documents.
            </summary>
        </member>
        <member name="P:Saxon.Api.XPathCompiler.XPathLanguageVersion">
            <summary>
            This property indicates which version of XPath language syntax is accepted. The accepted values
            are "2.0", "3.0", and "3.1". The default is "3.1".
            </summary>
            <remarks>
            <para>Requesting a value other than 3.1 restricts the XPath grammar to constructs defined
            in the appropriate version, and uses the appropriate subsets of the functions in the standard
            function library. However, the semantics of remaining constructs will generally follow the XPath 3.1
            rules. For example, there is a rule in XPath 2.0 that casting to
            <c>xs:QName</c> is only permitted if the operand is a string literal, but this is not enforced when
            this property is set to "2.0".</para>
            <para>There is no support for XPath 1.0.</para>
            </remarks>
        </member>
        <member name="P:Saxon.Api.XPathCompiler.ContextItemType">
            <summary>
            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.
            </summary>
        </member>
        <member name="P:Saxon.Api.XPathCompiler.BaseUri">
            <summary>
            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 the argument to the <c>doc()</c> function.
            </summary>
        </member>
        <member name="P:Saxon.Api.XPathCompiler.BackwardsCompatible">
            <summary>
            XPath 1.0 Backwards Compatibility Mode (that is, XPath 1.0 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).
            </summary>
            <remarks>
            <para>Setting XPath 1.0 compatibility mode does not prevent the use of constructs
            defined in a later XPath version; rather, it modifies the semantics of some
            constructs.</para></remarks>
        </member>
        <member name="P:Saxon.Api.XPathCompiler.Caching">
            <summary>
            This property controls caching of compiled XPath expressions. If caching is enabled,
            then compiled expressions are saved in a cache and reused if the same expression is compiled
            again. The cache is cleared (invalidated) if any change is made to the properties of the
            <c>XPathCompiler</c> that would affect the validity of cached expressions. Caching is disabled
            by default.
            </summary>
        </member>
        <member name="P:Saxon.Api.XPathCompiler.FastCompliation">
            <summary>
            Request fast compilation. Fast compilation will generally be achieved at the expense of run-time performance
            and quality of diagnostics. Fast compilation is a good trade-off if (a) the expression is known to be correct,
            and (b) once compiled, it is only executed once against a document of modest size.
            </summary>
            <remarks>
            Set to true to request fast compilation; set to false to revert to the optimization options
            defined in the Configuration.
            </remarks>
        </member>
        <member name="T:Saxon.Api.XPathExecutable">
            <summary>
            An <c>XPathExecutable</c> represents the compiled form of an XPath expression. 
            To evaluate the expression, it must first be loaded to form an <c>XPathSelector</c>.
            </summary>
            <remarks>
            <para>An <c>XPathExecutable</c> is immutable, and therefore thread-safe. It is simplest to
            load a new <c>XPathSelector</c> each time the expression is to be evaluated. However, the 
            <c>XPathSelector</c> is serially reusable within a single thread.</para>
            <para>An <c>XPathExecutable</c> is created by using the <c>Compile</c>
            method on the <c>XPathCompiler</c> class.</para>
            </remarks>    
        </member>
        <member name="M:Saxon.Api.XPathExecutable.EnumerateExternalVariables">
            <summary>
            Get a list of external variables used by the expression. This will include both variables that were explicitly
            declared to the <c>XPathCompiler</c>, and (if the <c>AllowUndeclaredVariables</c> option was set) variables that
            are referenced within the expression but not explicitly declared.
            </summary>
            <returns>
            An <c>IEnumerator</c> over the names of the external variables, as instances of <c>QName</c>.
            </returns>
        </member>
        <member name="M:Saxon.Api.XPathExecutable.EnumerateExternalVariables2">
            <summary>
            Get a list of external variables used by the expression. This will include both variables that were explicitly
            declared to the <c>XPathCompiler</c>, and (if the <c>AllowUndeclaredVariables</c> option was set) variables that
            are referenced within the expression but not explicitly declared.
            </summary>
            <returns>
            An <c>IEnumerator</c> over the names of the external variables, as instances of <c>QName</c>.
            </returns>
        </member>
        <member name="M:Saxon.Api.XPathExecutable.GetRequiredCardinalityForVariable(Saxon.Api.QName)">
            <summary>
            Get the required cardinality of a declared variable in the static context of the expression.
            </summary>
            <remarks>
            <para>The result is given as an occurrence indicator, one of:</para>
            <list>
            <item>'?' (zero-or-one)</item> 
            <item>'*' (zero-or-more)</item>
            <item>'+' (one-or-more)</item>
            <item>' ' (a single space) (exactly one)</item> 
            <item>'º' (masculine ordinal indicator, xBA) (exactly zero)</item>
            </list>
            <para>The type <c>empty-sequence()</c> can be represented by an occurrence indicator of 'º' with 
            any item type.</para>
            <para>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 
            <see cref="!:net.sf.saxon.s9api.OccurrenceIndicator#ZERO_OR_MORE"/>.</para>
            <para>If the variable was implicitly declared by reference (which can happen only when the
            <c>allowUndeclaredVariables</c> option is set), the returned type will be
            <see cref="!:net.sf.saxon.s9api.OccurrenceIndicator#ZERO_OR_MORE"/>.</para>
            <para>If no variable with the specified <c>QName</c> has been declared either explicitly or implicitly,
            the method returns '0'.</para>
            </remarks>
            <param name="variableName">the name of a declared variable</param>
            <returns>The required cardinality, in the form of an occurrence indicator.</returns>
        </member>
        <member name="M:Saxon.Api.XPathExecutable.Load">
            <summary>
            Load the compiled XPath expression to prepare it for execution.
            </summary>
            <returns>
            An <c>XPathSelector</c>. The returned <c>XPathSelector</c> can be used to
            set up the dynamic context, and then to evaluate the expression.
            </returns>
        </member>
        <member name="P:Saxon.Api.XPathExecutable.Implementation">
            <summary>
            Escape hatch to the <c>net.sf.saxon.s9api.XPathExecutable</c> object in the underlying Java implementation
            </summary>
        </member>
        <member name="T:Saxon.Api.XPathSelector">
            <summary inherits="IEnumerable">
            An <c>XPathSelector</c> represents a compiled and loaded XPath expression ready for execution.
            The <c>XPathSelector</c> holds details of the dynamic evaluation context for the XPath expression.
            </summary>
            <remarks>
            <para>An <c>XPathSelector</c> 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.</para>
            <para>An <c>XPathSelector</c> is always constructed by running the <c>Load</c> method of
            an <c>XPathExecutable</c>.</para>
            <para>The class <c>XPathSelector</c> implements <c>IEnumerable</c>, so it is possible to
            enumerate the results in a <c>for</c> expression.</para>
            </remarks>     
        </member>
        <member name="M:Saxon.Api.XPathSelector.SetVariable(Saxon.Api.QName,Saxon.Api.XdmValue)">
            <summary>
            Set the value of a variable
            </summary>
            <param name="name">The name of the variable. This must match the name of a variable
            that was declared to the <c>XPathCompiler</c>. No error occurs if the expression does not
            actually reference a variable with this name.</param>
            <param name="value">The value to be given to the variable.</param>
        </member>
        <member name="M:Saxon.Api.XPathSelector.Evaluate">
            <summary>
            Evaluate the expression, returning the result as an <c>XdmValue</c> (that is,
            a sequence of nodes, atomic values, and possibly function items such as maps and arrays).
            </summary>
            <remarks>
            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.
            </remarks>
            <returns>
            An <c>XdmValue</c> representing the results of the expression. 
            </returns>
            <exception cref="T:Saxon.Api.DynamicError">
            Throws <c>Saxon.Api.DynamicError</c> if the evaluation of the XPath expression fails
            with a dynamic error.
            </exception>
        </member>
        <member name="M:Saxon.Api.XPathSelector.EvaluateSingle">
            <summary>
            Evaluate the XPath expression, returning the result as an <c>XdmItem</c> (that is,
            a single node or atomic value).
            </summary>
            <returns>
            An <c>XdmItem</c> 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.
            </returns>
            <exception cref="T:Saxon.Api.DynamicError">
            Throws <c>Saxon.Api.DynamicError</c> if the evaluation of the XPath expression fails
            with a dynamic error.
            </exception>
        </member>
        <member name="M:Saxon.Api.XPathSelector.EffectiveBooleanValue">
            <summary>
            Evaluate the effective boolean value of the XPath expression, returning the result as a <c>Boolean</c>
            </summary>
            <returns>
            A <c>Boolean</c> representing the result of the expression, converted to its
            effective boolean value as if by applying the XPath <c>boolean()</c> function
            </returns>
            <exception cref="T:Saxon.Api.DynamicError">
            Throws <c>Saxon.Api.DynamicError</c> if the evaluation of the XPath expression fails
            with a dynamic error.
            </exception>
        </member>
        <member name="M:Saxon.Api.XPathSelector.GetEnumerator">
            <summary>
            Evaluate the expression, returning the result as an <c>IEnumerator</c> (that is,
            an enumerator over a sequence of nodes and/or atomic values).
            </summary>
            <returns>
            An enumerator over the sequence that represents the results of the expression.
            Each object in this sequence will be an instance of <c>XdmItem</c>. 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. 
            </returns>
            <exception cref="T:Saxon.Api.DynamicError">
            May throw a <c>Saxon.Api.DynamicError</c> if the evaluation of the XPath expression fails
            with a dynamic error. However, some errors will not be detected during the invocation of this
            method, but only when stepping through the returned <c>SequenceEnumerator</c>.
            </exception>
        </member>
        <member name="P:Saxon.Api.XPathSelector.ContextItem">
            <summary>
            The context item for the XPath expression evaluation.
            </summary>
            <remarks> 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.
            </remarks>
        </member>
        <member name="P:Saxon.Api.XPathSelector.Implementation">
            <summary>
            Escape hatch to the <c>net.sf.saxon.s9api.XPathSelector</c> object in the underlying Java implementation
            </summary>
        </member>
        <member name="P:Saxon.Api.XPathSelector.InputXmlResolver">
            <summary>
            The <code>XmlResolver</code> to be used at run-time to resolve and dereference URIs
            supplied to the <c>doc()</c> function.
            </summary>
        </member>
        <member name="T:Saxon.Api.URIQueryParameters">
            <summary>
            A set of query parameters on a URI passed to the <c>collection()</c> or <c>document()</c> function.
            </summary>
        </member>
        <member name="F:Saxon.Api.URIQueryParameters.ON_ERROR_FAIL">
            <summary>
            Constant indicating that failure to retrieve document in the collection is to be treated
            as a fatal error.
            </summary>
        </member>
        <member name="F:Saxon.Api.URIQueryParameters.ON_ERROR_WARNING">
            <summary>
            Constant indicating that failure to retrieve document in the collection is to be treated
            as a warning condition.
            </summary>
        </member>
        <member name="F:Saxon.Api.URIQueryParameters.ON_ERROR_IGNORE">
            <summary>
            Constant indicating that failure to retrieve document in the collection is to be silently
            ignored
            </summary>
        </member>
        <member name="M:Saxon.Api.URIQueryParameters.#ctor(System.String,Saxon.Api.Processor)">
            <summary>
            Create an object representing the query part of a URI
            </summary>
            <param name="query">the part of the URI after the "?" symbol</param>
            <param name="proc">the Saxon Processor</param>
        </member>
        <member name="M:Saxon.Api.URIQueryParameters.ValidationMode">
            <summary>
            Get the value of the validation=strict|lax|preserve|strip parameter, or null if unspecified.
            </summary>
        </member>
        <member name="M:Saxon.Api.URIQueryParameters.GetRecurse">
            <summary>
            Get the value of the recurse=yes|no parameter, or null if unspecified.
            </summary>
        </member>
        <member name="M:Saxon.Api.URIQueryParameters.GetOnError">
            <summary>
            Get the value of the on-error=fail|warning|ignore parameter, or null if unspecified.
            </summary>
        </member>
        <member name="M:Saxon.Api.URIQueryParameters.GetXInclude">
            <summary>
            Get the value of xinclude=yes|no, or null if unspecified.
            </summary>
        </member>
        <member name="M:Saxon.Api.URIQueryParameters.GetMeataData">
            <summary>
            Misspelt and obsolete synonym of <c>GetMetaData</c>
            </summary>
        </member>
        <member name="M:Saxon.Api.URIQueryParameters.GetMetaData">
            <summary>
            Get the value of metadata=yes|no, or null if unspecified.
            </summary>
        </member>
        <member name="M:Saxon.Api.URIQueryParameters.ContentType">
            <summary>
            Get the value of media-type, or null if absent.
            </summary>
        </member>
        <member name="M:Saxon.Api.URIQueryParameters.GetStable">
            <summary>
            Get the value of stable=yes|no, or null if unspecified.
            </summary>
        </member>
        <member name="T:Saxon.Api.XQueryCompiler">
            <summary>
            The <c>XQueryCompiler</c> object allows XQuery queries to be compiled.
            </summary>
            <remarks>
            <para>To construct an <c>XQueryCompiler</c>, use the factory method
            <c>NewXQueryCompiler</c> on the <see cref="P:Saxon.Api.XQueryCompiler.Processor"/> object.</para>
            <para>The <c>XQueryCompiler</c> holds information that represents the static context
            for the queries that it compiles. This information remains intact after performing
            a compilation. An <c>XQueryCompiler</c> may therefore be used repeatedly to compile multiple
            queries. Any changes made to the <c>XQueryCompiler</c> (that is, to the
            static context) do not affect queries that have already been compiled.</para>
            <para>An <c>XQueryCompiler</c> may be used concurrently in multiple threads, but
            it should not then be modified once initialized.</para>
            </remarks>
        </member>
        <member name="M:Saxon.Api.XQueryCompiler.DeclareCollation(System.Uri,System.Globalization.CompareInfo,System.Globalization.CompareOptions,System.Boolean)">
            <summary>
            Create a collation based on a given <c>CompareInfo</c> and <c>CompareOptions</c>    
            </summary>
            <remarks>
            In the current and recent releases of Saxon, collations are always defined at the level of a <c>Configuration</c>.
            Declaring a collation here may therefore have wider effects than intended. It is recommended not to use
            this method, but to use <see cref="!:Processor.DeclareCollation(Uri, CompareInfo, CompareOptions)"/> instead.
            </remarks>
            <param name="uri">The collation URI to be used within the XPath expression to refer to this collation</param>
            <param name="compareInfo">The <c>CompareInfo</c>, which determines the language-specific
            collation rules to be used</param>
            <param name="options">Options to be used in performing comparisons, for example
            whether they are to be case-blind and/or accent-blind</param>
            <param name="isDefault">If true, this collation will be used as the default collation</param>
        </member>
        <member name="M:Saxon.Api.XQueryCompiler.DeclareNamespace(System.String,System.String)">
            <summary>
            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).
            </summary>
            <param 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 name="uri">The namespace URI. It is possible to specify
            a zero-length string to "undeclare" a namespace.</param>
        </member>
        <member name="M:Saxon.Api.XQueryCompiler.SetErrorList(System.Collections.Generic.IList{Saxon.Api.XmlProcessingError})">
            <summary>
            List of errors. The caller may supply an empty list before calling <c>Compile</c>;
            the processor will then populate the list with error information obtained during
            the query compilation. Each error will be included as an object of type <c>XmlProcessingError</c>.
            If no error list is supplied by the caller, error information will be written to
            the standard error stream.
            </summary>
            <remarks>
            <para>By supplying a custom <c>List</c> with a user-written <c>add()</c> method, it is possible to
            intercept error conditions as they occur.</para>
            <para>Note that this error list is used only for errors detected during the compilation
            of the stylesheet. It is not used for errors detected when executing the stylesheet.</para>
            </remarks>
            <param name="value">Supplied list.</param>
        </member>
        <member name="M:Saxon.Api.XQueryCompiler.GetErrorList">
            <summary>
            Get list of errors as <code>IList&lt;XmlProcessingError&gt;</code>
            </summary>
        </member>
        <member name="M:Saxon.Api.XQueryCompiler.Compile(System.IO.Stream)">
            <summary>
            Compile a query supplied as a <c>Stream</c>.
            </summary>
            <remarks>
            <para>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 <c>CanSeek</c> property.
            If no encoding information is present, UTF-8 is assumed.</para>
            <para>The base URI of the query is set to the value of the <c>BaseUri</c>
            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.</para>
            </remarks>
            <example>
            <code>
            XQueryExecutable q = compiler.Compile(new FileStream("input.xq", FileMode.Open, FileAccess.Read));
            </code>
            </example>
            <param name="query">A stream containing the source text of the query</param>
            <returns>An <c>XQueryExecutable</c> which represents the compiled query object.
            The <c>XQueryExecutable</c> may be run as many times as required, in the same or a different
            thread. The <c>XQueryExecutable</c> is not affected by any changes made to the <c>XQueryCompiler</c>
            once it has been compiled.</returns>
            <exception cref="T:Saxon.Api.StaticError">Throws a <c>StaticError</c> if errors were detected
            during static analysis of the query. Details of the errors will be added as <c>StaticError</c>
            objects to the <c>ErrorList</c> if supplied; otherwise they will be written to the standard
            error stream. The exception that is returned is merely a summary indicating the
            status.</exception>
        </member>
        <member name="M:Saxon.Api.XQueryCompiler.Compile(System.String)">
            <summary>
            Compile a query supplied as a <c>String</c>.
            </summary>
            <remarks>
            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.
            </remarks>
            <example>
            <code>
            XQueryExecutable q = compiler.Compile("distinct-values(//*/node-name()");
            </code>
            </example>
            <param name="query">A string containing the source text of the query</param>
            <returns>An <c>XQueryExecutable</c> which represents the compiled query object.
            The <c>XQueryExecutable</c> may be run as many times as required, in the same or a different
            thread. The <c>XQueryExecutable</c> is not affected by any changes made to the <c>XQueryCompiler</c>
            once it has been compiled.</returns>
            <exception cref="T:Saxon.Api.StaticError">Throws a <c>StaticError</c> if errors were detected
            during static analysis of the query. Details of the errors will be added as <c>StaticError</c>
            objects to the <c>ErrorList</c> if supplied; otherwise they will be written to the standard
            error stream. The exception that is returned is merely a summary indicating the
            status.</exception>        
        </member>
        <member name="P:Saxon.Api.XQueryCompiler.Processor">
            <summary>
            Get the <c>Processor</c> from which this <c>XQueryCompiler</c> was constructed
            </summary>
        </member>
        <member name="P:Saxon.Api.XQueryCompiler.ContextItemType">
            <summary>
            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.
            </summary>
        </member>
        <member name="P:Saxon.Api.XQueryCompiler.BaseUri">
            <summary>
            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 <c>doc()</c> function.
            </summary>
        </member>
        <member name="P:Saxon.Api.XQueryCompiler.SchemaAware">
            <summary>
            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. 
            </summary>
            <remarks>
            <para>If the query is not schema-aware, then all input documents must be untyped 
            (or <c>xs:anyType</c>), 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.</para>
            </remarks>
        </member>
        <member name="P:Saxon.Api.XQueryCompiler.UpdatingEnabled">
            <summary>
            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.
            </summary>
            <remarks>
            <para>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-EE. Non-updating queries are accepted regardless of the value of this
            property.</para>
            </remarks>
        </member>
        <member name="P:Saxon.Api.XQueryCompiler.XQueryLanguageVersion">
            <summary>
            This property indicates which version of XQuery language syntax is accepted. In this version
            of Saxon the version is always "3.1"; any attempt to set a different value is ignored.
            </summary>
        </member>
        <member name="P:Saxon.Api.XQueryCompiler.QueryResolver">
            <summary>
            A user-supplied <c>IQueryResolver</c> used to resolve location hints appearing in an
            <c>import module</c> declaration.
            </summary>
            <remarks>
            <para>In the absence of a user-supplied <c>QueryResolver</c>, an <c>import module</c> 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 <c>XmlResolver</c> registered with the <c>Processor</c>.</para>
            </remarks>
        </member>
        <member name="P:Saxon.Api.XQueryCompiler.ErrorList">
            <summary>
            List of errors. The caller should supply an empty list before calling <c>Compile()</c>;
            the processor will then populate the list with error information obtained during
            the compilation. Each error will be included as an object of type <c>StaticError</c>.
            If no error list is supplied by the caller, error information will be written to
            the standard error stream.
            </summary>
            <remarks>
            By supplying a custom <c>List</c> with a user-written <c>add()</c> method, it is possible to
            intercept error conditions as they occur.
            </remarks>
        </member>
        <member name="P:Saxon.Api.XQueryCompiler.ErrorReporter">
            <summary>Set the <c>ErrorReporter</c> to be used when validating instance documents as a user defined IErrorReporter.
             Requirements here is IErrorReport implementation with a user-written <c>report()</c> method, it is possible to
            intercept error conditions as they occur.
            If this property is used then the ErrorList property and SetErrorList method is overriden.</summary>
            <remarks>The <c>IErrorReporter</c> to be used</remarks>
        </member>
        <member name="P:Saxon.Api.XQueryCompiler.Implementation">
            <summary>
            Escape hatch to the underlying Java implementation
            </summary>
        </member>
        <member name="P:Saxon.Api.XQueryCompiler.FastCompliation">
            <summary>
            Request fast compilation. Fast compilation will generally be achieved at the expense of run-time performance
            and quality of diagnostics. Fast compilation is a good trade-off if (a) the expression is known to be correct,
            and (b) once compiled, the expression is only executed once against a document of modest size.
            </summary>
            <remarks>
            <para><i>The current implementation is equivalent to switching off all optimizations. Setting this option, however,
            indicates an intent rather than a mechanism, and the implementation details may change in future to reflect
            the intent.</i></para>
            <para>Set to true to request fast compilation; set to false to revert to the optimization options
            defined in the Configuration.</para>
            </remarks>
        </member>
        <member name="T:Saxon.Api.XQueryExecutable">
            <summary>
            An <c>XQueryExecutable</c> represents the compiled form of a query. To execute the query,
            it must first be loaded to form an <c>XQueryEvaluator</c>.
            </summary>
            <remarks>
            <para>An <c>XQueryExecutable</c> is immutable, and therefore thread-safe. It is simplest to
            load a new <c>XQueryEvaluator</c> each time the query is to be run. However, the 
            <c>XQueryEvaluator</c> is serially reusable within a single thread.</para>
            <para>An <c>XQueryExecutable</c> is created by using one of the <c>Compile</c>
            methods on the <c>XQueryCompiler</c> class.</para>
            </remarks>    
        </member>
        <member name="M:Saxon.Api.XQueryExecutable.getUnderlyingCompiledQuery">
            <summary>Escape-hatch method to get the underlying Saxon implementation object if required.
            This provides access to methods that may not be stable from release to release.</summary>
        </member>
        <member name="M:Saxon.Api.XQueryExecutable.Load">
            <summary>
            Load the query to prepare it for execution.
            </summary>
            <returns>
            An <c>XQueryEvaluator</c>. The returned <c>XQueryEvaluator</c> can be used to
            set up the dynamic context for query evaluation, and to run the query.
            </returns>
        </member>
        <member name="P:Saxon.Api.XQueryExecutable.IsUpdateQuery">
            <summary>Ask whether this is an updating query (that is, one that returns a pending
            update list rather than a conventional value).</summary>
        </member>
        <member name="T:Saxon.Api.XQueryEvaluator">
            <summary inherits="IEnumerable">
            An <c>XQueryEvaluator</c> represents a compiled and loaded query ready for execution.
            The <c>XQueryEvaluator</c> holds details of the dynamic evaluation context for the query.
            </summary>
            <remarks>
            <para>An <c>XQueryEvaluator</c> must 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.</para>
            <para>An <c>XQueryEvaluator</c> is always constructed by running the <c>Load</c> method of
            an <c>XQueryExecutable</c>.</para>
            </remarks>     
        </member>
        <member name="M:Saxon.Api.XQueryEvaluator.SetExternalVariable(Saxon.Api.QName,Saxon.Api.XdmValue)">
            <summary>
            Set the value of an external variable declared in the query.
            </summary>
            <param name="name">The name of the external variable, expressed
            as a <c>QName</c>. 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 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>
        </member>
        <member name="M:Saxon.Api.XQueryEvaluator.Evaluate">
            <summary>
            Evaluate the query, returning the result as an <c>XdmValue</c> (that is,
            a sequence of nodes and/or atomic values).
            </summary>
            <returns>
            An <c>XdmValue</c> representing the results of the query
            </returns>
            <exception cref="T:Saxon.Api.DynamicError">Throws a <c>DynamicError</c> if any run-time failure
            occurs while evaluating the query.</exception>
        </member>
        <member name="M:Saxon.Api.XQueryEvaluator.EvaluateSingle">
            <summary>
            Evaluate the query, returning the result as an <c>XdmItem</c> (that is,
            a single node or atomic value).
            </summary>
            <returns>
            An <c>XdmItem</c> 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.
            </returns>
            <exception cref="T:Saxon.Api.DynamicError">Throws a <c>DynamicError</c> if any run-time failure
            occurs while evaluating the expression.</exception>
        </member>
        <member name="M:Saxon.Api.XQueryEvaluator.GetEnumerator">
            <summary>
            Evaluate the query, returning the result as an <c>IEnumerator</c> (that is,
            an enumerator over a sequence of nodes and/or atomic values).
            </summary>
            <returns>
            An enumerator over the sequence that represents the results of the query.
            Each object in this sequence will be an instance of <c>XdmItem</c>. 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. 
            </returns>
            <exception cref="T:Saxon.Api.DynamicError">Throws a <c>DynamicError</c> if any run-time failure
            occurs while evaluating the expression.</exception>
        </member>
        <member name="M:Saxon.Api.XQueryEvaluator.Run(Saxon.Api.XmlDestination)">
            <summary>
            Evaluate the query, sending the result to a specified destination.
            </summary>
            <param 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>
            <exception cref="T:Saxon.Api.DynamicError">Throws a <c>DynamicError</c> if any run-time failure
            occurs while evaluating the expression.</exception>
        </member>
        <member name="M:Saxon.Api.XQueryEvaluator.RunUpdate">
            <summary>
            Execute an updating query.
            </summary>
            <returns>An array containing the root nodes of documents that have been
            updated by the query.</returns>
            <exception cref="T:Saxon.Api.DynamicError">Throws a <c>DynamicError</c> if any run-time failure
            occurs while evaluating the expression, or if the expression is not an
            updating query.</exception>
        </member>
        <member name="M:Saxon.Api.XQueryEvaluator.CallFunction(Saxon.Api.QName,Saxon.Api.XdmValue[])">
            <summary>
            Call a global user-defined function in the compiled query.
            </summary>
            <remarks>
            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.
            </remarks>
            <param name="function">
            The name of the function to be called
            </param>
            <param 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>
            <exception cref="T:System.ArgumentException">If no function has been defined with the given name and arity
            or if any of the arguments does not match its required type according to the function
            signature.</exception>
            <exception cref="T:Saxon.Api.DynamicError">If a dynamic error occurs in evaluating the function.
            </exception>
        </member>
        <member name="P:Saxon.Api.XQueryEvaluator.ContextItem">
            <summary>
            The context item for the query.
            </summary>
            <remarks> This may be a node, an atomic value, or a function item such as a map or array.
            Most commonly it will be a document node, which might be constructed
            using a <c>DocumentBuilder</c> created from the <c>Processor</c> object.
            </remarks>
        </member>
        <member name="P:Saxon.Api.XQueryEvaluator.SchemaValidationMode">
            <summary>
            The <c>SchemaValidationMode</c> to be used in this query, especially for documents
            loaded using the <c>doc()</c>, <c>document()</c>, or <c>collection()</c> functions.
            </summary>
            <remarks>
            This does not affect any document supplied as the context item for the query, or as the values
            of external variables.
            </remarks>
        </member>
        <member name="P:Saxon.Api.XQueryEvaluator.InputXmlResolver">
            <summary>
            The <code>XmlResolver</code> to be used at run-time to resolve and dereference URIs
            supplied to the <c>doc()</c> function.
            </summary>
        </member>
        <member name="P:Saxon.Api.XQueryEvaluator.TraceFunctionDestination">
            <summary>
            Destination for output of messages produced using the <c>trace()</c> function. 
            </summary>
            <remarks>
            <para>If no specific destination is supplied by the caller, message information will be written to
            the standard error stream.</para>
            <para>The supplied destination is ignored if a <c>TraceListener</c> is in use.</para>
            </remarks>
        </member>
        <member name="P:Saxon.Api.XQueryEvaluator.Implementation">
            <summary>
            Escape hatch to the <c>net.sf.saxon.query.DynamicQueryContext</c> object in the underlying Java implementation
            </summary>
        </member>
        <member name="T:Saxon.Api.IQueryResolver">
            <summary>
            Interface defining a user-supplied class used to retrieve XQuery library modules listed
            in an <c>import module</c> declaration in the query prolog.
            </summary>
        </member>
        <member name="M:Saxon.Api.IQueryResolver.GetModules(System.String,System.Uri,System.String[])">
            public*
        </member>
        <member name="M:Saxon.Api.IQueryResolver.GetEntity(System.Uri)">
            public*
        </member>
        <member name="T:Saxon.Api.DotNetModuleURIResolver">
            <summary>
            Internal class that wraps a (.NET) <c>IQueryResolver</c> to create a (Java) <c>ModuleURIResolver</c>.
            <para>A <c>ModuleURIResolver</c> is used when resolving references to
            query modules. It takes as input a URI that identifies the module to be loaded, and a set of
            location hints, and returns one or more <c>StreamSource</c> obects containing the queries
            to be imported.</para>
            </summary>
        </member>
        <member name="M:Saxon.Api.DotNetModuleURIResolver.#ctor(Saxon.Api.IQueryResolver)">
            <summary>
            Initializes a new instance of the <see cref="T:Saxon.Api.DotNetModuleURIResolver"/> class.
            </summary>
            <param name="resolver">Resolver.</param>
        </member>
        <member name="M:Saxon.Api.DotNetModuleURIResolver.resolve(System.String,System.String,System.String[])">
            <summary>
            Resolve a module URI and associated location hints.
            </summary>
            <param name="moduleURI">ModuleURI. The module namespace URI of the module to be imported; or null when
            loading a non-library module.</param>
            <param name="baseURI">BaseURI. The base URI of the module containing the "import module" declaration;
            null if no base URI is known</param>
            <param name="locations">Locations. The set of URIs specified in the "at" clause of "import module",
            which serve as location hints for the module</param>
            <returns>an array of StreamSource objects each identifying the contents of a module to be
            imported. Each StreamSource must contain a
            non-null absolute System ID which will be used as the base URI of the imported module,
            and either an InputSource or a Reader representing the text of the module. The method
            may also return null, in which case the system attempts to resolve the URI using the
            standard module URI resolver.</returns>
        </member>
        <member name="T:Saxon.Api.XsltCompiler">
            <summary>
            An <c>XsltCompiler</c> object allows XSLT 3.0 stylesheets to be compiled.
            The compiler holds information that represents the static context
            for the compilation.
            </summary>
            <remarks>
            <para>To construct an <c>XsltCompiler</c>, use the factory method
            <c>NewXsltCompiler</c> on the <see cref="P:Saxon.Api.XsltCompiler.Processor"/> object.</para>
            <para>An <c>XsltCompiler</c> may be used repeatedly to compile multiple
            queries. Any changes made to the <c>XsltCompiler</c> (that is, to the
            static context) do not affect queries that have already been compiled.
            An <c>XsltCompiler</c> may be used concurrently in multiple threads, but
            it should not then be modified once initialized.</para>
            </remarks>
        </member>
        <member name="M:Saxon.Api.XsltCompiler.DeclareCollation(System.Uri,System.Globalization.CompareInfo,System.Globalization.CompareOptions,System.Boolean)">
            <summary>
            Create a collation based on a given <c>CompareInfo</c> and <c>CompareOptions</c>.    
            </summary>
            <remarks>
            In the current and recent releases of Saxon, collations are always defined at the level of a <c>Configuration</c>.
            Declaring a collation here may therefore have wider effects than intended. It is recommended not to use
            this method, but to use <see cref="!:Processor.DeclareCollation(Uri, CompareInfo, CompareOptions)"/> instead.
            </remarks>
            <param name="uri">The collation URI to be used within the XPath expression to refer to this collation</param>
            <param name="compareInfo">The <c>CompareInfo</c>, which determines the language-specific
            collation rules to be used</param>
            <param name="options">Options to be used in performing comparisons, for example
            whether they are to be case-blind and/or accent-blind</param>
            <param name="isDefault">If true, this collation will be used as the default collation</param>
        </member>
        <member name="M:Saxon.Api.XsltCompiler.SetErrorList(System.Collections.Generic.IList{Saxon.Api.XmlProcessingError})">
            <summary>
            List of errors. The caller may supply an empty list before calling <c>Compile</c>;
            the processor will then populate the list with error information obtained during
            the XSLT compilation. Each error will be included as an object of type <c>XmlProcessingError</c>.
            If no error list is supplied by the caller, error information will be written to
            the standard error stream.
            </summary>
            <remarks>
            <para>By supplying a custom <c>List</c> or IErrorReport implementation with a user-written <c>report()</c> method, it is possible to
            intercept error conditions as they occur.</para>
            <para>Note that this error list is used only for errors detected during the compilation
            of the stylesheet. It is not used for errors detected when executing the stylesheet.</para>
            </remarks>
            <param name="value">Supplied list.</param>
        </member>
        <member name="M:Saxon.Api.XsltCompiler.GetErrorList">
            <summary>
            Get list of errors as <code>IList&lt;XmlProcessingError&gt;</code>
            </summary>
        </member>
        <member name="M:Saxon.Api.XsltCompiler.Compile(System.IO.Stream)">
            <summary>
            Compile a stylesheet supplied as a Stream.
            </summary>
            <example>
            <code>
            Stream source = new FileStream("input.xsl", FileMode.Open, FileAccess.Read);
            XsltExecutable q = compiler.Compile(source);
            source.Close();
            </code>
            </example>
            <param name="input">A stream containing the source text of the stylesheet</param>
            <returns>An <c>XsltExecutable</c> which represents the compiled stylesheet object.
            The <c>XsltExecutable</c> may be loaded as many times as required, in the same or a different
            thread. The <c>XsltExecutable</c> is not affected by any changes made to the <c>XsltCompiler</c>
            once it has been compiled.</returns>
            <remarks>
            <para>If the stylesheet contains any <c>xsl:include</c> or <c>xsl:import</c> declarations,
            then the <c>BaseUri</c> property must be set to allow these to be resolved.</para>
            <para>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.</para>
            </remarks>
        </member>
        <member name="M:Saxon.Api.XsltCompiler.CompilePackage(System.IO.Stream)">
            <summary>Compile a library package.</summary>
            <remarks>
            <para>The source argument identifies an XML file containing an <c>xsl:package</c> element. Any packages
            on which this package depends must have been made available to the <c>XsltCompiler</c>
            by importing them using <see cref="M:Saxon.Api.XsltCompiler.ImportPackage(Saxon.Api.XsltPackage)"/>.</para>
            </remarks>
            <param name="input">source identifies an XML document holding the the XSLT package to be compiled</param>
            <returns>The <c>XsltPackage</c> that results from the compilation. Note that this package
            is not automatically imported to this <c>XsltCompiler</c>; if the package is required
            for use in subsequent compilations then it must be explicitly imported.</returns>
        </member>
        <member name="M:Saxon.Api.XsltCompiler.CompilePackages(System.Collections.Generic.IList{System.String})">
            <summary>Compile a list of packages.</summary>
            <param name='sources'> the collection of packages to be compiled, in the form of an
            <c>Iterable</c></param>
            <returns> the collection of compiled packages, in the form of an <c>Iterable</c></returns> 
        </member>
        <member name="M:Saxon.Api.XsltCompiler.ImportPackage(Saxon.Api.XsltPackage)">
            <summary>Import a library package. Calling this method makes the supplied package available for reference
            in the <code>xsl:use-package</code> declaration of subsequent compilations performed using this
            <code>XsltCompiler</code>.</summary>
            <param name='thePackage'> the package to be imported</param>
            <remarks>since 9.6</remarks>
        </member>
        <member name="M:Saxon.Api.XsltCompiler.ImportPackage(Saxon.Api.XsltPackage,System.String,System.String)">
            <summary>Import a library package. Calling this method makes the supplied package available for reference
            in the <code>xsl:use-package</code> declaration of subsequent compilations performed using this
            <code>XsltCompiler</code>.</summary>
            <param name='thePackage'> the package to be imported</param>
            <param name='packageName'> name of the package to be imported</param>
            <param name='version'> version identifier for the package to be imported</param>
            <remarks>since 9.8</remarks>
        </member>
        <member name="M:Saxon.Api.XsltCompiler.LoadLibraryPackage(System.Uri)">
            <summary>
            Load a compiled package from a file or from a remote location.
            </summary>
            <remarks>
            The supplied URI represents the location of a resource which must have been originally
            created using <see cref="M:Saxon.Api.XsltPackage.Save(System.IO.Stream)"/>.
            The result of loading the package is returned as an <code>XsltPackage</code> object.
            Note that this package is not automatically imported to this <code>XsltCompiler</code>;
            if the package is required for use in subsequent compilations then it must be explicitly
            imported.
            </remarks>
            <param name="location">the location from which the package is to be loaded, as a URI</param>
            <returns>the compiled package loaded from the supplied file or remote location</returns>
        </member>
        <member name="M:Saxon.Api.XsltCompiler.LoadExecutablePackage(System.Uri)">
            <summary>
            Load a compiled package from a file or from a remote location, with the intent to use this as a complete
            executable stylesheet, not as a library package.
            </summary>
            <remarks>
            The supplied URI represents the location of a resource which must have been originally
            created using <see cref="M:Saxon.Api.XsltPackage.Save(System.IO.Stream)"/>.
            </remarks>
            <param name="location"> the location from which the package is to be loaded, as a URI</param>
            <returns>the compiled package loaded from the supplied file or remote location</returns>
        </member>
        <member name="M:Saxon.Api.XsltCompiler.GetUnderlyingCompilerInfo">
            <summary>  
            Get the underlying <c>CompilerInfo</c> object, which provides more detailed (but less stable) control
            over some compilation options
            </summary>
            <returns> the underlying <c>CompilerInfo</c> object, which holds compilation-time options. The methods on
            this object are not guaranteed stable from release to release.
            </returns>
        </member>
        <member name="M:Saxon.Api.XsltCompiler.SetParameter(Saxon.Api.QName,Saxon.Api.XdmValue)">
            <summary>
            Externally set the value of a static parameter (new facility in XSLT 3.0) 
            </summary>
            <param 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 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>
        </member>
        <member name="M:Saxon.Api.XsltCompiler.ClearParameters">
            <summary>
            Clear the values of all stylesheet parameters previously set using <c>SetParameter(QName, XdmValue)</c>.
            This resets the parameters to their initial ("undeclared") state
            </summary>
        </member>
        <member name="M:Saxon.Api.XsltCompiler.Compile(System.IO.TextReader)">
            <summary>
            Compile a stylesheet supplied as a <c>TextReader</c>.
            </summary>
            <example>
            <code>
            String ss = "<![CDATA[<xsl:stylesheet version='2.0'>....</xsl:stylesheet>]]>";
            TextReader source = new StringReader(ss);
            XsltExecutable q = compiler.Compile(source);
            source.Close();
            </code>
            </example>
            <param name="input">A <c>TextReader</c> containing the source text of the stylesheet</param>
            <returns>An <c>XsltExecutable</c> which represents the compiled stylesheet object.
            The <c>XsltExecutable</c> may be loaded as many times as required, in the same or a different
            thread. The <c>XsltExecutable</c> is not affected by any changes made to the <c>XsltCompiler</c>
            once it has been compiled.</returns>
            <remarks>
            <para>If the stylesheet contains any <c>xsl:include</c> or <c>xsl:import</c> declarations,
            then the <c>BaseUri</c> property must be set to allow these to be resolved.</para>
            <para>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 
            <c>TextReader</c> 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.</para>
            </remarks>
        </member>
        <member name="M:Saxon.Api.XsltCompiler.Compile(System.Uri)">
            <summary>
            Compile a stylesheet, retrieving the source using a URI.
            </summary>
            <remarks>
            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.
            </remarks>
            <param name="uri">The URI identifying the location where the stylesheet document can be
            found</param>
            <returns>An <c>XsltExecutable</c> which represents the compiled stylesheet object.
            The <c>XsltExecutable</c> may be run as many times as required, in the same or a different
            thread. The <c>XsltExecutable</c> is not affected by any changes made to the <c>XsltCompiler</c>
            once it has been compiled.</returns>
        </member>
        <member name="M:Saxon.Api.XsltCompiler.Compile(System.Xml.XmlReader)">
            <summary>
            Compile a stylesheet, delivered using an <c>XmlReader</c>.
            </summary>
            <remarks>
            <para>
            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).
            </para>
            <para>
            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.
            </para>
            </remarks>
            <param name="reader">The XmlReader (that is, the XML parser) used to supply the document containing
            the principal stylesheet module.</param>
            <returns>An <c>XsltExecutable</c> which represents the compiled stylesheet object.
            The XsltExecutable may be run as many times as required, in the same or a different
            thread. The <c>XsltExecutable</c> is not affected by any changes made to the <c>XsltCompiler</c>
            once it has been compiled.</returns>
        </member>
        <member name="M:Saxon.Api.XsltCompiler.Compile(Saxon.Api.XdmNode)">
            <summary>
            Compile a stylesheet, located at an <c>XdmNode</c>. This may be a document node whose
            child is an <c>xsl:stylesheet</c> or <c>xsl:transform</c> element, or it may be
            the <c>xsl:stylesheet</c> or <c>xsl:transform</c> element itself.
            </summary>
            <param name="node">The document node or the outermost element node of the document
            containing the principal stylesheet module.</param>
            <returns>An <c>XsltExecutable</c> which represents the compiled stylesheet object.
            The <c>XsltExecutable</c> may be run as many times as required, in the same or a different
            thread. The <c>XsltExecutable</c> is not affected by any changes made to the <c>XsltCompiler</c>
            once it has been compiled.</returns>
        </member>
        <member name="M:Saxon.Api.XsltCompiler.CompileAssociatedStylesheet(System.Uri,System.String)">
            <summary>Locate and compile a stylesheet identified by an <c>&lt;?xml-stylesheet?&gt;</c>
            processing instruction within a source document, and that match the given criteria.
            </summary>
            <param name="uri">The URI of the source document containing the xml-stylesheet processing instruction.</param>
            <param name="media">The media attribute to be matched. May be null, in which case the 
            "application/xml" mime type will be used when fetching the source document from the Uri.</param>
            <returns>An <c>XsltExecutable</c> which represents the compiled stylesheet object.</returns>
            <remarks>There are some limitations in the current implementation. Parameters of the xml-stylesheet 
            instruction other than the media type, are ignored. The
            <c>href</c> attribute must either reference an embedded stylesheet within the same
            document or a non-embedded external stylesheet.</remarks>
        </member>
        <member name="M:Saxon.Api.XsltCompiler.CompileAssociatedStylesheet(Saxon.Api.XdmNode)">
            <summary>Locate and compile a stylesheet identified by an <c>&lt;?xml-stylesheet?&gt;</c>
            processing instruction within a source document.
            </summary>
            <param name="source">The document node of the source document containing the
            xml-stylesheet processing instruction.</param>
            <returns>An <c>XsltExecutable</c> which represents the compiled stylesheet object.</returns>
            <remarks>There are some limitations in the current implementation. The media type
            is ignored, as are the other parameters of the xml-stylesheet instruction. The
            <c>href</c> attribute must either reference an embedded stylesheet within the same
            document or a non-embedded external stylesheet.</remarks>
        </member>
        <member name="P:Saxon.Api.XsltCompiler.BaseUri">
            <summary>
            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 <c>xsl:include</c> and <c>xsl:import</c>
            declarations, in schema locations defined to <c>xsl:import-schema</c>, 
            or as an argument to the <c>document()</c> or <c>doc()</c> function.
            </summary>
            <remarks>
            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.
            </remarks>
        </member>
        <member name="P:Saxon.Api.XsltCompiler.DefaultCollationName">
            <summary>
            The name of the default collation used by stylesheets compiled using this <c>XsltCompiler</c>.
            This must be the name of a collation that is known to the <c>Processor</c>.
            </summary>
        </member>
        <member name="P:Saxon.Api.XsltCompiler.Processor">
            <summary>
            The <c>Processor</c> from which this <c>XsltCompiler</c> was constructed
            </summary>
        </member>
        <member name="P:Saxon.Api.XsltCompiler.XmlResolver">
            <summary>
            An <c>XmlResolver</c>, which will be used to resolve URI references while compiling
            a stylesheet.
            </summary>
            <remarks>
            If no <c>XmlResolver</c> is set for the <c>XsltCompiler</c>, the <c>XmlResolver</c>
            that is used is the one that was set on the <c>Processor</c> at the time <c>NewXsltCompiler</c>
            was called.
            </remarks>
        </member>
        <member name="P:Saxon.Api.XsltCompiler.SchemaAware">
            <summary>
            The <c>SchemaAware</c> 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.
            </summary>
            <remarks>
            <para>If the stylesheet is not schema-aware, then schema-validated input documents will be rejected.</para>
            <para>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.</para>
            <para>The initial setting of this property is false, regardless of whether or not the <c>Processor</c>
            is schema-aware. Setting this property to true if the processor is not schema-aware will cause an Exception.</para>
            </remarks>
        </member>
        <member name="P:Saxon.Api.XsltCompiler.AssertionsEnabled">
            <summary>
            Indicates whether or not assertions (<c>xsl:assert</c> instructions) are enabled at compile time. 
            </summary>
            <remarks>By default assertions are disabled at compile time. If assertions are enabled at compile time, then by
            default they will also be enabled at run time; but they can be disabled at run time by
            specific request. At compile time, assertions can be enabled for some packages and
            disabled for others; at run time, they can only be enabled or disabled globally.</remarks>
            <returns>true if assertions are enabled at compile time</returns>
        </member>
        <member name="P:Saxon.Api.XsltCompiler.XsltLanguageVersion">
            <summary>
            The <c>XsltLanguageVersion</c> property determines the version of the XSLT language specification
            implemented by the compiler. In this Saxon release the value is always "3.0".
            </summary>
            <remarks>
            <para>Getting this property always returns "3.0".</para>
            <para>Setting this property has no effect.</para>
            </remarks>
        </member>
        <member name="P:Saxon.Api.XsltCompiler.ByteCodeEnabled">
            <summary>
            This property determines whether bytecode is to be generated in the compiled stylesheet.
            </summary>
            <remarks>
            <para>
            Bytecode generation is enabled by default in Saxon-EE, but can be disabled by clearing this property.
            In Saxon-HE and Saxon-PE, attempting to set this property to true either has no effect, or causes an error.
            </para>
            <para>
            Setting this property on causes bytecode to be generated for sections of the stylesheet that are
            executed frequently enough to justify it. It does not force immediate (eager) byte code generation.
            </para>
            </remarks>
            <returns>true if bytecode is to be generated, false if not</returns>
        </member>
        <member name="P:Saxon.Api.XsltCompiler.JustInTimeCompilation">
            <summary>
            Property to say whether just-in-time compilation of template rules should be used.
            jit true if just-in-time compilation is to be enabled. With this option enabled,
            static analysis of a template rule is deferred until the first time that the
            template is matched.This can improve performance when many template
            rules are rarely used during the course of a particular transformation; however,
            it means that static errors in the stylesheet will not necessarily cause the
            <code>Compile(Source)</code> method to throw an exception (errors in code that is
             actually executed will still be notified to the registered <code>ErrorList</code>
             or <code>ErrorList</code>, but this may happen after the {
            <c>Compile(Source)</c>
             method returns). This option is enabled by default in Saxon - EE, and is not available
             in Saxon - HE or Saxon-PE.
             <p><b> Recommendation:</b> disable this option unless you are confident that the
             stylesheet you are compiling is error - free.</p>
            </summary>
        </member>
        <member name="P:Saxon.Api.XsltCompiler.ErrorList">
            <summary>
            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 <c>StaticError</c>.
            If no error list is supplied by the caller, error information will be written to
            an error list allocated by the system, which can be obtained as the value of this property.
            </summary>
            <remarks>
            By supplying a custom <c>List</c> with a user-written <c>add()</c> method, it is possible to
            intercept error conditions as they occur.
            </remarks>
        </member>
        <member name="P:Saxon.Api.XsltCompiler.ErrorReporter">
            <summary>Set the <c>ErrorReporter</c> to be used when validating instance documents as a user defined IErrorReporter.
            If this property is used then the ErrorList property and SetErrorList method is overriden </summary>
            <remarks>The <c>IErrorReporter</c> to be used</remarks>
        </member>
        <member name="P:Saxon.Api.XsltCompiler.Implementation">
            <summary>
            Escape hatch to the underlying Java implementation of the <c>XsltCompiler</c>
            </summary>
        </member>
        <member name="P:Saxon.Api.XsltCompiler.FastCompilation">
            <summary>
            Property to check and set fast compilation. Fast compilation will generally be achieved at the expense of run-time performance
            and quality of diagnostics. Fast compilation is a good trade-off if (a) the stylesheet is known to be correct,
            and (b) once compiled, it is only executed once against a document of modest size.
            </summary>
            <remarks>
            <para>Fast compilation may result in static errors going unreported, especially if they occur in code
            that is never executed.</para>
            <para><i>The current implementation is equivalent to switching off all optimizations other than just-in-time
            compilation of template rules. Setting this option, however, indicates an intent rather than a mechanism,
            and the implementation details may change in future to reflect the intent.</i></para>
            <para>Set to true to request fast compilation; set to false to revert to the optimization options
            defined in the Configuration.</para>
            </remarks>
        </member>
        <member name="P:Saxon.Api.XsltCompiler.FastCompliation">
            <summary>
            Property to check and set fast compilation.
            This property name has been misspelt, use <c>FastCompilation</c> instead.
            </summary>
        </member>
        <member name="T:Saxon.Api.XsltExecutable">
            <summary>
            An <c>XsltExecutable</c> represents the compiled form of a stylesheet. To execute the stylesheet,
            it must first be loaded to form an <see cref="T:Saxon.Api.XsltTransformer"/> or <see cref="T:Saxon.Api.Xslt30Transformer"/>.
            </summary>
            <remarks>
            <para>An <c>XsltExecutable</c> is immutable, and therefore thread-safe. It is simplest to
            load a new <c>XsltEvaluator</c> each time the stylesheet is to be run. However, the 
            <c>XsltEvaluator</c> is serially reusable within a single thread.</para>
            <para>An <c>XsltExecutable</c> is created by using one of the <c>Compile</c>
            methods on the <see cref="T:Saxon.Api.XsltCompiler"/> class.</para>
            </remarks>    
        </member>
        <member name="M:Saxon.Api.XsltExecutable.Load">
            <summary>
            Load the stylesheet to prepare it for execution.
            </summary>
            <returns>
            An <c>XsltTransformer</c>. The returned <c>XsltTransformer</c> can be used to
            set up the dynamic context for stylesheet evaluation, and to run the stylesheet.
            </returns>
        </member>
        <member name="M:Saxon.Api.XsltExecutable.Load30">
            <summary>
            Load the stylesheet to prepare it for execution. This version of the <c>load()</c> method
            creates an <code>Xslt30Transformer</code> which offers interfaces for stylesheet
            invocation corresponding to those described in the XSLT 3.0 specification. It can be used
            with XSLT 2.0 or XSLT 3.0 stylesheets, and in both cases it offers new XSLT 3.0 functionality such
            as the ability to supply parameters to the initial template, or the ability to invoke
            stylesheet-defined functions, or the ability to return an arbitrary sequence as a result
            without wrapping it in a document node.
            </summary>
            <returns>
            An <c>Xslt30Transformer</c>. The returned <c>Xslt30Transformer</c> can be used to
            set up the dynamic context for stylesheet evaluation, and to run the stylesheet.
            </returns>
        </member>
        <member name="M:Saxon.Api.XsltExecutable.Explain(Saxon.Api.XmlDestination)">
            <summary>
            Output an XML representation of the compiled code of the stylesheet, for purposes of 
            diagnostics and instrumentation.
            </summary>
            <param name="destination">The destination for the diagnostic output</param>
        </member>
        <member name="M:Saxon.Api.XsltExecutable.getWhitespaceStrippingPolicy">
            <summary>
            Get the whitespace stripping policy defined by this stylesheet, that is, the policy
            defined by the <c>xsl:strip-space</c> and <c>xsl:preserve-space</c> elements in the stylesheet.
            </summary>
            <returns> a newly constructed <c>WhitespacePolicy</c> based on the declarations in this
            stylesheet. This policy can be used as input to a <see cref="T:Saxon.Api.DocumentBuilder"/>.</returns>
        </member>
        <member name="M:Saxon.Api.XsltExecutable.GetGlobalParameters">
            <summary>
            Get the names of the <c>xsl:param</c> elements defined in this stylesheet, with details
            of each parameter including its required type, and whether it is required or optional.
            </summary>
            <returns>
            a <c>Dictionary</c> whose keys are the names of global parameters in the stylesheet,
            and whose values are <see cref="!:Saxon.Api.XsltExecutable+ParameterDetails"/> objects giving information about the
            corresponding parameter.
            </returns>
        </member>
        <member name="P:Saxon.Api.XsltExecutable.Processor">
            <summary>
            Get the Processor that was used to create this XsltExecutable
            </summary>
        </member>
        <member name="P:Saxon.Api.XsltExecutable.Implementation">
            <summary>
            Escape hatch to the underlying Java implementation object.
            </summary>
        </member>
        <member name="T:Saxon.Api.XsltExecutable.ParameterDetails">
            <summary>
            Information about a global parameter to a stylesheet.
            </summary>
        </member>
        <member name="M:Saxon.Api.XsltExecutable.ParameterDetails.#ctor(Saxon.Api.XdmSequenceType,System.Boolean)">
            <summary>
            Create parameter details.
            </summary>
            <param name="type">The declared type of the parameter.</param>
            <param name="isRequired">Indicates whether the parameter is required or optional.</param>
        </member>
        <member name="M:Saxon.Api.XsltExecutable.ParameterDetails.GetDeclaredItemType">
            <summary>
            Gets the declared item type of the parameter.
            </summary>
            <returns>The type defined in the <code>as</code> attribute of the <code>xsl:param</code> element,
            without its occurrence indicator</returns>
        </member>
        <member name="M:Saxon.Api.XsltExecutable.ParameterDetails.GetDeclaredCardinality">
            <summary>
            Gets the declared cardinality of the parameter.
            </summary>
            <returns>The occurrence indicator from the type appearing in the <code>as</code> attribute
            of the <code>xsl:param</code> element</returns>
        </member>
        <member name="M:Saxon.Api.XsltExecutable.ParameterDetails.GetUnderlyingDeclaredType">
            <summary>
            Gets the underlying declared type of the parameter.
            </summary>
            <returns>The underlying declared type.</returns>
        </member>
        <member name="P:Saxon.Api.XsltExecutable.ParameterDetails.IsRequired">
            <summary>
            Ask whether the parameter is required (mandatory) or optional
            </summary>
            <returns><c>true</c> if the parameter is mandatory (<code>required="yes"</code>), false
            if it is optional.</returns>
        </member>
        <member name="T:Saxon.Api.XsltTransformer">
            <summary inherits="XdmDestination">
            An <c>XsltTransformer</c> represents a compiled and loaded stylesheet ready for execution.
            The <c>XsltTransformer</c> holds details of the dynamic evaluation context for the stylesheet.
            </summary>
            <remarks>
            <para>An <c>XsltTransformer</c> must 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.</para>
            <para>An <c>XsltTransformer</c> is always constructed by running the <c>Load</c> method of
            an <c>XsltExecutable</c>.</para>
            <para>The <see cref="T:Saxon.Api.Xslt30Transformer"/> class provides invocation options that are more closely aligned
            with the XSLT 3.0 specification, for example streamed evaluation. However, both <c>XsltTransformer</c> 
            and <c>Xslt30Transformer</c> can be used irrespective of the XSLT language version used in the stylesheet.</para>
            </remarks>
        </member>
        <member name="M:Saxon.Api.XsltTransformer.SetInputStream(System.IO.Stream,System.Uri)">
            <summary>
            Supply the principal input document for the transformation in the form of a stream.
            </summary>
            <remarks>
            <para>If this method is used, the <c>InitialContextNode</c> is ignored.</para>
            <para>The supplied stream will be consumed by the <c>Run()</c> method.
            Closing the input stream after use is the client's responsibility.</para>
            <para>A base URI must be supplied in all cases. It is used to resolve relative
            URI references appearing within the input document.</para>
            <para>Schema validation is applied to the input document according to the value of
            the <c>SchemaValidationMode</c> property.</para>
            <para>Whitespace stripping is applied according to the value of the
            <c>xsl:strip-space</c> and <c>xsl:preserve-space</c> declarations in the stylesheet.</para>
            </remarks>
            <param 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 global context item for the transformation.
            </param>
            <param 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>
        </member>
        <member name="M:Saxon.Api.XsltTransformer.SetParameter(Saxon.Api.QName,Saxon.Api.XdmValue)">
            <summary>
            Set the value of a stylesheet parameter.
            </summary>
            <param 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 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>
        </member>
        <member name="M:Saxon.Api.XsltTransformer.GetUnderlyingDestination">
            <summary>
            Get the underlying destination.
            </summary>
        </member>
        <member name="M:Saxon.Api.XsltTransformer.Close">
            <summary>
            Close the <c>Destination</c>, releasing any resources that need to be released.
            </summary>
            <remarks>
            This method is called by the system on completion of a query or transformation.
            Some kinds of <c>Destination</c> may need to close an output stream, others might
            not need to do anything. The default implementation does nothing.
            </remarks>
        </member>
        <member name="M:Saxon.Api.XsltTransformer.Run(Saxon.Api.XmlDestination)">
            <summary>
            Run the transformation, sending the result to a specified destination.
            </summary>
            <param 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>
            <exception cref="T:Saxon.Api.DynamicError">Throws a <c>DynamicError</c> if the transformation
            fails.</exception>
        </member>
        <member name="P:Saxon.Api.XsltTransformer.InitialContextNode">
            <summary>
            The global context item for the stylesheet, as a node.
            </summary>
            <remarks><para>Although XSLT 3.0 allows the global context item to be any item,
            this interface only allows it to be a node.
            Most commonly it will be a document node, which might be constructed
            using the <c>Build</c> method of the <c>DocumentBuilder</c> object.</para>
            <para>Note that this can be inefficient if the stylesheet uses <c>xsl:strip-space</c>
            to strip whitespace, or <c>input-type-annotations="strip"</c> 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.</para>
            </remarks>
        </member>
        <member name="P:Saxon.Api.XsltTransformer.InitialMode">
            <summary>
            The initial mode for the stylesheet. This is either a <c>QName</c>, for a 
            specific mode, or null, for the default mode.
            </summary>
            <remarks>
            The default mode will usually be the unnamed mode, but if the stylesheet declares a
            named mode as the default mode, then supplying null as the <c>InitialMode</c> invokes this default.
            </remarks>
        </member>
        <member name="P:Saxon.Api.XsltTransformer.InitialTemplate">
            <summary>
            The initial template for the stylesheet. This is either a <c>QName</c>, for a 
            named template, or null, if no initial template has been set.
            </summary>
            <remarks>
            If the stylesheet is to be invoked by calling the template named <c>xsl:initial-template</c>,
            then the <c>InitialTemplate</c> property should be set to this <c>QName</c> explicitly.
            </remarks>
            <exception cref="T:Saxon.Api.DynamicError">Setting this property to the name of a template
            that does not exist in the stylesheet throws a <c>DynamicError</c> with error 
            code XTDE0040. Setting it to the name of a template that has template
            parameters throws a <c>DynamicError</c> with error code XTDE0060.</exception>
        </member>
        <member name="P:Saxon.Api.XsltTransformer.BaseOutputUri">
            <summary>
            The base output URI, which acts as the base URI for resolving the <c>href</c>
            attribute of <c>xsl:result-document</c>.
            </summary>
        </member>
        <member name="P:Saxon.Api.XsltTransformer.SchemaValidationMode">
            <summary>
            The <c>SchemaValidationMode</c> to be used in this transformation, especially for documents
            loaded using the <c>doc()</c>, <c>document()</c>, or <c>collection()</c> functions.
            </summary>
        </member>
        <member name="P:Saxon.Api.XsltTransformer.InputXmlResolver">
            <summary>
            The <c>XmlResolver</c> to be used at run-time to resolve and dereference URIs
            supplied to the <c>doc()</c> and <c>document()</c> functions.
            </summary>
        </member>
        <member name="P:Saxon.Api.XsltTransformer.ResultDocumentHandler">
            <summary>
            The <c>IResultDocumentHandler</c> to be used at run-time to process the output
            produced by any <c>xsl:result-document</c> instruction with an <c>href</c>
            attribute.
            </summary>
            <remarks>
            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).
            </remarks>
        </member>
        <member name="P:Saxon.Api.XsltTransformer.MessageListener">
            <summary>
            Listener for messages output using <c>&lt;xsl:message&gt;</c>.
            </summary>
            <remarks> 
            <para>The caller may supply a message listener before calling <c>Run</c>;
            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 <c>XdmNode</c>
            representing a document node.</para>
            <para>If no message listener is supplied by the caller, message information will be written to
            the standard error stream.</para>
            <para>Each message is presented as an XML document node. Calling <c>ToString()</c>
            on the message object will usually generate an acceptable representation of the
            message.</para>
            <para>When the <c>xsl:message</c> instruction specifies <c>terminate="yes"</c>,
            the message is first notified using this interface, and then an exception is thrown
            which terminates the transformation.</para>
            </remarks>
        </member>
        <member name="P:Saxon.Api.XsltTransformer.MessageListener2">
            <summary>
            Listener for messages output using <c>&lt;xsl:message&gt;</c>.
            </summary>
            <remarks> 
            <para>The caller may supply a message listener before calling <c>Run</c>;
            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 <c>XdmNode</c>
            representing a document node.</para>
            <para>If no message listener is supplied by the caller, message information will be written to
            the standard error stream.</para>
            <para>Each message is presented as an XML document node. Calling <c>ToString()</c>
            on the message object will usually generate an acceptable representation of the
            message.</para>
            <para>When the <c>xsl:message</c> instruction specifies <c>terminate="yes"</c>,
            the message is first notified using this interface, and then an exception is thrown
            which terminates the transformation.</para>
            <para>The <c>MessageListener2</c> property interface differs from the <c>MessageListener</c>
            in allowing the error code supplied to xsl:message to be notified</para>
            </remarks>
        </member>
        <member name="P:Saxon.Api.XsltTransformer.TraceFunctionDestination">
            <summary>
            Destination for output of messages using the <c>trace()</c> function.
            </summary>
            <remarks> 
            <para>If no message listener is supplied by the caller, message information will be written to
            the standard error stream.</para>
            <para>The supplied destination is ignored if a <c>TraceListener</c> is in use.</para>
            </remarks>
        </member>
        <member name="P:Saxon.Api.XsltTransformer.WrappedXsltTransformer">
            <summary>
            Get the underlying Java (s9api) XsltTransformer object which provides the underlying
            functionality of this object.
            </summary>
            <remarks>
            <para>Previously delivered under the misspelt name <code>Implemmentation</code></para>
            </remarks>
        </member>
        <member name="P:Saxon.Api.XsltTransformer.Destination">
            <summary>
            The destination for the result of the transformation. The class <c>XmlDestination</c> is an abstraction 
            that allows a number of different kinds of destination to be specified.
            </summary>
            <remarks>
            <para>The Destination can be used to chain transformations into a pipeline, by using one
            <c>XsltTransformer</c> as the destination of another.</para>
            </remarks>
        </member>
        <member name="P:Saxon.Api.XsltTransformer.Implementation">
            <summary>
            Escape hatch to the underlying Java implementation
            </summary>
        </member>
        <member name="T:Saxon.Api.RecoveryPolicy">
            <summary>
            <c>RecoveryPolicy</c> is an enumeration of the different actions that can be taken when a "recoverable error" occurs.
            </summary>  
        </member>
        <member name="F:Saxon.Api.RecoveryPolicy.RecoverSilently">
            <summary>
            Ignore the error, take the recovery action, do not produce any message
            </summary>
        </member>
        <member name="F:Saxon.Api.RecoveryPolicy.RecoverWithWarnings">
            <summary>
            Take the recovery action after outputting a warning message
            </summary>
        </member>
        <member name="F:Saxon.Api.RecoveryPolicy.DoNotRecover">
            <summary>
            Treat the error as fatal
            </summary>
        </member>
        <member name="T:Saxon.Api.IResultDocumentHandler">
            <summary>An <c>IResultDocumentHandler</c> can be nominated to handle output
            produced by the <c>xsl:result-document</c> instruction in an XSLT stylesheet.
            </summary>
            <remarks>
            <para>This interface affects any <c>xsl:result-document</c> instruction
            executed by the stylesheet, provided that it has an <c>href</c> attribute.</para> 
            <para>If no <c>IResultDocumentHandler</c> is nominated (in the
            <c>IResultDocumentHandler</c> property of the <c>XsltTransformer</c>), 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 <c>href</c> attribute, resolved
            (if it is relative) against the URI supplied in the <c>BaseOutputUri</c> property
            of the <c>XsltTransformer</c>.</para>
            <para>If an <c>IResultDocumentHandler</c> is nominated, however, its
            <c>HandleResultDocument</c> method will be called whenever an <c>xsl:result-document</c>
            instruction with an <c>href</c> attribute is evaluated, and the generated result tree
            will be passed to the <c>XmlDestination</c> returned by that method.</para> 
            </remarks>
        </member>
        <member name="M:Saxon.Api.IResultDocumentHandler.HandleResultDocument(System.String,System.Uri)">
            <summary> Handle output produced by the <c>xsl:result-document</c>
            instruction in an XSLT stylesheet. This method is called by the XSLT processor
            when an <c>xsl:result-document</c> with an <c>href</c> attribute is evaluated.
            </summary>
            <param name="href">An absolute or relative URI. This will be the effective value of the 
            <c>href</c> attribute of the <c>xsl:result-document</c> in the stylesheet.</param>
            <param name="baseUri">The base URI that should be used for resolving the value of
            <c>href</c> if it is relative. This will always be the value of the <c>BaseOutputUri</c>
            property of the <c>XsltTransformer</c>.</param>
            <returns>An <c>XmlDestination</c> to handle the result tree produced by the
            <c>xsl:result-document</c> instruction. The <c>Close</c> method of the returned
            <c>XmlDestination</c> will be called when the output is complete.</returns>
            <remarks>
            <para>The XSLT processor will ensure that the stylesheet cannot create
            two distinct result documents which are sent to the same URI. It is the responsibility
            of the <c>IResultDocumentHandler</c> to ensure that two distinct result documents are
            not sent to the same <c>XmlDestination</c>. Failure to observe this rule can result
            in output streams being incorrectly closed.
            </para>
            <para>Note that more than one result document can be open at the same time,
            and that the order of opening, writing, and closing result documents chosen
            by the processor does not necessarily bear any direct resemblance to the way
            that the XSLT source code is written.</para></remarks>
            public*
        </member>
        <member name="T:Saxon.Api.ResultDocumentHandlerWrapper">
            <summary>Internal wrapper class for <c>IResultDocumentHandler</c></summary>
        </member>
        <member name="M:Saxon.Api.ResultDocumentHandlerWrapper.#ctor(Saxon.Api.IResultDocumentHandler,net.sf.saxon.event.PipelineConfiguration)">
            <summary>
            Initializes a new instance of the <see cref="T:Saxon.Api.ResultDocumentHandlerWrapper"/> class.
            </summary>
            <param name="handler">Handler.</param>
            <param name="pipe">Pipe.</param>
        </member>
        <member name="M:Saxon.Api.ResultDocumentHandlerWrapper.close(javax.xml.transform.Result)">
            <summary>
            Close the specified result.
            </summary>
            <param name="result">Result.</param>
        </member>
        <member name="M:Saxon.Api.ResultDocumentHandlerWrapper.resolve(net.sf.saxon.expr.XPathContext,System.String,System.String,net.sf.saxon.serialize.SerializationProperties)">
            <summary>
            Resolve the specified href and baseString.
            </summary>
            <param name="href">Href.</param>
            <param name="baseString">Base string.</param>
        </member>
        <member name="T:Saxon.Api.IMessageListener">
            <summary>An <c>IMessageListener</c> can be nominated to handle output
            produced by the <c>xsl:message</c> instruction in an XSLT stylesheet.
            </summary>
            <remarks>
            <para>This interface affects any <c>xsl:message</c> instruction
            executed by the stylesheet.</para> 
            <para>If no <c>IMessageListener</c> is nominated (in the
            <c>MessageListener</c> property of the <c>XsltTransformer</c>), the output
            of <code>xsl:message</code> is serialized, and is written to standard error
            output stream.</para>
            <para>If an <c>IMessageListener</c> is nominated, however, its
            <c>Message</c> method will be called whenever an <c>xsl:message</c>
            instruction is evaluated.</para> 
            </remarks>
        </member>
        <member name="M:Saxon.Api.IMessageListener.Message(Saxon.Api.XdmNode,System.Boolean,Saxon.Api.IXmlLocation)">
            public*
        </member>
        <member name="T:Saxon.Api.IMessageListener2">
            <summary>An <c>IMessageListener</c> can be nominated to handle output
            produced by the <c>xsl:message</c> instruction in an XSLT stylesheet.
            </summary>
            <remarks>
            <para>This interface affects any <c>xsl:message</c> instruction
            executed by the stylesheet.</para> 
            <para>If no <c>IMessageListener</c> is nominated (in the
            <c>MessageListener</c> property of the <c>XsltTransformer</c>), the output
            of <code>xsl:message</code> is serialized, and is written to standard error
            output stream.</para>
            <para>If an <c>IMessageListener</c> is nominated, however, its
            <c>Message</c> method will be called whenever an <c>xsl:message</c>
            instruction is evaluated.</para> 
            <para>The <c>MessageListener2</c> interface differs from <c>MessageListener</c>
            in allowing the error code supplied to <c>xsl:message</c> to be made available.</para>
            </remarks>
        </member>
        <member name="M:Saxon.Api.IMessageListener2.Message(Saxon.Api.XdmNode,Saxon.Api.QName,System.Boolean,Saxon.Api.IXmlLocation)">
            public*
        </member>
        <member name="T:Saxon.Api.IXmlLocation">
            <summary>
            An <c>IXmlLocation</c> 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.
            </summary>
        </member>
        <member name="P:Saxon.Api.IXmlLocation.BaseUri">
            public*
        </member>
        <member name="P:Saxon.Api.IXmlLocation.LineNumber">
            public*
        </member>
        <member name="T:Saxon.Api.XmlLocation">
            <summary>
            Xml location. An implementation of <c>IXmlLocation</c>.
            </summary>
        </member>
        <member name="T:Saxon.Api.MessageListenerProxy">
            <summary>
            Message listener proxy. This class implements a <c>net.sf.saxon.s9api.MessageListener</c> that can receive 
            <c>xsl:message</c> output and send it to a user-supplied <c>MessageListener</c>
            </summary>
        </member>
        <member name="M:Saxon.Api.MessageListenerProxy.#ctor(Saxon.Api.IMessageListener)">
            <summary>
            Initializes a new instance of the <see cref="T:Saxon.Api.MessageListenerProxy"/> class.
            </summary>
            <param name="ml">ml.</param>
        </member>
        <member name="T:Saxon.Api.MessageListenerProxy2">
            <summary>
            Message listener proxy. This class implements a <c>net.sf.saxon.s9api.MessageListener2</c> that can receive 
            <c>xsl:message</c> output and send it to a user-supplied <c>MessageListener</c>
            </summary>
        </member>
        <member name="M:Saxon.Api.MessageListenerProxy2.#ctor(Saxon.Api.IMessageListener2)">
            <summary>
            Initializes a new instance of the <see cref="T:Saxon.Api.MessageListenerProxy"/> class.
            </summary>
            <param name="ml">ml.</param>
        </member>
        <member name="T:Saxon.Api.Xslt30Transformer">
            <summary>An <code>Xslt30Transformer</code> represents a compiled and loaded stylesheet ready for execution.
            The <code>Xslt30Transformer</code> holds details of the dynamic evaluation context for the stylesheet.</summary>
            <remarks><para>The <code>Xslt30Transformer</code> differs from <see cref="T:Saxon.Api.XsltTransformer"/> 
            in supporting new options
            for invoking a stylesheet, corresponding to facilities defined in the XSLT 3.0 specification. However,
            it is not confined to use with XSLT 3.0, and most of the new invocation facilities (for example,
            calling a stylesheet-defined function directly) work equally well with XSLT 2.0 and in some cases
            XSLT 1.0 stylesheets.</para>
            <para>An <code>Xslt30Transformer</code> must 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.</para>
            <para>An <code>Xslt30Transformer</code> is always constructed by running the <code>Load30</code>
            method of an <see cref="T:Saxon.Api.XsltExecutable"/>.</para>
            <para>Unlike <code>XsltTransformer</code>, an <code>Xslt30Transformer</code> is not a <code>Destination</code>.
            To pipe the results of one transformation into another, the target should be an <code>XsltTransfomer</code>
            rather than an <code>Xslt30Transformer</code>.</para>
            <para>Evaluation of an Xslt30Transformer proceeds in a number of phases:</para>
            <list type="number">
            <item>First, values may be supplied for stylesheet parameters and for the global context item. The
            global context item is used when initializing global variables. Unlike earlier transformation APIs,
            the global context item is quite independent of the "principal source document".
            </item>
            <item>The stylesheet may now be repeatedly invoked. Each invocation takes
            one of three forms:
            <list type="number">
            <item>Invocation by applying templates. In this case, the information required is (i) an initial
            mode (which defaults to the unnamed mode), (ii) an initial match sequence, which is any
            XDM value, which is used as the effective "select" expression of the implicit apply-templates
            call, and (iii) optionally, values for the tunnel and non-tunnel parameters defined on the
            templates that get invoked (equivalent to using <code>xsl:with-param</code> on the implicit
            <code>apply-templates</code> call).</item>
            <item>Invocation by calling a named template. In this case, the information required is
            (i) the name of the initial template (which defaults to "xsl:initial-template"), and
            (ii) optionally, values for the tunnel and non-tunnel parameters defined on the
            templates that get invoked (equivalent to using <code>xsl:with-param</code> on the implicit
            <code>call-template</code> instruction).</item>
            <item>Invocation by calling a named function. In this case, the information required is
            the sequence of arguments to the function call.</item>
            </list>
            </item>
            <item>Whichever invocation method is chosen, the result may either be returned directly, as an arbitrary
            XDM value, or it may effectively be wrapped in an XML document. If it is wrapped in an XML document,
            that document can be processed in a number of ways, for example it can be materialized as a tree in
            memory, it can be serialized as XML or HTML, or it can be subjected to further transformation.</item>
            </list>
            <para>Once the stylesheet has been invoked (using any of these methods), the values of the global context
            item and stylesheet parameters cannot be changed. If it is necessary to run another transformation with
            a different context item or different stylesheet parameters, a new <c>Xslt30Transformer</c>
            should be created from the original <c>XsltExecutable</c>.</para>
            <para> @since 9.6</para> 
            </remarks>
        </member>
        <member name="M:Saxon.Api.Xslt30Transformer.AsDocumentDestination(Saxon.Api.XmlDestination)">
            <summary>
            Construct a <c>Destination</c> object whose effect is to perform this transformation
            on any input that is sent to that <c>Destination</c>: for example, it allows this transformation
            to post-process the results of another transformation.
            </summary>
            <remarks>
            <para>This method allows a pipeline of transformations to be created in which
            one transformation is used as the destination of another. The transformations
            may use streaming, in which case intermediate results will not be materialized
            in memory. If a transformation does not use streaming, then its input will
            first be assembled in memory as a node tree.</para>
            <para>The <c>Destination</c> returned by this method performs <em>sequence normalization</em>
            as defined in the serialization specification: that is, the raw result of the transformation
            sent to this destination is wrapped into a document node. Any item-separator present in
            any serialization parameters is ignored (adjacent atomic values are separated by whitespace). 
            This makes the method unsuitable for passing intermediate results other than XML document
            nodes.</para>
            </remarks>
            <param name="finalDestination">supplied final destination</param>
            <returns>a <c>Destination</c> which accepts an XML document (typically as a stream
            of events) and which transforms this supplied XML document (possibly using streaming)
            as defined by the stylesheet from which which this <c>Xslt30Transformer</c>
            was generated,
            sending the principal result of the transformation to the supplied <c>finalDestination</c>.
            The transformation is performed as if by the <see cref="M:Saxon.Api.Xslt30Transformer.ApplyTemplates(System.IO.Stream,Saxon.Api.XmlDestination)"/>
            method: that is, by applying templates to the root node of the supplied XML document.
            </returns>
        </member>
        <member name="M:Saxon.Api.Xslt30Transformer.SetStylesheetParameters(System.Collections.Generic.Dictionary{Saxon.Api.QName,Saxon.Api.XdmValue})">
            <summary> Supply the values of global stylesheet variables and parameters.</summary>
            <param name="parameters"> A <c>Dictionary</c> whose keys are QNames identifying global stylesheet parameters,
            and whose corresponding values are the values to be assigned to those parameters. If necessary
            the supplied values are converted to the declared type of the parameter.
            The contents of the supplied <c>Dictionary</c> are copied by this method,
            so subsequent changes to the <c>Dictionary</c> have no effect.</param>
        </member>
        <member name="M:Saxon.Api.Xslt30Transformer.SetInitialTemplateParameters(System.Collections.Generic.Dictionary{Saxon.Api.QName,Saxon.Api.XdmValue},System.Boolean)">
            <param name="parameters"> The parameters to be used for the initial template</param>
            <param name="tunnel"> true if these values are to be used for setting tunnel parameters;
            false if they are to be used for non-tunnel parameters</param>
        </member>
        <member name="M:Saxon.Api.Xslt30Transformer.ApplyTemplates(System.IO.Stream,Saxon.Api.XmlDestination)">
            <summary>Invoke the stylesheet by applying templates to a supplied source document, 
            sending the results (wrapped in a document node) to a given <c>Destination</c>. The 
            invocation uses any initial mode set using <see cref="P:Saxon.Api.Xslt30Transformer.InitialMode"/>,
            and any template parameters set using <see cref="M:Saxon.Api.Xslt30Transformer.SetInitialTemplateParameters(System.Collections.Generic.Dictionary{Saxon.Api.QName,Saxon.Api.XdmValue},System.Boolean)"/>.
            </summary>
            <param name="input">The source document. To apply more than one transformation to the same source 
            document, the source document tree can be pre-built using a <see cref="T:Saxon.Api.DocumentBuilder"/>.</param>
            <param name="destination">The destination of the result document produced by wrapping the result 
            of the apply-templates call in a document node.  If the destination is a <see cref="T:Saxon.Api.Serializer"/>, 
            then the serialization parameters set in the serializer are combined with those defined in the 
            stylesheet (the parameters set in the serializer take precedence).</param>
        </member>
        <member name="M:Saxon.Api.Xslt30Transformer.ApplyTemplates(System.IO.Stream,System.Uri,Saxon.Api.XmlDestination)">
            <summary>Invoke the stylesheet by applying templates to a supplied source document, 
            using the supplied base URI,
            sending the results (wrapped in a document node) to a given <c>Destination</c>. The 
            invocation uses any initial mode set using <see cref="P:Saxon.Api.Xslt30Transformer.InitialMode"/>,
            and any template parameters set using <see cref="M:Saxon.Api.Xslt30Transformer.SetInitialTemplateParameters(System.Collections.Generic.Dictionary{Saxon.Api.QName,Saxon.Api.XdmValue},System.Boolean)"/>.
            </summary>
            <param name="input">The source document. To apply more than one transformation to the same source 
            document, the source document tree can be pre-built using a <see cref="T:Saxon.Api.DocumentBuilder"/>.</param>
            <param name="baseUri">Base URI used for the input document</param>
            <param name="destination">The destination of the result document produced by wrapping the result 
            of the apply-templates call in a document node.  If the destination is a <see cref="T:Saxon.Api.Serializer"/>, 
            then the serialization parameters set in the serializer are combined with those defined in the 
            stylesheet (the parameters set in the serializer take precedence).</param>
        </member>
        <member name="M:Saxon.Api.Xslt30Transformer.Transform(System.IO.Stream,Saxon.Api.XmlDestination)">
            <summary>
            Invoke the stylesheet by applying templates to a supplied source document, sending the results
            to a given <c>Destination</c>. The invocation uses the initial mode set using <see cref="P:Saxon.Api.Xslt30Transformer.InitialMode"/>
            (defaulting to the default mode defined in the stylesheet itself, which by default is the unnamed mode).
            It also uses any template parameters set using <see cref="M:Saxon.Api.Xslt30Transformer.SetInitialTemplateParameters(System.Collections.Generic.Dictionary{Saxon.Api.QName,Saxon.Api.XdmValue},System.Boolean)"/>.
            </summary>
            <param name="input">The source document. To apply more than one transformation to the same source 
            document, the source document tree can be pre-built using a <see cref="T:Saxon.Api.DocumentBuilder"/>.</param>
            <param name="destination">The destination of the principal result of the transformation.
            If the destination is a <see cref="T:Saxon.Api.Serializer"/>, then the serialization
            parameters set in the serializer are combined with those defined in the stylesheet
            (the parameters set in the serializer take precedence).</param>
            <remarks>since 9.9.1.5</remarks>
        </member>
        <member name="M:Saxon.Api.Xslt30Transformer.Transform(System.IO.Stream,System.Uri,Saxon.Api.XmlDestination)">
            <summary>
            Invoke the stylesheet by applying templates to a supplied Source document,  
            using the supplied base URI, sending the results
            to a given <c>Destination</c>. The invocation uses the initial mode set using <see cref="P:Saxon.Api.Xslt30Transformer.InitialMode"/>
            (defaulting to the default mode defined in the stylesheet itself, which by default is the unnamed mode).
            It also uses any template parameters set using <see cref="M:Saxon.Api.Xslt30Transformer.SetInitialTemplateParameters(System.Collections.Generic.Dictionary{Saxon.Api.QName,Saxon.Api.XdmValue},System.Boolean)"/>.
            </summary>
            <param name="input">The source document. To apply more than one transformation to the same source 
            document, the source document tree can be pre-built using a <see cref="T:Saxon.Api.DocumentBuilder"/>.</param>
            <param name="baseUri">Base URI used for the input document</param>
            <param name="destination">The destination of the principal result of the transformation.
            If the destination is a <see cref="T:Saxon.Api.Serializer"/>, then the serialization
            parameters set in the serializer are combined with those defined in the stylesheet
            (the parameters set in the serializer take precedence).</param>
            <remarks>since 9.9.1.5</remarks>
        </member>
        <member name="M:Saxon.Api.Xslt30Transformer.ApplyTemplates(System.IO.Stream,System.Uri)">
            <summary>Invoke the stylesheet by applying templates to a supplied source document, 
            using the supplied base URI,
            returning the raw results as an <c>XdmValue</c>. The 
            invocation uses any initial mode set using <see cref="P:Saxon.Api.Xslt30Transformer.InitialMode"/>,
            and any template parameters set using <see cref="M:Saxon.Api.Xslt30Transformer.SetInitialTemplateParameters(System.Collections.Generic.Dictionary{Saxon.Api.QName,Saxon.Api.XdmValue},System.Boolean)"/>.
            </summary>
            <param name="input">The source document. To apply more than one transformation to the same source 
            document, the source document tree can be pre-built using a <see cref="T:Saxon.Api.DocumentBuilder"/>.</param>
            <param name="baseUri">Base URI</param>
            <returns>the raw result of applying templates to the supplied selection value, without wrapping in
            a document node or serializing the result. If there is more than one item in the selection, the result
            is the concatenation of the results of applying templates to each item in turn.</returns>
        </member>
        <member name="M:Saxon.Api.Xslt30Transformer.ApplyTemplates(Saxon.Api.XdmValue,Saxon.Api.XmlDestination)">
            <summary>
            Invoke the stylesheet by applying templates to a supplied input sequence, sending the results (wrapped
            in a document node) to a given <c>Destination</c>. The invocation uses any initial mode set using 
            <see cref="P:Saxon.Api.Xslt30Transformer.InitialMode"/>, and any template parameters set using <see cref="M:Saxon.Api.Xslt30Transformer.SetInitialTemplateParameters(System.Collections.Generic.Dictionary{Saxon.Api.QName,Saxon.Api.XdmValue},System.Boolean)"/>.
            </summary>
            <param name="selection">The initial value to which templates are to be applied (equivalent to the <code>select</code>
            attribute of <code>xsl:apply-templates</code>)</param>
            <param name="destination">The destination of the result document produced by wrapping the result of the apply-templates
            call in a document node.  If the destination is a <see cref="T:Saxon.Api.Serializer"/>, then the serialization
            parameters set in the serializer are combined with those defined in the stylesheet
            (the parameters set in the serializer take precedence).</param>
        </member>
        <member name="M:Saxon.Api.Xslt30Transformer.ApplyTemplates(Saxon.Api.XdmValue)">
            <summary>
            Invoke the stylesheet by applying templates to a supplied input sequence, returning the raw results
            as an <see cref="T:Saxon.Api.XdmValue"/>. The invocation uses any initial mode set using <see cref="P:Saxon.Api.Xslt30Transformer.InitialMode"/>,
            and any template parameters set using <see cref="M:Saxon.Api.Xslt30Transformer.SetInitialTemplateParameters(System.Collections.Generic.Dictionary{Saxon.Api.QName,Saxon.Api.XdmValue},System.Boolean)"/>.
            </summary>
            <param name="selection">The initial value to which templates are to be applied (equivalent to the <code>select</code>
            attribute of <code>xsl:apply-templates</code>)</param>
            <returns>the raw result of applying templates to the supplied selection value, without wrapping in
            a document node or serializing the result. If there is more than one item in the selection, the result
            is the concatenation of the results of applying templates to each item in turn.</returns>
        </member>
        <member name="M:Saxon.Api.Xslt30Transformer.CallTemplate(Saxon.Api.QName,Saxon.Api.XmlDestination)">
            <summary> Invoke a transformation by calling a named template. The results of calling
            the template are wrapped in a document node, which is then sent to the specified
            destination. If <see cref="M:Saxon.Api.Xslt30Transformer.SetInitialTemplateParameters(System.Collections.Generic.Dictionary{Saxon.Api.QName,Saxon.Api.XdmValue},System.Boolean)"/> has been
            called, then the parameters supplied are made available to the called template (no error
            occurs if parameters are supplied that are not used).</summary> 
            <param name="templateName"> The name of the initial template. This must match the name of a
            public named template in the stylesheet. If the value is null,
            the QName <code>xsl:initial-template</code> is used.</param>
            <param name="destination"> The destination of the result document produced by wrapping the result 
            of the apply-templates call in a document node.  If the destination is a <see cref="T:Saxon.Api.Serializer"/>, 
            then the serialization parameters set in the serializer are combined with those defined in the stylesheet
            (the parameters set in the serializer take precedence).</param> 
        </member>
        <member name="M:Saxon.Api.Xslt30Transformer.CallTemplate(Saxon.Api.QName)">
            <summary>
            Invoke a transformation by calling a named template. The results of calling
            the template are returned as a raw value, without wrapping in a document nnode
            or serializing.
            </summary>
            <param name="templateName">The name of the initial template. This must match the name of a
            public named template in the stylesheet. If the value is null, the QName <c>xsl:initial-template</c> is used.</param>
            <returns>the raw results of the called template, without wrapping in a document node or serialization.</returns>
        </member>
        <member name="M:Saxon.Api.Xslt30Transformer.CallFunction(Saxon.Api.QName,Saxon.Api.XdmValue[])">
            <summary> Call a public user-defined function in the stylesheet. </summary>
            <param name="function"> The name of the function to be called</param>
            <param name="arguments">  The values of the arguments to be supplied to the function. These
            will be converted if necessary to the type as defined in the function signature, using
            the function conversion rules.</param>
            <returns> the result of calling the function. This is the raw result, without wrapping in a document
            node and without serialization.</returns>
        </member>
        <member name="M:Saxon.Api.Xslt30Transformer.CallFunction(Saxon.Api.QName,Saxon.Api.XdmValue[],Saxon.Api.XmlDestination)">
            <summary>Call a public user-defined function in the stylesheet, wrapping the result in an XML document, 
            and sending this document to a specified destination</summary>    
            <param name="function"> The name of the function to be called</param>
            <param name="arguments"> The values of the arguments to be supplied to the function. These
            will be converted if necessary to the type as defined in the function signature, using
            the function conversion rules.</param>
            <param name="destination"> The destination of the result document produced by wrapping the 
            result of the apply-templates call in a document node.  If the destination is a <see cref="T:Saxon.Api.Serializer"/>, 
            then the serialization parameters set in the serializer are combined with those defined in the stylesheet
            (the parameters set in the serializer take precedence).</param>
        </member>
        <member name="P:Saxon.Api.Xslt30Transformer.GlobalContextItem">
            <summary> Supply the context item to be used when evaluating global variables and parameters.
            This argument can be null if no context item is to be supplied.</summary>
        </member>
        <member name="P:Saxon.Api.Xslt30Transformer.GetUnderlyingController">
            <summary> Get the underlying <c>Controller</c> used to implement this <c>XsltTransformer</c>. This provides access
            to lower-level methods not otherwise available in the Saxon.Api interface. Note that classes
            and methods obtained by this route cannot be guaranteed stable from release to release.</summary>
        </member>
        <member name="P:Saxon.Api.Xslt30Transformer.ResultDocumentHandler">
            <summary>
            The <c>IResultDocumentHandler</c> to be used at run-time to process the output
            produced by any <c>xsl:result-document</c> instruction with an <c>href</c>
            attribute.
            </summary>
            <remarks>
            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).
            </remarks>
        </member>
        <member name="P:Saxon.Api.Xslt30Transformer.SchemaValidationMode">
            <summary>
            The <c>SchemaValidationMode</c> to be used in this transformation, especially for documents
            loaded using the <code>doc()</code>, <code>document()</code>, or <code>collection()</code> functions.
            </summary>
        </member>
        <member name="P:Saxon.Api.Xslt30Transformer.BaseOutputURI">
            <summary>Get the base output URI.</summary>
            <remarks><para> This returns the value set using the setter method. If no value has been set
            explicitly, then the method returns null if called before the transformation, or the computed
            default base output URI if called after the transformation.
            </para>
            <para> The base output URI is used for resolving relative URIs in the <code>href</code> attribute
            of the <code>xsl:result-document</code> instruction.</para></remarks>
            <returns> The base output URI</returns>
        </member>
        <member name="P:Saxon.Api.Xslt30Transformer.InputXmlResolver">
            <summary>
            The <c>XmlResolver</c> to be used at run-time to resolve and dereference URIs
            supplied to the <c>doc()</c> and <c>document()</c> functions.
            </summary>
        </member>
        <member name="P:Saxon.Api.Xslt30Transformer.AssertionsEnabled">
            <summary>
            Ask whether assertions (<c>xsl:assert</c> instructions) have been enabled at run time. 
            </summary>
            <remarks>By default they are disabled at compile time. If assertions are enabled at compile time, then by
            default they will also be enabled at run time; but they can be disabled at run time by
            specific request. At compile time, assertions can be enabled for some packages and
            disabled for others; at run time, they can only be enabled or disabled globally.</remarks>
            <returns>true if assertions are enabled at run time</returns>
            <remarks>Since 9.7</remarks>
        </member>
        <member name="P:Saxon.Api.Xslt30Transformer.ssAssertionsEnabled">
            <summary>
            Ask whether assertions (<c>xsl:assert</c> instructions) have been enabled at run time.
            This property name has been misspelt, use <c>AssertionsEnabled</c> instead.
            </summary>
        </member>
        <member name="P:Saxon.Api.Xslt30Transformer.MessageListener">
            <summary>
            Listener for messages output using <c>&lt;xsl:message&gt;</c>.
            </summary>
            <remarks> 
            <para>The caller may supply a message listener before calling <c>Run</c>;
            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 <c>XdmNode</c>
            representing a document node.</para>
            <para>If no message listener is supplied by the caller, message information will be written to
            the standard error stream.</para>
            <para>Each message is presented as an XML document node. Calling <c>ToString()</c>
            on the message object will usually generate an acceptable representation of the
            message.</para>
            <para>When the <c>xsl:message</c> instruction specifies <c>terminate="yes"</c>,
            the message is first notified using this interface, and then an exception is thrown
            which terminates the transformation.</para>
            </remarks>
        </member>
        <member name="P:Saxon.Api.Xslt30Transformer.MessageListener2">
            <summary>
            Listener for messages output using <c>&lt;xsl:message&gt;</c>.
            </summary>
            <remarks> 
            <para>The caller may supply a message listener before calling <c>Run</c>;
            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 <c>XdmNode</c>
            representing a document node.</para>
            <para>If no message listener is supplied by the caller, message information will be written to
            the standard error stream.</para>
            <para>Each message is presented as an XML document node. Calling <c>ToString()</c>
            on the message object will usually generate an acceptable representation of the
            message.</para>
            <para>When the <c>xsl:message</c> instruction specifies <c>terminate="yes"</c>,
            the message is first notified using this interface, and then an exception is thrown
            which terminates the transformation.</para>
            <para>The <c>MessageListener2</c> property interface differs from the <c>MessageListener</c>
            in allowing the error code supplied to xsl:message to be notified</para>
            </remarks>
        </member>
        <member name="P:Saxon.Api.Xslt30Transformer.TraceFunctionDestination">
            <summary>
            Destination for output of messages using the <c>trace()</c> function. 
            </summary>
            <remarks>
            <para>If no message listener is supplied by the caller, message information will be written to
            the standard error stream.</para>
            <para>The supplied destination is ignored if a <code>TraceListener</code> is in use.</para>
            </remarks>
        </member>
        <member name="P:Saxon.Api.Xslt30Transformer.InitialMode">
            <summary>Initial mode for the transformation. This is used if the stylesheet is
            subsequently invoked by any of the <code>applyTemplates</code> methods.</summary>
            <remarks><para>The value may be the name of the initial mode, or null to indicate the default
            (unnamed) mode</para></remarks>
        </member>
        <member name="T:Saxon.Api.XsltPackage">
            <summary> An <c>XsltPackage</c> object represents the result of compiling an XSLT 3.0 package, as
            represented by an XML document containing an <c>xsl:package</c> element.</summary>
        </member>
        <member name="M:Saxon.Api.XsltPackage.Link">
            <summary>Link this package with the packages it uses to form an executable stylesheet. This process fixes
            up any cross-package references to files, templates, and other components, and checks to ensure
            that all such references are consistent.</summary>
            <returns> the resulting <c>XsltExecutable</c></returns>
        </member>
        <member name="M:Saxon.Api.XsltPackage.Save(System.IO.Stream)">
            <summary>Save this compiled package to filestore.</summary>
            <param name="stream"> the stream to which the compiled package should be saved</param>
        </member>
        <member name="M:Saxon.Api.XsltPackage.getUnderlyingPreparedPackage">
            <summary>Escape-hatch interface to the underlying implementation class.</summary>
            <returns>the underlying <c>StylesheetPackage</c>. The interface to <c>StylesheetPackage</c>
            is not a stable part of the s9api API definition.</returns>
        </member>
        <member name="P:Saxon.Api.XsltPackage.Processor">
            <summary>
            Get the Processor from which this <c>XsltPackage</c> was constructed
            </summary>
        </member>
        <member name="P:Saxon.Api.XsltPackage.PackageName">
            <summary>
            Get the name of the package (the URI appearing as the value of <code>xsl:package/@name</code>)
            </summary>
            <returns>The package name</returns>
        </member>
        <member name="P:Saxon.Api.XsltPackage.Version">
            <summary>Get the version number of the package (the value of the attribute 
            <code>xsl:package/@package-version</code></summary>
            <returns>The package version number</returns>
        </member>
    </members>
</doc>
