<?xml version="1.0"?>
<doc>
    <assembly>
        <name>saxon9ee-api</name>
    </assembly>
    <members>
        <member name="T:Saxon.Api.XdmItemType">
            <summary>
            Abstract class representing an item type. This may be the generic item type <c>item()</c>,
            an atomic type, the generic node type <code>node()</code>, a specific node kind such as
            <c>element()</c> or <c>text()</c>, or the generic function type <code>function()</code>.
            </summary>
            <remarks>
            More specific node types (such as <c>element(E)</c> or <c>schema-element(E)</c> cannot currently
            be instantiated in this API.
            </remarks>
        </member>
        <member name="T:Saxon.Api.XdmAnyItemType">
            <summary>
            Singleton class representing the item type item(), which matches any item.
            </summary>
        </member>
        <member name="F:Saxon.Api.XdmAnyItemType.Instance">
            <summary>
            The singleton instance of this class: an <c>XdmItemType</c> corresponding to the
            item type <c>item()</c>, which matches any item.
            </summary>
        </member>
        <member name="T:Saxon.Api.XdmAnyNodeType">
            <summary>
            Singleton class representing the item type node(), which matches any node.
            </summary>
        </member>
        <member name="F:Saxon.Api.XdmAnyNodeType.Instance">
            <summary>
            The singleton instance of this class: an <c>XdmItemType</c> corresponding to the
            item type <c>node()</c>, which matches any node.
            </summary>
        </member>
        <member name="T:Saxon.Api.XdmAnyFunctionType">
            <summary>
            Singleton class representing the item type function(), which matches any function item.
            </summary>
        </member>
        <member name="F:Saxon.Api.XdmAnyFunctionType.Instance">
            <summary>
            The singleton instance of this class: an <c>XdmItemType</c> corresponding to the
            item type <c>function()</c>, which matches any function item.
            </summary>
        </member>
        <member name="T:Saxon.Api.XdmAtomicType">
            <summary>
            An instance of class <c>XdmAtomicType</c> represents a specific atomic type, for example
            <c>xs:double</c>, <c>xs:integer</c>, or <c>xs:anyAtomicType</c>. This may be either a built-in
            atomic type or a type defined in a user-written schema.
            </summary>
            <remarks>
            To get an <c>XdmAtomicType</c> instance representing a built-in atomic type, use one of the predefined instances
            of the subclass <c>XdmBuiltInAtomicType</c>. To get an <c>XdmAtomicType</c> instance representing a user-defined
            atomic type (defined in a schema), use the method <c>GetAtomicType</c> defined on the <c>SchemaManager</c> class.
            </remarks>
        </member>
        <member name="M:Saxon.Api.XdmAtomicType.BuiltInAtomicType(Saxon.Api.QName)">
            <summary>
            Get an XdmAtomicType object representing a built-in atomic type with a given name
            </summary>
            <param name="name">The name of the required built-in atomic type</param>
            <returns>An XdmAtomicType object representing the built-in atomic type with the supplied name.
            Returns null if there is no built-in atomic type with this name.
            It is undefined whether two requests for the same built-in type will return the same object.</returns>
        </member>
        <member name="P:Saxon.Api.XdmAtomicType.Name">
            <summary>
            The name of the atomic type, or null if the type is anonymous
            </summary>
        </member>
        <member name="T:Saxon.Api.XdmNodeKind">
            <summary>
            Instances of <c>XdmNodeKind</c> represent the item types denoted in XPath as <c>document-node()</c>,
            <c>element()</c>, <c>attribute()</c>, <c>text()</c>, and so on. These are all represented by singular named instances.
            </summary>
        </member>
        <member name="F:Saxon.Api.XdmNodeKind.Document">
            <summary>
            The item type <c>document-node()</c>
            </summary>
        </member>
        <member name="F:Saxon.Api.XdmNodeKind.Element">
            <summary>
            The item type <c>element()</c>
            </summary>
        </member>
        <member name="F:Saxon.Api.XdmNodeKind.Attribute">
            <summary>
            The item type <c>attribute()</c>
            </summary>
        </member>
        <member name="F:Saxon.Api.XdmNodeKind.Text">
            <summary>
            The item type <c>text()</c>
            </summary>
        </member>
        <member name="F:Saxon.Api.XdmNodeKind.Comment">
            <summary>
            The item type <c>comment()</c>
            </summary>
        </member>
        <member name="F:Saxon.Api.XdmNodeKind.ProcessingInstruction">
            <summary>
            The item type <c>processing-instruction()</c>
            </summary>
        </member>
        <member name="F:Saxon.Api.XdmNodeKind.Namespace">
            <summary>
            The item type <c>namespace-node()</c>
            </summary>
        </member>
        <member name="M:Saxon.Api.XdmNodeKind.ForNode(Saxon.Api.XdmNode)">
            <summary>
            Get the item type representing the node kind of a supplied node
            </summary>
            <param name="node">The node whose node kind is required</param>
            <returns>The relevant node kind</returns>
        </member>
        <member name="M:Saxon.Api.XdmNodeKind.ForNodeType(System.Xml.XmlNodeType)">
            <summary>
            Get the item type corresponding to an <c>XmlNodeType</c> as defined in the System.Xml package
            </summary>
            <param name="type">The <c>XmlNodeType</c> to be converted</param>
            <returns>The corresponding <c>XdmNodeKind</c></returns>
        </member>
        <member name="T:Saxon.Api.XdmSequenceType">
            <summary>
            An instance of class <c>XdmSequenceType</c> represents a sequence type, that is, the combination
            of an item type and an occurrence indicator.
            </summary>
        </member>
        <member name="M:Saxon.Api.XdmSequenceType.#ctor(Saxon.Api.XdmItemType,System.Char)">
            <summary>
            Create an XdmSequenceType corresponding to a given XdmItemType and occurrence indicator
            </summary>
            <param name="itemType">The item type</param>
            <param name="occurrenceIndicator">The occurrence indicator, one of '?' (zero-or-one), 
            '*' (zero-or-more), '+' (one-or-more), ' ' (a single space) (exactly one),
            or 'º' (masculine ordinal indicator, xBA) (exactly zero). The type empty-sequence()
            can be represented by an occurrence indicator of 'º' with any item type.</param>
        </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>. However,
            there is no guarantee that all single-item sequences will be instances of
            <c>XdmItem</c>: if you want to ensure this, use the <c>Simplify</c> property.</para>
            <para>There are various ways of creating an <c>XdmValue</c>. To create an atomic
            value, use one of the constructors on <c>XdmAtomicValue</c> (which is a subtype of <c>XdmValue</c>).
            To construct an <c>XdmNode</c> (another subtype) by parsing an XML document, or by wrapping a DOM document,
            use a <c>DocumentBuilder</c>. To create a sequence of values, use the <c>Append</c>
            method on this class to form a list from individual items or sublists.</para>
            <para>An <c>dmValue</c> is also returned as the result of evaluating a query
            using the XQuery and XPath interfaces.</para>
            <para>The subtype <c>XdmEmptySequence</c> represents an empty sequence: an
            <c>XdmValue</c> of length zero. Again, there is no guarantee that every empty sequence
            will be represented as an instance of <c>XdmEmptySequence</c>, unless you use
            the <c>Simplify</c> property.</para>
            </remarks>
        </member>
        <member name="M:Saxon.Api.XdmValue.#ctor">
            <summary>
            Internal constructor
            </summary>
        </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.Append(Saxon.Api.XdmValue)">
            <summary>
            Create a new XdmValue by concatenating the sequences of items in this XdmValue and another XdmValue
            </summary>
            <remarks>
            Neither of the input XdmValue objects is modified by this operation
            </remarks>
            <param name="otherValue">
            The other XdmValue, whose items are to be appended to the items from this XdmValue
            </param>
        </member>
        <member name="M:Saxon.Api.XdmValue.Wrap(net.sf.saxon.om.Sequence)">
            <summary>
            Create an XdmValue from an underlying Saxon Sequence object.
            This method is provided for the benefit of applications that need to mix
            use of the Saxon .NET API with direct use of the underlying objects
            and methods offered by the Java implementation.
            </summary>
            <param name="value">An object representing an XDM value in the
            underlying Saxon implementation. If the parameter is null,
            the method returns null.</param>
            <returns>An XdmValue that wraps the underlying Saxon value
            representation.</returns>
        </member>
        <member name="M:Saxon.Api.XdmValue.Unwrap">
            <summary>
            Extract the underlying Saxon Sequence object from an XdmValue.
            This method is provided for the benefit of applications that need to mix
            use of the Saxon .NET API with direct use of the underlying objects
            and methods offered by the Java implementation.
            </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>IXdmEnumerator</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="P:Saxon.Api.XdmValue.Simplify">
            <summary>
            Simplify a value: that is, reduce it to the simplest possible form.
            If the sequence is empty, the result will be an instance of <c>XdmEmptySequence</c>.
            If the sequence is a single node, the result will be an instance of <c>XdmNode</c>;
            if it is a single atomic value, it will be an instance of <c>XdmAtomicValue</c>.
            </summary>
        </member>
        <member name="T:Saxon.Api.XdmItem">
            <summary inherits="XdmValue">
            The class <c>XdmItem</c> represents an item in a sequence, as defined
            by the XDM data model. An item 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 inherits="XdmItem">
            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>xs:untypedAtomic</c>
            </summary>
            <remarks>
            Note that there is no guarantee that every <c>XdmValue</c> comprising a single
            atomic value will be an instance of this class. To force this, use the <c>Simplify</c>
            property of the <c>XdmValue</c>.
            </remarks>
        </member>
        <member name="M:Saxon.Api.XdmAtomicValue.IsAtomic">
            <summary>
            Determine whether the item is an atomic value
            </summary>
            <returns>
            true (the item is an atomic value)
            </returns>
        </member>
        <member name="M:Saxon.Api.XdmAtomicValue.#ctor(System.String)">
            <summary>
            Construct an atomic value of type <c>xs:string</c>
            </summary>
            <param name="str">The string value</param>
        </member>
        <member name="M:Saxon.Api.XdmAtomicValue.#ctor(System.Int64)">
            <summary>
            Construct an atomic value of type <c>xs:integer</c>
            </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.
            </summary>
            <remarks>
            <para>This method should not be used to create simple atomic values representing strings,
            numbers, booleans, and so on. For that purpose, use the relevant constructor.
            Wrapped external objects are used only when calling .NET native code external
            to a query or stylesheet.</para>
            <para>In releases prior to 9.2, this method also existed with the alternative spelling
            <code>wrapExternalObject</code> (lower-case "w"). This was retained for backwards compatibility,
            but caused problems for Visual Basic users, where it is not permitted to have two methods whose
            names differ only in case. Any applications using <code>wrapExternalObject</code> must
            therefore be changed to use <code>WrapExternalObject</code>. Apologies for the inconvenience.</para>
            </remarks>
            <param name="external">The object to be wrapped.</param>
            <returns>The wrapped object</returns>
        </member>
        <member name="M:Saxon.Api.XdmAtomicValue.GetBooleanValue">
            <summary>
            Get the value converted to a boolean using the XPath casting rules
            </summary>
            <returns>the result of converting to a boolean (Note: this is not the same as the
            effective boolean value).</returns> 
        </member>
        <member name="M:Saxon.Api.XdmAtomicValue.GetLongValue">
            <summary>
            Get the value converted to a boolean using the XPath casting rules
            </summary>
            <returns>the result of converting to an integer</returns>
        </member>
        <member name="M:Saxon.Api.XdmAtomicValue.GetDoubleValue">
            <summary>
            Get the value converted to a double using the XPath casting rules.
            <p>If the value is a string, the XSD 1.1 rules are used, which means that the string
            "+INF" is recognised.</p>
            </summary>
            <returns>the result of converting to a double</returns>
        </member>
        <member name="M:Saxon.Api.XdmAtomicValue.GetDecimalValue">
            <summary>
            Get the value converted to a decimal using the XPath casting rules
            </summary>
            <returns>return the result of converting to a decimal</returns>
        </member>
        <member name="M:Saxon.Api.XdmAtomicValue.ToString">
            <summary>
            Convert the atomic value to a string
            </summary>
            <returns>The value converted to a string, according to the rules
            of the XPath 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>xs:untypedAtomic</c>. For the purposes of this method, <c>xs:integer</c> is considered
            to be a primitive type.
            </returns>
        </member>
        <member name="P:Saxon.Api.XdmAtomicValue.Value">
            <summary>Get the value as a CLI object of the nearest equivalent type.</summary>
            <remarks>
            <para>The return type is as follows:</para>
            <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>xs:untypedAtomic - String</para>
            <para>wrapped external object - the original external object</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.XdmFunctionItem">
            <summary inherits="XdmItem">
            The class <c>XdmFunctionItem</c> represents an item in an XPath 3.0 sequence
            that represents a function.
            </summary>
            <remarks>
            <para>Note that there is no guarantee that every <c>XdmValue</c> comprising a single
            function item will be an instance of this class. To force this, use the <c>Simplify</c>
            property of the <c>XdmValue</c>.</para>
            <para>At present the only way of creating an instance of this class is as the result of
            an XPath or XQuery expression that returns a function item. Note that this feature requires
            XPath 3.0 or XQuery 3.0 to be enabled, which in turn requires use of Saxon-EE.</para>
            </remarks>
        </member>
        <member name="M:Saxon.Api.XdmFunctionItem.IsAtomic">
            <summary>
            Determine whether the item is an atomic value
            </summary>
            <returns>
            false (a function item is not an atomic value)
            </returns>
        </member>
        <member name="M:Saxon.Api.XdmFunctionItem.invoke(Saxon.Api.XdmValue[],Saxon.Api.Processor)">
            <summary>
            Invoke the function
            </summary>
            <param name="arguments">The arguments to the function</param>
            <param name="processor">The Saxon processor, used to provide context information</param>
            <returns>The result of calling the function</returns>
            
        </member>
        <member name="P:Saxon.Api.XdmFunctionItem.FunctionName">
            <summary>
            The name of the function, as a QName. The result will be null if the function is anonymous.
            </summary>
        </member>
        <member name="P:Saxon.Api.XdmFunctionItem.Arity">
            <summary>
            The arity of the function, that is, the number of arguments it expects
            </summary>
        </member>
        <member name="T:Saxon.Api.XdmNode">
            <summary inherits="XdmItem">
            The class <c>XdmNode</c> represents a Node in the XDM Data Model. A Node
            is an <c>XdmItem</c>, and is therefore an <c>XdmValue</c> in its own right, and may also participate
            as one item within a sequence value.
            </summary>
            <remarks>
            <para>An <c>XdmNode</c> is implemented as a wrapper around an object
            of type <c>net.sf.saxon.NodeInfo</c>. Because this is a key interface
            within Saxon, it is exposed via this API, even though it is a Java
            interface that is not part of the API proper.</para>
            <para>The <c>XdmNode</c> interface exposes basic properties of the node, such
            as its name, its string value, and its typed value. Navigation to other nodes
            is supported through a single method, <c>EnumerateAxis</c>, which allows
            other nodes to be retrieved by following any of the XPath axes.</para>
            </remarks>
        </member>
        <member name="M:Saxon.Api.XdmNode.IsAtomic">
            <summary>
            Determine whether the item is an atomic value
            </summary>
            <returns>
            false (the item is not an atomic value)
            </returns>
        </member>
        <member name="M:Saxon.Api.XdmNode.getUnderlyingXmlNode">
            <summary>
            Unwraps the underlying XmlNode object from the XdmValue.
            If the method does not wrap a XmlNode then a null is returned
            </summary>
            <returns>The underlying XmlNode</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 AxisInfo.
            </param>
            <remarks>
            The nodes are returned in axis order: that is, document order for a forwards
            axis, reverse document order for a reverse AxisInfo.
            </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 AxisInfo.
            </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 AxisInfo.
            </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>
            <param name="writer">
            The <c>XmlWriter</c> to which the node is to be written
            </param>
        </member>
        <member name="M:Saxon.Api.XdmNode.Equals(System.Object)">
            <summary>
            Two instances of XdmNode are equal if they represent the same node. That is, the Equals()
            method returns the same result as the XPath "is" operator.
            </summary>
            <param name="obj">The object node to be compared</param>
        </member>
        <member name="M:Saxon.Api.XdmNode.GetHashCode">
            <summary>
            The hashCode of a node reflects the equality relationship: if two XdmNode instances
            represent the same node, then they have the same hashCode
            </summary>
        </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)">
            <summary>
            Construct a QName representing a name in no namespace
            </summary>
            <remarks>
            This constructor does not check that the components of the QName are
            lexically valid.
            </remarks>
            <param name="local">The local part of the name
            </param>
        </member>
        <member name="M:Saxon.Api.QName.#ctor(System.String,System.String)">
            <summary>
            Construct a 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.FromEQName(System.String)">
             <summary>
            Factory method to construct a QName from a string containing the expanded
            QName in EQName notation, that is, <c>Q{uri}local</c>
             </summary>
             <remarks>
            The prefix part of the <c>QName</c> will be set to an empty string.
             </remarks>
             <param name="expandedName">The URI in EQName notation: <c>{uri}local</c> if the
             name is in a namespace. For a name in no namespace, either of the
             forms <c>Q{}local</c> or simply <c>local</c> are accepted.</param>
            <returns> the QName corresponding to the supplied name in EQName notation. This will always
            have an empty prefix.</returns>
        </member>
        <member name="M:Saxon.Api.QName.FromStructuredQName(net.sf.saxon.om.StructuredQName)">
            <summary>
            Factory method to construct a QName from Saxon's internal <c>StructuredQName</c>
            representation.
            </summary>
        </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>
            <remarks>
            A given <c>QName</c> object can only be registered with one <c>Processor</c>.
            </remarks>
            <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="M:Saxon.Api.QName.GetFingerprint(net.sf.saxon.Configuration)">
            <summary>
            Get the internal Saxon fingerprint of this name
            </summary>
            <param name="config">The Saxon configuration (the fingerprint for a QName is different in different configurations)</param>
            <returns>
            The integer fingerprint of the name
            </returns>
        </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.IXdmEnumerator">
            <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>XdmItem</c>. In addition to the
            methods defined by <c>IEnumerator</c>, an additional method <c>GetAnother</c>
            must be implemented: this provides a new iterator over the same sequence
            of items, positioned at the start of the sequence.
            </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.IXdmEnumerator.GetAnother">
            public*
        </member>
        <member name="T:Saxon.Api.SequenceEnumerator">
            <summary>
            This class is an implementation of <c>IXdmEnumerator</c> that wraps
            a (Java) SequenceIterator.
            </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="M:Saxon.Api.SequenceEnumerator.GetAnother">
            <summary>
            Create another XdmEnumerator over the same sequence of values, positioned at the start
            of the sequence, with no change to this XdmEnumerator.
            </summary>
            <returns>
            A new XdmEnumerator over the same sequence of XDM items, positioned at the start of the sequence.
            </returns>
        </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.DotNetSequenceIterator">
            <summary>
            Implementation of the (Java) interface SequenceIterator that wraps
            a (.NET) IXdmEnumerator
            </summary>
        </member>
        <member name="T:Saxon.Api.XdmAxis">
            <summary>
            Enumeration identifying the thirteen XPath axes
            </summary>
        </member>
        <member name="F:Saxon.Api.XdmAxis.Ancestor">
            <summary>The XPath ancestor axis</summary> 
        </member>
        <member name="F:Saxon.Api.XdmAxis.AncestorOrSelf">
            <summary>The XPath ancestor-or-self axis</summary> 
        </member>
        <member name="F:Saxon.Api.XdmAxis.Attribute">
            <summary>The XPath attribute axis</summary> 
        </member>
        <member name="F:Saxon.Api.XdmAxis.Child">
            <summary>The XPath child axis</summary> 
        </member>
        <member name="F:Saxon.Api.XdmAxis.Descendant">
            <summary>The XPath descendant axis</summary> 
        </member>
        <member name="F:Saxon.Api.XdmAxis.DescendantOrSelf">
            <summary>The XPath descandant-or-self axis</summary> 
        </member>
        <member name="F:Saxon.Api.XdmAxis.Following">
            <summary>The XPath following axis</summary> 
        </member>
        <member name="F:Saxon.Api.XdmAxis.FollowingSibling">
            <summary>The XPath following-sibling axis</summary> 
        </member>
        <member name="F:Saxon.Api.XdmAxis.Namespace">
            <summary>The XPath namespace axis</summary> 
        </member>
        <member name="F:Saxon.Api.XdmAxis.Parent">
            <summary>The XPath parent axis</summary> 
        </member>
        <member name="F:Saxon.Api.XdmAxis.Preceding">
            <summary>The XPath preceding axis</summary> 
        </member>
        <member name="F:Saxon.Api.XdmAxis.PrecedingSibling">
            <summary>The XPath preceding-sibling axis</summary> 
        </member>
        <member name="F:Saxon.Api.XdmAxis.Self">
            <summary>The XPath self axis</summary> 
        </member>
        <member name="T:Saxon.Api.EmptyEnumerator">
            <summary>
            An implementation of <code>IXdmEnumerator</code> that iterates over an empty sequence.
            </summary>
        </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.DeclareCollation(System.Uri,System.Globalization.CompareInfo,System.Globalization.CompareOptions,System.Boolean)">
            <summary>
            Create a collation based on a given <c>CompareInfo</c> and <c>CompareOptions</c>    
            </summary>
            <param name="uri">The collation URI to be used within the XPath expression to refer to this collation</param>
            <param name="comparerInfo">The <c>CompareInfo</c>, which determines the language-specific
            collation rules to be used</param>
            <param name="options">Options to be used in performing comparisons, for example
            whether they are to be case-blind and/or accent-blind</param>
            <param name="isDefault">If true, this collation will be used as the default collation</param>
        </member>
        <member name="M:Saxon.Api.XQueryCompiler.DeclareNamespace(System.String,System.String)">
            <summary>
            Declare a namespace for use by the query. This has the same
            status as a namespace appearing within the query prolog (though
            a declaration in the query prolog of the same prefix will take
            precedence)
            </summary>
            <param name="prefix">The namespace prefix to be declared. Use
            a zero-length string to declare the default namespace (that is, the
            default namespace for elements and types).</param>
            <param name="uri">The namespace URI. It is possible to specify
            a zero-length string to "undeclare" a namespace.</param>
        </member>
        <member name="M:Saxon.Api.XQueryCompiler.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.Processor">
            <summary>
            Get the Processor from which this XQueryCompiler was constructed
            </summary>
        </member>
        <member name="P:Saxon.Api.XQueryCompiler.ContextItemType">
            <summary>
            The required context item type for the expression. This is used for
            optimizing the expression at compile time, and to check at run-time
            that the value supplied for the context item is the correct type.
            </summary>
        </member>
        <member name="P:Saxon.Api.XQueryCompiler.BaseUri">
            <summary>
            The base URI of the query, which forms part of the static context
            of the query. This is used for resolving any relative URIs appearing
            within the query, for example in references to library modules, schema
            locations, or as an argument to the <c>doc()</c> function.
            </summary>
        </member>
        <member name="P:Saxon.Api.XQueryCompiler.SchemaAware">
            <summary>
            Say that the query must be compiled to be schema-aware, even if it contains no
            "import schema" declarations. Normally a query is treated as schema-aware
            only if it contains one or more "import schema" declarations. If it is not schema-aware,
            then all input documents must be untyped (or xs:anyType), and validation of temporary nodes is disallowed
            (though validation of the final result tree is permitted). Setting the argument to true
            means that schema-aware code will be compiled regardless.
            schemaAware If true, the stylesheet will be compiled with schema-awareness
            enabled even if it contains no xsl:import-schema declarations. If false, the stylesheet
            is treated as schema-aware only if it contains one or more xsl:import-schema declarations.
            </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.XQueryLanguageVersion">
            <summary>
            This property indicates which version of XQuery language syntax is accepted. The default
            value is "1.0". This property must be set to "3.0" before compiling a query that
            uses XQuery 3.0 (formerly known as XQuery 1.1) syntax.
            </summary>
            <remarks>
            <para>Support for XQuery 3.0 is currently limited: for details see the Saxon documentation.
            It cannot be used together with
            XQuery Updates. As well as enabling XQuery 3.0 via this API call, it must also be enabled
            by setting version="3.0" in the query prolog.</para>
            <para><i>Property added in Saxon 9.2</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="M:Saxon.Api.XQueryEvaluator.CallFunction(Saxon.Api.QName,Saxon.Api.XdmValue[])">
            <summary>
             Call a global user-defined function in the compiled query.
            </summary>
            <remarks>
             If this is called more than once (to evaluate the same function repeatedly with different arguments,
             or to evaluate different functions) then the sequence of evaluations uses the same values of global
             variables including external variables (query parameters); the effect of any changes made to query parameters
             between calls is undefined.
             </remarks>
             <param name="function">
             The name of the function to be called
             </param>
             <param name="arguments">
             The values of the arguments to be supplied to the function. These
             must be of the correct type as defined in the function signature (there is no automatic
             conversion to the required type).
             </param>
             <exception cref="T:System.ArgumentException">If no function has been defined with the given name and arity
             or if any of the arguments does not match its required type according to the function
             signature.</exception>
             <exception cref="T:Saxon.Api.DynamicError">If a dynamic error occurs in evaluating the function.
             </exception>
        </member>
        <member name="P:Saxon.Api.XQueryEvaluator.ContextItem">
            <summary>
            The context item for the query.
            </summary>
            <remarks> This may be 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.SchemaValidationMode">
            <summary>
            The <c>SchemaValidationMode</c> to be used in this transformation, especially for documents
            loaded using the <c>doc()</c>, <c>document()</c>, or <c>collection()</c> functions.
            </summary>
            
        </member>
        <member name="P:Saxon.Api.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>
            <para>Since 9.6. Changed in 9.6 to use a StandardLogger</para>
            </remarks>
        </member>
        <member name="P:Saxon.Api.XQueryEvaluator.Implementation">
            <summary>
            Escape hatch to the <c>net.sf.saxon.query.DynamicQueryContext</c> object in the underlying Java implementation
            </summary>
        </member>
        <member name="T:Saxon.Api.IQueryResolver">
            <summary>
            Interface defining a user-supplied class used to retrieve XQuery library modules listed
            in an <c>import module</c> declaration in the query prolog.
            </summary>
        </member>
        <member name="M:Saxon.Api.IQueryResolver.GetModules(System.String,System.Uri,System.String[])">
            public*
        </member>
        <member name="M:Saxon.Api.IQueryResolver.GetEntity(System.Uri)">
            public*
        </member>
        <member name="T:Saxon.Api.DotNetModuleURIResolver">
            <summary>
            Internal class that wraps a (.NET) IQueryResolver to create a (Java) ModuleURIResolver
            <para>A ModuleURIResolver is used when resolving references to
            query modules. It takes as input a URI that identifies the module to be loaded, and a set of
            location hints, and returns one or more StreamSource obects containing the queries
            to be imported.</para>
            </summary>
        </member>
        <member name="M:Saxon.Api.DotNetModuleURIResolver.#ctor(Saxon.Api.IQueryResolver)">
            <summary>
            Initializes a new instance of the <see cref="T:Saxon.Api.DotNetModuleURIResolver"/> class.
            </summary>
            <param name="resolver">Resolver.</param>
        </member>
        <member name="M:Saxon.Api.DotNetModuleURIResolver.resolve(System.String,System.String,System.String[])">
            <summary>
            Resolve a module URI and associated location hints.
            </summary>
            <param name="moduleURI">ModuleURI. The module namespace URI of the module to be imported; or null when
            loading a non-library module.</param>
            <param name="baseURI">BaseURI. The base URI of the module containing the "import module" declaration;
            null if no base URI is known</param>
            <param name="locations">Locations. The set of URIs specified in the "at" clause of "import module",
            which serve as location hints for the module</param>
            <returns>an array of StreamSource objects each identifying the contents of a module to be
            imported. Each StreamSource must contain a
            non-null absolute System ID which will be used as the base URI of the imported module,
            and either an InputSource or a Reader representing the text of the module. The method
            may also return null, in which case the system attempts to resolve the URI using the
            standard module URI resolver.</returns>
        </member>
        <member name="T:Saxon.Api.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>
            <para> The <code>XPathCompiler</code> has the ability to maintain a cache of compiled
            expressions. This is active only if enabled by setting the <c>Caching</c> property.
            If caching is enabled, then the compiler will recognize an attempt to compile
            the same expression twice, and will avoid the cost of recompiling it. The cache
            is emptied by any method that changes the static context for subsequent expressions,
            for example, by setting the <c>BaseUri</c> property. Unless the cache is emptied,
            it grows indefinitely: compiled expressions are never discarded.</para>
            </remarks>
        </member>
        <member name="M:Saxon.Api.XPathCompiler.DeclareCollation(System.Uri,System.Globalization.CompareInfo,System.Globalization.CompareOptions,System.Boolean)">
            <summary>
            Create a collation based on a given <c>CompareInfo</c> and <c>CompareOptions</c>    
            </summary>
            <param name="uri">The collation URI to be used within the XPath expression to refer to this collation</param>
            <param name="compareInfo">The <c>CompareInfo</c>, which determines the language-specific
            collation rules to be used</param>
            <param name="options">Options to be used in performing comparisons, for example
            whether they are to be case-blind and/or accent-blind</param>
            <param name="isDefault">If true, this collation will be used as the default collation</param>
        </member>
        <member name="M:Saxon.Api.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.SetDecimalFormatProperty(Saxon.Api.QName,System.String,System.String)">
            <summary>
            Sets a property of a selected decimal format, for use by the <c>format-number</c> function.
            </summary>
            <remarks>
            This method checks that the value is valid for the particular property, but it does not
            check that all the values for the decimal format are consistent (for example, that the
            decimal separator and grouping separator have different values). This consistency
            check is performed only when the decimal format is used.
            </remarks>
            <param name="format">The name of the decimal format whose property is to be set.
             Supply null to set a property of the default (unnamed) decimal format.
             This correponds to a name used in the third argument of <c>format-number</c>.</param>
            <param name="property">The name of the property to set: one of
              "decimal-separator", "grouping-separator", "infinity", "NaN",
              "minus-sign", "percent", "per-mille", "zero-digit", "digit",
              or "pattern-separator".</param>
            <param name="value">The new value for the property.</param>
        </member>
        <member name="M:Saxon.Api.XPathCompiler.DeclareVariable(Saxon.Api.QName)">
            <summary>
            Declare a variable for use by the XPath expression. If the expression
            refers to any variables, then they must be declared here, unless the
            <c>AllowUndeclaredVariables</c> property has been set to true.
            </summary>
            <param name="name">The name of the variable, as a <c>QName</c></param>
        </member>
        <member name="M:Saxon.Api.XPathCompiler.Compile(System.String)">
            <summary>
            Compile an expression supplied as a 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>
            <exception cref="T:Saxon.Api.StaticError">
            Throws a <c>Saxon.Api.StaticError</c> if there is any static error in the XPath expression.
            This includes both syntax errors, semantic errors such as references to undeclared functions or
            variables, and statically-detected type errors.
            </exception>
        </member>
        <member name="M:Saxon.Api.XPathCompiler.Evaluate(System.String,Saxon.Api.XdmItem)">
            <summary>
            Compile and execute an expression supplied as a String, with a given context item.
            </summary>
            <param name="expression">A string containing the source text of the XPath expression</param>
            <param name="contextItem">The context item to be used for evaluation of the XPath expression.
            May be null, in which case the expression is evaluated without any context item.</param>
            <returns>An <c>XdmValue</c> which is the result of evaluating the XPath expression.</returns>
            <exception cref="T:Saxon.Api.StaticError">
            Throws a <c>Saxon.Api.StaticError</c> if there is any static error in the XPath expression.
            This includes both syntax errors, semantic errors such as references to undeclared functions or
            variables, and statically-detected type errors.
            </exception>
            <exception cref="T:Saxon.Api.DynamicError">
            Throws a <c>Saxon.Api.DynamicError</c> if there is any dynamic error during evaluation of the XPath expression.
            This includes, for example, referring to the context item if no context item was supplied.
            </exception>
        </member>
        <member name="M:Saxon.Api.XPathCompiler.EvaluateSingle(System.String,Saxon.Api.XdmItem)">
            <summary>
            Compile and execute an expression supplied as a String, with a given context item, where
            the expression is expected to return a single item as its result
            </summary>
            <param name="expression">A string containing the source text of the XPath expression</param>
            <param name="contextItem">The context item to be used for evaluation of the XPath expression.
            May be null, in which case the expression is evaluated without any context item.</param>
            <returns>If the XPath expression returns a singleton, then the the <c>XdmItem</c> 
            which is the result of evaluating the XPath expression. If the expression returns an empty sequence,
            then null. If the expression returns a sequence containing more than one item, then the first
            item in the result.</returns>
            <exception cref="T:Saxon.Api.StaticError">
            Throws a <c>Saxon.Api.StaticError</c> if there is any static error in the XPath expression.
            This includes both syntax errors, semantic errors such as references to undeclared functions or
            variables, and statically-detected type errors.
            </exception>
            <exception cref="T:Saxon.Api.DynamicError">
            Throws a <c>Saxon.Api.DynamicError</c> if there is any dynamic error during evaluation of the XPath expression.
            This includes, for example, referring to the context item if no context item was supplied.
            </exception>
        </member>
        <member name="P:Saxon.Api.XPathCompiler.Processor">
            <summary>
            Get the Processor from which this XPathCompiler was constructed
            </summary>
        </member>
        <member name="P:Saxon.Api.XPathCompiler.AllowUndeclaredVariables">
            <summary>
            This property indicates whether the XPath expression may contain references to variables that have not been
            explicitly declared by calling <c>DeclareVariable</c>. The property is false by default (that is, variables
            must be declared).
            </summary>
            <remarks>
            If undeclared variables are permitted, then it is possible to determine after compiling the expression which
            variables it refers to by calling the method <c>EnumerateExternalVariables</c> on the <c>XPathExecutable</c> object.
            </remarks>
            
        </member>
        <member name="P:Saxon.Api.XPathCompiler.SchemaAware">
            <summary>
            Say whether XPath expressions compiled using this XPathCompiler are
            schema-aware. They will automatically be schema-aware if the method
            {@link #importSchemaNamespace(String)} is called. An XPath expression
            must be marked as schema-aware if it is to handle typed (validated)
            input documents.
            </summary>
        </member>
        <member name="P:Saxon.Api.XPathCompiler.XPathLanguageVersion">
            <summary>
            This property indicates which version of XPath language syntax is accepted. The default
            value is "1.0". This property must be set to "3.0" before compiling a query that
            uses XPath 3.0 (formerly known as XPath 2.1) syntax.
            </summary>
            <remarks>
            <para>Support for XPath 3.0 is currently limited: for details see the Saxon documentation.</para>
            <para><i>Property added in Saxon 9.4</i></para></remarks>
        </member>
        <member name="P:Saxon.Api.XPathCompiler.ContextItemType">
            <summary>
            The required context item type for the expression. This is used for
            optimizing the expression at compile time, and to check at run-time
            that the value supplied for the context item is the correct type.
            </summary>
        </member>
        <member name="P:Saxon.Api.XPathCompiler.BaseUri">
            <summary>
            The base URI of the expression, which forms part of the static context
            of the expression. This is used for resolving any relative URIs appearing
            within the expression, for example in 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="P:Saxon.Api.XPathCompiler.Caching">
            <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.EnumerateExternalVariables">
            <summary>
            Get a list of external variables used by the expression. This will include both variables that were explicitly
            declared to the <c>XPathCompiler</c>, and (if the <c>AllowUndeclaredVariables</c> option was set) variables that
            are referenced within the expression but not explicitly declared.
            </summary>
            <returns>
            An IEnumerator over the names of the external variables, as instances of <c>QName</c>.</returns>
        </member>
        <member name="M:Saxon.Api.XPathExecutable.GetRequiredCardinalityForVariable(Saxon.Api.QName)">
            <summary>
            Get the required cardinality of a declared variable in the static context of the expression.
            The occurrence indicator, one of '?' (zero-or-one), 
            '*' (zero-or-more), '+' (one-or-more), ' ' (a single space) (exactly one),
            or 'º' (masculine ordinal indicator, xBA) (exactly zero). The type empty-sequence()
            can be represented by an occurrence indicator of 'º' with any item type.
            If the variable was explicitly declared, this will be the occurrence indicator that was set when the
            variable was declared. If no item type was set, it will be {@link OccurrenceIndicator#ZERO_OR_MORE}.
            If the variable was implicitly declared by reference (which can happen only when the
            allowUndeclaredVariables option is set), the returned type will be
            {@link OccurrenceIndicator#ZERO_OR_MORE}.
            If no variable with the specified QName has been declared either explicitly or implicitly,
            the method returns 0.
            </summary>
            <param name="variableName">the name of a declared variable</param>
            <returns>the required cardinality.</returns>
        </member>
        <member name="M:Saxon.Api.XPathExecutable.Load">
            <summary>
            Load the compiled XPath expression to prepare it for execution.
            </summary>
            <returns>
            An <c>XPathSelector</c>. The returned <c>XPathSelector</c> can be used to
            set up the dynamic context, and then to evaluate the expression.
            </returns>
        </member>
        <member name="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>
            <exception cref="T:Saxon.Api.DynamicError">
            Throws <c>Saxon.Api.DynamicError</c> if the evaluation of the XPath expression fails
            with a dynamic error.
            </exception>
        </member>
        <member name="M:Saxon.Api.XPathSelector.EvaluateSingle">
            <summary>
            Evaluate the XPath expression, returning the result as an <c>XdmItem</c> (that is,
            a single node or atomic value).
            </summary>
            <returns>
            An <c>XdmItem</c> representing the result of the expression, or null if the expression
            returns an empty sequence. If the expression returns a sequence of more than one item,
            any items after the first are ignored.
            </returns>
            <exception cref="T:Saxon.Api.DynamicError">
            Throws <c>Saxon.Api.DynamicError</c> if the evaluation of the XPath expression fails
            with a dynamic error.
            </exception>
        </member>
        <member name="M:Saxon.Api.XPathSelector.EffectiveBooleanValue">
            <summary>
            Evaluate the effective boolean value of the XPath expression, returning the result as a <c>Boolean</c>
            </summary>
            <returns>
            A <c>Boolean</c> representing the result of the expression, converted to its
            effective boolean value as if by applying the XPath boolean() function
            </returns>
            <exception cref="T:Saxon.Api.DynamicError">
            Throws <c>Saxon.Api.DynamicError</c> if the evaluation of the XPath expression fails
            with a dynamic error.
            </exception>
        </member>
        <member name="M:Saxon.Api.XPathSelector.GetEnumerator">
            <summary>
            Evaluate the expression, returning the result as an <c>IEnumerator</c> (that is,
            an enumerator over a sequence of nodes and/or atomic values).
            </summary>
            <returns>
            An enumerator over the sequence that represents the results of the expression.
            Each object in this sequence will be an instance of <c>XdmItem</c>. Note
            that the expression may be evaluated lazily, which means that a successful response
            from this method does not imply that the expression has executed successfully: failures
            may be reported later while retrieving items from the iterator. 
            </returns>
            <exception cref="T:Saxon.Api.DynamicError">
            May throw a <c>Saxon.Api.DynamicError</c> if the evaluation of the XPath expression fails
            with a dynamic error. However, some errors will not be detected during the invocation of this
            method, but only when stepping through the returned <c>SequenceEnumerator</c>.
            </exception>
        </member>
        <member name="P:Saxon.Api.XPathSelector.ContextItem">
            <summary>
            The context item for the XPath expression evaluation.
            </summary>
            <remarks> This may be either a node or an atomic
            value. Most commonly it will be a document node, which might be constructed
            using the <c>Build</c> method of the <c>DocumentBuilder</c> object.
            </remarks>
        </member>
        <member name="P:Saxon.Api.XPathSelector.InputXmlResolver">
            <summary>
            The <code>XmlResolver</code> to be used at run-time to resolve and dereference URIs
            supplied to the <c>doc()</c> function.
            </summary>
        </member>
        <member name="T:Saxon.Api.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.DeclareCollation(System.Uri,System.Globalization.CompareInfo,System.Globalization.CompareOptions,System.Boolean)">
            <summary>
            Create a collation based on a given <c>CompareInfo</c> and <c>CompareOptions</c>    
            </summary>
            <param name="uri">The collation URI to be used within the XPath expression to refer to this collation</param>
            <param name="compareInfo">The <c>CompareInfo</c>, which determines the language-specific
            collation rules to be used</param>
            <param name="options">Options to be used in performing comparisons, for example
            whether they are to be case-blind and/or accent-blind</param>
            <param name="isDefault">If true, this collation will be used as the default collation</param>
        </member>
        <member name="M:Saxon.Api.XsltCompiler.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.Stream,System.String,System.Boolean)">
            <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>
            <param name="theBaseUri">Specify the base Uri of the stream</param>
            <param name="closeStream">Flag to indicate if the stream should be closed in the method</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>
        <!-- Badly formed XML comment ignored for member "M:Saxon.Api.XsltCompiler.CompilePackage(System.IO.Stream)" -->
        <!-- Badly formed XML comment ignored for member "M:Saxon.Api.XsltCompiler.CompilePackages(System.Collections.Generic.IList{System.IO.Stream})" -->
        <member name="M:Saxon.Api.XsltCompiler.ImportPackage(Saxon.Api.XsltPackage)">
            <summary>Import a library package. Calling this method makes the supplied package available for reference
            in the <code>xsl:use-package</code> declaration of subsequent compilations performed using this
            <code>XsltCompiler</code>.</summary>
            <param name='thePackage'> thePackage the package to be imported</param>
            <remarks>since 9.6</remarks>
        </member>
        <member name="M:Saxon.Api.XsltCompiler.GetUnderlyingCompilerInfo">
            <summary>  
              Get the underlying CompilerInfo object, which provides more detailed (but less stable) control
              over some compilation options
              </summary>
             <returns> the underlying CompilerInfo object, which holds compilation-time options. The methods on
             this object are not guaranteed stable from release to release.
             </returns>
        </member>
        <member name="M:Saxon.Api.XsltCompiler.SetParameter(Saxon.Api.QName,Saxon.Api.XdmValue)">
            <summary>
            Externally set the value of a static parameter (new facility in XSLT 3.0) 
            </summary>
            <param name="name">The name of the parameter, expressed
            as a QName. If a parameter of this name has been declared in the
            stylesheet, the given value will be assigned to the variable. If the
            variable has not been declared, calling this method has no effect (it is
            not an error).</param>
            <param name="value">The value to be given to the parameter.
            If the parameter declaration defines a required type for the variable, then
            this value will be converted in the same way as arguments to function calls
            (for example, numeric promotion is applied).</param>
        </member>
        <member name="M:Saxon.Api.XsltCompiler.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.
            The <c>XmlReader</c> will be used as supplied; it is the caller's responsibility to
            ensure that the settings of the <c>XmlReader</c> are consistent with the requirements
            of the XSLT specification (for example, that entity references are expanded and whitespace
            is preserved).
            </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.Processor">
            <summary>
            Get the Processor from which this XsltCompiler was constructed
            </summary>
        </member>
        <member name="P:Saxon.Api.XsltCompiler.XmlResolver">
            <summary>
            An <c>XmlResolver</c>, which will be used to resolve URI references while compiling
            a stylesheet
            </summary>
            <remarks>
            If no <c>XmlResolver</c> is set for the <c>XsltCompiler</c>, the <c>XmlResolver</c>
            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.SchemaAware">
            <summary>
            The <c>SchemaAware</c> property determines whether the stylesheet is schema-aware. By default, a stylesheet
            is schema-aware if it contains one or more <code>xsl:import-schema</code> declarations. This option allows
            a stylesheet to be marked as schema-aware even if it does not contain such a declaration.
            </summary>
            <remarks>
            <para>If the stylesheet is not schema-aware, then schema-validated input documents will be rejected.</para>
            <para>The reason for this option is that it is expensive to generate code that can handle typed input
            documents when they will never arise in practice.</para>
            <para>The initial setting of this property is false, regardless of whether or not the <c>Processor</c>
            is schema-aware. Setting this property to true if the processor is not schema-aware will cause an Exception.</para>
            </remarks>
        </member>
        <member name="P:Saxon.Api.XsltCompiler.XsltLanguageVersion">
            <summary>
            The <c>XsltLanguageVersion</c> property determines whether the version of the XSLT language specification
            implemented by the compiler. The values 2.0 and 3.0 refer to the XSLT 2.0 and XSLT 3.0 (formerly XSLT 2.1) specifications.
            The value 0.0 (which is the initial default) indicates that the value is to be taken from the <c>version</c>
            attribute of the <c>xsl:stylesheet</c> element.
            </summary>
            <remarks>
            <para>Values that are not numerically equal to one of the above values are rejected.</para>
            <para>A warning is output (unless suppressed) when the XSLT language version supported by the processor
            is different from the value of the <c>version</c> attribute of the <c>xsl:stylesheet</c> element.</para>
            <para>XSLT 3.0 features are supported only in Saxon-PE and Saxon-EE. Setting the value to 3.0 under 
            Saxon-HE will cause an error if (and only if) the stylesheet actually uses XSLT 3.0 constructs.</para>
            </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="M:Saxon.Api.XsltExecutable.Load30">
            <summary>
            Load the stylesheet to prepare it for execution. This version of the load() method
            creates an <code>Xslt30Transformer</code> which offers interfaces for stylesheet
            invocation corresponding to those described in the XSLT 3.0 specification. It can be used
            with XSLT 2.0 or XSLT 3.0 stylesheets, and in both cases it offers new XSLT 3.0 functionality such
            as the ability to supply parameters to the initial template, or the ability to invoke
            stylesheet-defined functions, or the ability to return an arbitrary sequence as a result
            without wrapping it in a document node.
            </summary>
            <returns>
            An <c>Xslt30Transformer</c>. The returned <c>Xslt30Transformer</c> can be used to
            set up the dynamic context for stylesheet evaluation, and to run the stylesheet.
            </returns>
        </member>
        <member name="M:Saxon.Api.XsltExecutable.Explain(Saxon.Api.XmlDestination)">
            <summary>
            Output an XML representation of the compiled code of the stylesheet, for purposes of 
            diagnostics and instrumentation
            </summary>
            <param name="destination">The destination for the diagnostic output</param>
        </member>
        <member name="M:Saxon.Api.XsltExecutable.GetGlobalParameters">
            <summary>
            Get the names of the xsl:param elements defined in this stylesheet, with details
            of each parameter including its required type, and whether it is required or optional
            </summary>
            <returns>
            a Dictionary whose keys are the names of global parameters in the stylesheet,
            and whose values are {@link ParameterDetails} objects giving information about the
            corresponding parameter.
            </returns>
        </member>
        <member name="P:Saxon.Api.XsltExecutable.Implementation">
            <summary>
            Escape hatch to the underlying Java implementation object
            </summary>
        </member>
        <member name="T:Saxon.Api.XsltExecutable.ParameterDetails">
            <summary>
            Inner class containing information about a global parameter to a compiled stylesheet.
            </summary>
        </member>
        <member name="M:Saxon.Api.XsltExecutable.ParameterDetails.#ctor(Saxon.Api.XdmSequenceType,System.Boolean)">
            <summary>
            Initializes a new instance of the <see cref="!:Saxon.Api.XsltExecutable+ParameterDetails"/> class.
            </summary>
            <param name="type1">Type1.</param>
            <param name="isRequired1">If set to <c>true</c> is required1.</param>
        </member>
        <member name="M:Saxon.Api.XsltExecutable.ParameterDetails.getDeclaredItemType">
             Get the declared item type of the parameter
            
             @return the type defined in the <code>as</code> attribute of the <code>xsl:param</code> element,
                     without its occurrence indicator
            <summary>
            Gets the type of the declared item.
            </summary>
            <returns>The type defined in the <code>as</code> attribute of the <code>xsl:param</code> element,
             without its occurrence indicator</returns>
        </member>
        <member name="M:Saxon.Api.XsltExecutable.ParameterDetails.getDeclaredCardinality">
            <summary>
            Gets the declared cardinality of the parameter.
            </summary>
            <returns>The occurrence indicator from the type appearing in the <code>as</code> attribute
            of the <code>xsl:param</code> element</returns>
        </member>
        <member name="M:Saxon.Api.XsltExecutable.ParameterDetails.getUnderlyingDeclaredType">
            
        </member>
        <member name="P:Saxon.Api.XsltExecutable.ParameterDetails.IsRequired">
            <summary>
            Ask whether the parameter is required (mandatory) or optional
            </summary>
            <return><c>true</c> if the parameter is mandatory (<code>required="yes"</code>), false
                    if it is optional.</return>
        </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="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="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.GetReceiver(net.sf.saxon.event.PipelineConfiguration)">
            <summary>
            Get a <c>Result</c> to which the XML document can be sent as a series
            of events. This method is intended primarily for internal use.
            </summary>
            <remarks>
            The returned value must be an implementation of the JAXP <c>Result</c> interface that is
            recognized by Saxon.
            </remarks>
            <param name="pipe">Configuration information for use by the implementation</param>
        </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="M:Saxon.Api.XdmDestination.#ctor">
            <summary>Construct an <c>XdmDestination</c></summary>
        </member>
        <member name="M:Saxon.Api.XdmDestination.Reset">
            <summary>Reset the state of the <c>XdmDestination</c> so that it can be used to hold
            the result of another query or transformation.</summary>
        </member>
        <!-- Badly formed XML comment ignored for member "M:Saxon.Api.XdmDestination.GetReceiver(net.sf.saxon.event.PipelineConfiguration)" -->
        <member name="P:Saxon.Api.XdmDestination.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.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.XdmDestination.TreeProtector">
            TreeProtector is a filter that ensures that the events reaching the Builder constitute a single
            tree rooted at an element or document node (because anything else will crash the builder)
        </member>
        <member name="M:Saxon.Api.XsltTransformer.SetInputStream(System.IO.Stream,System.Uri)">
            <summary>
            Supply the principal input document for the transformation in the form of a stream.
            </summary>
            <remarks>
            <para>If this method is used, the <c>InitialContextNode</c> is ignored.</para>
            <para>The supplied stream will be consumed by the <c>Run()</c> method.
            Closing the input stream after use is the client's responsibility.</para>
            <para>A base URI must be supplied in all cases. It is used to resolve relative
            URI references appearing within the input document.</para>
            <para>Schema validation is applied to the input document according to the value of
            the <c>SchemaValidationMode</c> property.</para>
            <para>Whitespace stripping is applied according to the value of the
            <c>xsl:strip-space</c> and <c>xsl:preserve-space</c> declarations in the stylesheet.</para>
            </remarks>
            <param name="input">
            The stream containing the source code of the principal input document to the transformation. The document
            node at the root of this document will be the initial context node for the transformation.
            </param>
            <param name="baseUri">
            The base URI of the principal input document. This is used for example by the <c>document()</c>
            function if the document contains links to other documents in the form of relative URIs.</param>
        </member>
        <member name="M:Saxon.Api.XsltTransformer.SetParameter(Saxon.Api.QName,Saxon.Api.XdmValue)">
            <summary>
            Set the value of a stylesheet parameter.
            </summary>
            <param name="name">The name of the parameter, expressed
            as a QName. If a parameter of this name has been declared in the
            stylesheet, the given value will be assigned to the variable. If the
            variable has not been declared, calling this method has no effect (it is
            not an error).</param>
            <param name="value">The value to be given to the parameter.
            If the parameter declaration defines a required type for the variable, then
            this value will be converted in the same way as arguments to function calls
            (for example, numeric promotion is applied).</param>
        </member>
        <member name="M:Saxon.Api.XsltTransformer.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="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><para>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.</para>
            <para>Note that this can be inefficient if the stylesheet uses <c>xsl:strip-space</c>
            to strip whitespace, or <c>input-type-annotations="strip"</c> to remove type
            annotations, since this will result in the transformation operating on a virtual document
            implemented as a view or wrapper of the supplied document.</para>
            </remarks>
        </member>
        <member name="P:Saxon.Api.XsltTransformer.InitialMode">
            <summary>
            The initial mode for the stylesheet. This is either a 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.SchemaValidationMode">
            <summary>
            The <c>SchemaValidationMode</c> to be used in this transformation, especially for documents
            loaded using the <c>doc()</c>, <c>document()</c>, or <c>collection()</c> functions.
            </summary>
            
        </member>
        <member name="P:Saxon.Api.XsltTransformer.InputXmlResolver">
            <summary>
            The <c>XmlResolver</c> to be used at run-time to resolve and dereference URIs
            supplied to the <c>doc()</c> and <c>document()</c> functions.
            </summary>
        </member>
        <member name="P:Saxon.Api.XsltTransformer.ResultDocumentHandler">
            <summary>
            The <c>IResultDocumentHandler</c> to be used at run-time to process the output
            produced by any <c>xsl:result-document</c> instruction with an <c>href</c>
            attribute.
            </summary>
            <remarks>
            In the absence of a user-supplied result document handler, the <c>href</c>
            attribute of the <c>xsl:result-document</c> instruction must be a valid relative
            URI, which is resolved against the value of the <c>BaseOutputUri</c> property,
            and the resulting absolute URI must identify a writable resource (typically
            a file in filestore, using the <c>file:</c> URI scheme).
            </remarks>
        </member>
        <member name="P:Saxon.Api.XsltTransformer.MessageListener">
            <summary>
            Listener for messages output using &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>
            <para>Since 9.6. Changed in 9.6 to use a StandardLogger</para>
            </remarks>
        </member>
        <member name="P:Saxon.Api.XsltTransformer.Destination">
            <summary>
            The destination for the results of the stylesheet. The class XmlDestination is an abstraction 
            that allows a number of different kinds of destination to be specified.
            </summary>
            <para>Set the destination to be used for the result of the transformation.</para>
            <remarks>
            <para>The Destination can be used to chain transformations into a pipeline, by using one
            <c>XsltTransformer</c> as the destination of another</para>
            </remarks>
        </member>
        <member name="P:Saxon.Api.XsltTransformer.Implementation">
            <summary>
            Escape hatch to the underlying Java implementation
            </summary>
        </member>
        <member name="T:Saxon.Api.RecoveryPolicy">
            <summary>
            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 sent to the same <c>XmlDestination</c>. Failure to observe this rule can result
            in output streams being incorrectly closed.
            </para>
            <para>Note that more than one result document can be open at the same time,
            and that the order of opening, writing, and closing result documents chosen
            by the processor does not necessarily bear any direct resemblance to the way
            that the XSLT source code is written.</para></remarks>
        </member>
        <member name="T:Saxon.Api.ResultDocumentHandlerWrapper">
            <summary>Internal wrapper class for <c>IResultDocumentHandler</c></summary>
        </member>
        <member name="M:Saxon.Api.ResultDocumentHandlerWrapper.#ctor(Saxon.Api.IResultDocumentHandler,net.sf.saxon.event.PipelineConfiguration)">
            <summary>
            Initializes a new instance of the <see cref="T:Saxon.Api.ResultDocumentHandlerWrapper"/> class.
            </summary>
            <param name="handler">Handler.</param>
            <param name="pipe">Pipe.</param>
        </member>
        <member name="M:Saxon.Api.ResultDocumentHandlerWrapper.newInstance">
            <summary>
            Create new instance
            </summary>
            <returns>The <c>JOutURIResolver</c> instance.</returns>
        </member>
        <member name="M:Saxon.Api.ResultDocumentHandlerWrapper.resolve(System.String,System.String)">
            <summary>
            Resolve the specified href and baseString.
            </summary>
            <param name="href">Href.</param>
            <param name="baseString">Base string.</param>
        </member>
        <member name="M:Saxon.Api.ResultDocumentHandlerWrapper.close(javax.xml.transform.Result)">
            <summary>
            Close the specified result.
            </summary>
            <param name="result">Result.</param>
        </member>
        <member name="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>
            <param name="content"></param>
             <param name="terminate"></param>
             <param name="location"></param>
        </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>
        <member name="T:Saxon.Api.XmlLocation">
            <summary>
            Xml location. An implementation of IXmlLocation
            </summary>
        </member>
        <member name="T:Saxon.Api.MessageListenerProxy">
            <summary>
            Message listener proxy. This class implements a Receiver that can receive xsl:message output and send it to a
            user-supplied MessageListener
            </summary>
        </member>
        <member name="M:Saxon.Api.MessageListenerProxy.#ctor(net.sf.saxon.event.PipelineConfiguration,Saxon.Api.IMessageListener)">
            <summary>
            Initializes a new instance of the <see cref="T:Saxon.Api.MessageListenerProxy"/> class.
            </summary>
            <param name="pipe">pipe.</param>
            <param name="ml">ml.</param>
        </member>
        <member name="M:Saxon.Api.MessageListenerProxy.startDocument(System.Int32)">
            <summary>
            Starts the document.
            </summary>
            <param name="properties">Properties.</param>
        </member>
        <member name="M:Saxon.Api.MessageListenerProxy.startElement(net.sf.saxon.om.NodeName,net.sf.saxon.type.SchemaType,System.Int32,System.Int32)">
            <summary>
            Starts the element.
            </summary>
            <param name="nameCode">Name code.</param>
            <param name="typeCode">Type code.</param>
            <param name="locationId">Location identifier.</param>
            <param name="properties">Properties.</param>
        </member>
        <member name="M:Saxon.Api.MessageListenerProxy.characters(java.lang.CharSequence,System.Int32,System.Int32)">
            <summary>
            Characters the specified s, locationId and properties.
            </summary>
            <param name="s">S.</param>
            <param name="locationId">Location identifier.</param>
            <param name="properties">Properties.</param>
        </member>
        <member name="M:Saxon.Api.MessageListenerProxy.append(net.sf.saxon.om.Item,System.Int32,System.Int32)">
            <summary>
            Append the specified item, locationId and copyNamespaces.
            </summary>
            <param name="item">Item.</param>
            <param name="locationId">Location identifier.</param>
            <param name="copyNamespaces">Copy namespaces.</param>
        </member>
        <member name="M:Saxon.Api.MessageListenerProxy.write(net.sf.saxon.om.Item)">
            <summary>
            Write the specified item.
            </summary>
            <param name="item">Item.</param>
        </member>
        <!-- Badly formed XML comment ignored for member "T:Saxon.Api.Xslt30Transformer" -->
        <member name="M:Saxon.Api.Xslt30Transformer.SetStylesheetParameters(System.Collections.Generic.Dictionary{Saxon.Api.QName,Saxon.Api.XdmValue})">
            <summary> Supply the values of global stylesheet variables and parameters.</summary>
             <param> parameters a map whose keys are QNames identifying global stylesheet parameters,
             and whose corresponding values are the values to be assigned to those parameters. If necessary
             the supplied values are converted to the declared type of the parameter.
             The contents of the supplied map are copied by this method,
             so subsequent changes to the map have no effect.
             </param>
             <param name="parameters">Parameters. A Dictionary whose keys are QNames identifying global stylesheet parameters,
            and whose corresponding values are the values to be assigned to those parameters. If necessary
            the supplied values are converted to the declared type of the parameter.
            The contents of the supplied map are copied by this method,
            so subsequent changes to the map have no effect.</param>
        </member>
        <member name="M:Saxon.Api.Xslt30Transformer.SetInitialTemplateParameters(System.Collections.Generic.Dictionary{Saxon.Api.QName,Saxon.Api.XdmValue},System.Boolean)">
            <param name="parameters"> The parameters to be used for the initial template</param>
            <param name="tunnel"> true if these values are to be used for setting tunnel parameters;
            false if they are to be used for non-tunnel parameters</param>
        </member>
        <member name="M:Saxon.Api.Xslt30Transformer.ApplyTemplates(System.IO.Stream,Saxon.Api.XmlDestination)">
            <summary>Invoke the stylesheet by applying templates to a supplied Source document, sending the results (wrapped
            in a document node) to a given Destination. The invocation uses any initial mode set using {@link #setInitialMode(QName)},
            and any template parameters set using {@link #setInitialTemplateParameters(java.util.Map, boolean)}.
            </summary>
            <param name="input">Input. The source document.To apply more than one transformation to the same source document, the source document
            tree can be pre-built using a {@link DocumentBuilder}.</param>
            <param name="destination">Destination. the destination of the result document produced by wrapping the result of the apply-templates
            call in a document node.  If the destination is a {@link Serializer}, then the serialization
            parameters set in the serializer are combined with those defined in the stylesheet
            (the parameters set in the serializer take precedence).</param>
        </member>
        <member name="M:Saxon.Api.Xslt30Transformer.ApplyTemplates(System.IO.Stream,System.Uri)">
            <summary>
            Invoke the stylesheet by applying templates to a supplied Source document, returning the raw results
            as an {@link XdmValue}. The invocation uses any initial mode set using {@link #setInitialMode(QName)},
            and any template parameters set using {@link #setInitialTemplateParameters(java.util.Map, boolean)}.
            </summary>
            <param name="input">Input. The source document</param>
            <param name="baseUri">Base URI.</param>
            <returns>XdmValue. The raw result of processing the supplied Source using the selected template rule, without
            wrapping the returned sequence in a document node</returns>
        </member>
        <member name="M:Saxon.Api.Xslt30Transformer.ApplyTemplates(Saxon.Api.XdmValue,Saxon.Api.XmlDestination)">
            <summary>
            Invoke the stylesheet by applying templates to a supplied input sequence, sending the results (wrapped
            in a document node) to a given Destination. The invocation uses any initial mode set using {@link #setInitialMode(QName)},
            and any template parameters set using {@link #setInitialTemplateParameters(java.util.Map, boolean)}.
            </summary>
            <param name="selection">Selection. the initial value to which templates are to be applied (equivalent to the <code>select</code>
            attribute of <code>xsl:apply-templates</code>)</param>
            <param name="destination">Destination. The destination of the result document produced by wrapping the result of the apply-templates
            call in a document node.  If the destination is a {@link Serializer}, then the serialization
            parameters set in the serializer are combined with those defined in the stylesheet
            (the parameters set in the serializer take precedence).</param>
        </member>
        <member name="M:Saxon.Api.Xslt30Transformer.ApplyTemplates(Saxon.Api.XdmValue)">
            <summary>
            Invoke the stylesheet by applying templates to a supplied input sequence, returning the raw results.
            as an {@link XdmValue}. The invocation uses any initial mode set using {@link #setInitialMode(QName)},
            and any template parameters set using {@link #setInitialTemplateParameters(java.util.Map, boolean)}.
            </summary>
            <param name="selection">Selection. selection the initial value to which templates are to be applied (equivalent to the <code>select</code>
            attribute of <code>xsl:apply-templates</code>)</param>
            <returns>Xdmvalue. he raw result of applying templates to the supplied selection value, without wrapping in
            a document node or serializing the result. If there is more that one item in the selection, the result
            is the concatenation of the results of applying templates to each item in turn.</returns>
        </member>
        <member name="M:Saxon.Api.Xslt30Transformer.CallTemplate(Saxon.Api.QName,Saxon.Api.XmlDestination)">
            <summary> Invoke a transformation by calling a named template. The results of calling
             the template are wrapped in a document node, which is then sent to the specified
             destination. If {@link #setInitialTemplateParameters(java.util.Map, boolean)} has been
             called, then the parameters supplied are made available to the called template (no error
             occurs if parameters are supplied that are not used).</summary> 
            <param name="templateName"> The name of the initial template. This must match the name of a
             public named template in the stylesheet. If the value is null,
             the QName <code>xsl:initial-template</code> is used.</param>
             <param name="destination"> The destination of the result document produced by wrapping the result of the apply-templates
             call in a document node.  If the destination is a {@link Serializer}, then the serialization
             parameters set in the serializer are combined with those defined in the stylesheet
             (the parameters set in the serializer take precedence).</param> 
        </member>
        <member name="M:Saxon.Api.Xslt30Transformer.CallFunction(Saxon.Api.QName,Saxon.Api.XdmValue[])">
            <summary> Call a public user-defined function in the stylesheet. </summary>
             <param name="function"> The name of the function to be called</param>
            <param name="argument">  The values of the arguments to be supplied to the function. These
             will be converted if necessary to the type as defined in the function signature, using
             the function conversion rules.</param>
             <returns> the result of calling the function. This is the raw result, without wrapping in a document
             node and without serialization.</returns>
        </member>
        <!-- Badly formed XML comment ignored for member "M:Saxon.Api.Xslt30Transformer.CallFunction(Saxon.Api.QName,Saxon.Api.XdmValue[],Saxon.Api.XmlDestination)" -->
        <member name="P:Saxon.Api.Xslt30Transformer.GlobalContextItem">
            <summary> Supply the context item to be used when evaluating global variables and parameters.
             The item to be used as the context item within the initializers
             of global variables and parameters. This argument can be null if no context item is to be
              supplied.</summary>
        </member>
        <member name="P:Saxon.Api.Xslt30Transformer.GetUnderlyingController">
            <summary> Get the underlying Controller used to implement this XsltTransformer. This provides access
             to lower-level methods not otherwise available in the s9api interface. Note that classes
             and methods obtained by this route cannot be guaranteed stable from release to release.</summary>
            <returns> The underlying {@link Controller}</returns>
        </member>
        <member name="P:Saxon.Api.Xslt30Transformer.SchemaValidationMode">
            <summary>
            The <c>SchemaValidationMode</c> to be used in this transformation, especially for documents
            loaded using the <code>doc()</code>, <code>document()</code>, or <code>collection()</code> functions.
            </summary>
            
        </member>
        <!-- Badly formed XML comment ignored for member "P:Saxon.Api.Xslt30Transformer.BaseOutputURI" -->
        <member name="P:Saxon.Api.Xslt30Transformer.InputXmlResolver">
            <summary>
            The <c>XmlResolver</c> to be used at run-time to resolve and dereference URIs
            supplied to the <c>doc()</c> and <c>document()</c> functions.
            </summary>
        </member>
        <member name="P:Saxon.Api.Xslt30Transformer.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.Xslt30Transformer.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 <code>TraceListener</code> is in use.</para>
            <para>Since 9.6. Changed in 9.6 to use a StandardLogger</para>
            </remarks>
        </member>
        <member name="P:Saxon.Api.Xslt30Transformer.InitialMode">
             <summary>initial mode for the transformation. This is used if the stylesheet is
             subsequently invoked by any of the <code>applyTemplates</code> methods.</summary>
            <remarks><para>The value may be the name of the initial mode, or null to indicate the default
             (unnamed) mode</para></remarks>
        </member>
        <member name="T:Saxon.Api.XsltPackage">
            <summary> An <c>XsltPackage</c> object represents the result of compiling an XSLT 3.0 package, as
             represented by an XML document containing an <c>xsl:package</c> element.</summary>
             <remarks><para>
             @since 9.6
             </para></remarks>
        </member>
        <member name="M:Saxon.Api.XsltPackage.#ctor(Saxon.Api.Processor,net.sf.saxon.s9api.XsltPackage)">
            <summary>
            Initializes a new instance of the <see cref="T:Saxon.Api.XsltPackage"/> class.
            </summary>
            <param name="p">Processor</param>
            <param name="pp">XsltPackage</param>
        </member>
        <member name="M:Saxon.Api.XsltPackage.Link">
            <summary>Link this package with the packages it uses to form an executable stylesheet. This process fixes
            up any cross-package references to files, templates, and other components, and checks to ensure
            that all such references are consistent.</summary>
            <returns> the resulting XsltExecutable</returns>
        </member>
        <member name="M:Saxon.Api.XsltPackage.getUnderlyingPreparedPackage">
            <summary>Escape-hatch interface to the underlying implementation class.</summary>
            <returns>the underlying StylesheetPackage. The interface to StylesheetPackage
            is not a stable part of the s9api API definition.</returns>
        </member>
        <member name="P:Saxon.Api.XsltPackage.Processor">
            <summary>
            Get the Processor from which this XsltCompiler was constructed
            </summary>
        </member>
        <member name="P:Saxon.Api.XsltPackage.PackageName">
            	 * <summary>
                 * Get the name of the package (the URI appearing as the value of <code>xsl:package/@name</code>)
                 *</summary>
                 * <returns>return the package name</returns>
        </member>
        <member name="P:Saxon.Api.XsltPackage.Version">
            <summary>Get the version number of the package (the value of the attribute <code>xsl:package/@package-version</code></summary>
            @return the package version number
        </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.InnerMessage">
            <summary>
            Return the message associated with this error concatenated with the message from the causing exception
            </summary> 
        </member>
        <member name="P:Saxon.Api.StaticError.ModuleUri">
            <summary>
            The URI of the query or stylesheet module in which the error was detected
            (as a string)
            </summary>
            <remarks>
            May be null if the location of the error is unknown, or if the error is not
            localized to a specific module, or if the module in question has no known URI
            (for example, if it was supplied as an anonymous 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.ColoumnNumber">
            <summary>
            The line number locating the error within a query or stylesheet module
            </summary>
            <remarks>
            May be set to -1 if the location of the error is unknown
            </remarks>        
        </member>
        <member name="P:Saxon.Api.StaticError.IsWarning">
            <summary>
            Indicate whether this error is being reported as a warning condition. If so, applications
            may ignore the condition, though the results may not be as intended.
            </summary>
        </member>
        <member name="P:Saxon.Api.StaticError.IsTypeError">
            <summary>
            Indicate whether this condition is a type error.
            </summary>
        </member>
        <member name="P:Saxon.Api.StaticError.UnderlyingException">
            <summary>
            Return the underlying exception. This is unstable as this is an internal object
            </summary>
            <returns>XPathException</returns>
        </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="P:Saxon.Api.DynamicError.UnderlyingException">
            <summary>
            Return the underlying exception. This is unstable as this is an internal object
            </summary>
            <returns>XPathException</returns>
        </member>
        <!-- Badly formed XML comment ignored for member "T:Saxon.Api.ErrorGatherer" -->
        <member name="M:Saxon.Api.ErrorGatherer.#ctor(System.Collections.IList)">
            <summary>
            Initializes a new instance of the <see cref="T:Saxon.Api.ErrorGatherer"/> class.
            </summary>
            <param name="errorList">Error list.</param>
        </member>
        <member name="M:Saxon.Api.ErrorGatherer.warning(javax.xml.transform.TransformerException)">
            <summary>
            Warning the specified exception.
            </summary>
            <param name="exception">TransformerException.</param>
        </member>
        <member name="M:Saxon.Api.ErrorGatherer.error(javax.xml.transform.TransformerException)">
            <summary>
            Report a Transformer exception thrown.
            </summary>
            <param name="error">Error.</param>
        </member>
        <member name="M:Saxon.Api.ErrorGatherer.fatalError(javax.xml.transform.TransformerException)">
            <summary>
            Report a fatal exception thrown.
            </summary>
            <param name="error">TransformerException.</param>
        </member>
        <member name="P:Saxon.Api.ErrorGatherer.ErrorList">
            <summary>
            Gets the error list.
            </summary>
            <returns>Returns the error list</returns>
        </member>
        <member name="T:Saxon.Api.StaticContext">
            <summary>
            The class <c>StaticContext</c> provides information about the static context of an expression
            </summary>
        </member>
        <member name="M:Saxon.Api.StaticContext.GetNamespaceForPrefix(System.String)">
            <summary>
            Resolve an in-scope namespace prefix to obtain the corresponding namespace URI. If the prefix
            is a zero-length string, the default namespace for elements and types is returned.
            </summary>
            <param name="Prefix">The namespace prefix</param>
            <returns>The corresponding namespace URI if there is one, or null otherwise</returns>
            
        </member>
        <member name="P:Saxon.Api.StaticContext.ModuleUri">
            <summary>
            The URI of the module where an expression appears, suitable for use in diagnostics
            </summary>
            
        </member>
        <member name="P:Saxon.Api.StaticContext.LineNumber">
            <summary>
            The line number within a module where an expression appears, suitable for use in diagnostics
            </summary>
            
        </member>
        <member name="P:Saxon.Api.StaticContext.BaseUri">
            <summary>
            The static base URI of the expression. Often the same as the URI of the containing module,
            but not necessarily so, for example in a stylesheet that uses external XML entities or the
            xml:base attribute
            </summary>
            
        </member>
        <member name="P:Saxon.Api.StaticContext.Processor">
            <summary>
            The <c>Processor</c> that was used to create the query or stylesheet from which this extension
            function was invoked.
            </summary>
            <remarks>
            <para>This property is useful if the extension function wishes to create new nodes (the <code>Processor</code>
            can be used to obtain a <code>DocumentBuilder</code>), or to execute XPath expressions or queries.</para>
            <para>There may be circumstances in which the <c>Processor</c> is not available, in which case this method
            may return null, or may return a different <c>Processor</c>. This will happen only if low-level interfaces
            have been used to cause a <c>Configuration</c> to be shared between several <c>Processor</c> instances,
            or between a <c>Processor</c> and other applications.</para>
            </remarks>
        </member>
        <member name="P:Saxon.Api.StaticContext.Implementation">
            <summary>
            The underlying object in the Saxon implementation, an instance of class
            <code>net.sf.saxon.expr.StaticContext</code>
            </summary>
            <remarks>
            <para>This property provides access to internal methods in the Saxon engine that are
            not specifically exposed in the .NET API. In general these methods should be
            considered to be less stable than the classes in the Saxon.Api namespace.</para> 
            <para>The internal methods follow
            Java naming conventions rather than .NET conventions.</para>
            <para>Information about the returned object (and the objects it provides access to)
            is included in the Saxon JavaDoc docmentation, available 
            <link href="http://www.saxonica.com/documentation/javadoc/index.html">online</link>.
            </para>
            </remarks>
        </member>
        <member name="T:Saxon.Api.DynamicContext">
            <summary>
            The class <c>DynamicContext</c> provides information about the dynamic context of an expression
            </summary>
            
        </member>
        <member name="P:Saxon.Api.DynamicContext.ContextItem">
            <summary>
            The context item. May be null if no context item is defined
            </summary>
            
        </member>
        <member name="P:Saxon.Api.DynamicContext.ContextPosition">
            <summary>
            The context position (equivalent to the XPath position() function).
            </summary>
            <remarks>Calling this method throws an exception if the context item is undefined.</remarks>
            
        </member>
        <member name="P:Saxon.Api.DynamicContext.ContextSize">
            <summary>
            The context size (equivalent to the XPath last() function).
            </summary>
            <remarks>Calling this method throws an exception if the context item is undefined.</remarks>
            
        </member>
        <member name="P:Saxon.Api.DynamicContext.Implementation">
            <summary>
            The underlying object in the Saxon implementation, an instance of class
            <code>net.sf.saxon.expr.XPathContext</code>
            </summary>
            <remarks>
            <para>This property provides access to internal methods in the Saxon engine that are
            not specifically exposed in the .NET API. In general these methods should be
            considered to be less stable than the classes in the Saxon.Api namespace.</para> 
            <para>The internal methods follow
            Java naming conventions rather than .NET conventions.</para>
            <para>Information about the returned object (and the objects it provides access to)
            is included in the Saxon JavaDoc docmentation, available 
            <link href="http://www.saxonica.com/documentation/javadoc/index.html">online</link>.
            </para>
            </remarks>
        </member>
        <member name="T:Saxon.Api.ExtensionFunctionDefinition">
            <summary>
            <para>Abstract superclass for user-written extension functions. An extension function may be implemented as a subclass
            of this class, with appropriate implementations of the defined methods.</para>
            <para>More precisely, a subclass of <c>ExtensionFunctionDefinition</c> identifies a family of extension functions
            with the same (namespace-qualified) name but potentially having different arity (number of arguments).</para>
            </summary>
            <remarks>
            <para>A user-defined extension function is typically implemented using a pair of classes: a class that extends 
            <code>ExtensionFunctionDefinition</code>, whose purpose is to define the properties of the extension function
            (in particular, its signature -- the types of its arguments and result); and a class that extends
            <code>ExtensionFunctionCall</code>, whose purpose is to perform the actual evaluation.</para> 
            <para>The <code>ExtensionFunctionDefinition</code> is immutable and will normally have a singleton instance
            for each subclass; this singleton instance is registered with the <code>Processor</code> to associate the
            name of the extension function with its definition.</para>
            <para>The <code>ExtensionFunctionCall</code> has one instance for each call on the extension function appearing
            in the source code of a stylesheet or query; this instance is created when Saxon calls the method <code>MakeFunctionCall</code>
            provided by the <code>ExtensionFunctionDefinition</code> object. The instance of <code>ExtensionFunctionCall</code>
            holds information about the static context of the function call, and its <code>Call</code> method is called
            (by Saxon) to evaluate the extension function at run-time.</para>
            </remarks>
        </member>
        <member name="M:Saxon.Api.ExtensionFunctionDefinition.ResultType(Saxon.Api.XdmSequenceType[])">
            <summary>
            Method returning the declared type of the return value from the function. The type of the return
            value may be known more precisely if the types of the arguments are known (for example, some functions
            return a value that is the same type as the first argument. The method is therefore called supplying the
            static types of the actual arguments present in the call.
            </summary>
            <remarks>
            This method must be implemented in every subclass.
            </remarks>
            <param name="ArgumentTypes">
            The static types of the arguments present in the function call
            </param>
            <returns>
            An <c>XdmSequenceType</c> representing the declared return type of the extension function
            </returns>
        </member>
        <member name="M:Saxon.Api.ExtensionFunctionDefinition.MakeFunctionCall">
            <summary>
            Factory method to create an <c>ExtensionFunctionCall</c> object, representing a specific function call in the XSLT or XQuery
            source code. Saxon will call this method once it has identified that a specific call relates to this extension
            function.
            </summary>
            <remarks>
            This method must be implemented in every subclass. The implementation should normally instantiate the relevant subclass
            of <code>ExtensionFunctionCall</code>, and return the new instance.
            </remarks>
            <returns>
            An instance of the appropriate implementation of <code>ExtensionFunctionCall</code>
            </returns>
        </member>
        <member name="P:Saxon.Api.ExtensionFunctionDefinition.FunctionName">
            <summary>
            Read-only property returning the name of the extension function, as a QName.
            </summary>
            <remarks>
            A getter for this property must be implemented in every subclass.
            </remarks>
        </member>
        <member name="P:Saxon.Api.ExtensionFunctionDefinition.MinimumNumberOfArguments">
            <summary>
            Read-only property giving the minimum number of arguments in a call to this extension function.
            </summary>
            <remarks>
            A getter for this property must be implemented in every subclass.
            </remarks>
        </member>
        <member name="P:Saxon.Api.ExtensionFunctionDefinition.MaximumNumberOfArguments">
            <summary>
            Read-only property giving the maximum number of arguments in a call to this extension function.
            </summary>
            <remarks>
            A getter for this property must be implemented in every subclass.
            </remarks>
        </member>
        <member name="P:Saxon.Api.ExtensionFunctionDefinition.ArgumentTypes">
            <summary>
            Read-only property giving the required types of the arguments to this extension function. 
            If the number of items in the array is less than the maximum number of arguments, 
            then the last entry in the returned ArgumentTypes is assumed to apply to all the rest; 
            if the returned array is empty, then all arguments are assumed to be of type <c>item()*</c>
            </summary>
            <remarks>
            A getter for this property must be implemented in every subclass.
            </remarks>
        </member>
        <member name="P:Saxon.Api.ExtensionFunctionDefinition.TrustResultType">
            <summary>
            This property may return true for a subclass if it guarantees that the returned result of the function
            will always be of the declared return type: setting this to true by-passes the run-time checking of the type
            of the value, together with code that would otherwise perform atomization, numeric type promotion, and similar
            conversions. If the value is set to true and the value is not of the correct type, the effect is unpredictable
            and probably disastrous.
            </summary>
            <remarks>
            The default value of this property is <c>false</c>. A getter for this property may be implemented in a subclass
            to return a different value.
            </remarks>
        </member>
        <member name="P:Saxon.Api.ExtensionFunctionDefinition.DependsOnFocus">
            <summary>
            This property must return true for a subclass if the evaluation of the function makes use of the context
            item, position, or size from the dynamic context. It should also return true (despite the property name)
            if the function makes use of parts of the static context that vary from one part of the query or stylesheet
            to another. Setting the property to true inhibits certain Saxon optimizations, such as extracting the call
            from a loop, or moving it into a global variable.
            </summary>
            <remarks>
            The default value of this property is <c>false</c>. A getter for this property may be implemented in a subclass
            to return a different value.
            </remarks>
        </member>
        <member name="P:Saxon.Api.ExtensionFunctionDefinition.HasSideEffects">
            <summary>
            This property should return true for a subclass if the evaluation of the function has side-effects.
            Saxon never guarantees the result of calling functions with side-effects, but if this property is set,
            then certain aggressive optimizations will be avoided, making it more likely that the function behaves
            as expected.
            </summary>
            <remarks>
            The default value of this property is <c>false</c>. A getter for this property may be implemented in a subclass
            to return a different value.
            </remarks>
        </member>
        <member name="T:Saxon.Api.ExtensionFunctionCall">
            <summary>
            <para>An instance of this class will be created by the compiler for each function call to this extension function
            that is found in the source code. The class is always instantiated by calling the method <c>MakeFunctionCall()</c>
            of the corresponding <c>ExtensionFunctionDefinition</c>. 
            The implementation may therefore retain information about the static context of the
            call. Once compiled, however, the instance object must be immutable.</para>
            </summary>
        </member>
        <member name="M:Saxon.Api.ExtensionFunctionCall.SupplyStaticContext(Saxon.Api.StaticContext)">
            <summary>
            Method called by the compiler (at compile time) to provide information about the static context of the
            function call. The implementation may retain this information for use at run-time, if the result of the
            function depends on information in the static context.
            </summary>
            <remarks>
            For efficiency, the implementation should only retain copies of the information that it actually needs. It
            is not a good idea to hold a reference to the static context itself, since that can result in a great deal of
            compile-time information being locked into memory during run-time execution.
            </remarks>
            <param name="context">Information about the static context in which the function is called</param>
        </member>
        <member name="M:Saxon.Api.ExtensionFunctionCall.CopyLocalData(Saxon.Api.ExtensionFunctionCall)">
            <summary>
            A subclass must implement this method if it retains any local data at the instance level. On some occasions
            (for example, when XSLT or XQuery code is inlined), Saxon will make a copy of an <c>ExtensionFunction</c> object.
            It will then call this method on the old object, supplying the new object as the value of the argument, and the
            method must copy all local data items from the old object to the new.
            </summary>
            <param name="destination">The new extension function object. This will always be an instance of the same
            class as the existing object.</param>
        </member>
        <member name="M:Saxon.Api.ExtensionFunctionCall.Call(Saxon.Api.IXdmEnumerator[],Saxon.Api.DynamicContext)">
            <summary>
            Method called at run time to evaluate the function.
            </summary>
            <param name="arguments">The values of the arguments to the function, supplied as iterators over XPath
            sequence values.</param>
            <param name="context">The dynamic context for evaluation of the function. This provides access
            to the context item, position, and size, and if required to internal data maintained by the Saxon
            engine.</param>
            <returns>An iterator over a sequence, representing the result of the extension function.
            Note that Saxon does not guarantee to read this sequence to completion, so calls on the iterator
            must have no side-effects. In rare circumstances (for example, when <code>last()</code> is
            used) Saxon may clone the returned iterator by calling its <c>GetAnother()</c> method, 
            allowing the function results to be read more than once.</returns>
        </member>
        <member name="T:Saxon.Api.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.SUPPRESS_INDENTATION">
            <summary>QName identifying the serialization parameter "suppress-indentation"
            (introduced in XSLT/XQuery 3.0). Previously available as "saxon:suppress-indentation"
            The value is the string "yes" or "no" or "omit".</summary>
        </member>
        <member name="F:Saxon.Api.Serializer.UNDECLARE_PREFIXES">
            <summary>QName identifying the serialization parameter "undeclare-prefixes".
            The value is the string "yes" or "no".</summary>
        </member>
        <member name="F:Saxon.Api.Serializer.USE_CHARACTER_MAPS">
            <summary>QName identifying the serialization parameter "use-character-maps".
            This is available only with XSLT. The value of the parameter is a list of expanded QNames
            in Clark notation giving the names of character maps defined in the XSLT stylesheet.</summary>
        </member>
        <member name="F:Saxon.Api.Serializer.VERSION">
            <summary>QName identifying the serialization parameter "version"</summary>
        </member>
        <member name="F:Saxon.Api.Serializer.SAXON_CHARACTER_REPRESENTATION">
            <summary>QName identifying the serialization parameter "saxon:character-representation"</summary>
        </member>
        <member name="F:Saxon.Api.Serializer.SAXON_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.SetProcessor(Saxon.Api.Processor)">
             <summary>Set the Processor associated with this Serializer. This will be called automatically if the
             serializer is created using one of the <c>Processor.NewSerializer()</c> methods.</summary>
            
             <param name="processor"> processor the associated Processor</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(net.sf.saxon.event.PipelineConfiguration)">
            <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>
        <!-- Badly formed XML comment ignored for member "M:Saxon.Api.DomDestination.GetReceiver(net.sf.saxon.event.PipelineConfiguration)" -->
        <member name="M:Saxon.Api.DomDestination.GetReceiver(net.sf.saxon.Configuration)">
            <summary>
            Gets the receiver.
            </summary>
            <param name="config">Config.The Saxon configuration. This is supplied so that the destination can
            use information from the <code>Configuration</code> (for example, a reference to the name pool)
            to construct or configure the returned Receiver.</param>
            <returns>The receiver.</returns>
        </member>
        <member name="P:Saxon.Api.DomDestination.XmlDocument">
            <summary>After construction, retrieve the constructed document node</summary>
            <remarks>If the zero-argument constructor was used, this will be a newly
            constructed document node. If the constructor supplied a document node, the
            same document node will be returned. If the constructor supplied a document fragment
            node or an element node, this method returns the <c>OwnerDocument</c> property of 
            that node.</remarks>
        </member>
        <member name="T:Saxon.Api.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>
        <!-- Badly formed XML comment ignored for member "M:Saxon.Api.NullDestination.GetReceiver(net.sf.saxon.event.PipelineConfiguration)" -->
        <member name="T:Saxon.Api.TextWriterDestination">
            <summary>
            A <c>TextWriterDestination</c> is an implementation of <c>XmlDestination</c> that wraps
            an instance of <c>XmlWriter</c>.
            </summary>
            <remarks>
            <para>The name <c>TextWriterDestination</c> is a misnomer; originally this class would
            only wrap an <c>XmlTextWriter</c>. It will now wrap any <c>XmlWriter</c>.</para>
            <para>Note that when a <c>TextWriterDestination</c> is used to process the output of a stylesheet
            or query, the output format depends only on the way the underlying <c>XmlWriter</c>
            is configured; serialization parameters present in the stylesheet or query are ignored.
            The XSLT <c>disable-output-escaping</c> option is also ignored. If serialization
            is to be controlled from the stylesheet or query, use a <c>Serializer</c> as the
            <c>Destination</c>.</para>
            </remarks>
        </member>
        <member name="M:Saxon.Api.TextWriterDestination.#ctor(System.Xml.XmlWriter)">
            <summary>Construct a TextWriterDestination</summary>
            <param name="writer">The <c>XmlWriter</c> that is to be notified of the events
            representing the XML document.</param>
        </member>
        <!-- Badly formed XML comment ignored for member "M:Saxon.Api.TextWriterDestination.GetReceiver(net.sf.saxon.event.PipelineConfiguration)" -->
        <member name="P:Saxon.Api.TextWriterDestination.CloseAfterUse">
            <summary>
            The <c>CloseAfterUse</c> property indicates whether the underlying <c>XmlWriter</c> is closed
            (by calling its <c>Close()</c> method) when Saxon has finished writing to it. The default
            value is true, in which case <c>Close()</c> is called. If the property is set to <c>false</c>,
            Saxon will refrain from calling the <c>Close()</c> method, and merely call <c>Flush()</c>,
            which can be useful if further output is to be written to the <c>XmlWriter</c> by the application.
            </summary>
        </member>
        <member name="F:Saxon.Api.NamespaceConstant.NULL">
            A URI representing the null namespace (actually, an empty string)
        </member>
        <member name="F:Saxon.Api.NamespaceConstant.NULL_CODE">
            The numeric URI code representing the null namespace (actually, zero)
        </member>
        <member name="F:Saxon.Api.NamespaceConstant.XML">
            Fixed namespace name for XML: "http://www.w3.org/XML/1998/namespace".
        </member>
        <member name="F:Saxon.Api.NamespaceConstant.XML_CODE">
            Numeric code representing the XML namespace
        </member>
        <member name="F:Saxon.Api.NamespaceConstant.XSLT">
            Fixed namespace name for XSLT: "http://www.w3.org/1999/XSL/Transform"
        </member>
        <member name="F:Saxon.Api.NamespaceConstant.XSLT_CODE">
            Numeric code representing the XSLT namespace
        </member>
        <member name="F:Saxon.Api.NamespaceConstant.SAXON">
            Fixed namespace name for SAXON: "http://saxon.sf.net/"
        </member>
        <member name="F:Saxon.Api.NamespaceConstant.SAXON_CODE">
            Numeric code representing the SAXON namespace
        </member>
        <member name="F:Saxon.Api.NamespaceConstant.SCHEMA">
            Namespace name for XML Schema: "http://www.w3.org/2001/XMLSchema"
        </member>
        <member name="F:Saxon.Api.NamespaceConstant.SCHEMA_CODE">
            Numeric code representing the schema namespace
        </member>
        <member name="F:Saxon.Api.NamespaceConstant.SCHEMA_INSTANCE">
            XML-schema-defined namespace for use in instance documents ("xsi")
        </member>
        <member name="F:Saxon.Api.NamespaceConstant.SCHEMA_VERSIONING">
            Namespace defined in XSD 1.1 for schema versioning
        </member>
        <member name="F:Saxon.Api.NamespaceConstant.SQL">
            Fixed namespace name for SAXON SQL extension: "http://saxon.sf.net/sql"
        </member>
        <member name="F:Saxon.Api.NamespaceConstant.EXSLT_COMMON">
            Fixed namespace name for EXSLT/Common: "http://exslt.org/common"
        </member>
        <member name="F:Saxon.Api.NamespaceConstant.EXSLT_MATH">
            Fixed namespace name for EXSLT/math: "http://exslt.org/math"
        </member>
        <member name="F:Saxon.Api.NamespaceConstant.EXSLT_SETS">
            Fixed namespace name for EXSLT/sets: "http://exslt.org/sets"
        </member>
        <member name="F:Saxon.Api.NamespaceConstant.EXSLT_DATES_AND_TIMES">
            Fixed namespace name for EXSLT/date: "http://exslt.org/dates-and-times"
        </member>
        <member name="F:Saxon.Api.NamespaceConstant.EXSLT_RANDOM">
            Fixed namespace name for EXSLT/random: "http://exslt.org/random"
        </member>
        <member name="F:Saxon.Api.NamespaceConstant.FN">
            The standard namespace for functions and operators
        </member>
        <member name="F:Saxon.Api.NamespaceConstant.OUTPUT">
            The standard namespace for XQuery output declarations
        </member>
        <member name="F:Saxon.Api.NamespaceConstant.ERR">
            The standard namespace for system error codes
        </member>
        <member name="F:Saxon.Api.NamespaceConstant.LOCAL">
            Predefined XQuery namespace for local functions
        </member>
        <member name="F:Saxon.Api.NamespaceConstant.MATH">
            Math namespace for the XPath 3.0 math functions
        </member>
        <member name="F:Saxon.Api.NamespaceConstant.MAP_FUNCTIONS">
            Namespace URI for XPath 3.0 functions associated with maps
        </member>
        <member name="F:Saxon.Api.NamespaceConstant.MICROSOFT_XSL">
            Recognize the Microsoft namespace so we can give a suitably sarcastic error message
        </member>
        <member name="F:Saxon.Api.NamespaceConstant.XHTML">
            The XHTML namespace http://www.w3.org/1999/xhtml
        </member>
        <member name="F:Saxon.Api.NamespaceConstant.SVG">
            The SVG namespace
        </member>
        <member name="F:Saxon.Api.NamespaceConstant.MATHML">
            The MathML namespace
        </member>
        <member name="F:Saxon.Api.NamespaceConstant.XMLNS">
            The XMLNS namespace (used in DOM)
        </member>
        <member name="F:Saxon.Api.NamespaceConstant.XLINK">
            The XLink namespace
        </member>
        <member name="F:Saxon.Api.NamespaceConstant.XQUERY_OPTIONS">
            The xquery-option namespace for the XQuery 3.0 feature names
        </member>
        <member name="F:Saxon.Api.NamespaceConstant.XQUERY">
            The xquery namespace for the XQuery 3.0 declare option
        </member>
        <member name="F:Saxon.Api.NamespaceConstant.JAVA_TYPE">
            Namespace for types representing external Java objects
        </member>
        <member name="F:Saxon.Api.NamespaceConstant.DOT_NET_TYPE">
            Namespace for types representing external .NET objects
        </member>
        <member name="F:Saxon.Api.NamespaceConstant.ANONYMOUS">
            Namespace for names allocated to anonymous types. This exists so that
            a name fingerprint can be allocated for use as a type annotation.
        </member>
        <member name="F:Saxon.Api.NamespaceConstant.SCM">
            Namespace for the Saxon serialization of the schema component model
        </member>
        <member name="F:Saxon.Api.NamespaceConstant.OBJECT_MODEL_SAXON">
            URI identifying the Saxon object model for use in the JAXP 1.3 XPath API
        </member>
        <member name="F:Saxon.Api.NamespaceConstant.OBJECT_MODEL_XOM">
            URI identifying the XOM object model for use in the JAXP 1.3 XPath API
        </member>
        <member name="F:Saxon.Api.NamespaceConstant.OBJECT_MODEL_JDOM">
            URI identifying the JDOM object model for use in the JAXP 1.3 XPath API
        </member>
        <member name="F:Saxon.Api.NamespaceConstant.OBJECT_MODEL_AXIOM">
            URI identifying the AXIOM object model for use in the JAXP 1.3 XPath API
        </member>
        <member name="F:Saxon.Api.NamespaceConstant.OBJECT_MODEL_DOM4J">
            URI identifying the DOM4J object model for use in the JAXP 1.3 XPath API
        </member>
        <member name="F:Saxon.Api.NamespaceConstant.OBJECT_MODEL_DOT_NET_DOM">
            URI identifying the .NET DOM object model (not used, but needed for consistency)
        </member>
        <member name="F:Saxon.Api.NamespaceConstant.CODEPOINT_COLLATION_URI">
            URI identifying the Unicode codepoint collation
        </member>
        <member name="F:Saxon.Api.NamespaceConstant.SAXON_GENERATED_GLOBAL">
            URI for the names of generated global variables
        </member>
        <member name="F:Saxon.Api.NamespaceConstant.SAXON_CONFIGURATION">
            URI for the Saxon configuration file
        </member>
        <member name="F:Saxon.Api.NamespaceConstant.EXPATH_ZIP">
            URI for the EXPath zip module
        </member>
        <member name="M:Saxon.Api.NamespaceConstant.isReserved(System.String)">
            Determine whether a namespace is a reserved namespace
            @param uri the namespace URI to be tested
            @return true if this namespace URI is a reserved namespace
        </member>
        <member name="M:Saxon.Api.NamespaceConstant.isReservedInQuery(System.String)">
            Determine whether a namespace is a reserved namespace
            @param uri the namespace URI to be tested
            @return true if this namespace URI is reserved in XQuery
        </member>
        <member name="M:Saxon.Api.NamespaceConstant.isReservedInQuery30(System.String)">
            Determine whether a namespace is a reserved namespace
            @param uri the namespace URI to be tested
            @return true if this namespace URI is reserved in XQuery
        </member>
        <member name="M:Saxon.Api.NamespaceConstant.findSimilarNamespace(System.String)">
            Find a similar namespace to one that is a possible mis-spelling
            @param candidate the possibly mis-spelt namespace
            @return the correct spelling of the namespace
        </member>
        <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. This Processor will have capabilities that depend on the version
            of the software that has been loaded, and on the features that have been licensed.
            </summary>
        </member>
        <member name="M:Saxon.Api.Processor.#ctor(System.Boolean)">
            <summary>
            Create a Processor.
            </summary>
            <param name="licensedEdition">Set to true if the Processor is to use a licensed edition of Saxon
            (that is, Saxon-PE or Saxon-EE). If true, the Processor will attempt to enable the capabilities
            of the licensed edition of Saxon, according to the version of the software that is loaded, and will
            verify the license key. If false, the Processor will load a default Configuration that gives restricted
            capability and does not require a license, regardless of which version of the software is actually being run.</param>
        </member>
        <member name="M:Saxon.Api.Processor.#ctor(System.Boolean,System.Boolean)">
            <summary>
            Create a Processor.
            </summary>
            <param name="licensedEdition">Set to true if the Processor is to use a licensed edition of Saxon
            (that is, Saxon-PE or Saxon-EE). If true, the Processor will attempt to enable the capabilities
            of the licensed edition of Saxon, according to the version of the software that is loaded, and will
            verify the license key. If false, the Processor will load a default Configuration that gives restricted
            capability and does not require a license, regardless of which version of the software is actually being run.</param>
            <param name="loadLocally">This option has no effect at this release.</param>
        </member>
        <member name="M:Saxon.Api.Processor.#ctor(System.IO.Stream)">
            <summary>
            Create a Processor, based on configuration information supplied in a configuration file.
            </summary>
            <remarks>
            Not fully supported in this release: for experimental use only.
            </remarks>
            <param name="configurationFile">A stream holding the text of the XML configuration file. Details of the file format
            can be found in the Saxon documentation.</param>
            
        </member>
        <member name="M:Saxon.Api.Processor.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.NewSerializer">
            <summary>
            Create a Serializer
            </summary>
             <returns> a new Serializer </returns>
        </member>
        <member name="M:Saxon.Api.Processor.NewSerializer(System.IO.TextWriter)">
            <summary>
            Create a Serializer initialized to write to a given Writer.
            Closing the writer after use is the responsibility of the caller.
            </summary>
            <param name="textWriter">writer The TextWriter to which the Serializer will write</param>
             <returns> a new Serializer </returns>
        </member>
        <member name="M:Saxon.Api.Processor.NewSerializer(System.IO.Stream)">
            <summary>
            Create a Serializer initialized to write to a given OutputStream.
            Closing the output stream after use is the responsibility of the caller.
            </summary>
            <param name="stream">stream The OutputStream to which the Serializer will write</param>
             <returns> a new Serializer </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 of that processor. Collections should not normally be registered
            while queries and transformations are in progress.</para>
            </remarks>
            
        </member>
        <member name="M:Saxon.Api.Processor.RegisterExtensionFunction(Saxon.Api.ExtensionFunctionDefinition)">
            <summary>
            Register an extension function with the Processor
            </summary>
            <param name="function">
            An object that defines the extension function, including its name, arity, arguments types, and
            a reference to the class that implements the extension function call.
            </param>
        </member>
        <member name="M:Saxon.Api.Processor.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, "9.2.0.2")
            </summary>
        </member>
        <member name="P:Saxon.Api.Processor.Edition">
            <summary>
            Get the Saxon product edition (for example, "EE" for Enterprise Edition)
            </summary>
            
        </member>
        <member name="P:Saxon.Api.Processor.SchemaManager">
            <summary>
            Gets the 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.ErrorWriter">
            <summary>
            A TextWriter used to get and set the errors from the standard output Writer
            </summary>
            <remarks>
            <para>By default the <c>Console.Error</c> is used on the .NET platform.</para>
            <para>A user can supply their own TextWriter to redirect error messages from the standard output.</para>
            </remarks>
        </member>
        <member name="P:Saxon.Api.Processor.XmlVersion">
            <summary>
            The XML version used in this <c>Processor</c> (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 Microsoft <c>System.Xml</c> parser if the
            "http://saxon.sf.net/feature/preferJaxpParser" property on the <c>Processor</c> is set to false;
            otherwise it is parsed using the Apache Xerces XML parser.</para>
            <para>Before calling this method, the <c>BaseUri</c> property must be set to identify the
            base URI of this document, used for resolving any relative URIs contained within it.</para>
            <para>Note that the Microsoft <c>System.Xml</c> parser does not report whether attributes are
            defined in the DTD as being of type <c>ID</c> and <c>IDREF</c>. This is true whether or not
            DTD-based validation is enabled. This means that such attributes are not accessible to the 
            <c>id()</c> and <c>idref()</c> functions.</para>         
            </remarks>
            <param name="input">The 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.IO.TextReader)">
            <summary>
            Load an XML document supplied using a TextReader.
            </summary>
            <remarks>
            <para>The document is parsed using the Microsoft <c>System.Xml</c> parser if the
            "http://saxon.sf.net/feature/preferJaxpParser" property on the <c>Processor</c> is set to false;
            otherwise it is parsed using the Apache Xerces XML parser.</para>
            <para>Before calling this method, the <c>BaseUri</c> property must be set to identify the
            base URI of this document, used for resolving any relative URIs contained within it.</para>
            <para>Note that the Microsoft <c>System.Xml</c> parser does not report whether attributes are
            defined in the DTD as being of type <c>ID</c> and <c>IDREF</c>. This is true whether or not
            DTD-based validation is enabled. This means that such attributes are not accessible to the 
            <c>id()</c> and <c>idref()</c> functions.</para>         
            </remarks>
            <param name="input">The <c>TextReader</c> containing the XML source to be parsed</param>
            <returns>An <c>XdmNode</c>, the document node at the root of the tree of the resulting
            in-memory document
            </returns>
        </member>
        <member name="M:Saxon.Api.DocumentBuilder.Build(System.Xml.XmlReader)">
            <summary>
            Load an XML document, delivered using an 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 around the DOM tree, allowing it to be modified in situ.
            </para>
            </remarks>
            <param name="source">The DOM Node to be copied to form a Saxon tree</param>
            <returns>An <c>XdmNode</c>, the document node at the root of the tree of the resulting
            in-memory document
            </returns>
        </member>
        <member name="M:Saxon.Api.DocumentBuilder.Wrap(System.Xml.XmlDocument)">
            <summary>
            Wrap an XML DOM document, supplied as an <c>XmlNode</c>, as a Saxon 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="P:Saxon.Api.DocumentBuilder.DocumentProjectionQuery">
            <summary>
             Set a compiled query to be used for implementing document projection. The effect of using
             this option is that the tree constructed by the DocumentBuilder contains only those parts
             of the source document that are needed to answer this query. Running this query against
             the projected document should give the same results as against the raw document, but the
             projected document typically occupies significantly less memory. It is permissible to run
             other queries against the projected document, but unless they are carefully chosen, they
             will give the wrong answer, because the document being used is different from the original.
             </summary>
             <para>The query should be written to use the projected document as its initial context item.
             For example, if the query is <code>//ITEM[COLOR='blue')</code>, then only <code>ITEM</code>
             elements and their <code>COLOR</code> children will be retained in the projected document.</para>
             <para>This facility is only available in Saxon-EE; if the facility is not available,
             calling this method has no effect.</para>
            <para>query the compiled query used to control document projection</para>
             @since 9.6
        </member>
        <member name="T:Saxon.Api.SchemaValidationMode">
            <summary>
            Enumeration identifying the various Schema validation modes
            </summary>
        </member>
        <member name="F:Saxon.Api.SchemaValidationMode.None">
            <summary>No validation (or strip validation, which removes existing type annotations)</summary> 
        </member>
        <member name="F:Saxon.Api.SchemaValidationMode.Strict">
            <summary>Strict validation</summary>
        </member>
        <member name="F:Saxon.Api.SchemaValidationMode.Lax">
            <summary>Lax validation</summary>
        </member>
        <member name="F:Saxon.Api.SchemaValidationMode.Preserve">
            <summary>Validation mode preserve, which preserves any existing type annotations</summary>
        </member>
        <member name="F:Saxon.Api.SchemaValidationMode.Unspecified">
            <summary>Unspecified validation: this means that validation is defined elsewhere, for example in the
            Saxon Configuration</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. This is the default model and is suitable for most purposes.
            </summary>
        </member>
        <member name="F:Saxon.Api.TreeModel.TinyTreeCondensed">
            <summary>
            Saxon Condensed TinyTree. This is a variant of the TinyTree that shares storage for 
            duplicated text and attribute nodes. It gives a further saving in space occupied, at the cost
            of some increase in the time taken for tree construction.
            </summary>
        </member>
        <member name="F:Saxon.Api.TreeModel.LinkedTree">
            <summary>
            Saxon LinkedTree. This tree model is primarily useful when using XQuery Update, since it is the
            only standard tree model to support updates.
            </summary>
        </member>
        <member name="F:Saxon.Api.TreeModel.Unspecified">
            <summary>
            Unspecified tree model. This value is used to indicate that there is no preference for any specific
            tree model, which allows the choice to fall back to other interfaces.
            </summary>
        </member>
        <member name="T:Saxon.Api.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.
            The <c>XmlReader</c> is used as supplied; it is the caller's responsibility to ensure that
            its settings are appropriate for parsing a schema document (for example, that entity references
            are expanded and whitespace is retained.)
            </remarks>
            <param name="reader">The 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="M:Saxon.Api.SchemaManager.GetAtomicType(Saxon.Api.QName)">
            <summary>
            Factory method to get an <c>AtomicType</c> object representing the atomic type with a given QName.
            </summary>
            <remarks>
            It is undefined whether two calls on this method supplying the same QName will return the same
            <c>XdmAtomicType</c> object instance.
            </remarks>
            <param name="qname">The QName of the required type</param>
            <returns>An <c>AtomicType</c> object representing this type if it is present in this schema (and is an
            atomic type); otherwise, null. </returns>
        </member>
        <member name="P:Saxon.Api.SchemaManager.XsdVersion">
            <summary>
            The version of the W3C XML Schema Specification handled by this SchemaManager
            </summary>
            <remarks>
            <para>The value must be "1.0" (indicating XML Schema 1.0) or "1.1" (indicating XML Schema 1.1.
            The default is "1.0". New constructs defined in XSD 1.1 are rejected unless this property
            is set to "1.1" before compiling the schema.
            </para>
            </remarks>
            
        </member>
        <member name="P:Saxon.Api.SchemaManager.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>
            <param name="destination">
            The destination to hold the validated document.
            </param>
        </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[])">
            public*
        </member>
        <member name="M:Saxon.Api.SchemaResolver.GetEntity(System.Uri)">
            public*
        </member>
        <member name="T:Saxon.Api.DotNetSchemaURIResolver">
            <summary>
            internal class that wraps a (.NET) QueryResolver to create a (Java) SchemaURIResolver
            </summary>
        </member>
        <member name="M:Saxon.Api.DotNetSchemaURIResolver.#ctor(Saxon.Api.SchemaResolver)">
            <summary>
            Initializes a new instance of the <see cref="T:Saxon.Api.DotNetSchemaURIResolver"/> class.
            </summary>
            <param name="resolver">Resolver.</param>
        </member>
        <member name="M:Saxon.Api.DotNetSchemaURIResolver.resolve(System.String,System.String,System.String[])">
            <summary>
            Resolve the specified targetNamespace, baseURI and locations.
            </summary>
            <param name="targetNamespace">Target namespace.</param>
            <param name="baseURI">BaseURI.</param>
            <param name="locations">Locations.</param>
        </member>
    </members>
</doc>
