<?xml version="1.0"?>
<doc>
    <members>
        <member name="T:Saxon.Api.Processor">
            <summary>
            The Processor class serves three purposes: it allows global Saxon configuration
            options to be set; it acts as a factory for generating XQuery, XPath, and XSLT
            compilers; and it owns certain shared resources such as the Saxon NamePool and 
            compiled schemas. This is the first object that a Saxon application should create. Once
            established, a Processor may be used in multiple threads.
            </summary>
        </member>
        <member name="M:Saxon.Api.Processor.#ctor">
            <summary>
            Create a new Processor
            </summary>
        </member>
        <member name="M:Saxon.Api.Processor.#ctor(System.Boolean)">
            <summary>
            Create a Processor, indicating whether it is to be schema-aware.
            </summary>
            <param name="schemaAware">Set to true if the Processor is to be schema-aware.
            This requires the Saxon-SA product to be installed, with a valid license key.</param>
        </member>
        <member name="M:Saxon.Api.Processor.#ctor(System.Boolean,System.Boolean)">
            <summary>
            Create a Processor, indicating whether it is to be schema-aware.
            </summary>
            <param name="schemaAware">Set to true if the Processor is to be schema-aware.
            This requires the Saxon-SA product to be installed, with a valid license key.</param>
            <param name="loadLocally">This option has no effect at this release.</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 XQueryCompiler, which may be used to compile XQuery queries.
            </summary>
            <remarks>
            The returned XQueryCompiler retains a live link to the Processor, and
            may be affected by subsequent changes to the Processor.
            </remarks>
            <returns>A new XQueryCompiler</returns>
        </member>
        <member name="M:Saxon.Api.Processor.NewXsltCompiler">
            <summary>
            Create a new XsltCompiler, which may be used to compile XSLT stylesheets.
            </summary>
            <remarks>
            The returned XsltCompiler retains a live link to the Processor, and
            may be affected by subsequent changes to the Processor.
            </remarks>
            <returns>A new XsltCompiler</returns>
        </member>
        <member name="M:Saxon.Api.Processor.NewXPathCompiler">
            <summary>
            Create a new XPathCompiler, which may be used to compile XPath expressions.
            </summary>
            <remarks>
            The returned XPathCompiler retains a live link to the Processor, and
            may be affected by subsequent changes to the Processor.
            </remarks>
            <returns>A new XPathCompiler</returns>
        </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 "unregistered" by providing null as the value of the
            contents argument. 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 that processor. Collections should not normally be registered
            while queries and transformations are in progress.</para>
            </remarks>
            
        </member>
        <member name="M:Saxon.Api.Processor.WriteXdmValue(Saxon.Api.XdmValue,Saxon.Api.XmlDestination)">
            <summary>
            Copy an XdmValue to an XmlDestination
            </summary>
            <remarks>
            This method can be used to copy any kind of <c>XdmValue</c> to any kind
            of <c>XdmDestination</c>. The supplied <c>XdmValue</c> is first converted
            to an XML document according to the rules of the XSLT/XQuery serialization
            specification (for example, if the <c>XdmValue</c> is a sequence of atomic
            values, they will be turned in a text node in which the values are converted
            to strings and separated by single spaces). The resulting document is then
            written to the supplied <c>XmlDestination</c>.</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.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="P:Saxon.Api.Processor.ProductTitle">
            <summary>
            Get the full name of the Saxon product version implemented by this Processor
            </summary>
        </member>
        <member name="P:Saxon.Api.Processor.ProductVersion">
            <summary>
            Get the Saxon product version number (for example, "8.8.1")
            </summary>
        </member>
        <member name="P:Saxon.Api.Processor.IsSchemaAware">
            <summary>
            Indicates whether the Processor is schema-aware
            </summary>
        </member>
        <member name="P:Saxon.Api.Processor.SchemaManager">
            <summary>
            Gets the SchemaManager for the Processor. Returns null
            if the Processor is not schema-aware.
            </summary>
        </member>
        <member name="P:Saxon.Api.Processor.XmlResolver">
            <summary>
            An XmlResolver, which will be used while compiling and running queries, 
            XPath expressions, and stylesheets, if no other XmlResolver 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
            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>.</para>
            </remarks>
        </member>
        <member name="P:Saxon.Api.Processor.XmlVersion">
            <summary>
            The XML version used in this <c>Processor</c> (for example, this determines what characters
            are permitted in a name)
            </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 Configuration 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 object (and the objects it provides access to)
            is included in the Saxon JavaDoc docmentation, available 
            <link href="http://www.saxonica.com/documentation/javadoc/index.html">online</link>.
            </para>
            </remarks>
        </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>. This will be
             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 Stream.
            </summary>
            <remarks>
            <para>The document is parsed using the <c>System.Xml</c> parser.</para>
            <para>Before calling this method, the BaseUri 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 Stream 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 XmlReader.
            </summary>
            <remarks>
            <para>The XmlReader is responsible for parsing the document; this method builds a tree
            representation of the document (in an internal Saxon format) and returns its document node.
            The XmlReader is not required to perform validation but it must expand any entity references.
            Saxon uses the properties of the <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 XMLReader 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 XdmNode.
            </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 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 XdmNode.
            </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 XmlResolver, which will be used to resolve URIs of documents being loaded
            and of references to external entities within those documents (including any external DTD).
            </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 XmlDocument.</para>
            <para>The resulting line numbers are accessible to applications using the
            extension function saxon:line-number() 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 the schema-aware version of the Saxon product (Saxon-SA).</para>
            </remarks>
        </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-SA).</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 TinyTree is used. The main reason for using the LinkedTree alternative is if
             updating is required (the TinyTree 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 Stream or a TextReader.
            </remarks>
        </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</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="T:Saxon.Api.WhitespacePolicy">
            <summary>
            Enumeration identifying the various Whitespace stripping policies
            </summary>
        </member>
        <member name="F:Saxon.Api.WhitespacePolicy.PreserveAll">
            <summary>No whitespace is 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.StripAll">
            <summary>All whitespace text nodes are stripped</summary>
        </member>
        <member name="T:Saxon.Api.TreeModel">
            <summary>
            Enumeration identifying the different tree model implementations
            </summary>
            
        </member>
        <member name="F:Saxon.Api.TreeModel.TinyTree">
            <summary>
            Saxon TinyTree
            </summary>
        </member>
        <member name="F:Saxon.Api.TreeModel.LinkedTree">
            <summary>
            Saxon LinkedTree
            </summary>
        </member>
        <member name="F:Saxon.Api.TreeModel.Unspecified">
            <summary>
            Unspecified tree model
            </summary>
        </member>
        <member name="T:Saxon.Api.XmlDestination">
            <summary>
            An abstract destination for the results of a query or transformation
            </summary>
            <remarks>
            <para>Note to implementors: To implement a new kind of destination, you need
            to supply a method <c>getResult</c> which returns an implementation of
            the JAXP <c>Result</c> interface. Optionally, if the destination
            performs serialization, you can also implement <c>getOutputProperties</c>,
            which returns the properties used for serialization.
            </para>
            </remarks>
        </member>
        <member name="M:Saxon.Api.XmlDestination.GetResult">
            <summary>
            Get a <c>Result</c> to which the XML document can be sent as a series
            of events.
            </summary>
            <remarks>
            This must be an implementation of the JAXP <c>Result</c> interface that is
            recognized by Saxon.
            </remarks>
        </member>
        <member name="M:Saxon.Api.XmlDestination.GetOutputProperties">
            <summary>
            Get a set of <c>Properties</c> representing the parameters to the serializer.
            The default implementation returns an empty set of properties.
            </summary>
        </member>
        <member name="M:Saxon.Api.XmlDestination.Close">
            <summary>
            Close the Destination, 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 Destination may need to close an output stream, others might
            not need to do anything. The default implementation does nothing.
            </remarks>
        </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.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.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_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_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 "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 whose content should not be indented even when
            indent=yes is specified.</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="M:Saxon.Api.Serializer.#ctor">
            <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.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</param>
            <exception>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.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.GetResult">
            <summary inherit="yes"/>
        </member>
        <member name="M:Saxon.Api.Serializer.GetOutputProperties">
            <summary inherit="yes"/>
        </member>
        <member name="M:Saxon.Api.Serializer.Close">
            <summary inherit="yes"/>
        </member>
        <member name="T:Saxon.Api.DomDestination">
            <summary>
            A <c>DomDestination</c> represents an XmlDocument that is constructed to hold the
            output of a query or transformation.
            </summary>
            <remarks>
            No data needs to be supplied to the <c>DomDestination</c> object. The query or transformation
            populates an <c>XmlDocument</c>, which may then be retrieved as the value of the <c>XmlDocument</c>
            property
            </remarks>
        </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 XmlDocument 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 DocumentFragment 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.GetResult">
            <summary inherit="yes"/>
        </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.NullDestination">
            <summary>
            A <c>NullDestination</c> is an XmlDestination 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.GetResult">
            <summary inherit="yes"/>
        </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.</para>
            </remarks>
        </member>
        <member name="M:Saxon.Api.TextWriterDestination.#ctor(System.Xml.XmlWriter)">
            <summary>Construct a TextWriterDestination</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.GetResult">
            <summary inherit="yes"/>
        </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 transformation.</summary>
        </member>
        <member name="M:Saxon.Api.XdmDestination.GetResult">
            <summary inherit="yes"/>
        </member>
        <member name="P:Saxon.Api.XdmDestination.BaseUri">
            <summary>This property determines the base URI of the constructed XdmNode. 
            If the baseURI property of the XdmDestination is set before the destination is written to,
            then the constructed XdmNode will have this base URI. Setting this property after constructing the node
            has no effect.
            </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
            XdmDestination, 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.StaticError">
            <summary>
            The StaticError 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.#ctor(javax.xml.transform.TransformerException)">
            <summary>
            Create a new StaticError, wrapping a Saxon XPathException
            </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 QName. 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.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 Stream)
            </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.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="T:Saxon.Api.DynamicError">
            <summary>
            The DynamicError 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 DynamicError, specifying the error message
            </summary>
            <param name="message">The error message</param>
        </member>
        <member name="M:Saxon.Api.DynamicError.#ctor(javax.xml.transform.TransformerException)">
            <summary>
            Create a new DynamicError, wrapping a Saxon XPathException
            </summary>
            <param name="err">The exception to be wrapped</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 QName. 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 Stream)
            </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="T:Saxon.Api.XdmValue">
            <summary>
            An value in the XDM data model. A value is a sequence of zero or more
            items, each item being either an atomic value or a node.
            </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 <c>XdmItem</c>, which is a subtype of <c>XdmValue</c>.</para>
            </remarks>
        </member>
        <member name="M:Saxon.Api.XdmValue.#ctor(System.Collections.IEnumerable)">
            <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.Wrap(net.sf.saxon.om.ValueRepresentation)">
            <summary>
            Create an XdmValue from an underlying Saxon ValueRepresentation 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.</param>
            <returns>An XdmValue that wraps the underlying Saxon value
            representation.</returns>
        </member>
        <member name="M:Saxon.Api.XdmValue.Unwrap">
            <summary>
            Extract the underlying Saxon ValueRepresentation object from an XdmValue.
            This method is provided for the benefit of applications that need to mix
            use of the Saxon .NET API with direct use of the underlying objects
            and methods offered by the Java implementation.
            </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 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 value. Each item in the list
            will be an object of type <c>XdmItem</c>
            </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
            </returns> 
        </member>
        <member name="T:Saxon.Api.XdmItem">
            <summary>
            The class <c>XdmItem</c> represents an item in a sequence, as defined
            by the XDM data model. An item is either an atomic value or a node.
            </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 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.</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
            </returns>
        </member>
        <member name="T:Saxon.Api.XdmAtomicValue">
            <summary>
            The class <c>XdmAtomicValue</c> represents an item in an XPath 2.0 sequence
            that is an atomic value. The value may belong to any of the 19 primitive types
            defined in XML Schema, or to a type derived from these primitive types, or to 
            the XPath 2.0 type <c>xdt:untypedAtomic</c>
            </summary>
        </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>
            </summary>
            <param name="i">The integer value</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.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.QName,Saxon.Api.Processor)">
            <summary>
            Construct an atomic value of a given built-in or user-defined type
            </summary>
            <example>
              <code>AtomicValue("abcd", QName.XDT_UNTYPED_ATOMIC)</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 name="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.wrapExternalObject(System.Object)">
            <summary>
            Create an atomic value that wraps an external object. Such values can be used
            in conjunction with extension functions. (Synonym of <c>WrapExternalObject</c>,
            retained for backwards compatibility.)
            </summary>
            <param name="external">The object to be wrapped.</param>
            <returns>The wrapped object</returns>
        </member>
        <member name="M:Saxon.Api.XdmAtomicValue.WrapExternalObject(System.Object)">
            <summary>
            Create an atomic value that wraps an external object. Such values can be used
            in conjunction with extension functions.
            </summary>
            <param name="external">The object to be wrapped.</param>
            <returns>The wrapped object</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 2.0 cast operator</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 <c>Processor</c> object. 
            This is needed for access to the NamePool,
            which maps the internal form of type names to their external form.</param>
            <returns>The type of the value, as a QName. This may be a built-in type or a user-defined
            atomic type.
            </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>xdt: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>
            <para>xs:string - String</para>
            <para>xs:integer - Long</para>
            <para>xs:decimal - Decimal</para>
            <para>xs:double - Double</para>
            <para>xs:float - Float</para>
            <para>xs:boolean - Bool</para>
            <para>xs:QName - QName</para>
            <para>xs:anyURI - Uri</para>
            <para>xdt:untypedAtomic - String</para>
            <para>Other types - currently String, but this may change in the future</para>
            </remarks>
            <returns>The value converted to the most appropriate CLI type</returns>
        </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.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.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 a <c>XmlWriter</c> can only handle a well-formed XML document. This method
            will therefore signal an exception if the node is a document node with no children, or with
            more than one element child.
            </remarks>
        </member>
        <member name="M:Saxon.Api.XdmNode.ToString">
            <summary>
            Return a string representation of the node.
            </summary>
            <remarks>
            This currently returns the same as the <c>OuterXml</c> property.
            To get the string value as defined in XPath, use the <c>StringValue</c> property.
            </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 XmlNodeType.None 
            is returned.
            </remarks>
        </member>
        <member name="P:Saxon.Api.XdmNode.TypedValue">
            <summary>
            The typed value of the node, as an instance of <c>XdmValue</c>.
            </summary>
            <exception>
            A DynamicError is thrown if the node has no typed value, as will be the case for
            an element with element-only content.
            </exception>
        </member>
        <member name="P:Saxon.Api.XdmNode.StringValue">
            <summary>
            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, and 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>
            The Base URI of the node.
            </summary>
        </member>
        <member name="P:Saxon.Api.XdmNode.DocumentUri">
            <summary>
            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 method="xml", indent="yes", omit-xml-declaration="yes".</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 QName class represents an instance of xs:QName, as defined in the XPath 2.0
            data model. Internally, it has three components, a namespace URI, a local name, and
            a prefix. The prefix is intended to be used only when converting the value back to 
            a string.
            </summary>
            <remarks>
            Note that a QName is not itself an <c>XdmItem</c> in this model; however it can
            be wrapped in an XdmItem.
            </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,System.String)">
            <summary>
            Construct a QName using a namespace URI and a lexical representation.
            The lexical representation may be a local name on its own, or it may 
            be in the form <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 QName 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 QName from a lexical QName, supplying an element node whose
            in-scope namespaces are to be used to resolve any prefix contained in the QName.
            </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>
            <para>If the prefix of the lexical QName is not in scope, returns null.</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 XmlQualifiedName</param>
        </member>
        <member name="M:Saxon.Api.QName.FromClarkName(System.String)">
            <summary>
            Factory method to construct a QName 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.Register(Saxon.Api.Processor)">
            <summary>
            Register a QName 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>.
            </summary>
            <param name="processor">The Processor in which the name is to be registered.</param>
        </member>
        <member name="M:Saxon.Api.QName.IsValid(Saxon.Api.Processor)">
            <summary>
            Validate the QName against the XML 1.0 or XML 1.1 rules for valid names.
            </summary>
            <param name="processor">The Processor in which the name is to be validated.
            This determines whether the XML 1.0 or XML 1.1 rules for forming names are used.</param>
            <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 QName, 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>
            <remarks>
            The result of the function does not depend on registering the QName 
            with the <c>Processor</c>, but is computed more quickly if the QNames have
            both been registered
            </remarks>
            <param name="other">The value to be compared with this QName. If this value is not a QName, the
            result is always false. Otherwise, it is true if the namespace URI and local name both match.</param>
        </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="M:Saxon.Api.QName.ToQNameValue">
            <summary>
            Convert to a net.sf.saxon.value.QNameValue
            </summary>
        </member>
        <member name="P:Saxon.Api.QName.Prefix">
            <summary>The prefix of the QName. This plays no role in operations such as comparison
            of QNames for equality, but is retained (as specified in XPath) so that a string representation
            can be reconstructed.
            </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>The namespace URI of the QName. Returns "" (the zero-length string) if the
            QName is not in a namespace.
            </summary>
        </member>
        <member name="P:Saxon.Api.QName.LocalName">
            <summary>The local part of the QName</summary>
        </member>
        <member name="P:Saxon.Api.QName.ClarkName">
            <summary>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="T:Saxon.Api.SequenceEnumerator">
            <summary>
            This class represents an enumeration of the values in an XPath
            sequence. It implements the IEnumerator interface, and the objects
            returned are always instances of <c>XPathItem</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.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.Reset">
            <summary>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="P:Saxon.Api.SequenceEnumerator.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.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 Processor there is exactly one
            <c>SchemaManager</c> (in a non-schema-aware Processor 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 &lt;xs:redefine&gt;</para>
            </remarks>
        </member>
        <member name="M:Saxon.Api.SchemaManager.Compile(System.IO.Stream,System.Uri)">
            <summary>
            Compile a schema supplied as a Stream. 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 XmlReader. 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.
            If the <c>XmlReader</c> is an <c>XmlTextReader</c>, Saxon will set its <c>Normalization</c>
            property to true, and will wrap it in a (non-validating) <c>XmlValidatingReader</c> to ensure
            that entity references are expanded.
            </remarks>
            <param name="reader">The XmlReader (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 XdmNode. 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="P:Saxon.Api.SchemaManager.SchemaResolver">
            <summary>
            The SchemaResolver is a user-supplied class used for resolving references to
            schema documents. It applies to references from one schema document to another
            appearing in <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 Compile;
            the processor will then populate the list with error information obtained during
            the schema compilation. Each error will be included as an object of type StaticError.
            If no error list is supplied by the caller, error information will be written to
            the standard error stream.
            </summary>
            <remarks>
            <para>By supplying a custom List with a user-written add() 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="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.SetSource(System.IO.Stream,System.Uri)">
            <summary>
            Supply the instance document to be validated in the form of a Stream
            </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 Uri 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 XmlReader.
            </summary>
            <remarks>
            The XmlReader 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 XdmNode
            </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 XdmDestination.
            </remarks>
        </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.ErrorList">
            <summary>
            List of errors. The caller may supply an empty list before calling Compile;
            the processor will then populate the list with error information obtained during
            the schema compilation. Each error will be included as an object of type StaticError.
            If no error list is supplied by the caller, error information will be written to
            the standard error stream.
            </summary>
            <remarks>
            <para>By supplying a custom List with a user-written add() 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 SchemaResolver is a user-supplied class used for resolving references to
            schema documents. It applies to references from one schema document to another
            appearing in <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[])">
            <summary>
            Given a targetNamespace and a set of location hints, return a set of schema documents.
            </summary>
            <param name="targetNamespace">The target namespace of the required schema components</param>
            <param name="baseUri">The base URI of the module containing the reference to a schema document
            declaration</param>
            <param name="locationHints">The sequence of URIs (if any) listed as location hints.
            In most cases there will only be one; but the <c>import schema</c> declaration in
            XQuery permits several.</param>
            <returns>A set of absolute Uris identifying the query modules to be loaded. There is no requirement
            that these correspond one-to-one with the URIs defined in the <c>locationHints</c>. The 
            returned URIs will be dereferenced by calling the <c>GetEntity</c> method.
            </returns>
        </member>
        <member name="M:Saxon.Api.SchemaResolver.GetEntity(System.Uri)">
            <summary>
            Dereference a URI returned by <c>GetModules</c> to retrieve a <c>Stream</c> containing
            the actual XML schema document.
            </summary>
            <param name="absoluteUri">A URI returned by the <code>GetSchemaDocuments</code> method.</param>
            <returns>Either a <c>Stream</c> or a <c>String</c> containing the query text. 
            The supplied URI will be used as the base URI of the query module.</returns>
        </member>
        <member name="T:Saxon.Api.XPathCompiler">
            <summary>
            An XPathCompiler 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 XPathCompiler, use the factory method
            <c>newXPathCompiler</c> on the <c>Processor</c> object.</para>
            <para>An XPathCompiler may be used repeatedly to compile multiple
            queries. Any changes made to the XPathCompiler (that is, to the
            static context) do not affect queries that have already been compiled.
            An XPathCompiler may be used concurrently in multiple threads, but
            it should not then be modified once initialized.</para>
            </remarks>
        </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.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.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.
            </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 String.
            </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 XPathExecutable 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>
        </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 references to library modules, schema
            locations, or as an argument to the <c>doc()</c> function.
            </summary>
        </member>
        <member name="P:Saxon.Api.XPathCompiler.BackwardsCompatible">
            <summary>
            XPath 1.0 Backwards Compatibility Mode. If true, backwards compatibility mode
            is set. In backwards compatibility mode, more implicit type conversions are
            allowed in XPath expressions, for example it is possible to compare a number
            with a string. The default is false (backwards compatibility mode is off).
            </summary>
        </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 one of the <c>Compile</c>
            methods on the <c>XPathCompiler</c> class.</para>
            </remarks>    
        </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="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>
            </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 XPathCompiler. 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 and/or atomic values).
            </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>
        </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>
        </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>
        </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="T:Saxon.Api.XQueryCompiler">
            <summary>
            An XQueryCompiler 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 <c>Processor</c> 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.
            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.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.Compile(System.IO.Stream)">
            <summary>
            Compile a query supplied as a Stream.
            </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 XQueryExecutable 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 StaticError if errors were detected
            during static analysis of the query. Details of the errors will be added as StaticError
            objects to the ErrorList 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 String.
            </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 XQueryExecutable 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 StaticError if errors were detected
            during static analysis of the query. Details of the errors will be added as StaticError
            objects to the ErrorList 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.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.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-SA. Non-updating queries are accepted regardless of the value of this
            property.</para>
            <para><i>Property added in Saxon 9.1</i></para></remarks>
        </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 Compile;
            the processor will then populate the list with error information obtained during
            the compilation. Each error will be included as an object of type StaticError.
            If no error list is supplied by the caller, error information will be written to
            the standard error stream.
            </summary>
            <remarks>
            By supplying a custom List with a user-written add() method, it is possible to
            intercept error conditions as they occur.
            </remarks>
        </member>
        <member name="P:Saxon.Api.XQueryCompiler.Implementation">
            <summary>
            Escape hatch to the underying Java implementation
            </summary>
        </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.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 convensional value).</summary>
            <remarks><para><i>Property added in Saxon 9.1</i></para></remarks>
        </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> should not be used concurrently in multiple threads. It is safe,
            however, to reuse the object within a single thread to run the same query several times.
            Running the query does not change the context that has been established.</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 QName. If an external variable of this name has been declared in the
            query prolog, the given value will be assigned to the variable. If the
            variable has not been declared, calling this method has no effect (it is
            not an error).</param>
            <param 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 DynamicError 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 DynamicError 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 DynamicError 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 DynamicError 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 DynamicError if any run-time failure
            occurs while evaluating the expression, or if the expression is not an
            updating query.</exception>
        </member>
        <member name="P:Saxon.Api.XQueryEvaluator.ContextItem">
            <summary>
            The context item for the query.
            </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>LoadDocument</c> method of the <c>Processor</c> object.
            </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 &lt;trace()&gt;. 
            <para>If no specific destination is supplied by the caller, message information will be written to
            the standard error stream.</para>
            </summary>
            <remarks>
            <para>The supplied destination is ignored if a <c>TraceListener</c> is in use.</para>
            <para><i>Property added in Saxon 9.1</i></para>
            </remarks>
        </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[])">
            <summary>
            Given a module URI and a set of location hints, return a set of query modules.
            </summary>
            <param name="moduleUri">The URI of the required library module as written in the
            <c>import module</c> declaration</param>
            <param name="baseUri">The base URI of the module containing the <c>import module</c>
            declaration</param>
            <param name="locationHints">The sequence of URIs (if any) listed as location hints
            in the <c>import module</c> declaration in the query prolog.</param>
            <returns>A set of absolute Uris identifying the query modules to be loaded. There is no requirement
            that these correspond one-to-one with the URIs defined in the <c>locationHints</c>. The 
            returned URIs will be dereferenced by calling the <c>GetEntity</c> method.
            </returns>
        </member>
        <member name="M:Saxon.Api.IQueryResolver.GetEntity(System.Uri)">
            <summary>
            Dereference a URI returned by <c>GetModules</c> to retrieve a <c>Stream</c> containing
            the actual query text.
            </summary>
            <param name="absoluteUri">A URI returned by the <code>GetModules</code> method.</param>
            <returns>Either a <c>Stream</c> or a <c>String</c> containing the query text. 
            The supplied URI will be used as the base URI of the query module.</returns>
        </member>
        <member name="T:Saxon.Api.XsltCompiler">
            <summary>
            An <c>XsltCompiler</c> object allows XSLT 2.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 <c>Processor</c> 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.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 XsltExecutable 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.Compile(System.IO.TextReader)">
            <summary>
            Compile a stylesheet supplied as a TextReader.
            </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 XsltExecutable 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 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(System.Xml.XmlReader)">
            <summary>
            Compile a stylesheet, delivered using an XmlReader.
            </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.
            If the <c>XmlReader</c> is an <c>XmlTextReader</c>, Saxon will set its <c>Normalization</c>
            property to true, and will wrap it in a (non-validating) <c>XmlValidatingReader</c> to ensure
            that entity references are expanded.
            </remarks>
            <remarks>
            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.
            </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 XdmNode. 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 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.CompileAssociatedStylesheet(Saxon.Api.XdmNode)">
            <summary>Locate and compile a stylesheet identified by an &lt;?xml-stylesheet?&gt;
            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
            href 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.XmlResolver">
            <summary>
            An XmlResolver, 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>
            is used that was set on the <c>Processor</c> at the time <c>NewXsltCompiler</c>
            was called.
            </remarks>
        </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 StaticError.
            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 List with a user-written add() method, it is possible to
            intercept error conditions as they occur.
            </remarks>
        </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 <c>XsltTransformer</c>.
            </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 <c>XsltCompiler</c> 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="T:Saxon.Api.XsltTransformer">
            <summary inherits="IEnumerable">
            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> should not be used concurrently in multiple threads. It is safe,
            however, to reuse the object within a single thread to run the same stylesheet several times.
            Running the stylesheet does not change the context that has been established.</para>
            <para>An <c>XsltTransformer</c> is always constructed by running the <c>Load</c> method of
            an <c>XsltExecutable</c>.</para>
            </remarks>     
        </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.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 DynamicError if the transformation
            fails.</exception>
        </member>
        <member name="P:Saxon.Api.XsltTransformer.InitialContextNode">
            <summary>
            The initial context item for the stylesheet.
            </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.XsltTransformer.InitialMode">
            <summary>
            The initial mode for the stylesheet. This is either a QName, for a 
            named mode, or null, for the unnamed (default) mode.
            </summary>
        </member>
        <member name="P:Saxon.Api.XsltTransformer.InitialTemplate">
            <summary>
            The initial template for the stylesheet. This is either a QName, for a 
            named template, or null, if no initial template has been set.
            </summary>
            <exception cref="T:Saxon.Api.DynamicError">Setting this property to the name of a template
            that does not exist in the stylesheet throws a DynamicError with error 
            code XTDE0040. Setting it to the name of a template that has template
            parameters throws a DynamicError 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.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 &lt;xsl:message&gt;. 
            <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>
            </summary>
            <remarks>
            <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 &lt;xsl:message&gt; 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.TraceFunctionDestination">
            <summary>
            Destination for output of messages using &lt;trace()&gt;. 
            <para>If no message listener is supplied by the caller, message information will be written to
            the standard error stream.</para>
            </summary>
            <remarks>
            <para>The supplied destination is ignored if a <c>TraceListener</c> is in use.</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>
            RecoveryPolicy 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 set 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>
        </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)">
            <summary>Handle the output of an <c>xsl:message</c> instruction
            in the stylesheet
            </summary>
            
        </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">
            <summary>
            The base URI (system ID) of an external entity within an XML document.
            Set to null if the base URI is not known (for example, for an XML document
            created programmatically where no base URI has been set up).
            </summary>
        </member>
        <member name="P:Saxon.Api.IXmlLocation.LineNumber">
            <summary>
            The line number of a node relative to the start of the external entity.
            The value -1 indicates that the line number is not known or not applicable.
            </summary>
        </member>
    </members>
</doc>
