All Classes

Class	Description
Abs	This class implements the fn:abs() function
Abs.AbsElaborator
AbsentExtensionElement	This element is a surrogate for an extension element (or indeed an xsl element) for which no implementation is available.
AbsolutePath	Represents the path from the root of an XDM tree to a specific node, as a sequence of (name, position) pairs
AbsolutePath.PathElement	Inner class representing one step in the path
AbsorbingFunctionCallAdjunct	Handle streaming for calls to user-defined functions with streamability="absorbing"
AbsorptionFeed	This class is used as an abstract superclass for expressions where the consuming operand is absorbed by the expression: for example, data(), string(), or copy-of().
AbsorptionFeed.PendingItem	A pending item represents a tree under construction.
AbstractArrayItem	An abstract implementation of XDM array items, containing methods that can be implemented generically.
AbstractBlockIterator	Iterate over the instructions in a sequence of instructions (or an XPath comma expression), concatenating the result of each instruction into a single combined sequence.
AbstractDestination	An abstract class providing reusable code for implementing the Destination interface}
AbstractFunction	Abstract superclass (and factory class) for implementations of Function
AbstractNodeWrapper	A node in the XML parse tree representing an XML element, character content, or attribute.
AbstractNumberer	Class AbstractNumberer is a base implementation of Numberer that provides language-independent default numbering This supports the xsl:number element.
AbstractReceiver	An abstract implementation of Receiver in which all events are (by default) ignored
AbstractResourceCollection	AbstractCollection is an abstract superclass for the various implementations of ResourceCollection within Saxon.
AbstractResourceCollection.InputDetails	Information about a resource
AbstractStaticContext	An abstract and configurable implementation of the StaticContext interface, which defines the static context of an XPath expression.
AbstractStaticContext.WarningHandler	Interface defining a callback for handling warnings
AbstractTraceListener	This is the standard trace listener used when the -T option is specified on the command line.
AbstractUniStringConsumer	This abstract implementation of UniStringConsumer exists largely for C#, as a place to capture the default methods defined in the interface, and avoid them proliferating into multiple subclasses
AbstractVirtualNode	AbstractVirtualNode is an abstract superclass for VirtualNode implementations in which the underlying node is itself a Saxon NodeInfo.
AbstractWatch	A Watch represents a class that is interested in looking at nodes for the purpose of evaluating uniqueness and key constraints, or for XSLT streaming.
AbstractXMLFilter	AbstractFilterImpl is skeletal implementation of the SAX XMLFilter interface, used for both streaming and non-streaming filters.
AbstractXsltTransformer	A class that exists to contain common code shared between XsltTransformer and Xslt30Transformer
AccessorFn	This class supports the get_X_from_Y functions defined in XPath 2.0
AccessorFn.AccessorFnElaborator	Elaborator for accessor functions such as hours-from-date-Time, minutes-from-duration
AccessorFn.Component
AccessorFn.DayFromDate
AccessorFn.DayFromDateTime
AccessorFn.DaysFromDuration
AccessorFn.HoursFromDateTime
AccessorFn.HoursFromDuration
AccessorFn.HoursFromTime
AccessorFn.LocalNameFromQName
AccessorFn.MinutesFromDateTime
AccessorFn.MinutesFromDuration
AccessorFn.MinutesFromTime
AccessorFn.MonthFromDate
AccessorFn.MonthFromDateTime
AccessorFn.MonthsFromDuration
AccessorFn.NamespaceUriFromQName
AccessorFn.PrefixFromQName
AccessorFn.SecondsFromDateTime
AccessorFn.SecondsFromDuration
AccessorFn.SecondsFromTime
AccessorFn.TimezoneFromDate
AccessorFn.TimezoneFromDateTime
AccessorFn.TimezoneFromTime
AccessorFn.YearFromDate
AccessorFn.YearFromDateTime
AccessorFn.YearsFromDuration
Accumulator	Represents a single accumulator declared in an XSLT 3.0 stylesheet
AccumulatorAfterStreamer	Generate streaming code for an accumulator-after() function call, particularly in the case where the instruction is consuming and therefore has to defer evaluation until the endElement event.
AccumulatorData	Holds the values of an accumulator function for one non-streamed document
AccumulatorFn	Non-streaming implementation of accumulator-before() and accumulator-after()
AccumulatorFn.AccumulatorAfter
AccumulatorFn.AccumulatorBefore
AccumulatorFn.Phase
AccumulatorManager	Manager for accumulator functions (XSLT 3.0).
AccumulatorRegistry	Static registry for accumulators (XSLT 3.0) defined within a single package.
AccumulatorRegistryEE	Static registry containing the accumulators defined within a package; the Saxon-EE subclass includes support for streamed accumulators.
AccumulatorRule	This class represents one of the rules making up the definition of an accumulator
AccumulatorWatch	This watch implements a single accumulator in streaming mode.
Action	A functional interface that simply encapsulates a callback action of any kind, allowing the action to fail with an XPathException.
Action	A completely general functional interface for functions that take no arguments, return void, and potentially throw a SaxonApiException.
ActiveDOMSource	An extension of DOMSource that implements the ActiveSource interface, so it knows how to send itself to a Receiver
ActiveSAXSource	This class extends the standard SAXSource class by providing a ActiveSAXSource.deliver(Receiver, ParseOptions) method, meaning that Saxon can treat it just like any other ActiveSource implementation.
ActiveSource	An ActiveSource is a Source that is capable of delivering an XML document to a Receiver;
ActiveStAXSource	An extension of StAXSource that makes the source active: that is, able to deliver itself to a Saxon Receiver.
ActiveStreamSource	An extension of the StreamSource object providing a ActiveStreamSource.deliver(Receiver, ParseOptions) method so that the contents of the source can be delivered to a supplied Receiver
Actor	This object represents the compiled form of a user-written function, template, attribute-set, etc (the source can be either an XSLT stylesheet function or an XQuery function).
AdaptiveEmitter	This class implements the Adaptive serialization method defined in XSLT+XQuery Serialization 3.1.
AdjacentTextNodeMerger	This class performs the first phase of processing in "constructing simple content": it takes an input sequence, eliminates empty text nodes, and combines adjacent text nodes into one.
AdjacentTextNodeMerger.AdjacentTextNodeMergerElaborator	Elaborator for an adjacent text node merging expression - inserted into a pipeline for node construction
AdjacentTextNodeMergerAdjunct	Streaming implementation of an AdjacentTextNodeMerger expression
AdjacentTextNodeMergingIterator	AdjacentTextNodeMergingIterator is an iterator that eliminates zero-length text nodes and merges adjacent text nodes from the underlying iterator
Adjust_1	This class implements the XPath 2.0 functions adjust-date-to-timezone(), adjust-time-timezone(), and adjust-dateTime-timezone(), with a single argument
Adjust_2	This class implements the XPath 2.0 functions adjust-date-to-timezone(), adjust-time-timezone(), and adjust-dateTime-timezone(), with two arguments
Affinity	A set of constants enumerating the possible relationships between one type and another
Aggregate	This abstract class provides functionality common to the sum(), avg(), count(), exists(), and empty() functions.
AllDifferent	The proposed XPath 4.0 all-different() function, with the collation argument already known
AllElementsSpaceStrippingRule	A whitespace stripping rule that strips all elements unless xml:space indicates that whitespace should be preserved.
AllElementValidator	This class is validator used to check the content of an element whose complex type uses the "xs:all" construction in XML Schema.
AllEqual	The proposed XPath 4.0 all-equal() function, with the collation argument already known
AllModelGroup	An AllModelGroup represents an xs:all element in the schema
AlphaCode	An AlphaCode is a compact, context-independent string representation of a SequenceType
Alphanumeric	This class contains static utility methods to test whether a character is alphanumeric, as defined by the rules of xsl:number: that is, whether it is in one of the Unicode categories Nd, Nl, No, Lu, Ll, Lt, Lm or Lo In Saxon 9.9 the data has been regenerated from Unicode 10.0.0.
AlphanumericCollator	A Comparer that treats strings as an alternating sequence of alpha parts and numeric parts.
AnalyzeString	An xsl:analyze-string element in the stylesheet.
AnalyzeString.AnalyzeStringElaborator
AnalyzeStringFn	Implements the fn:analyze-string function defined in XPath 3.0.
AnalyzeUri	This class implements the saxon:analyze-uri() function which returns a map containing the components of a URI
AncestorCharacteristic	Given an expression, this characteristic returns a boolean indicating whether or not the context item has a parent (or ancestor, respectively) that matches a given pattern
AncestorIterator	This class enumerates the ancestor:: or ancestor-or-self:: axes, starting at a given node.
AncestorPatternOptimizer	A PatternOptimizer is an agent responsible for optimizing a particular class of patterns.
AncestorQualifiedPattern	An AncestorQualifiedPattern represents a path of the form A/B or A//B, where nodes must match the pattern B and also have a parent/ancestor (respectively) that matches A.
AnchorPattern	This is a special pattern that matches the "anchor node".
AndExpression
AndExpression.AndElaborator	Elaborator for an AndExpression (P and Q)
Annotation	This class represents an annotation that appears in a function or variable declarations
AnnotationList	An immutable list of function or variable annotations, or of annotation assertions
AnnotationParent	An abstract superclass for schema elements whose only permitted content is an Annotation element
AnyExternalObject	An external object is a fourth kind of Item (after nodes, atomic values, and functions): it acts as a wrapper for a Java object (or, in C#, a .NET object).
AnyExternalObjectType	This class represents the type of an external object returned by an extension function, or supplied as an external variable/parameter.
AnyFunctionType	An ItemType representing the type function(*).
AnyFunctionTypeWithAssertions	The item type function(*) when it is preceded by one or more annotation assertions
AnyItemType	An implementation of ItemType that matches any item (node or atomic value)
AnyNodeTest	NodeTest is an interface that enables a test of whether a node has a particular name and type.
AnySimpleType	This class has a singleton instance which represents the XML Schema built-in type xs:anySimpleType
AnyType	This class has a singleton instance which represents the XML Schema built-in type xs:anyType, also known as the urtype.
AnyTypeValidator	Validator to validate an element against the class xs:anyType
AnyURIValue	An XPath value of type xs:anyURI.
ApplyFn	This class implements the function fn:apply(), which is a standard function in XQuery 3.1.
ApplyImports	An xsl:apply-imports element in the stylesheet.
ApplyImportsAction	Watch for an xsl:apply-imports instruction.
ApplyImportsAdjunct	Compile an xsl:apply-imports expression/instruction to Java source code.
ApplyNextMatchingTemplate	An xsl:apply-imports or xsl:next-match element in the stylesheet.
ApplyTemplates	An instruction representing an xsl:apply-templates element in the stylesheet
ApplyTemplates.ApplyTemplatesElaborator
ApplyTemplates.ApplyTemplatesPackage	An ApplyTemplatesPackage is an object that encapsulates the sequence of nodes to be processed, the mode, the parameters to be supplied, and the execution context.
ApplyTemplatesAction	This watch implements xsl:apply-templates in streaming mode.
ApplyTemplatesAdjunct	Handle streaming for the xsl:apply-templates instruction
ApplyTemplatesFeed	This class is used when a streaming template applies xsl:apply-templates to composed items, typically to the items in the current group established using xsl:for-each-group
Archive	Implementation of extension functions in the EXPath Archive package, see http://expath.org/spec/archive
Archive.ArchiveType
Archive.CompressionType
ARegexIterator	Class ARegexIterator - provides an iterator over matched and unmatched substrings.
ARegularExpression	Glue class to interface the Jakarta regex engine to Saxon (The prefix 'A' indicates an Apache regular expression, as distinct from a JDK regular expression).
ArithmeticExpression	Arithmetic Expression: an expression using one of the operators plus, minus, multiply, div, idiv, mod.
ArithmeticExpression.ArithmeticElaborator	Elaborator for an ArithmeticExpression (for example P + Q)
ArithmeticExpression10	Arithmetic Expression: an expression using one of the operators plus, minus, multiply, div, idiv, mod, in backwards compatibility mode: see ArithmeticExpression for the non-backwards compatible case.
ArrayBlockAdjunct	Generate streaming code for a SquareArrayConstructor, that is a sequence of expressions or instructions used to establish the content of an XDM array
ArrayFunctionSet	Function signatures (and pointers to implementations) of the functions defined in XPath 3.1
ArrayFunctionSet.ArrayAppend	Implementation of the function array:append(array, item()*) => array
ArrayFunctionSet.ArrayBuild	Implementation of the proposed XP40 function array:build()
ArrayFunctionSet.ArrayEmpty	Implementation of the proposed 4.0 function array:empty(array)
ArrayFunctionSet.ArrayExists	Implementation of the proposed 4.0 function array:exists(array)
ArrayFunctionSet.ArrayFilter	Implementation of the function array:filter(array, function) => array
ArrayFunctionSet.ArrayFlatten	Implementation of the function array:flatten => item()*
ArrayFunctionSet.ArrayFoldLeft	Implementation of the function array:fold-left(array, item()*, function) => array
ArrayFunctionSet.ArrayFoldRight	Implementation of the function array:fold-left(array, item()*, function) => array
ArrayFunctionSet.ArrayFoot	Implementation of the proposed 4.0 function array:foot(array) => item()*
ArrayFunctionSet.ArrayForEach	Implementation of the function array:for-each(array, function) => array
ArrayFunctionSet.ArrayForEachPair	Implementation of the function array:for-each-pair(array, array, function) => array
ArrayFunctionSet.ArrayFromSequence	Implementation of the function array:_from-sequence(item()*) => array(*) which is used internally for the implementation of array{} and of the saxon:array extension
ArrayFunctionSet.ArrayGeneratingFunction	Abstract superclass for functions that produce an array, and that decide what kind of array implementation to use based on past experience.
ArrayFunctionSet.ArrayGet	Implementation of the function array:get(array, xs:integer) => item()*
ArrayFunctionSet.ArrayHead	Implementation of the function array:head(array) => item()*
ArrayFunctionSet.ArrayIndexWhere	Implementation of the function array:for-each-pair(array, array, function) => array
ArrayFunctionSet.ArrayInsertBefore	Implementation of the function array:insert-before(array, xs:integer, item()*) => array
ArrayFunctionSet.ArrayJoin	Implementation of the function array:join(arrays) => array
ArrayFunctionSet.ArrayMembers	Implementation of the proposed XP40 function array:members(array(*)) => record(value)*
ArrayFunctionSet.ArrayOfMembers	Implementation of the proposed XP40 function array:of(parcel*) => array
ArrayFunctionSet.ArrayPut	Implementation of the function array:put(arrays, index, newValue) => array
ArrayFunctionSet.ArrayRemove	Implementation of the function array:remove(array, xs:integer) => array
ArrayFunctionSet.ArrayReplace	Implementation of the function array:replace(array, position, action) => array
ArrayFunctionSet.ArrayReverse	Implementation of the function array:reverse(array, xs:integer, xs:integer) => array
ArrayFunctionSet.ArraySize	Implementation of the function array:size(array) => integer
ArrayFunctionSet.ArraySlice	Implementation of the function array:slice(array, start, end, step) => array
ArrayFunctionSet.ArraySplit	Implementation of the function array:slice(array, start, end, step) => array
ArrayFunctionSet.ArraySubarray	Implementation of the function array:subarray(array, xs:integer, xs:integer) => array
ArrayFunctionSet.ArrayTail	Implementation of the function array:tail(array) => item()*
ArrayFunctionSet.ArrayToSequence	Implementation of the function array:_to-sequence(array) => item()* which is used internally for the implementation of array?*
ArrayFunctionSet.ArrayTrunk	Implementation of the function array:trunk(array) => item()*
ArrayItem	Interface supported by different implementations of an XDM array item.
ArrayItemType	An instance of this class represents a specific array item type, for example function(xs:int) as xs:boolean
ArrayIterator	ArrayIterator is used to enumerate items held in a Java array.
ArrayIterator.Of<T extends Item>	Parameterised subclass to accept items of a particular item type
ArrayIterator.OfNodes<N extends NodeInfo>	ArrayIterator.OfNodes is a subclass of ArrayIterator where the array always contains Nodes; it therefore implements the AxisIterator interface.
ArraySort	Implementation of the extension function array:sort(array, function) => array
AscendingRangeIterator	An Iterator that produces numeric values in a monotonic sequence, ascending or descending.
AscentFunctionCallAdjunct	Handle streaming for calls to user-defined functions with streamability="ascent"
ASCIICharacterSet	This class defines properties of the US-ASCII character set
Assertion	An Assertion schema component (See XML Schema 1.1 Part 1)
AssertionFacet	Represents an assertion facet on a schema-defined simple type.
AssertionTreeBuilder	This class sits in the validation pipeline, ready (when requested) to build subtrees of the validated document for use in testing assertions against complex types.
Assign	Compiled instruction deriving from saxon:assign element in stylesheet.
Assignation	Assignation is an abstract superclass for the kinds of expression that declare range variables: for, some, and every.
ATokenIterator	A ATokenIterator is an iterator over the strings that result from tokenizing a string using a regular expression
AtomicArray	A sequence of atomic values, implemented using an underlying arrayList.
AtomicComparer	Interface representing an object that can be used to compare two XPath atomic values for equality or for ordering.
AtomicConstructorFunction	A function item representing a constructor function for an atomic type.
AtomicCounter	An integer that can be incremented atomically with thread safety
AtomicEqual	Implements the XPath 4.0 fn:atomic-equal() function.
AtomicItemFeed	An AtomicItemFeed is an ItemFeed in which the only allowed event is ItemFeed.append(Item) passing an atomic value.
AtomicIterator	A SequenceIterator is used to iterate over a sequence.
AtomicMatchKey	Marker interface to identify an object that acts as a surrogate for an atomic value, with the property that if two atomic values are equal under the XPath 'eq' operator, then their corresponding surrogates are equal under the Java equals() comparison (and by implication, they have equal hash codes).
AtomicSequence	Interface representing a sequence of atomic values.
AtomicSequenceConverter	An AtomicSequenceConverter is an expression that performs a cast (or other supplied conversion) on each member of a supplied sequence
AtomicSequenceConverter.AtomicSequenceConverterElaborator	Elaborator for an AtomicSequenceConverter (including an UntypedAtomicConverter, which is the same except that it uses a different converter internally)
AtomicSequenceConverter.AtomicSequenceMappingFunction	Mapping function wrapped around a converter
AtomicSequenceConverter.ToStringMappingFunction	Mapping function that converts every item in a sequence to a string
AtomicSequenceConverterAdjunct	Compile a AtomicSequenceConverter or UntypedSequenceConverter expression to streaming code.
AtomicSortComparer	An AtomicComparer used for comparing atomic values of arbitrary item types.
AtomicType	Interface for atomic types (these are either built-in atomic types or user-defined atomic types).
AtomicValue	The AtomicValue class corresponds to the concept of an atomic value in the XPath 2.0 data model.
AtomizedValueIterator	Interface implemented by an iterator that can deliver atomized results.
Atomizer	An Atomizer is an expression corresponding essentially to the fn:data() function: it maps a sequence by replacing nodes with their typed values
Atomizer.AtomizerElaborator	Elaborator for an Atomizer
AtomizerAdjunct	Streaming adjunct class for an atomizer (or call on the data() function)
AtomizingIterator	AtomizingIterator returns the atomization of an underlying sequence supplied as an iterator.
AttributeCollectionImpl	AttributeCollectionImpl is an implementation of the SAX2 interface Attributes.
AttributeCreator	Abstract class for fixed and computed attribute constructor expressions
AttributeDecl	An XML Schema Attribute Declaration.
AttributeGetter	An AttributeGetter is an expression that returns the value of a specific attribute of the context item, provided that it is an untyped element node.
AttributeGetter.AttributeGetterElaborator	Elaborator for an AttributeGetter expression (which gets a named attribute of the context item and returns its value as an untyped atomic value)
AttributeGroupDecl	An XML Schema Attribute Group Declaration.
AttributeGroupReference	An XML Schema Attribute Group Reference, corresponding to an xs:attributeGroup element with a 'ref' attribute.
AttributeImpl	A node in the "linked" tree representing an attribute.
AttributeInfo	This class contains immutable information about an attribute.
AttributeInfo.Deleted	AttributeInfo.Deleted is a subclass used to mark a deleted attribute (in XQuery Update)
AttributeInheritor	This class handles attribute inheritance.
AttributeIterator	AttributeIterator iterates over all the attribute nodes of a streamed Element node.
AttributeLocation	A Location corresponding to an attribute in a document (often a stylesheet)
AttributeMap	AttributeMap represents an immutable collection of attributes available on a particular element node.
AttributeMapWithIdentity	An implementation of AttributeMap suitable for representing attributes on a mutable tree.
AttributeSet	The compiled form of an xsl:attribute-set element in the stylesheet.
AttributeSorter	AttributeSorter: This filter sorts attributes into the order requested using the saxon:attribute-order serialization property
AttributeUse	An XML Schema Attribute Use: that is, a reference to an attribute declaration from within a complex type or attribute group.
AttributeValidator	This class is an abstract superclass for all the receivers that do element content validation.
AttributeValueTemplate	This class represents an attribute value template.
AttributeWildcard	This class represents an xs:anyAttribute element in the schema.
AttrOverNodeInfo	This class is an implementation of the DOM Attr class that wraps a Saxon NodeInfo representation of an attribute or namespace node.
AugmentedSource	This class is an extension of the JAXP Source interface.
AutomatonState	Defines a state of a finite state machine used when validating an instance against a complex type.
AvailableEnvironmentVariables
AvailableSystemProperties
Average	Implementation of the fn:avg function
AxiomAttributeWrapper	A node in the XML parse tree representing an XML element, character content, or attribute.
AxiomDocument	Information about a tree that wraps an AXIOM document
AxiomDocument.FollowingSiblingIterator
AxiomDocument.PrecedingSiblingIterator
AxiomDocumentNodeWrapper	The document node in an AXIOM tree
AxiomDocumentNodeWrapper.FollowingSiblingIterator
AxiomDocumentNodeWrapper.PrecedingSiblingIterator
AxiomElementNodeWrapper	A node in the XDM tree; specifically, a node that wraps an Axiom element node.
AxiomLeafNodeWrapper	A node in the XDM tree.
AxiomObjectModel	This interface must be implemented by any third-party object model that can be wrapped with a wrapper that implements the Saxon Object Model (the NodeInfo interface).
AxiomParentNodeWrapper	A node in the XDM tree; specifically, a node that wraps an Axiom document node or element node.
AxiomWriter	JDOMWriter is a Receiver that constructs a JDOM document from the stream of events
Axis	This is an enumeration class containing constants representing the thirteen XPath axes
AxisAtomizingIterator	This iterator returns a sequence of atomic values, the result of atomizing the sequence of nodes returned by an underlying SequenceIterator.
AxisExpression	An AxisExpression is always obtained by simplifying a PathExpression.
AxisExpression.AxisExpressionElaborator	Elaborator for an AxisExpression
AxisExpressionAdjunct	Compile an axis expression to streaming code.
AxisInfo	An axis, that is a direction of navigation in the document structure.
AxisIterator	A SequenceIterator is used to iterate over a sequence of items.
Base64BinaryEmitter	This emitter implements output method saxon:base64Binary.
Base64BinaryValue	A value of type xs:base64Binary
BasePatternWithPredicate	Class for handling patterns with simple non-positional boolean predicates
BaseUri_1	This class implements the fn:base-uri() function in XPath 2.0
BaseUri_1.BaseUriFnElaborator	Elaborator for simple string-valued properties of nodes such as name(), local-name(), namespace-uri(), and generate-id()
BasicTransformerFactory	A TransformerFactory instance can be used to create Transformer and Template objects.
BasicUpdatingExpression	A basic updating expression: insert, replace, delete, rename (but not copy)
BigDecimalValue	An implementation class for decimal values other than integers
BigIntegerValue	An integer value: note this is a subtype of decimal in XML Schema, not a primitive type.
BigRangeIterator	An Iterator that produces numeric values in a monotonic ascending or descending sequence, where the integers may exceed the range of a Long
BinaryEmitter	This is an abstract superclass for the two binary output methods saxon:base64Binary and saxon:hexBinary.
BinaryExpression	Binary Expression: a numeric or boolean expression consisting of the two operands and an operator
BinaryResource	A binary resource that might appear in a resource collection.
BinaryTextDecoder	This class generates decodes processing instructions in text output that represent text encoded in base64 binary or hexBinary
Bindery	The Bindery class holds information about variables and their values.
Bindery.FailureValue	A value that can be saved in a global variable to indicate that evaluation failed, and that subsequent attempts at evaluation should also fail
Binding	Binding is a interface used to represent the run-time properties and methods associated with a variable: specifically, a method to get the value of the variable.
BindingReference	BindingReference is a interface used to mark references to a variable declaration.
Block	An expression that delivers the concatenation of the results of its subexpressions.
Block.BlockElaborator	Elaborator for a "Block", which is typically either an XPath sequence expression (a, b, c) or an XSLT sequence constructor
Block.ChainAction
BlockAdjunct	Generate streaming code for a Block, that is a sequence of expressions or instructions
BlockIterator	Iterate over the instructions in a sequence of instructions (or an XPath comma expression), concatenating the result of each instruction into a single combined sequence.
BMPString	An implementation of UnicodeString that wraps a Java string which is known to contain no surrogates.
BooleanElaborator	Abstract superclass for elaborators whose primary evaluation method is to return a single boolean.
BooleanEvaluator	Interface implemented by expressions that return a boolean result.
BooleanExpression	Boolean expression: two truth values combined using AND or OR.
BooleanExpressionPattern	A BooleanExpressionPattern is a pattern of the form .[ Expr ] introduced in XSLT 3.0.
BooleanFn	This class supports the XPath function boolean()
BooleanFn.BooleanFnElaborator
BooleanFnFeed	Feed implementation supporting the fn:boolean() and fn:not() functions
BooleanFnFeed.Negative	Feed implementation for the fn:not function
BooleanFnFeed.Positive	Feed implementation for the fn:boolean function
BooleanFnStreamer	Streaming code for an fn:boolean() function call
BooleanValue	A boolean XPath value
BreakInstr	A compiled xsl:break instruction.
BreakInstr.BreakElaborator
BufferingApplyTemplatesFeed	This class is used when a streaming xsl:for-each requests processing of a grounded consuming sequence with a static dependency on last()
BufferingFeed	A BufferingFeed is used to wrap an expression that does not have intrinsic capability to accept streamed input.
BufferingFilterExpressionFeed	This class is used when a streaming template requests filtering of items that don't come directly from the streamed document, but rather are constructed in the course of the push pipeline
BufferingForEachExpressionFeed	This class is used when a streaming xsl:for-each requests processing of a grounded consuming sequence with a static dependency on last()
Builder	The abstract Builder class is responsible for taking a stream of SAX events and constructing a Document tree.
BuilderMonitor	A BuilderMonitor can be inserted into a pipeline immediately in front of a Builder.
BuildingContentHandler	A SAX ContentHandler that builds a Saxon tree, and allows the node at the root of the tree to be retrieved on completion.
BuildingStreamWriter	A BuildingStreamWriter allows a document to be constructed by calling the methods defined in the XMLStreamWriter interface; after the document has been constructed, its root node may be retrieved by calling the getDocumentNode() method.
BuildingStreamWriterImpl	This class is an implementation of XMLStreamWriter, allowing a document to be constructed by means of a series of XMLStreamWriter method calls such as writeStartElement(), writeAttribute(), writeCharacters(), and writeEndElement().
BuildURI	Supports the fn:build-uri function.
BuiltInAtomicType	This class represents a built-in atomic type, which may be either a primitive type (such as xs:decimal or xs:anyURI) or a derived type (such as xs:ID or xs:dayTimeDuration).
BuiltInFunctionSet	This class is used to contain information about a set of built-in functions.
BuiltInFunctionSet.Entry	An entry in the table describing the properties of a function
BuiltInListType	This class is used to implement the built-in list types NMTOKENS, ENTITIES, IDREFS.
BuiltInRules	Enumeration representing the permitted values of xsl:mode/@on-no-match, decomposed into more primitive actions
BuiltInRuleSet	Defines a set of built-in template rules (rules for use when no user-defined template rules match a given node)
BuiltInType	This non-instantiable class acts as a register of Schema objects containing all the built-in types: that is, the types defined in the "xs" namespace.
Calculator	This class evaluates arithmetic expressions; it acts as a helper class to the ArithmeticExpression class.
Calculator.AnyDivAny	Arithmetic: anyAtomicType div AnyAtomicType
Calculator.AnyIdivAny	Arithmetic: anyAtomicType idiv AnyAtomicType
Calculator.AnyMinusAny	Arithmetic: anyAtomicType - AnyAtomicType
Calculator.AnyModAny	Arithmetic: anyAtomicType mod AnyAtomicType
Calculator.AnyPlusAny	Arithmetic: anyAtomicType + AnyAtomicType
Calculator.AnyTimesAny	Arithmetic: anyAtomicType * AnyAtomicType
Calculator.DecimalDivDecimal	Arithmetic: decimal div decimal (including types that promote to decimal, that is, integer)
Calculator.DecimalIdivDecimal	Arithmetic: decimal idiv decimal (including types that promote to decimal, that is, integer)
Calculator.DecimalMinusDecimal	Arithmetic: decimal - decimal (including types that promote to decimal, that is, integer)
Calculator.DecimalModDecimal	Arithmetic: decimal mod decimal (including types that promote to decimal, that is, integer)
Calculator.DecimalPlusDecimal	Arithmetic: decimal + decimal (including types that promote to decimal, that is, integer)
Calculator.DecimalTimesDecimal	Arithmetic: decimal * decimal (including types that promote to decimal, that is, integer)
Calculator.DoubleDivDouble	Arithmetic: double div double (including types that promote to double)
Calculator.DoubleMinusDouble	Arithmetic: double - double (including types that promote to double)
Calculator.DoubleModDouble	Arithmetic: double mod double (including types that promote to double)
Calculator.DoubleOpDouble	Marker interface for operations on doubles
Calculator.DoublePlusDouble	Arithmetic: double + double (including types that promote to double)
Calculator.DoubleTimesDouble	Arithmetic: double * double (including types that promote to double)
Calculator.FloatDivFloat	Arithmetic: float div float (including types that promote to float)
Calculator.FloatIdivFloat	Arithmetic: float idiv float (including types that promote to float)
Calculator.FloatMinusFloat	Arithmetic: float - float (including types that promote to float)
Calculator.FloatModFloat	Arithmetic: float mod float (including types that promote to float)
Calculator.FloatPlusFloat	Arithmetic: float + float (including types that promote to float)
Calculator.FloatTimesFloat	Arithmetic: float * float (including types that promote to float)
Calculator.IntegerDivInteger	Arithmetic: integer div integer
Calculator.IntegerIdivInteger	Arithmetic: integer idiv integer
Calculator.IntegerMinusInteger	Arithmetic: integer - integer
Calculator.IntegerModInteger	Arithmetic: integer mod integer
Calculator.IntegerPlusInteger	Arithmetic: integer + integer
Calculator.IntegerTimesInteger	Arithmetic: integer * integer
CalendarValue	Abstract superclass for Date, Time, and DateTime.
CalendarValueComparer	A comparer specifically for comparing two date, time, or dateTime values
Callable	A generic interface for calling expressions by supplying the values of their subexpressions
CallableDelegate	An implementation of Callable that allows the logic to be supplied as a lambda expression.
CallableDelegate.Lambda
CallableFeed	A CallableFeed is used to wrap an expression that does (a) not have intrinsic capability to accept streamed input, and (b) does not expect any operand to be a sequence, and (c) implements the Callable interface.
CallableFunction	A function item that wraps a Callable
CallableWithBoundFocus	A Callable that wraps another Callable and a Dynamic Context, in effect acting as a closure that executes the original callable with a saved context.
CallTemplate	Instruction representing an xsl:call-template element in the stylesheet.
CallTemplate.CallTemplateElaborator
CallTemplate.CallTemplatePackage	A CallTemplatePackage is an object that encapsulates the name of a template to be called, the parameters to be supplied, and the execution context.
CallTemplateAdjunct
Capture	Represents a match of a captured subgroup
Cardinality	This class contains static methods to manipulate the cardinality property of a type.
CardinalityChecker	A CardinalityChecker implements the cardinality checking of "treat as": that is, it returns the supplied sequence, checking that its cardinality is correct
CardinalityChecker.CardinalityCheckerElaborator	Elaborator for a treat as expression, which is usually system-generated by the type checking phase of the compiler
CardinalityCheckerAdjunct	Generate streaming code for a cardinality checker
CardinalityCheckingFeed	A Feed to go on the streaming pipeline that checks the cardinality of the sequence represented by the events passing down the pipeline.
CardinalityCheckingIterator	CardinalityCheckingIterator returns the items in an underlying sequence unchanged, but checks that the number of items conforms to the required cardinality.
CaseFirstCollator	A StringCollator that sorts lowercase before uppercase, or vice versa.
CaseVariants	This singleton class holds data about the case-variants of Unicode characters.
CastableExpression	Castable Expression: implements "Expr castable as atomic-type?".
CastExpression	Cast Expression: implements "cast as data-type ( expression )".
CastExpression.CastExprElaborator	Elaborator for cast as expression, or the equivalent constructor function call
CastingExpression	Casting Expression: abstract superclass for "cast as X" and "castable as X", which share a good deal of logic
CastingTarget	This marker interface represents a type that can be used as the target of a cast or castable operation, that is, an atomic type, list type, or plain union type
CatalogCollection	A resource collection implemented by means of a catalog file.
CatalogResourceResolver	The standard implementation of the ResourceResolver interface for use with catalogs.
CatchingReceiver	This class catches all errors thrown by a Receiver pipeline, and reports them to a specified ErrorReporter; after an error has occurred, all further events are ignored.
Categories	Singleton class holding data for Regular expression character categories.
Categories.Category	A Category is a CharacterClass represented in a regular expression as \p{Xx}.
CDATAFilter	CDATAFilter: This ProxyReceiver converts character data to CDATA sections, if the character data belongs to one of a set of element types to be handled this way.
Ceiling	This class supports the ceiling() function
Ceiling.CeilingElaborator
ChainedEntityResolver	An EntityResolver that first tries one supplied EntityResolver, and if that returns null, falls back to another.
ChainedResourceResolver	An ResourceResolver that first tries one supplied ResourceResolver, and if that returns null, falls back to another.
CharacterClass	A character class represents a set of characters for regex matching purposes.
Characteristic	A Characteristic represents a distinguishing feature of an item that may be used by several patterns in a rule chain, and which can usefully be evaluated once for all rules in the rule chain.
CharacterMap	This class defines a character map, that is, a mapping from characters to strings used by the serializer when mapping individual characters in the output.
CharacterMapExpander	CharacterMapExpander: This ProxyReceiver expands characters occurring in a character map, as specified by the XSLT 2.0 xsl:character-map declaration
CharacterMapIndex	This class represents a set of named character maps.
CharacterReferenceGenerator	A class that expands a character to a character reference, entity reference, etc, and writes the resulting reference to a writer
CharacterSet	This interface defines properties of a character set, built in to the Saxon product.
CharacterSetFactory	This class delivers a CharacterSet object for a given named encoding.
CharactersFn	Implements the saxon:characters() function.
CharactersFn	Implements the saxon:characters() or fn:characters() function.
CharFn	Implements the fn:char() function.
CheckSumFilter	A filter to go on a Receiver pipeline and calculate a checksum of the data passing through the pipeline.
ChoiceModelGroup	A ChoiceCompositor represents an xs:choice element in the schema
Choose	Compiled representation of an xsl:choose or xsl:if element in the stylesheet.
Choose.ChooseExprElaborator	Elaborator for a "Choose" expression (which may be xsl:if, xsl:choose, or an XPath conditional expression).
ChooseAdjunct	Streaming code to implement a conditional ("if/choose") expression
Clause	A "Clause" refers specifically to one of the clauses of a FLWOR expression, for example the "for" clause, the "let" clause, the "where" or "order by" clause.
Clause.ClauseName
ClauseInfo	A "trace" clause in a FLWOR expression, added by a TraceCodeInjector
CleanerProxy	This utility class exists in order to put all functionality relating to use of the Java 9 class Cleaner in one place, to allow the product to continue to work with Java 8.
CleanerProxy.CleanableProxy
Closable	This class represents the common ability of many XQJ classes to be closed.
CloseNotifier	A receiver that performs specified actions when closed
Closure	A Closure represents a value that has not yet been evaluated: the value is represented by an expression, together with saved values of all the context variables that the expression depends on.
CodedName	An implementation of NodeName that encapsulates an integer fingerprint, a string prefix, and a reference to the NamePool from which the fingerprint was allocated.
CodeInjector	A code injector can be used to add code to the expression tree (for example, diagnostic tracing code) during the process of parsing and tree construction
CodepointCollatingComparer	An AtomicComparer used for comparing strings, untypedAtomic values, and URIs using the Unicode codepoint collation.
CodepointCollator	A collating sequence that uses Unicode codepoint ordering
CodepointEqual	Implements the XPath 2.0 fn:codepoint-equal() function.
CodepointIterator	Iterator over a string to produce a sequence of single character strings
CodepointsToString	This class implements the function fn:codepoints-to-string()
CodepointsToStringStreamer
CoercedFunction	A function item obtained by coercing a supplied function; this adds a wrapper to perform dynamic type checking of the arguments in any call, and type checking of the result.
CollatingAtomicComparer	An AtomicComparer used for comparing strings, untypedAtomic values, and URIs using a collation.
CollatingFunctionFixed	Abstract superclass for functions that take an optional collation argument, in which the collation is not present as an explicit argument, either because it was defaulted in the original function call, or because it has been bound during static analysis.
CollatingFunctionFree	Generic class for all functions that take an optional collation argument, where the collation argument is supplied and has not yet been resolved.
CollationKeyFn	Implements the collation-key function defined in the XSLT 3.0 and XPath 3.1 specifications
CollationMatchKey	A match key for comparing strings under a collation.
CollationURIResolver	A CollationURIResolver accepts a collation name as input, and returns a collation (represented by a StringCollator as output.
CollectionFinder	An instance of CollectionFinder can be registered with the Saxon configuration; it is called in response to calls on the fn:collection() and fn:uri-collection() functions.
CollectionFn	Implement the fn:collection() function.
CombinedNodeTest	A CombinedNodeTest combines two node tests using one of the operators union (=or), intersect (=and), difference (= "and not").
CommandLineOptions	This is a helper class for classes such as net.sf.saxon.Transform and net.sf.saxon.Query that process command line options
CommandLineOptions.ParamSetter
Comment	An instruction representing an xsl:comment element in the stylesheet.
CommentImpl	CommentImpl is an implementation of a Comment node
CommentStripper	The CommentStripper class is a filter that removes all comments and processing instructions.
CommonSubexpressionPromoter	This class is responsible for identifying and extracting common subexpressions within an expression.
CompactStringValue	A compact representation of an atomic xs:string value used in saved tables for key and keyref constraints, designed to economize on space.
Compare	This class implements the XPath 2.0 fn:compare() function
CompareToConstant	This class implements a comparison of a computed value to a literal constant using one of the operators eq, ne, lt, gt, le, ge.
CompareToIntegerConstant	This class implements a comparison of a numeric value to an integer constant using one of the operators eq, ne, lt, gt, le, ge.
CompareToIntegerConstant.CompareToIntegerConstantElaborator	Elaborator for a "compare to integer constant" expression
CompareToStringConstant	This class implements a comparison of a computed value to a string constant using one of the operators eq, ne, lt, gt, le, ge.
CompareToStringConstant.CompareToStringConstantElaborator	Elaborator for a "compare to string constant" expression
ComparisonException	A ComparisonException is a ClassCastException that encapsulates an XPathException.
ComparisonExpression	Interface implemented by expressions that perform a comparison
Compilation	Represents an XSLT compilation episode, compiling a single package.
CompileQuery	This class implements the saxon:compile-query() extension function
CompilerInfo	This class exists to hold information associated with a specific XSLT compilation episode.
CompileStylesheet	This class implements the saxon:compile-stylesheet() extension function
CompileXPath	This class implements the saxon:compile-XPath() extension function, which is specially-recognized by the system because it needs access to parts of the static context.
ComplexContentOutputter	This class is used for generating complex content, that is, the content of an element or document node.
ComplexContentValidator	This class is a filter that is used to validate the content of an element with a complex type.
ComplexNodeEventFeed	This event feed supports instructions that create a document or element node.
ComplexNodePushElaborator	Elaborator for element construction expressions (both fixed and computed).
ComplexType	A complex type as defined in XML Schema: either a user-defined complex type, or xs:anyType, or xs:untyped.
ComplexVariety	The different varieties of complex types
Component	Represents a component as defined in the XSLT 3.0 specification: for example a function, a named template, an attribute set, a global variable.
Component.M
ComponentBinding	A ComponentBinding is a reference from one component to another; for example a variable reference or function call.
ComponentDeclaration	The object represents a declaration (that is, a top-level element) in a stylesheet.
ComponentInversion	This class represents the inversion of a template or function body
ComponentInvocation	Represents an expression or instruction such as call-template, or a user function call, or a global variable reference, that needs to be bound to a target component, and can potentially be re-bound when the containing component is copied into another package.
ComponentReference	A reference to a schema component.
ComponentTest
ComponentTracer	A wrapper expression used to trace execution of components such as functions, templates, and global variables in XSLT and XQuery.
ComponentWithValueConstraint	Interface for Element Declaration, Attribute Declaration and Attribute Use, created because they share common functionality for handling fixed and default values
ComposingAdjunct	Watch factory class for an class that composes items from sequences of events: examples are copy-of(), data(), and string().
CompositeAtomicKey	A composite atomic key is a sequence of atomic values; two such keys are matched be comparing the constituent values pairwise.
CompoundMode	A CompoundMode is a mode representing the templates contained within an xsl:override element in a using package together with the rules in the corresponding mode of the base package.
CompressedWhitespace	This class provides a compressed representation of a sequence of whitespace characters.
ComputedAttribute	An instruction derived from an xsl:attribute element in stylesheet, or from an attribute constructor in XQuery, in cases where the attribute name is not known statically
ComputedElement	An instruction representing an xsl:element element in an XSLT stylesheet, or a computed element constructor in XQuery.
ComputedElement.ComputedElementElaborator	Elaborator for a FixedElement (literal result element) expression.
Concat	Implementation of the fn:concat() function
Concat31	Implementation of the fn:concat() function as defined in XPath 2.0, 3.0, and 3.1
ConcatenatingAxisIterator	An iterator over nodes, that concatenates the nodes returned by two supplied iterators.
ConcatenatingIntIterator	An iterator over nodes, that concatenates the nodes returned by two supplied iterators.
ConcatenatingIterable<E>	An iterable over arbitrary objects, that concatenates the objects returned by two supplied iterables.
ConcatenatingIterator<E>	An iterator (typically over nodes), that concatenates the nodes returned by two supplied iterators.
ConditionalBlock	An XSLT 3.0 sequence constructor containing xsl:on-empty and/or xsl:on-non-empty instructions
ConditionalBlockAdjunct	Generate streaming code for a conditional Block, that is a sequence constructor containing xsl:on-empty and/or xsl:on-not-empty instructions
ConditionalBlockAdjunct.ConditionalBlockFeed
ConditionalInstruction	This is a marker interface for Choose and Switch instructions
ConditionalSorter	An expression that sorts an underlying sequence into document order if some condition is true, or that returns the sequence "as is" (knowing that it doesn't need sorting) if the condition is false.
ConditionalSorter.ConditionalSorterElaborator	Elaborator for a conditional sorter, which sorts the results of a subexpression into document order only if a supplied condition is true
ConfigurableResourceResolver	A ResourceResolver that allows properties to be set and examined
Configuration	This class holds details of user-selected configuration options for a set of transformations and/or queries.
Configuration.ApiProvider	Marker interface to represent an API that is provided as a layer on top of this Configuration
Configuration.LicenseFeature	This class contains constants representing features of the software that may or may not be licensed.
ConfigurationReader	Class used to read a config.xml file and transfer all settings from the file to the Configuration
ConfigurationReaderPE	Subclass of ConfigurationReader providing functionality particular to Saxon Professional Edition
ConnectionPoolXQDataSource	A factory for PooledXQConnection objects.
ConstantFunction	A ConstantFunction is a zero-argument function that always delivers the same result, supplied at the time the function is instantiated.
ConstantFunction.False
ConstantFunction.True
ConstraintChecker	This class handles the checking of Schema-defined unique, key, and keyref constraints.
ConstructorFunctionLibrary	The ConstructorFunctionLibrary represents the collection of constructor functions for atomic types.
ConsumingOperand	This expression is used as a proxy for the consuming operand of an expression such as an arithmetic expression for which there is no explicit streaming support.
Container	The Container interface represents a document node or element node under construction; there are concrete subclasses representing document nodes and element nodes respectively.
Contains	Implements the fn:contains() function, with the collation already known
Contains.ContainsFnElaborator	Expression elaborator for a call to contains(), starts-with(), or ends-with()
ContainsToken	Implements the fn:contains-token() function with the collation already bound.
ContainsTokenPatternOptimizer	A PatternOptimizer is an agent responsible for optimizing a particular class of patterns.
ContentDetector	A ContentDetector is a filter that can be added to a Receiver pipeline to note whether the current element node has children.
ContentHandlerProxy	A ContentHandlerProxy is a Receiver that converts events into the form expected by an underlying SAX2 ContentHandler.
ContentHandlerProxy.ContentHandlerProxyTraceListener	Create a TraceListener that will collect information about the current location in the source document.
ContentHandlerProxyLocator	Implementation of the SAX Locator interface, used to supply location information to the ContentHandler.
ContentType	Corresponds to a Content Type Property Record as defined in the XML Schema 1.1 specification
ContentTypeTest	NodeTest is an interface that enables a test of whether a node matches particular conditions.
ContentValidator	This class is an abstract superclass for all the validators.
ContentValidator.Nillability
ContextAccessorFunction	A ContextAccessorFunction is a function that is dependent on the dynamic context.
ContextFreeAtomicComparer	A comparer for comparing two "ordinary" atomic values, where the values implement the Comparable interface and the equals() method with the appropriate XPath semantics.
ContextFreeAtomicValue	This interface is implemented by AtomicValues that can be compared without regard to context - specifically, the result of eq and lt comparisons does not depend on collations or on the context-dependent timezone.
ContextItemAccessorFunction	A ContextItemAccessorFunction is a function that takes no arguments, but operates implicitly on the context item.
ContextItemAccessorFunction.Number_0	Subclass of ContextItemAccessorFunction to handle number().
ContextItemAccessorFunction.StringAccessor	Subclass of ContextItemAccessorFunction to handle string-length() and normalize-space().
ContextItemExprAdjunct
ContextItemExpression	This class represents the expression "(dot)", which always returns the context item.
ContextItemExpression.ContextItemElaborator	Elaborator for the context item expression, "dot".
ContextItemStaticInfo	A data structure that represents the required type of the context item, together with information about whether it is known to be present or absent or whether it is not known statically whether it is present or absent.
ContextItemStaticInfoEE	Saxon-EE version of ContextItemStaticInfo, with extra information used for streamability analysis
ContextMappingFunction	ContextMappingFunction is an interface that must be satisfied by an object passed to a ContextMappingIterator.
ContextMappingIterator	ContextMappingIterator merges a sequence of sequences into a single flat sequence.
ContextOriginator	Represents a construct that is responsible for originating a new context; used in analysing the stack of context objects for diagnostics
ContextStackFrame	An entry on the context stack.
ContextStackFrame.ApplyTemplates	Subclass of ContextStackFrame representing an xsl:apply-templates call in XSLT
ContextStackFrame.BuiltInTemplateRule	Subclass of ContextStackFrame representing a built-in template rule in XSLT
ContextStackFrame.CallingApplication	Subclass of ContextStackFrame representing the outermost stack frame, for the calling application
ContextStackFrame.CallTemplate	Subclass of ContextStackFrame representing an xsl:call-template instruction in XSLT
ContextStackFrame.FunctionCall	Subclass of ContextStackFrame representing a call to a user-defined function either in XSLT or XQuery
ContextStackFrame.VariableEvaluation	Subclass of ContextStackFrame representing the evaluation of a variable (typically a global variable)
ContextStackIterator	This class provides a representation of the current runtime call stack, as represented by the stack of XPathContext objects.
ContextSwitchingExpression	Interface implemented by expressions that switch the context, for example A/B or A[B]
Controller	The Controller underpins Saxon's implementation of the JAXP Transformer class, and represents an executing instance of a transformation or query.
ConversionResult	This is a marker interface used as the result of methods that convert or cast values from one type to another.
ConversionRules	This class defines a set of rules for converting between different atomic types.
Converter	A converter implements conversions from one atomic type to another - that is, it implements the casting rules for a (source type, destination type) pair.
Converter.Base64BinaryToHexBinary	Converts base64 to hexBinary
Converter.BooleanToDecimal	Converts a boolean to a decimal
Converter.BooleanToDouble	Converts a boolean to a double
Converter.BooleanToFloat	Converts a boolean to an xs:float
Converter.BooleanToInteger	Converts a boolean to an integer
Converter.DateTimeToDate	Converts a dateTime to a date
Converter.DateTimeToGDay	Converts a dateTime to a gDay
Converter.DateTimeToGMonth	Converts a dateTime to a gMonth
Converter.DateTimeToGMonthDay	Converts a dateTime to a gMonthDay
Converter.DateTimeToGYear	Converts a dateTime to a gYear
Converter.DateTimeToGYearMonth	Converts a dateTime to a gYearMonth
Converter.DateTimeToTime	Converts a dateTime to a time
Converter.DateToDateTime	Converts a date to a dateTime
Converter.DecimalToInteger	Converts a decimal to an integer.
Converter.DoubleToDecimal	Convers a double to a decimal
Converter.DoubleToInteger	Converts a double to an integer
Converter.DownCastingConverter	Converter that checks that a value belonging to a supertype is a valid instance of a subtype, and returns an instance of the subtype
Converter.DurationToDayTimeDuration	Converts a duration to a dayTimeDuration
Converter.DurationToYearMonthDuration	Converts a duration to a yearMonthDuration
Converter.FloatToDecimal	Converts a float to a decimal
Converter.FloatToInteger	Converts a float to an integer
Converter.HexBinaryToBase64Binary	Converts hexBinary to base64Binary
Converter.IdentityConverter	Converter that does nothing - it returns the input unchanged
Converter.IntegerToDecimal	Converts an integer to a decimal
Converter.NotationToQName	Converts Notation to QName
Converter.NumericToBoolean	Converts a numeric value to a boolean
Converter.NumericToDecimal	Converts any numeric value to a decimal
Converter.NumericToDouble	Converts any numeric value to a double.
Converter.NumericToFloat	Converts any numeric value to xs:float
Converter.NumericToInteger	Converts any numeric value to an integer.
Converter.PromoterToAnyURI	Converter that implements the promotion rules from xs:string to xs:anyURI
Converter.PromoterToBase64Binary
Converter.PromoterToDouble	Converter that implements the promotion rules to a required type of xs:double
Converter.PromoterToFloat	Converter that implements the promotion rules to a required type of xs:float
Converter.PromoterToHexBinary	Converter that implements the promotion rules from xs:string to xs:anyURI
Converter.PromoterToString	Converter that implements the promotion rules from xs:anyURI to xs:string
Converter.QNameToNotation	Converts QName to Notation
Converter.ToStringConverter	Converts any value to a string
Converter.ToUntypedAtomicConverter	Converts any value to untyped atomic
Converter.TwoPhaseConverter	Converter that operates in two phases, via an intermediate type
Converter.UnfailingConverter	Specialisation for converters that always succeed
Converter.UpCastingConverter	Converter that does nothing except change the type annotation of the value.
Copy	Handler for xsl:copy elements in stylesheet.
Copy.CopyElaborator
Copy.CopyElementDetails
CopyAdjunct	Compile an xsl:copy expression/instruction to streaming code.
CopyInformee	A CopyInformee is an agent that receives extra information while a tree is being copied.
CopyModifyExpression	A copy-modify expression (called a "transform" expression in the XQuery Update specification)
CopyNamespaceSensitiveException	Exception indicating that an attempt was made to copy namespace-sensitive content without copying its associated namespaces
CopyOf	An xsl:copy-of element in the stylesheet.
CopyOfAdjunct
CopyOfFeed	This class is used to construct a grounded copy of a streamed node, by capturing the events representing the streamed node as they are notified, and constructing the grounded copy from these events.
CopyOfFeed.AccumulatorCopier
CopyOfFn	XSLT 3.0 function copy-of().
CopyOptions	Non-instantiable class to define options for the NodeInfo.copy(net.sf.saxon.event.Receiver, int, net.sf.saxon.s9api.Location) method
Count	Implementation of the fn:count function
Count.CountFnElaborator
CountClause	A "count" clause in a FLWOR expression
CountClausePull	A tuple stream that implements a "count" clause in an XQuery 3.0 FLWOR expression
CountClausePush	A tuple stream in push mode that implements a "count" clause in an XQuery 3.0 FLWOR expression
CountingCompletionService<V>	Extension of ExecutorCompletionService to count the number of tasks submitted and take that many completed tasks before calling it a day.
CountingFilter	A filter that can be inserted into a Receiver pipeline to count the events that pass through.
CountingState	A counting state is a dynamic object representing the combination of an AutomatonState and a counter value
CountStreamer	Streaming code for the count() function.
CSharp	This class contains dummy methods which, if called, have no effect; but calls on these methods are detected by the Java-to-C# converter and affect the C# code that is generated.
CSharpDelegate	Annotate a Java class or interface to indicate whether the corresponding C# class should be implemented as a delegate.
CSharpExtendInterface	Annotate a Java interface to reference an additional interface with method definitions that will be present in the C# product.
CSharpInjectMembers	Annotate a Java class or interface with C# code that is to be injected literally into the body of the class or interface when converting to C#.
CSharpInnerClass	This annotation appears on the declaration of a method that creates an instance of an anonymous inner class, and it is used to define what information needs to be passed to the generated C# inner class.
CSharpModifiers	This annotation appears on the declation of a method or field if, for some reason, the automatic generation of the correct modifiers for C# produces incorrect results.
CSharpNullable	Annotate a Java class or interface to indicate that the C# directive "#nullable enable" is to be included in the generated C# code.
CSharpOmit	Annotate a Java method to indicate that it is to be dropped from the C# generated code (alternative to conditional exclusion using the preprocessor)
CSharpReplaceBody	Annotate a Java method with C# code that is to be injected literally into the body of the method when converting to C#, replacing the Java method body.
CSharpReplaceException	Annotation used by the Java-to-C# transpiler: it causes any exception named in a catch clause within a Java method to be replaced by a different exception in the generated C#
CSharpReplaceMethod	Annotate a Java method, constructor, or field with C# code that is to replace the entire Java method.
CSharpSimpleEnum	Annotate a Java enum to indicate that a simple mapping to a C# enum should be used.
CSharpSuppressWarnings	This annotation appears on the declation of a method or field if, for some reason, the automatic generation of the correct modifiers for C# produces incorrect results.
CSharpTypeBounds	This annotation appears on the declaration of a class using generic type parameters if the C# code needs to have type bounds that cannot be inferred directly from the Java declaration.
Current	Implement the XSLT current() function
CurrentGroup	Implements the XSLT function current-group()
CurrentGroupCall	Implements the XSLT function current-group()
CurrentGroupingKey	Implements the XSLT function current-grouping-key()
CurrentGroupingKeyCall	Implements the XSLT function current-grouping-key()
CurrentGroupPattern	This is a special pattern that matches the "anchor node".
CurrentGroupStreamer	Provides streaming code for a call on current-group().
CurrentItemExpression	The expression is generated when compiling the current() function in XSLT.
CurrentMergeGroup	Implements the XSLT 3.0 function current-merge-group()
CurrentMergeGroupStreamer	Generate streaming code for a call on current-merge-group().
CurrentMergeKey	Implements the XSLT function current-grouping-key()
CurrentOutputUri	This class implements the XSLT 3.0 function current-output-uri()
CurriedFunction	A function obtained by currying another function, that is, the result of calling fn:partial-apply
CustomMap<K,V>	A map implementation using a custom equality matcher, to avoid having to wrap each entry in a wrapper object to achieve customised equality testing.
CustomSet<T>	A mutable set implementation using a custom equality matcher, to avoid having to wrap each entry in a wrapper object to achieve customised equality testing.
Data_1	Implement XPath function fn:data() with a single argument
DataElement	This element represents a top-level element in a user-defined namespace, or a child/descendant of such an element.
DataURIScheme	This class handles URIs using the data: URI scheme defined in RFC 2397
Date	This class implements extension functions in the http://exslt.org/dates-and-times namespace.
DateTimeConstructor	This class supports the dateTime($date, $time) function
DateTimeConstructor.DateTimeFnElaborator
DateTimeValue	A value of type xs:dateTime.
DateTimeValue.DateTimeComparable	DateTimeComparable is an object that implements the XML Schema rules for comparing date/time values
DateTimeValue.MutableDateTimeValue
DateValue	A value of type Date.
DayTimeDurationValue	A value of type xs:dayTimeDuration (or a subtype thereof).
Debugger	This interface may be implemented by an external debugging tool
DecimalCharacterReferenceGenerator	A class that represents a character as a decimal character reference and writes the result to a supplied Writer.
DecimalDivide	Implements the saxon:decimal-divide() function
DecimalFormatManager	DecimalFormatManager manages the collection of named and unnamed decimal formats, for use by the format-number() function.
DecimalSortComparer	An AtomicComparer used for sorting values that are known to be instances of xs:decimal (including xs:integer), It also supports a separate method for getting a collation key to test equality of items
DecimalSymbols	This class is modelled on Java's DecimalFormatSymbols, but it allows the use of any Unicode character to represent symbols such as the decimal point and the grouping separator, whereas DecimalFormatSymbols restricts these to a char (1-65535).
DecimalValue	Abstract class representing the XDM type xs:decimal.
Declaration	This interface represents the union of global variable declarations and function declarations in XQuery modules
DecodeFromURI	Implements the fn:decode-from-uri function.
DecomposingFeed	Appends the output of an ItemFeed to an Outputter
DeepCopyRuleSet	The built-in rule set introduced in XSLT 3.0, which performs a deep copy of any unmatched node.
DeepDescentFunctionCallAdjunct	Handle streaming for calls to user-defined functions with streamability="absorbing"
DeepEqual	XSLT 2.0 deep-equal() function, where the collation is already known.
DeepEqual40	XSLT 2.0 deep-equal() function, where the collation is already known.
DeepEqual40.DeepEqualOptions
DeepEqualStreamer	Implement streaming of deep-equal function.
DeepSkipRuleSet	The rule set introduced in XSLT 3.0, which (for any kind of node) simply ignores the node and its descendants.
DeepUpdate	Handler for saxon:deep-update elements in stylesheet.
DefaultedArgumentExpression	DefaultedArgumentExpression is a placeholder used in a function call for an argument that is evaluated using the default value expression from the function definition, in cases where that expression has not yet been compiled (typically because the function call precedes the function declaration).
DefaultedArgumentExpression.DefaultCollationArgument
DefaultTalker
DelegatingArrayItem	A DelegatingArrayItem is an abstract class representing an array that is implemented by delegating all array-related functionality to a base class.
DelegatingFeed	A DelegatingFeed is an ItemFeed that delegates most of its work to a supplied Outputter.
DelegatingMapItem	A DelegatingMapItem is an abstract class representing a map that is implemented by delegating all map-related functionality to another map.
DeleteAction	A pending update action representing the effect of a delete expression
DeleteExpression	A delete expression in XQuery Update
Derivation
DescendingComparer	A Comparer used for comparing descending keys.
DescendingRangeIterator	Iterator that produces numeric values in a monotonic sequence, ascending or descending.
Destination	A Destination represents a place where XDM values can be sent.
DestinationHelper	A helper class for implementing the Destination interface
DeterminizedState	A state in a determinized finite state machine
DiagnosticClause	A "let" clause in a FLWOR expression
DiagnosticClausePull	Implements the trace clause in a FLWOR expression.
DiagnosticClausePush	Implements the changes to a tuple stream effected by the Let clause in a FLWOR expression
DictionaryMap	A simple implementation of MapItem where the strings are keys, and modification is unlikely.
DifferenceIterator	An enumeration representing a nodeset that is teh difference of two other NodeSets.
DigitsFacet	Represents either of the facets totalDigits or fractionDigits
DirectoryCollection	This class represents a resource collection containing all, or selected, files within a filestore directory.
DirectResourceResolver	A DirectResourceResolver is a ResourceResolver that resolves requests using the direct, native capabilities of the platform.
DistinctFacet	The saxon:distinct facet on a list type can be used to constrain the list to contain distinct values.
DistinctValues	The XPath 2.0 distinct-values() function, with the collation argument already known
DistinctValues.DistinctIterator	Iterator class to return the distinct values in a sequence
DistinctValuesStreamer	Implement the distinct-values function in streaming mode.
Doc	Implement the fn:doc() function - a simplified form of the Document function
Doc_2	Implement the saxon:doc() function - a variant of the fn:doc function with a second argument to supply option parameters.
DocAvailable	Implement the fn:doc-available() function
Doctype	A saxon:doctype element in the stylesheet.
Document	A Container representing a document node.
DocumentBuilder	A document builder holds properties controlling how a Saxon document tree should be built, and provides methods to invoke the tree construction.
DocumentBuilderImpl	This class implements the JAXP DocumentBuilder interface, allowing a Saxon TinyTree to be constructed using standard JAXP parsing interfaces.
DocumentFn	Implements the XSLT document() function
DocumentImpl	A node in the XML parse tree representing the Document itself (or equivalently, the root node of the Document).
DocumentInstr	An instruction to create a document node.
DocumentInstr.DocumentInstrElaborator	Elaborator for an AtomicSequenceConverter (including an UntypedAtomicConverter, which is the same except that it uses a different converter internally)
DocumentInstrAdjunct	Evaluate an xsl:document instruction in streaming code.
DocumentInstrAdjunct.DocumentInstrFeed
DocumentKey	This class encapsulates a string used as the value of the document-uri() property of a document, together with a normalized representation of the string used for equality comparisons.
DocumentNodeTest	A DocumentNodeTest implements the test document-node(element(~,~))
DocumentNumberAllocator	This class (which has one instance per Configuration) is used to allocate unique document numbers.
DocumentOrderIterator	DocumentOrderIterator takes as input an iteration of nodes in any order, and returns as output an iteration of the same nodes in document order, eliminating any duplicates.
DocumentOverNodeInfo	This class is an implementation of the DOM Document class that wraps a Saxon DocumentInfo representation of a document node.
DocumentPool	An object representing the collection of documents handled during a single transformation.
DocumentSorter	A DocumentSorter is an expression that sorts a sequence of nodes into document order.
DocumentSorter.DocumentSorterElaborator	Elaborator for a docOrder expression - sorts nodes into document order and eliminates duplicates
DocumentSorterAdjunct	Generate streaming code for a document sorting expression node.
DocumentUri_1	This class supports the document-uri() function
DocumentValidator	DocumentValidator checks that a document is well-formed: specifically, that it contains a single element node child and no text node children.
DocumentWrapper	The tree info object for a tree implemented as a wrapper around a DOM Document.
DocumentWrappingPullProvider	Returns the events provided by an underlying PullProvider, with the addition of a START_DOCUMENT event immediately after the START_OF_INPUT, and an END_DOCUMENT event immediately before the END_OF_INPUT
DoInstr	Compiled instruction deriving from saxon:do element in stylesheet.
DoInstr.DoInstructionElaborator
DOM4JDocumentWrapper	TreeInfo class for a virtual tree that wraps a DOM4J tree
DOM4JNodeWrapper	A node in the XML parse tree representing an XML element, character content, or attribute.
DOM4JObjectModel	This class is the DOM4J implementation of Saxon's ExternalObjectModel interface; it supports the wrapping of DOM4J documents as instances of the Saxon NodeInfo interface.
DOM4JWriter	JDOMWriter is a Receiver that constructs a DOM4J document from the stream of events
DOMDestination	This class represents a Destination (for example, the destination of the output of a transformation) in which the results are written to a newly constructed DOM tree in memory.
DOMEnvelope	DOMEnvelope is an object model representation in which DOM interfaces are wrapped around Saxon NodeInfo nodes: that is, it implements the DOM on top of a Saxon tree implementation such as the tiny tree or linked tree.
DOMExceptionImpl	DOM operations only raise exceptions in "exceptional" circumstances, i.e., when an operation is impossible to perform (either for logical reasons, because data is lost, or because the implementation has become unstable).
DominoAttr	An attribute node in the Domino tree
DominoNode	A node in the Domino tree (other than an attribute or namespace node)
DominoTree	An adaptation of the TinyTree structure, used to index a DOM.
DominoTreeModel	Tree model implementation for the DOMINO tree
DominoTreeModel.DominoBuilder	A Builder class for the Domino tree model
DOMNodeList	This class wraps a list of nodes as a DOM NodeList
DOMNodeWrapper	A node in the XML parse tree representing an XML element, character content, or attribute.
DOMObjectModel	This interface must be implemented by any third-party object model that can be wrapped with a wrapper that implements the Saxon Object Model (the NodeInfo interface).
DOMSender	DOMSender.java: pseudo-SAX driver for a DOM source document.
DOMTransform	Variant of command line net.sf.saxon.Transform do build the source document in DOM and then proceed with the transformation.
DOMWriter	DOMWriter is a Receiver that attaches the result tree to a specified Node in the DOM Document
DotNetLocalizerFactory	Default factory for number/date localizers for the .NET platform.
DoubleSortComparer	An AtomicComparer used for sorting values that are known to be numeric.
DoubleValue	A numeric (double precision floating point) value
DummyNamespaceResolver	A dummy namespace resolver used when validating QName-valued attributes written to the result tree.
DuplicateValues	The XPath 4.0 duplicate-values() function, with the collation argument already known
DuplicateValues.DuplicatesIterator	Iterator class to return the distinct values in a sequence
Durability	The Durability of a node affects how it is handled for the purposes of caching by memo functions.
DurationValue	A value of type xs:duration
DurationValue.DurationComparable	DurationValueComparable is a Comparable value that acts as a surrogate for a Duration, having ordering rules that implement the XML Schema specification.
DynamicContextAccessor	A DynamicContextAccessor is a function that takes no arguments, but operates implicitly on the dynamic context.
DynamicContextAccessor.CurrentDate
DynamicContextAccessor.CurrentDateTime
DynamicContextAccessor.CurrentTime
DynamicContextAccessor.DefaultLanguage
DynamicContextAccessor.ImplicitTimezone
DynamicFunctionCall	This class implements the function fn:apply(), which is a standard function in XQuery 3.1.
DynamicLoader	Utility class used to perform dynamic loading of user-hook implementations
DynamicLoaderEE	Specialization of DynamicLoader for use in Saxon-EE
DynamicLoaderPE	Specialization of DynamicLoader for use in Saxon-PE
DynamicQueryContext	This object represents a dynamic context for query execution.
EagerLetExpression	An EagerLetExpression is the same as a LetExpression except that the variable is evaluated using eager evaluation rather than lazy evaluation.
EagerPullEvaluator	A SequenceEvaluator that evaluates an expression eagerly, in pull mode.
EagerPushEvaluator	A SequenceEvaluator that evaluates an expression eagerly, in push mode.
EarlyEvaluationContext	This class is an implementation of XPathContext used when evaluating constant sub-expressions at compile time.
Edge	Internal class to represent the data associated with a transition: the element that triggers the transition, and the new state that results from the transition.
Edge.MaxOccursParticle
Edge.MaxOccursTerm	Special singular Term identifying a transition to be used when the maxOccurs value of a counting state is reached.
Elaborator	This class is at the heart of the mechanism for elaborating expressions.
Element	A Container representing an element node.
ElementAvailable	This class supports the XSLT element-available function.
ElementCreator	An instruction that creates an element node.
ElementCreator.ElementCreationDetails	ElementCreationDetails is a package of information and callbacks designed to parameterize the element construction process, to allow maximum use of common code for direct interpreted evaluation, elaborated evaluation, streamed evaluation, etc; supporting the variations that exist between computed element constructors, fixed element constructors, and shallow copy.
ElementCreatorAdjunct	Generate streaming code for an xsl:element instruction.
ElementCreatorFeed	This event feed supports instructions that create a document or element node.
ElementDecl	The object represents an element declaration in the schema.
ElementImpl	ElementImpl implements an element node in the Linked tree model.
ElementNameTracker	This is a filter that can be added to a pull pipeline to remember element names so that they are available immediately after the END_ELEMENT event is notified
ElementOverNodeInfo	This class is an implementation of the DOM Element class that wraps a Saxon NodeInfo representation of an element node.
ElementParticle	A reference to an element declaration within the content model of a complex type.
ElementWildcard	This class represents an <any> element in the schema.
Emitter	Emitter: This abstract class defines methods that must be implemented by components that format SAXON output.
Empty	Implementation of the fn:empty function
EmptyAtomicSequence	An implementation of AtomicSequence that contains no items.
EmptyAttributeMap	An implementation of AttributeMap representing an empty AttributeMap
EmptyCharacterClass	A character class represents a set of characters for regex matching purposes.
EmptyContentValidator	This class is a filter that is used to validate that an element has empty content.
EmptyGreatestComparer	A Comparer that modifies a base comparer by sorting empty key values and NaN values last (greatest), as opposed to the default which sorts them first.
EmptyIntIterator	An iterator over a zero-length sequence of integers
EmptyIterator	EmptyIterator: an iterator over an empty sequence.
EmptySequence	An EmptySequence object represents a sequence containing no members.
EmptySource	This class is an implementation of the JAXP Source interface.
EmptyStreamer	Streaming code for an fn:empty() function call
EmptyTextNodeRemover	This class performs part of the processing in "constructing simple content": it takes an input sequence and eliminates empty text nodes into one.
EmptyTextNodeRemover.EmptyTextNodeRemoverElaborator	Elaborator for an empty text node remove expression - inserted into a pipeline for node construction
EmptyTextNodeRemoverAdjunct	Streamed evaluation of an EmptyTextNodeRemover expression.
EmptyUnicodeString	A zero-length Unicode string
EncodeForUri	This class supports the function fn:encode-for-uri()
EncodingDetector	Utility class to detect the encoding of a stream by examining the initial bytes
EndsWith	Implements the fn:ends-with() function, with the collation already fixed
EnterpriseConfiguration	A subclass of Configuration that defines a processor with Saxon-EE capabilities.
EnterpriseTransformerFactory	The is the JAXP TransformerFactory implementation for the enterprise edition of Saxon.
EnterpriseXPathFactory	An implementation of the JAXP XPath Factory that creates an enterprise configuration.
EntityResolverWrappingResourceResolver	An implementation of the SAX EntityResolver2 interface implemented by calling a supplied ResourceResolver
EntityValidator	This class validates that elements and attributes of type ENTITY or ENTITIES have values are declared in the DOCTYPE declaration of the instance document as unparsed entities.
Entry
EnumerationFacet	Represents a single enumeration facet defined on a simple type.
EnumerationFacetSet	Represents the set of enumeration values defined on a single simple type, This is a "virtual" facet that combines all the enumeration facets in one simple type definition.
EnumerationType	Proposed extension for XPath 4.0: an enumeration type is a way of defining a subtype of xs:string, with a defined set of permitted values, without recourse to a schema or schema-awareness.
EnumSetTool	A couple of utility methods for handling EnumSet objects.
EnvironmentVariable	Implement the XPath 3.0 fn:environment-variable() function
EnvironmentVariableResolver	This interface defines a Saxon plug-in used to resolve calls on the XPath 3.0 functions available-environment-variables() and environment-variable().
EQName	This class implements the saxon:EQName extension function.
EqualityComparer	A comparer for comparing two atomic values where (a) equals is defined, and is implemented using the Java equals() method, and (b) ordering is not defined, and results in a dynamic error.
EqualityMatcher<T>	Interface representing objects used to perform equality matching.
EqualityPatternOptimizer	A PatternOptimizer is an agent responsible for optimizing a particular class of patterns.
Erector	This class is instantiated to build a DOMINO tree, taking a DOM Document as input; its task is to add the indexing information.
Err	Class containing utility methods for handling error messages
Error	Implement XPath function fn:error()
Error.UserDefinedXPathException
ErrorExpression	Error expression: this expression is generated when the supplied expression cannot be parsed, and the containing element enables forwards-compatible processing.
ErrorIterator	A SequenceIterator that throws an exception as soon as its next() method is called.
ErrorReporter	The ErrorReporter is a generic functional interface for reporting errors and warnings.
ErrorReporterToListener	A bridging class that allows errors in an XSLT Transformation, or in a Query, to be reported to a JAXP ErrorListener.
ErrorType	This class has a singleton instance which represents the XML Schema 1.1 built-in type xs:error.
EscapeHtmlUri	This class supports the function fn:escape-html-uri()
EscapeNCName	The saxon:escape-NCName function takes an arbitrary string and converts it to an NCName.
Eval	This class implements the saxon:eval() extension function
Evaluate	This class implements the saxon:evaluate() extension function
Evaluate.PreparedExpression	Inner class PreparedExpression represents a compiled XPath expression together with the standard variables $p1 ..
EvaluateInstr	An EvaluateInstr is the compiled form of an xsl:evaluate instruction
EvaluationNuisance	This filter sometimes gets inserted into a serialization pipeline when running under an evaluation license: it's a deterrent to using the evaluation version for production
Evaluators	Constants for different mechanisms of expression evaluation
Event	An event is an object representing one of the events that can be passed to a receiver: for example, a startElement, endElement, characters, or comment event.
Event.Append	Event representing an arbitrary item being sent to the event stream in composed form.
Event.Comment	Event representing a comment node
Event.EndDocument	Event representing end of document
Event.EndElement	Event representing the end of an element
Event.ProcessingInstruction	Event representing a processing instruction node
Event.StartDocument	Event representing start of document
Event.StartElement	Event representing the start of an element (including attributes or namespaces)
Event.Text	Event representing a text node
EventBuffer	An EventBuffer is a receiver of events that records the events in memory for subsequent replay.
EventMonitor	An EventMonitor is a filter that passes all events down the pipeline unchanged, keeping a note of whether any data has passed through the filter.
EventSource	An implementation of the JAXP Source class that supplies a document in the form of a stream of push events sent to a Receiver
EveryFn	This class implements the function fn:every(), which is a proposed function for XPath 4.0
ExceptPattern	A pattern formed as the difference of two other patterns
Executable	A compiled stylesheet or a query in executable form.
ExecutableFunctionLibrary	An ExecutableFunctionLibrary is a function library that contains definitions of functions for use at run-time.
ExistenceFeed	ItemFeed implementation supporting the fn:exists(), fn:empty(), and fn:count() function
Exists	Implementation of the fn:exists function
ExistsStreamer	Streaming code for an fn:exists() function call
ExpandedQNameFn	Implements the fn:expanded-QName() function proposed for 4.0
ExpandedStreamResult	An ExpandedStreamResult is similar to a StreamResult, and is created from a StreamResult.
EXPathBinaryFunctionSet	Implementation of extension functions in the EXPath Binary package, see http://expath.org/spec/binary
EXPathBinaryFunctionSet.BinaryAnd
EXPathBinaryFunctionSet.BinaryBin
EXPathBinaryFunctionSet.BinaryDecodeString
EXPathBinaryFunctionSet.BinaryEncodeString
EXPathBinaryFunctionSet.BinaryFind
EXPathBinaryFunctionSet.BinaryFromOctets
EXPathBinaryFunctionSet.BinaryHex
EXPathBinaryFunctionSet.BinaryInsertBefore
EXPathBinaryFunctionSet.BinaryJoin
EXPathBinaryFunctionSet.BinaryLength
EXPathBinaryFunctionSet.BinaryNot
EXPathBinaryFunctionSet.BinaryOctal
EXPathBinaryFunctionSet.BinaryOr
EXPathBinaryFunctionSet.BinaryPackDouble
EXPathBinaryFunctionSet.BinaryPackFloat
EXPathBinaryFunctionSet.BinaryPackInteger
EXPathBinaryFunctionSet.BinaryPadLeft
EXPathBinaryFunctionSet.BinaryPadRight
EXPathBinaryFunctionSet.BinaryPart
EXPathBinaryFunctionSet.BinaryShift
EXPathBinaryFunctionSet.BinaryToOctets
EXPathBinaryFunctionSet.BinaryUnpackDouble
EXPathBinaryFunctionSet.BinaryUnpackFloat
EXPathBinaryFunctionSet.BinaryUnpackInteger
EXPathBinaryFunctionSet.BinaryUnpackUnsignedInteger
EXPathBinaryFunctionSet.BinaryVersion
EXPathBinaryFunctionSet.BinaryXor
EXPathFileFunctionSet	Implementation of the file:base-dir function in the EXPath file library.
EXPathFileFunctionSet.FileAppend
EXPathFileFunctionSet.FileAppendBinary
EXPathFileFunctionSet.FileAppendText
EXPathFileFunctionSet.FileAppendTextLines
EXPathFileFunctionSet.FileBaseDir
EXPathFileFunctionSet.FileChildren
EXPathFileFunctionSet.FileCopy
EXPathFileFunctionSet.FileCreateDir
EXPathFileFunctionSet.FileCreateTempDir
EXPathFileFunctionSet.FileCreateTempFile
EXPathFileFunctionSet.FileCurrentDir
EXPathFileFunctionSet.FileDelete
EXPathFileFunctionSet.FileDirSeparator
EXPathFileFunctionSet.FileExists
EXPathFileFunctionSet.FileIsDir
EXPathFileFunctionSet.FileIsFile
EXPathFileFunctionSet.FileLastModified
EXPathFileFunctionSet.FileLineSeparator
EXPathFileFunctionSet.FileList
EXPathFileFunctionSet.FileMove
EXPathFileFunctionSet.FileName
EXPathFileFunctionSet.FileParent
EXPathFileFunctionSet.FilePathSeparator
EXPathFileFunctionSet.FilePathToNative
EXPathFileFunctionSet.FilePathToUri
EXPathFileFunctionSet.FileReadBinary
EXPathFileFunctionSet.FileReadText
EXPathFileFunctionSet.FileReadTextLines
EXPathFileFunctionSet.FileResolvePath
EXPathFileFunctionSet.FileSize
EXPathFileFunctionSet.FileTempDir
EXPathFileFunctionSet.FileWrite
EXPathFileFunctionSet.FileWriteBinary
EXPathFileFunctionSet.FileWriteText
EXPathFileFunctionSet.FileWriteTextLines
ExperimentalSequenceTypeMarshaller
ExperimentalXPathCompiler	This class provides support to the XX (xslt-in-xslt) compiler.
ExplicitCollection	This class represents a resource collection containing an explicitly enumerated set of resources
ExplicitTimezoneFacet	Represents an explicitTimezone facet on a schema-defined simple type derived from date, time, dateTime, gYear, gYearMonth, gMonth, gMonthDay, or gDay
ExportAgent	An export agent performs the job of exporting an expression to a SEF file.
Expression	Interface supported by an XPath expression.
ExpressionAction	General action class which can be used to process all nodes on an expression tree
ExpressionContext	An ExpressionContext represents the context for an XPath expression written in the stylesheet.
ExpressionFn	This class implements the saxon:expression() extension function.
ExpressionOwner	Abstraction representing any class that can act as the container for an expression: either an Operand of a parent expression, or a top-level construct such as a function or template or XQuery expression
ExpressionPresenter	This class handles the display of an abstract expression tree in an XML format with some slight resemblance to XQueryX
ExpressionPresenter.ExportOptions
ExpressionPresenterToJson	This class handles export of packages for SaxonJS 2 by converting the XML representation of SEF files to a JSON representation, at the level of emitting events.
ExpressionTool	This class, ExpressionTool, contains a number of useful static methods for manipulating expressions.
ExpressionVisitor	The ExpressionVisitor supports the various phases of processing of an expression tree which require a recursive walk of the tree structure visiting each node in turn.
ExsltCommonFunctionSet	Implementation of the exslt-common function library.
ExsltCommonFunctionSet.NodeSetFn	Implement exslt:node-set
ExsltCommonFunctionSet.ObjectTypeFn	Implement exslt:object-type
ExtensionElementCreator	Interface ExtensionElementCreator.
ExtensionElementFactory	Interface ExtensionElementFactory.
ExtensionFunction	This is an interface for simple external/extension functions.
ExtensionFunctionCall	This abstract class is provided to allow user-written extension functions to be implemented with the full capabilities of functions that are an intrinsic part of the Saxon product.
ExtensionFunctionDefinition	This abstract class is provided to allow user-written extension functions to be implemented with the full capabilities of functions that are an intrinsic part of the Saxon product.
ExtensionFunctionFactory	This is a marker interface representing an abstract superclass of JavaExtensionFunctionFactory and DotNetExtensionFunctionFactory.
ExtensionInstruction	Abstract class representing an extension instruction
ExternalObjectModel	This interface must be implemented by any third-party object model that can be wrapped with a wrapper that implements the Saxon Object Model (the NodeInfo interface).
ExternalObjectType	This class represents the type of an external object returned by an extension function, or supplied as an external variable/parameter.
Facet	Represents an XML Schema Facet.
FailedAccumulatorData	Represents the values of an accumulator whose evaluation has failed.
FailedResource	FailedResource represents an item in a collection that could not be processed because of some kind of error
FailRuleSet	The built-in rule set introduced in XSLT 3.0, which raises an error when there is no user-supplied template rule that matches a node.
FallbackElaborator	The FallbackElaborator performs elaboration of expressions for which no more specific elaborator is available.
Feature<T>	Feature defines a set of constants, representing the details of Saxon configuration options which can be supplied to the Saxon method Configuration.setProperty(), and to other interfaces
FeatureCode	FeatureCode defines a set of integer constants, representing unique identifiers for the features that can be configured.
FeatureData
FeatureIndex
FeatureKeys	FeatureKeys defines a set of constants, representing the names of Saxon configuration options which can be supplied to the Saxon implementations of the JAXP interfaces TransformerFactory, SchemaFactory, Validator, and ValidationHandler, and to other interfaces such as the s9api Processor
FeedMaker	An expression that can be evaluated in streaming mode is represented at compile time by a list of FeedMaker objects.
FeedMakerDelegate
FeedMakerDelegate.Lambda
FeedToEventBuffer	An ItemFeed that captures all written events in a buffer for subsequent replay.
FieldChecker	A FieldChecker is instantiated when a field in an identity constraint is matched; it receives notification of all events until the end of the element (or attribute) that matched the selector.
FieldOrSelector	The selector of an IdentityConstraint
FieldWatch	A FieldWatch is a class that is looking for nodes that match a field selector within a uniqueness or key constraint.
FilterExpression	A FilterExpression contains a base expression and a filter predicate, which may be an integer expression (positional filter), or a boolean expression (qualifier)
FilterExpression.FilterExprElaborator	Elaborator for a filter expression
FilterExpression.FilterExprElaborator.PositionalFilteredIterator	An iterator for a filter expression in which the predicate is capable of evaluating as a number (in which case it needs to be compared with the context position, rather than being converted to a boolean)
FilterExpression.FilterExprElaborator.SimpleFilteredIterator	An iterator for a filter expression where it is known that the filter value will not be numeric, and can therefore be evaluated directly as a boolean
FilterExpressionAdjunct	Generate streaming code for a filter expression (when not part of a Watch).
FilterFactory	Factory class to create a ProxyReceiver which filters events on a push pipeline
FilterFn	This class implements the function fn:filter(), which is a standard function in XQuery 3.0
FilterFnStreamer	Generate streaming code for the fn:filter function.
FilterFunctionCallAdjunct	Handle streaming for calls to user-defined functions with streamability="filter"
FilterImpl	FilterImpl is an XMLFilter (a SAX2 filter) that performs a transformation taking a SAX stream as input and producing a SAX stream as output.
FilteringAdjunct	A subclass of StreamingAdjunct used for expressions that have a sequence-valued operand with usage transmission.
FilteringFeed	This class selects a subset of the items, nodes, or events selected by some supplying expression.
FilteringFeed.Filter	Interface defining the filter function, to be implemented by the caller
FilteringFeed.FilterDelegate
FilteringFeed.FilterLambda	An implementation of Filter that accepts lambda expressions (C# delegates)
FilteringFeed.FilterResult	Three possible results of the Filter#matches operation
FilterIterator	A FilterIterator filters an input sequence using a filter expression.
FingerprintedQName	A QName triple (prefix, URI, local) with the additional ability to hold an integer fingerprint.
FiniteStateMachine	Class representing a finite state machine, as a collection of states with transitions between them.
FiniteStateMachine.TermParticlePair
FirstItemExpression	A FirstItemExpression returns the first item in the sequence returned by a given base expression
FirstItemExpression.FirstItemExprElaborator	An elaborator for a "first-item" expression, typically written as X[1] or as head(X).
FirstItemExpressionAdjunct	Generate streaming code for a first item expression (when not part of a Watch).
FixedAttribute	An instruction derived from an xsl:attribute element in stylesheet, or from an attribute constructor in XQuery.
FixedElement	An instruction that creates an element node whose name is known statically.
FixedElement.FixedElementElaborator	Elaborator for a FixedElement (literal result element) expression.
FleetingDocumentNode	A Fleeting node (that is a transient node in a streamed document) that represents a document node
FleetingElementNode	Represents an element node available transiently within a streamed document
FleetingNode	A FleetingNode is a node that exists transiently in the course of streaming processing.
FleetingParentNode	A streamed document or element node.
FloatingPointConverter	This is a utility class that handles formatting of numbers as strings.
FloatValue	A numeric (single precision floating point) value
Floor	This class implements the fn:floor() function
Floor.FloorElaborator
FLWORExpression	This class represents a FLWOR expression, evaluated using tuple streams
FocusIterator	An iterator that maintains the values of position() and current(), typically implemented as a wrapper over an iterator which does not maintain these values itself.
FocusTrackingIterator	An iterator that maintains the values of position() and current(), as a wrapper over an iterator which does not maintain these values itself.
Fold
FoldingFunction	Implementation of aggregate functions such as sum() and avg() that supply a fold() function.
FoldLeftFn	This class implements the function fn:fold-left(), which is a standard function in XPath 3.0
FoldLeftFn.FoldLeftFold
FoldRightFn	This class implements the function fn:fold-right(), which is a standard function in XQuery 1.1
FoldStreamer	Streaming code for functions implemented as fold operations.
FootFn	This class implements the function fn:foot(), which is proposed as a standard function in XPath 4.0
ForClause	A "for" clause in a FLWOR expression
ForClauseOuterPull	This class represents the tuple stream returned by a "for" clause in a FLWOR expression
ForClauseOuterPush	This class implements the changes to the tuple stream effected by a "for" clause in a FLWOR expression where "allowing empty" is specified
ForClausePull	This class implements the changes to the tuple stream effected by a "for" clause in a FLWOR expression
ForClausePush	This class implements the changes to the tuple stream effected by a "for" clause in a FLWOR expression
ForEach	Handler for xsl:for-each elements in a stylesheet.
ForEach.ForEachElaborator
ForEachAction	This watch implements xsl:for-each in streaming mode.
ForEachAdjunct	Compile an xsl:for-each instruction to streaming code.
ForEachFn	This class implements the function fn:for-each() (formerly fn:map), which is a standard function in XQuery 3.0
ForEachGroup	Handler for xsl:for-each-group elements in stylesheet.
ForEachGroup.ForEachGroupElaborator
ForEachGroupAdjunct	Compile an xsl:for-each-group instruction to streaming code.
ForEachGroupParallelAction	This watch implements xsl:for-each-group in streaming mode, in cases where the population is being forked (using group-by), and where the population is not grounded.
ForEachGroupPartitionAction	This watch implements xsl:for-each-group in streaming mode, in cases where the population is being partitioned (that is, group-adjacent, group-starting-with, and group-ending-with), and where the population is not grounded.
ForEachPairFn	This class implements the function fn:for-each-pair() (formerly fn:map-pairs()), which is a standard function in XQuery 3.0
ForExpression	A ForExpression maps an expression over a sequence.
ForExpression.ForExprElaborator	An elaborator for a "for" expression, typically written as {for $x in SEQ return R}.
ForExpression.MappingAction	The MappingAction represents the action to be taken for each item in the source sequence.
ForExpressionAdjunct	Streaming code to implement a "for" expression
ForExpressionAdjunct.ForExpressionFeed
Fork	This class implements an xsl:fork expression.
ForkAdjunct	Streaming code to implement an xsl:fork expression
FormatDate	Implement the format-date(), format-time(), and format-dateTime() functions in XSLT 2.0 and XQuery 1.1.
FormatInteger
FormatNumber	Implementation of format-number() function.
FormatNumber.SubPicture	Inner class to represent one sub-picture (the negative or positive subpicture)
FractionDigitsFacet	Represents the fraction-digits facet in a simple type restriction
FunctionAnnotationHandler	Interface to a user-supplied class that handles XQuery annotation assertions in a particular namespace.
FunctionAnnotations	Implementation of the saxon:function-annotations() extension function.
FunctionArity	This class implements the function function-arity(), which is a standard function in XPath 3.0
FunctionAvailable	This class implements the XSLT function-available functions.
FunctionCall	Abstract superclass for calls to system-defined and user-defined functions
FunctionCall.FunctionCallElaborator
FunctionDefinition	A FunctionDefinition represents the declaration of a user-defined function in XQuery or XSLT; in 4.0 a function definition has an arity range.
FunctionItem	XDM 3.0 introduces a third kind of item, beyond nodes and atomic values: the function.
FunctionItemType	An ItemType representing the type of a function item (subclasses are used for maps and arrays)
FunctionLibrary	A FunctionLibrary handles the binding of function calls in XPath (or XQuery) expressions.
FunctionLibraryList	A FunctionLibraryList is a list of FunctionLibraries.
FunctionLiteral	A FunctionLiteral is a wrapper around a FunctionItem; it is an expression, whose value is the function that it wraps.
FunctionLookup	This class supports the function-lookup() function in XPath 3.0.
FunctionLookup.FunctionLookupExportAgent
FunctionName	This class implements the function function-name(), which is a standard function in XPath 3.0
FunctionSequenceCoercer	An FunctionSequenceCoercer is an expression that performs function coercion on a sequence of function items: it takes a sequence of supplied items as input, and wraps each one in a CoercedFunction value, which dynamically converts the supplied arguments to the required type, and converts the result in the opposite direction, or throws a type error if conversion is not possible.
FunctionSequenceCoercer.Coercer
FunctionStreamability	Enumeration class giving the different streamability categories defined for stylesheet functions in XSLT 3.0
GDateValue	Abstract superclass for the primitive types containing date components: xs:date, xs:gYear, xs:gYearMonth, xs:gMonth, xs:gMonthDay, xs:gDay
GDateValue.GDateComparable
GDateValue.MutableGDateValue
GDayValue	Implementation of the xs:gDay data type
GeneralComparison	GeneralComparison: a boolean expression that compares two expressions for equals, not-equals, greater-than or less-than.
GeneralComparison.ComparisonCardinality
GeneralComparison.GeneralComparisonElaborator	Elaborator for a general comparison expression such as (A = B).
GeneralComparison10	GeneralComparison10: a boolean expression that compares two expressions for equals, not-equals, greater-than or less-than.
GeneralComparison20	The class GeneralComparison20 specializes GeneralComparison for the case where the comparison is done with 2.0 semantics (i.e.
GeneralComparisonAdjunct	Watch factory class for a general comparison
GeneralComparisonEqualityFeed	This class is used when a streaming template requests a general comparison with one operand being pushed from the streamed input document, and the other being evaluated in pull mode.
GeneralComparisonInequalityFeed	This class is used when a streaming template requests a general comparison with one operand being pushed from the streamed input document, and the other being evaluated in pull mode; used when the operator is "!=" which means we only need to remember one value (the result is true as soon as we find two values that differ).
GeneralComparisonMinimaxFeed	This class is used when a streaming template requests a general comparison with one operand being pushed from the streamed input document, and the other being evaluated in pull mode.
GeneralComparisonOperand	Given an expression, this characteristic evaluates the set of hash keys corresponding to the string values of the items selected by that expression
GeneralEqualityEE	This class provides an implementation of the GeneralComparison "=" operator, which deals efficiently with comparing two sequences.
GeneralEqualityEE.GeneralEqualityElaboratorEE	Elaborator for a general comparison expression such as (A = B).
GeneralNodePattern	A GeneralNodePattern represents a pattern which, because of the presence of positional predicates or otherwise, can only be evaluated "the hard way", by evaluating the equivalent expression with successive ancestors of the tested node as context item.
GeneralPatternOptimizer	A PatternOptimizer is an agent responsible for optimizing a particular class of patterns.
GeneralPositionalPattern	A GeneralPositionalPattern is a pattern of the form A[P] where A is an axis expression using the child axis and P is an expression that depends on the position.
GenerateId_1	This class supports the generate-id() function with one argument
GenerateId_1.GenerateIdElaborator
GenericAtomicComparer	An AtomicComparer used for comparing atomic values of arbitrary item types.
GenericAtomicComparer.AtomicComparisonFunction	An AtomicComparisonFunction compares two atomic values to return a result of true or false.
GenericTreeInfo	A generic (model-independent) implementation of the TreeInfo interface, suitable for use with all tree models where the object representing the document node does not itself act as the TreeInfo implementation
Genre	The Genre of an item is the top-level classification of its item type: one of Atomic, Node, Function, Map, Array, or External
Gizmo	A Gizmo is a simple tool for performing a particular easily specified transformation on an XML document, for example deleting or renaming all the elements with a particular name.
GlobalContextRequirement	Information about the requirements placed by a query or stylesheet on the global context item: whether it is mandatory or optional, what its type must be, and whether it has a default value.
GlobalExtractor	This class is responsible for extracting global variables from subexpressions within a function or template
GlobalOrderComparer	A Comparer used for comparing nodes in document order.
GlobalParam	The compiled form of a global xsl:param element in an XSLT stylesheet or an external variable declared in the prolog of a Query.
GlobalParameterSet	A GlobalParameterSet is a set of parameters supplied when invoking a stylesheet or query.
GlobalVariable	A compiled global variable in a stylesheet or query.
GlobalVariableManager	This interface provides access to a collection of global variables.
GlobalVariableReference	A reference to a global variable
GlobalVariableReference.GlobalVariableReferenceElaborator	Elaborator for a global variable reference, for example $globalVar.
GMonthDayValue	Implementation of the xs:gYear data type
GMonthValue	Implementation of the xs:gMonth data type
GroundedItemFeed	An GroundedItemFeed is an ItemFeed in which decomposed document and element nodes (that is, start|end Document|Element events) are not accepted, and parentless leaf nodes supplied using methods such as GroundedItemFeed.characters(net.sf.saxon.str.UnicodeString, net.sf.saxon.s9api.Location, int) or Outputter.attribute(NodeName, SimpleType, String, Location, int) are converted into calls on ItemFeed.append(Item) supplying an Orphan item.
GroundedIterator	This interface is an extension to the SequenceIterator interface; it represents a SequenceIterator that is based on an in-memory representation of a sequence, and that is therefore capable of returning a Sequence containing all the items in the sequence.
GroundedValue	A value that exists in memory and that can be directly addressed
GroundedValueAsIterable	A class that wraps a GroundedValue as a Java Iterable
GroupAdjacentIterator	A GroupAdjacentIterator iterates over a sequence of groups defined by xsl:for-each-group group-adjacent="x".
GroupAdjacentTester	This class implements GroupingFeed when the group-adjacent option is used.
GroupBoundaryTester	This feed supports xsl:for-each-group in streaming mode.
GroupBreakingIterator	A GroupBreakingIterator iterates over a sequence of groups defined by xsl:for-each-group break-when="x".
GroupByClause	This class represents an "group by" clause in a FLWOR expression
GroupByClause.ObjectToBeGrouped	Inner class representing the contents of a tuple from the pre-grouping tuple stream; a set of such objects consitutes a group.
GroupByClause.TupleComparisonKey	Inner class representing a tuple comparison key: that is, an arbitrary object whose equals() and hashCode() methods can be used to test whether two tuples have equivalent grouping keys
GroupByClausePull	Represents the tuple stream delivered by an "group by" clause.
GroupByClausePush	Represents the tuple stream delivered by an "group by" clause.
GroupByIterator	A GroupByIterator iterates over a sequence of groups defined by xsl:for-each-group group-by="x".
GroupEndingIterator	A GroupEndingIterator iterates over a sequence of groups defined by xsl:for-each-group group-ending-with="x".
GroupEndingTester	This class implements GroupingFeed when the group-ending-with option is used.
GroupIterator	A GroupIterator is an iterator that iterates over a sequence of groups.
GroupMatchingIterator	A GroupMatchingIterator contains code shared between GroupStartingIterator and GroupEndingIterator
GroupStarting	This class supports the extension function saxon:group-starting.
GroupStartingIterator	A GroupStartingIterator iterates over a sequence of groups defined by xsl:for-each-group group-starting-with="x".
GroupStartingTester	This class implements GroupingFeed when the group-starting-with option is used.
GroupToBeSorted	This class is a specialization of ObjectToBeSorted for use when the sequence being sorted is a sequence of groups.
GYearMonthValue	Implementation of the xs:gYearMonth data type
GYearValue	Implementation of the xs:gYear data type
HasChildren_1	This class implements the function fn:has-children($node), which is a standard function in XPath 3.0
HashTrieMap	An immutable map.
HeadFn	This class implements the function fn:head(), which is a standard function in XPath 3.0
HexBinaryEmitter	This emitter implements output method saxon:hexBinary.
HexBinaryValue	A value of type xs:hexBinary
HexCharacterReferenceGenerator	A class that represents a character as a hexadecimal character reference and writes the result to a supplied Writer
HighestOrLowest	This class implements the saxon:highest() and saxon:lowest() extension functions.
HighestOrLowest	This class implements the saxon:highest() and saxon:lowest() extension functions.
History	The History object is used to avoid backtracking too far.
HomogeneityChecker	This class is an expression that does a run-time check of the result of a "/" expression to ensure that (a) the results consists entirely of atomic values and function items, or entirely of nodes, and (b) if the results are nodes, then they are deduplicated and sorted into document order.
HomogeneityChecker.HomogeneityCheckerElaborator	Elaborator for a homogeneity checker, which checks that the items in a sequence are either all nodes, or all non-nodes.
HomogeneityCheckerIterator	An iterator that returns the same items as its base iterator, checking to see that they are either all nodes, or all non-nodes; if they are all nodes, it delivers them in document order.
HostLanguage	Identifies a host language in which XPath expressions appear.
HTML40Emitter	This class generates HTML 4.0 output
HTML50Emitter	This class generates HTML 5.0 output
HTML5CaseBlindCollator	A collating sequence that compares strings according to the HTML5 rules for case-blind matching.
HTMLEmitter	This class generates HTML output
HTMLEntityReferenceGenerator	A class that represents a character as a decimal character reference and writes the result to a supplied Writer.
HTMLIndenter	HTMLIndenter: This ProxyReceiver indents HTML elements, by adding whitespace character data where appropriate.
HTMLIndenterPE	HTMLIndenter with extra functionality used by Saxon-PE and Saxon-EE
HTMLTagHashSet	A simple class for testing membership of a fixed set of case-insensitive ASCII strings.
HTMLURIEscaper	This class is used as a filter on the serialization pipeline; it performs the function of escaping URI-valued attributes in HTML
HyperType	Atomic types are the intersection of XPath item types and XSD simple types, and use multiple inheritance to inherit methods representing the characteristics of both these kinds.
IAccumulatorData	Holds the values of an accumulator function for one non-streamed document
ICompilerService	Marker interface representing a bytecode generation service
ICULibrary	Class to report whether ICU features are loaded.
ICUNumberer_de	A numberer for German using the ICU features, which supports variable ordinal suffixing, for example '-en', '-es'
ICUNumbererEnUnhyphenated	A numberer for English, using the ICU features, which produces space-separated word numbers, for example "Twenty Two" rather than the ICU default, which is hyphen-separated: "Twenty-Two".
ICUNumbererPE	A numberer using the ICU features, used principally for formatting numbers as words and day/month names
Idempotency
IdentityComparable	The IdentityComparable class provides a way to compare objects for strong equality.
IdentityComparison	IdentityComparison: a boolean expression that compares two nodes for equals, not-equals, greater-than or less-than based on identity and document ordering
IdentityComparison.IdentityComparisonElaborator	Elaborator for an identity comparison (operators is, <<, and >> )
IdentityConstraint	The base class for the XML Schema Identity Constraints (key, keyref, unique).
IdentityConstraintReference	A reference to an identity constraint
IdentityField	The field selector for an IdentityConstraint
IdentityFn	Implementation of the fn:identity function proposed for 4.0
IdentitySelector	The selector of an IdentityConstraint
IdentityTransformer	Saxon implementation of the JAXP IdentityTransformer.
IdentityTransformerHandler	IdentityTransformerHandler implements the javax.xml.transform.sax.TransformerHandler interface.
IDFilter	IDFilter is a ProxyReceiver that extracts the subtree of a document rooted at the element with a given ID value.
Idref
IdValidator	This class validates that ID elements and attributes have unique values and that IDREF and IDREFS elements and attributes refer to an ID in the same document.
IDynamicLoader	Interface to a class used to perform dynamic loading of classes such as user-hook implementations, as well as product-supplied resources like stylesheets and DTDs.
IgnorableSpaceStrippingRule	A whitespace stripping rule that strips whitespace text node children from all elements having an element-only content model, regardless of the value of the xml:space attribute
IgnorableWhitespaceStripper	The IgnorableWhitespaceStripper removes whitespace text nodes belonging to elements whose schema-defined type defines element-only content
ImmutableArrayItem	Implementation of ArrayItem backed by a persistent immutable array, so that operations that "update" the array do not have to copy the whole array
ImmutableHashTrieMap<K,V>
ImmutableList<T>	An immutable list implementation that only supports sequential traversal using an iterator, prepending an item to the start, and extraction of the head()/tail() of the list.
ImmutableMap<K,V>
ImportedFunctionLibrary	This implementation of FunctionLibrary contains all the functions imported into a Query Module.
IncrementalIterator	This class implements an AxisIterator by providing a start item, and a function that selects the next item as a function of the previous item.
IndentWhitespace	This class provides a compressed representation of a string used to represent indentation: specifically, an integer number of newlines followed by an integer number of spaces.
IndependentContext	An IndependentContext provides a context for parsing an XPath expression appearing in a context other than a stylesheet.
Index	This class supports the extension function saxon:index, which returns an indexed sequence
IndexedFilterExpression	An IndexedFilterExpression contains a base expression and a filter predicate.
IndexedStack<T>	This class replicates functionality that is available in a Java Stack, but not in a C# Stack, for example the ability to access elements by direct index (0-based, counting from the bottom of the stack).
IndexedValue	A representation of a (sequence) value that allows the construction of one or more indexes to provide rapid access to the items in the sequence.
IndexedVariableEvaluator	Evaluator for a variable that needs to be indexed, because the optimizer has identified that it will contain a sequence that is accessed using predicates based on the content Note, indexing is only used in Saxon-EE; the implementation in Saxon-HE is a dummy.
IndexOf	The XPath 2.0 index-of() function, with the collation already known
IndexOfStreamer	Generate streaming code for the index-of() function.
IndexWhere	The saxon:index-where() or fn:index-where extension function
Initializer	This interface can be implemented by users (there are no implementations in Saxon itself).
Innermost	This class implements the function fn:has-children(), which is a standard function in XPath 3.0
InputStreamMarker	Allows the position of an input stream to be marked and reset.
InScopeNamespacesFn	Implementation of the saxon:in-scope-namespaces extension function.
InScopePrefixes	This class implements the XPath 2.0 function fn:in-scope-prefixes()
InsertAction	A pending update action representing the effect of an insert expression
InsertAttributeAction	A pending update action representing the insert attribute action.
InsertBefore	The XPath 2.0 insert-before() function
InsertBefore.InsertIterator	Insertion iterator.
InsertBeforeStreamer	Implement streaming of insert-before instruction.
InsertExpression	An insert expression in XQuery Update
InSituValidator	This class performs in-situ validation of a tree represented in memory as a NodeInfo object.
InspectionAdjunct	Abstract superclass for constructs that have operand usage "inspection" on their primary (sequence-valued) operand
InstanceOfAdjunct	Generate streaming code for an "instance of" expression
InstanceOfExpression	InstanceOf Expression: implements "Expr instance of data-type"
InstanceOfExpression.InstanceOfElaborator	Elaborator for an instance of expression
Instantiator<T>	Interface representing a factory class for instantiating instances of a specific class
Instruction	Abstract superclass for all instructions in the compiled stylesheet.
InstructionWithComplexContent	Interface implemented by instructions that contain a sequence constructor evaluated using the rules for "constructing complex content": for example, xsl:element, xsl:copy, xsl:document, xsl:result-document
Instrumentation	Internal class used for instrumentation purposes.
Int64Value	An integer value: note this is a subtype of decimal in XML Schema, not a primitive type.
IntArraySet	Set of int values.
IntArraySet.IntArrayIterator	Iterator class: iterate over an array of integers
IntBlockSet	Set of int values.
IntComplementSet	An immutable integer set containing all int values except those in an excluded set
IntegerRange	This class represents a sequence of integers, for example 1 by 5 to 50.
IntegerRangeTest	An IntegerRangeTest is an expression of the form E = N to M where N and M are both expressions of type integer.
IntegerRangeTest.IntegerRangeTestElaborator
IntegerValue	This class represents the XPath built-in type xs:integer.
IntegratedFunctionCall	Expression representing a call to a user-written extension function implemented as a subtype of ExtensionFunctionCall
IntegratedFunctionCall.ConfigurationCheckingFunction	This class checks that NodeInfo objects returned by an extension function were created under the right Configuration
IntegratedFunctionLibrary	A library of integrated function calls, that is, user-written extension functions implemented as instances of the class ExtensionFunctionDefinition.
IntEmptySet	An immutable integer set containing no integers
IntEqualityPatternOptimizer	A PatternOptimizer is an agent responsible for optimizing a particular class of patterns.
IntersectionIterator	An enumeration representing a nodeset that is an intersection of two other NodeSets.
IntersectPattern	A pattern formed as the difference of two other patterns
Intersperse	The proposed XPath 4.0 intersperse() function
IntExceptPredicate	An IntPredicate formed as the difference of two other predicates: it matches an integer if the first operand matches the integer and the second does not
IntHashMap<T>	A hash table that maps int keys to Object values.
IntHashSet	Set of int values.
IntIntersectionPredicate	An IntPredicate formed as the union of two other predicates: it matches an integer if either of the operands matches the integer
IntIterator	An iterator over a sequence of unboxed int values.
IntPredicateLambda	This class allows an integer predicate (a boolean function of an integer) to be written as a lambda expression, in a way that works both in Java and C#.
IntPredicateProxy	This interface represents an integer predicate (that is, a boolean function of an integer).
IntRangeSet	Set of int values.
IntRangeToIntMap	Set of int values.
IntRepeatIterator	An iterator over a single integer repeated a fixed number of times
IntSet	A set of integers represented as int values
IntSetCharacterClass	A character class represents a set of characters for regex matching purposes.
IntSetPredicate	An implementation of IntPredicate that tests whether a given integer is a member of some IntSet
IntSingletonIterator	An iterator over a single integer
IntSingletonSet	An immutable integer set containing a single integer
IntStepIterator	An iterator over a sequence of integers with regular steps, e.g.
IntToIntArrayMap	An implementation of IntToIntMap that relies on serial searching, and is therefore optimized for very small map sizes
IntToIntHashMap	A hash table that maps int keys to int values.
IntToIntMap	Interface defining a map from integers to integers
IntUnionPredicate	An IntPredicate formed as the union of two other predicates: it matches an integer if either of the operands matches the integer
IntUniversalSet	An immutable integer set containing every integer
IntValuePredicate	An IntPredicate that matches a single specific integer
Invalidity	An Invalidity is a validation error, that is, a failure of the instance document to conform to the schema being used for validation.
InvalidityHandler	Interface for reporting validation errors found during validation of an instance document against a schema.
InvalidityHandlerWrappingErrorListener	Interface for reporting validation errors found during validation of an instance document against a schema.
InvalidityHandlerWrappingErrorReporter	Interface for reporting validation errors found during validation of an instance document against a schema.
InvalidityReportGenerator	This class InvalidityReportGenerator extends the standard error handler for errors found during validation of an instance document against a schema, used if user specifies -report option on validate.
InvalidityReportGeneratorEE	This class InvalidityReportGenerator extends the standard error handler for errors found during validation of an instance document against a schema, used if user specifies -report option on validate.
InverseCharacterClass	A character class represents a set of characters for regex matching purposes.
Inversion	This class represents an expression that has been "inverted" (in the Jackson sense) so that its execution is push-driven, that is, driven by events from the streamed document.
Inversion.PushAction	A PushAction is a collection of data that together represents the strategy for how an expression should be evaluated in push mode.
IPackageLoader
IriToUri	This class supports the functions encode-for-uri() and iri-to-uri()
IrregularGroupFormatter	Handles grouping separators when formatting a number in cases where the grouping separators are not at regular intervals
IsIdRef	This class implements the saxon:is-idref() extension function, which is specially-recognized by the system because calls are generated by the optimizer.
IsLastExprAdjunct
IsLastExpression	A position() eq last() expression, generated by the optimizer.
IsLastExpression.IsLastElaborator	Elaborator for an "isLast" expression, equivalent to position() = last() or position() != last()
IsNaN	Implements the saxon:is-NaN() function.
ISO88591CharacterSet	This class defines properties of the ISO-8859-1 character set
Item	An Item is an object that can occur as a member of a sequence.
ItemChecker	A ItemChecker implements the item type checking of "treat as": that is, it returns the supplied sequence, checking that all its items are of the correct type.
ItemChecker.ItemCheckerElaborator	Elaborator for a treat as expression, which is usually system-generated by the type checking phase of the compiler
ItemCheckerAdjunct	Streaming code for an item checker
ItemCheckingFeed	A Feed to go on the streaming pipeline that checks the item type of the items in the sequence represented by the events passing down the pipeline.
ItemCheckingIterator	ItemCheckingIterator applies a supplied function to each item in a sequence.
ItemConsumer<T extends Item>	A FunctionalInterface for any method that processes individual items, and which may generate exceptions.
ItemElaborator	An ItemElaborator is an abstract superclass for use by expressions that deliver zero or one items as their result.
ItemEvaluator	Interface implemented by classes that evaluate an expression to deliver a single item
ItemFeed	An ItemFeed evaluates an expression in "composed push" mode.
ItemFilter	ItemMapper is an implementation of ItemMappingFunction that wraps a predicate function typically supplied as a lambda expression: unlike a standard Predicate, however, the test is allowed to throw an XPathException.
ItemFilter.Lambda
ItemMapper	ItemMapper is an implementation of ItemMappingFunction that wraps a function typically supplied as a lambda expression.
ItemMapper.Lambda
ItemMappingFeed	A Feed which applies an ItemMappingFunction to each supplied item.
ItemMappingFunction	ItemMappingFunction is an interface that must be satisfied by an object passed to a ItemMappingIterator.
ItemMappingIterator	ItemMappingIterator applies a mapping function to each item in a sequence.
ITemplateCall	An interface satisfied by all instructions that invoke templates: apply-templates, call-template.
ItemsAfterStreamer	Generate streaming code for the saxon:items-after function.
ItemsAt	Implements the XPath 4.0 items-at() function
ItemsBeforeStreamer	Generate streaming code for the saxon:items-before function.
ItemsEnding	This class supports the two extension functions saxon:items-until and saxon:items-before, also available as experimental XPath 4.0 functions in the fn namespace.
ItemsEnding.ItemsBefore
ItemsEnding.ItemsUntil
ItemsFromStreamer	Generate streaming code for the saxon:items-from function.
ItemsStarting	This class supports the two extension functions saxon:items-from and saxon:items-after, also available as experimental XPath 4.0 functions in the fn namespace.
ItemsStarting.ItemsAfter
ItemsStarting.ItemsFrom
ItemsUntilStreamer	Generate streaming code for the saxon:items-until function.
ItemToBeSorted	This class is a specialization of class ObjectToBeSorted for use when the sequence being sorted is a sequence of items (including tuples, which are represented as items).
ItemType	An item type, as defined in the XPath/XQuery specifications.
ItemType	ItemType is an interface that allows testing of whether an Item conforms to an expected type.
ItemType.BuiltInAtomicItemType	ItemType representing a built-in atomic type
ItemTypeCheckingFunction	A mapping function for use in conjunction with an ItemMappingIterator that checks that all the items in a sequence are instances of a given item type
ItemTypeFactory	This class is used for creating ItemType objects.
ItemTypePattern	An ItemTypePattern is a pattern that consists simply of an ItemType; although a node test is an item type, this class is used only for non-node item types, such as atomic types, map types, array types etc.
ItemTypeWithSequenceTypeCache	Extension of the ItemType interface implemented by some item types, to provide a cache of SequenceType objects based on this item type, with different occurrence indicators.
ItemWithMergeKeys	A class representing an item together with its merge keys and the name of the merge source object from which it derived, suitable for encapsulation as an ObjectValue.
IterateAction	This watch implements xsl:iterate in streaming mode.
IterateAdjunct	Implement streaming code for xsl:iterate
IterateInstr	An IterateInstr is the compiled form of an xsl:iterate instruction
IterateInstr.IterateElaborator
IterateWhileFn	This class implements the function fn:iterate-while(), which is a proposed function for XPath 4.0
IteratorWrapper	Class IteratorWrapper - provides a SequenceIterator over a Java Iterator.
IXSLElementFactory	Class IXSLElementFactory.
IXSLFunctionSet	The IXSLFunctionSet represents additions to the set of Saxon vendor-supplied extension functions that are available on SaxonJS.
IXSLFunctionSet.Call
IXSLFunctionSet.Eval
IXSLFunctionSet.ScheduleActionFn
IXSLFunctionSet.Source
IXSLFunctionSet.Stub	Most of the functions in this library will only run in SaxonJS, some of them only in the browser
IXSLPromise	Handler for ixsl:promise elements in stylesheet.
IXSLRemoveAttribute	Handler for ixsl:remove-attribute elements in stylesheet.
IXSLRemoveProperty	Handler for ixsl:remove-property elements in stylesheet.
IXSLScheduleAction	Handler for ixsl:schedule-action elements in stylesheet.
IXSLSetAttribute	Handler for ixsl:set-attribute elements in stylesheet.
IXSLSetProperty	Handler for ixsl:set-property elements in stylesheet.
IXSLSetStyle	Handler for ixsl:set-style elements in stylesheet.
JarCollection	A JarCollection represents a collection of resources held in a JAR or ZIP archive, accessed typically using a URI using the (Java-defined) "jar" URI scheme, or simply a "file" URI where the target file is a JAR or ZIP file.
JavaCharacterSet	This class establishes properties of a character set that is known to the Java VM but not specifically known to Saxon.
JavaCollationFactory	A JavaCollationFactory allows a Collation to be created given a set of properties that the collation should have.
JavaExtensionFunctionCall	This class acts as a container for an extension function defined to call a method in a user-defined class.
JavaExtensionFunctionFactory	This class acts as a factory for creating expressions that call Java extension functions.
JavaExtensionLibrary	The JavaExtensionLibrary is a FunctionLibrary that binds XPath function calls to calls on Java methods (or constructors, or fields).
JavaExternalObjectType	This class represents the type of an external Java object returned by an extension function, or supplied as an external variable/parameter.
JavaLocalizerFactory	Default factory for number/date localizers for the Java platform
JavaPlatform	Implementation of the Platform class containing methods specific to the Java platform (as distinct from .NET).
JavaPlatformEE	Implementation of the Platform class containing methods specific to the Java platform (as distinct from .NET) for Saxon-EE.
JavaPlatformPE	Implementation of the Platform class containing methods specific to the Java platform (as distinct from .NET) for Saxon-PE and Saxon-EE.
JavaRegularExpression	An implementation of RegularExpression that calls the JDK regular expression library directly.
JavaVerifier
JAXPVariableReference	This class represents a variable in an XPath expression compiled using the JAXP XPath API.
JAXPVariableReference.CallableElaborator
JAXPXPathStaticContext	A JAXPXPathStaticContext provides a context for parsing an XPath expression in a context other than a stylesheet.
JDOM2DocumentWrapper	The tree information for a tree acting as a wrapper for a JDOM2 Document.
JDOM2NodeWrapper	A node in the XML parse tree representing an XML element, character content, or attribute.
JDOM2ObjectModel	This interface must be implemented by any third-party object model that can be wrapped with a wrapper that implements the Saxon Object Model (the NodeInfo interface).
JDOM2Query	Variant of command line net.sf.saxon.Transform do build the source document in JDOM2 and then proceed with the transformation.
JDOM2Transform	Variant of command line net.sf.saxon.Transform do build the source document in JDOM2 and then proceed with the transformation.
JDOM2Writer	JDOMWriter is a Receiver that constructs a JDOM2 document from the stream of events
JLine2Talker	Handles terminal interaction for Gizmo using the JLine2 library: https://github.com/jline/jline2
JLine2Talker.XPathCompleter
JPConverter	This class together with its embedded subclasses handles conversion from Java values to XPath values.
JPConverter.ExternalObjectWrapper
JPConverter.FromBigDecimal
JPConverter.FromBigInteger
JPConverter.FromBoolean
JPConverter.FromBooleanArray
JPConverter.FromByte
JPConverter.FromByteArray
JPConverter.FromCharacter
JPConverter.FromCharArray
JPConverter.FromCollection
JPConverter.FromDate
JPConverter.FromDouble
JPConverter.FromDoubleArray
JPConverter.FromFloat
JPConverter.FromFloatArray
JPConverter.FromInstant
JPConverter.FromInt
JPConverter.FromIntArray
JPConverter.FromLocalDate
JPConverter.FromLocalDateTime
JPConverter.FromLong
JPConverter.FromLongArray
JPConverter.FromObject
JPConverter.FromObjectArray
JPConverter.FromOffsetDateTime
JPConverter.FromQName
JPConverter.FromSequence
JPConverter.FromSequenceIterator
JPConverter.FromShort
JPConverter.FromShortArray
JPConverter.FromSource
JPConverter.FromString
JPConverter.FromUnicodeString
JPConverter.FromURI
JPConverter.FromXdmValue
JPConverter.FromZonedDateTime
JPConverter.VoidConverter
JRegexIterator	Class JRegexIterator - provides an iterator over matched and unmatched substrings.
JSFunctionLibrary	The JSFunctionLibrary is a FunctionLibrary that binds XPath function calls to calls on JavaScript methods.
JsonBuilder	A JsonBuilder is used to parse JSON documents
JsonDoc	Implements the json-to-xml function defined in XSLT 3.0.
JSONEmitter	This class implements the back-end text generation of the JSON serialization method.
JsonHandler	Default handler class for accepting the result from parsing JSON strings
JsonHandlerMap	Event handler for the JSON parser which constructs a structure of maps and arrays representing the content of the JSON text.
JsonHandlerXML	Handler to generate an XML representation of JSON from a series of events
JsonParser	Parser for JSON, which notifies parsing events to a JsonHandler
JsonParser.JsonToken
JsonReceiver	A Receiver which receives a stream of XML events using the vocabulary defined for the XML representation of JSON in XSLT 3.0, and which generates the corresponding JSON text as a string
JSONResource	A Resource (that is, an item in a collection) holding JSON content
JSONSerializer	This class implements the JSON serialization method defined in XSLT+XQuery Serialization 3.1.
JsonToXMLFn	Implements the json-to-xml function defined in XSLT 3.0.
JTokenIterator	A JTokenIterator is an iterator over the strings that result from tokenizing a string using a regular expression, in this case a regular expression evaluated using the JDK regex engine
Key	A class that represents the XML Schema Identity Constraint: Key.
KeyDefinition	Corresponds to a single xsl:key declaration.
KeyDefinitionSet	A set of xsl:key definitions in a stylesheet that share the same name
KeyFn
KeyIndex	A key index is an index maintained to support xsl:key key definitions, including both user-defined keys and keys added by the optimizer.
KeyIndex.Status
KeyManager	KeyManager manages the set of key definitions in a stylesheet, and the indexes associated with these key definitions.
KeyMap	Implementation of the saxon:key-map() extension function.
KeyRef	This class represents an xs:keyRef identity constraint in a schema
KeySelectorWatch	This class watches the selector for a key or unique constraint
KeyValuePair	A key and a corresponding value to be held in a Map.
LambdaCallable	A generic interface for calling expressions by supplying the values of their subexpressions
Lang
LargeAttributeMap	An implementation of AttributeMap suitable for larger collections of attributes (say, more than five).
LargeTextBuffer	The segments (other than the last) have a fixed size of 65536 codepoints, which may use one byte per codepoint, two bytes per codepoint, or three bytes per codepoint, depending on the largest codepoint present in the segment.
LastItemExpression	A LastItemExpression returns the last item in the sequence returned by a given base expression.
LastItemExpression.LastItemExprElaborator	Elaborator for a "last item expression" (typically SEQ[last()])
LastModified	Extension function to determined the last-modified date of a file
LastPositionFinder	A LastPositionFinder is an interface implemented by any SequenceIterator that is able to return the position of the last item in the sequence.
LastStreamer
LaxValidator	This class performs lax validation on an element.
LazyPullEvaluator	SequenceEvaluator that evaluates an expression lazily in pull mode; that is, it delivers a LazySequence which defers actual evaluation until the value is actually needed.
LazySequence	A sequence that wraps an iterator, without being materialized.
Leading	This class implements the saxon:leading() extension functions.
LearningEvaluator	A LearningEvaluator initially performs lazy incremental evaluation of an expression; but if this proves unproductive, it switches after a while to eager evaluation.
LengthFacet	Represents the length facet
LengthRangeFacet	Abstract class for the three facets length, minLength, and maxLength.
LetClause	A "let" clause in a FLWOR expression
LetClausePull	Implements the changes to a tuple stream effected by the Let clause in a FLWOR expression
LetClausePush	Implements the changes to a tuple stream effected by the Let clause in a FLWOR expression
LetExpression	A LetExpression represents the XQuery construct let $x := expr return expr.
LetExpression.LetExprElaborator	Elaborator for a let expression (either let $x := SELECT return ACTION in XPath, or the equivalent sequence constructor using local xsl:variable declarations in XSLT).
LetExpressionAdjunct	Compiles streaming code to implement a Let expression
LetExpressionAdjunctB	Compiles streaming code to implement a Let expression for which the "action" part (the return clause) is consuming
LFUCache<K,V>	A "Least Frequently Used" cache.
LicenseException	Exception thrown when there are problems with the license file
LineNumberMap	Line numbers are not held in nodes in the tree, because they are not usually needed.
LinkedBuilderMonitor	Monitor construction of a document tree.
LinkedTreeBuilder	The LinkedTreeBuilder class is responsible for taking a stream of Receiver events and constructing a Document tree using the linked tree implementation.
ListCastableFunction	A function item representing a castability test for a list type
ListConstructorFunction	A function item representing a constructor function for a list type
ListIterator	Class ListIterator, iterates over a sequence of items held in a Java List.
ListIterator.Of<T extends Item>
ListIterator.OfAtomic<A extends AtomicValue>	ListIterator.OfAtomic is a subclass of ListIterator where the list always contains atomic values; it therefore implements the AtomicIterator interface.
ListType	Interface representing a simple type of variety List
Literal	A Literal is an expression whose value is constant: it is a class that implements the Expression interface as a wrapper around a GroundedValue.
Literal.LiteralElaborator	Elaborator for a literal.
LiteralAdjunct	Streamed evaluation of a literal (not difficult!)
LiteralEvaluator	A SequenceEvaluator for literals.
LiteralResultElement	This class represents a literal result element in the style sheet (typically an HTML element to be output).
LoadXqueryModule	This class implements the function load-xquery-module(), which is a standard function in XPath 3.1.
Loc	Class to hold details of the location of an expression, of an error in a source file, etc.
LocalBinding	Binding for local variables and parameters: anything that is allocated a slot on the XPathContext stack frame.
LocalizerFactory	Interface allowing localization modules for different languages to be dynamically loaded
LocalName_1	This class supports the local-name() function
LocalName_1.LocalNameElaborator
LocalNameTest	NodeTest is an interface that enables a test of whether a node has a particular name and type.
LocalOrderComparer	A Comparer used for comparing nodes in document order.
LocalParam	The compiled form of an xsl:param element within a template in an XSLT stylesheet.
LocalParam.LocalParamElaborator	The Elaborator for this kind of expression
LocalParamBlock	Represents the set of xsl:param elements at the start of an xsl:iterate instruction
LocalParamBlock.LocalParamBlockElaborator
LocalUnionType	A class that represents a union type declared locally, for example using the (Saxon-extension) item-type syntax union(a,b,c), or internally in Java code.
LocalVariableBinding	Represents the defining occurrence of a variable declared within a FLWOR expression, for example the $p in "for $x at $p in ...".
LocalVariableEvaluator
LocalVariableReference	Variable reference: a reference to a local variable.
LocalVariableReference.LocalVariableReferenceElaborator	Elaborator for a local variable reference, for example $var.
Locatable	Represents a construct that has a meaningful location for use in diagnostics
Location	Saxon interface to represent a location, typically the location of an expression within a query or stylesheet.
LocationCopier	A Receiver that can be inserted into an event pipeline to copy location information.
Locksmith
Logger	Interface to diagnostic event logging mechanism.
LookaheadIterator	A SequenceIterator is used to iterate over a sequence.
LookaheadIteratorImpl	This class wraps any sequence iterator, turning it into a lookahead iterator, by looking ahead one item
LookupAllExpression	A lookup expression is an expression of the form A?*, where A must be a map or an array
LookupAllExpression.LookupAllElaborator
LookupExpression	A lookup expression is an expression of the form A?B.
LookupExpression.LookupElaborator
LoopLifter	Class to handle loop-lifting optimization, that is, extraction of subexpressions appearing within a loop when there is no dependency on the controlling variable of the loop.
LowerCase	This class implements the fn:lower-case() function
LowerCase.LowerCaseFnElaborator
LSSchemaResolver	This class is a SchemaURIResolver implemented as a wrapper around a JAXP LSResourceResolver
Mailer2	Helper class for saxon:send-mail() extension function
Maker<T>	Interface representing a factory class for instances of a specific type.
ManualGroupIterator	The class ManualGroupIterator represents an iterator that is never repositioned, but can be used to represent the focus in the dynamic context.
ManualIterator	ManualIterator: a pseudo-iterator used while streaming.
ManualRegexIterator	The class ManualRegexIterator represents an iterator that is never repositioned, but can be used to represent the current regex groups in the dynamic context.
MapCreate	This is a variant of the map:new() or map:merge() function which differs in that duplicate keys are considered an error.
MapEntryStreamer	Streaming code to implement an xsl:map instruction or map constructor, where each map entry is allowed to be consuming.
MapFunctionSet	Function signatures (and pointers to implementations) of the functions defined in the map namespace in XPath 3.1
MapFunctionSet.MapBuild	Implementation of the proposed XPath 4.0 function map:build($sequence, $key, $value, $combined) as xs:anyAtomicType) => map(*)
MapFunctionSet.MapContains	Implementation of the XPath 3.1 function map:contains(Map, key) => boolean
MapFunctionSet.MapEntries	Implementation of the proposed 4.0 function map:entries(Map) => map(*)*
MapFunctionSet.MapEntry	Implementation of the extension function map:entry(key, value) => Map
MapFunctionSet.MapFilter	Implementation of the proposed XPath 4.0 function map:filter(Map, function(*)) => Map
MapFunctionSet.MapFind	Implementation of the XPath 3.1 function map:find(item()*, key) => array
MapFunctionSet.MapForEach	Implementation of the function map:for-each(Map, Function) => item()*
MapFunctionSet.MapGet	Implementation of the XPath 3.1 function map:get(Map, key) => value
MapFunctionSet.MapKeys	Implementation of the XPath 3.1 function map:keys(Map) => atomicValue*
MapFunctionSet.MapMerge	Implementation of the function map:merge() => Map From 9.8, map:merge is also used to implement map constructors in XPath and the xsl:map instruction in XSLT.
MapFunctionSet.MapOfPairs	Implementation of the function map:of-pairs() => Map
MapFunctionSet.MapPair	Implementation of the proposed 4.0 function map:pair(key, value) => record(key, value)
MapFunctionSet.MapPairs	Implementation of the proposed 4.0 function map:pairs(Map) => record(key, value)*
MapFunctionSet.MapPut	Implementation of the extension function map:put() => Map
MapFunctionSet.MapRemove	Implementation of the XPath 3.1 function map:remove(Map, key) => value
MapFunctionSet.MapSize	Implementation of the extension function map:size(map) => integer
MapItem	Interface supported by different implementations of an XDM map item
MappingFunction	MappingFunction is an interface that must be satisfied by an object passed to a MappingIterator.
MappingIterator	MappingIterator merges a sequence of sequences into a single flat sequence.
MappingJavaIterable<S,T>	A Java Iterable which applies a mapping function to each item in a supplied Iterable
MappingJavaIterator<S,T>	A Java Iterator which applies a mapping function to each item in an input sequence
MapSearch	The saxon:map-search function, new in Saxon 9.9
MapType	An instance of this class represents a specific map item type, for example map(x:integer, element(employee))
MapUntypedContains	Implementation of an internal function map:untyped-contains(Map, key) => boolean, which is like map:contains except that if the supplied key is untyped atomic, it is converted to all the possible types present in the map and returns true if the key after conversion is present.
Matches	This class implements the 3-argument matches() function for regular expression matching
Matches.MatchesFnElaborator
Math	This class implements extension functions in the http://exslt.org/math namespace.
MathFunctionSet	Abstract class providing functionality common to functions math:sin(), math:cos(), math:sqrt() etc; contains the concrete implementations of these functions as inner subclasses
MathFunctionSet.Atan2Fn	Implement math:atan2
MathFunctionSet.PiFn	Implement math:pi
MathFunctionSet.PowFn	Implement math:pow
MathFunctionSet.TrigFn1	Generic superclass for all the arity-1 trig functions
MaxExclusiveFacet	Implements the maxExclusive facet on a simple type
MaxInclusiveFacet	Implements the maxInclusive facet on a simple type
MaxLengthFacet	Represents the minLength facet
MemoClosure	A MemoClosure represents a value that has not yet been evaluated: the value is represented by an expression, together with saved values of all the context variables that the expression depends on.
MemoClosureEvaluator	A MemoClosureEvaluator is a SequenceEvaluator that evaluates an expression lazily and incrementally; it evaluates new items in the result as and when they are needed.
MemoFunction	A user-defined function that is declared as a memo function, meaning that it remembers results of previous calls.
MemoFunction.NodeSurrogate	A NodeSurrogate is a value that represents a node; it encapsulates a Java function that can be called to test whether a particular node is the one that it represents.
MemoSequence	A Sequence implementation that represents a lazy evaluation of a supplied iterator.
MemoSequence.ProgressiveIterator	A ProgressiveIterator starts by reading any items already held in the reservoir; when the reservoir is exhausted, it reads further items from the inputIterator, copying them into the reservoir as they are read.
MergeGroupingIterator	An iterator that groups the result of merging several xsl:merge input streams, identifying groups of adjacent items having the same merge key value
MergeInstr
MergeInstr.MergeKeyMappingFunction	Mapping function for items encountered during the merge; the mapping function wraps the merged item and its merge keys into a single composite object
MergeInstr.MergeSource	Inner class representing one merge source
MergeInstrAdjunct	Streaming adjunct for the xsl:merge instruction.
MergeInstrAdjunct.MergePusher
MergeIterator	An iterator representing the sorted merge of two merge inputs, retaining all duplicates.
Message	A Message represents the output of an xsl:message or xsl:assert instruction.
MessageCount	This class implements the saxon:message-count() function which returns the value of message counters at the moment of execution
MessageEmitter	MessageEmitter is the default Receiver for xsl:message output.
MessageInstr	An xsl:message or xsl:assert element in the stylesheet.
MessageListener	A user-written implementation of the MessageListener interface may be registered with the XsltTransformer to receive notification of xsl:message output.
MessageListener2	Deprecated.
MessageWarner	MessageWarner is a user-selectable receiver for XSLT xsl:message output.
MetadataResource	Represents information about a resource, as well as a pointer to the resource itself
MetaTagAdjuster	The MetaTagAdjuster adds a meta element to the content of the head element, indicating the required content type and encoding; it also removes any existing meta element containing this information
MinExclusiveFacet	Implements the minExclusive facet on a simple type
Minimax	This class implements the min() and max() functions, with the collation argument already known.
Minimax.Max	Concrete subclass to define the fn:max() function
Minimax.Min	Concrete subclass to define the fn:min() function
MinimaxStreamer	Generate streaming code for the min() and max() functions.
MinInclusiveFacet	Implements the minInclusive facet on a simple type
MinLengthFacet	Represents the minLength facet
MissingComponentException	This exception occurs when an attempt is made to dereference a reference from one schema component to another, if the target of the reference cannot be found.
MissingComponentExceptionImpl	This exception occurs when an attempt is made to dereference a reference from one schema component to another, if the target of the reference cannot be found.
Mode	A Mode is a collection of rules; the selection of a rule to apply to a given element is determined by a Pattern.
Mode.RuleAction	Interface for helper classes used to process all the rules in the Mode
Mode.RuleFilter	Interface for helper classes used to filter a chain of rules
ModeEE	A version of class Mode that optimizes various aspects of the template patterns, most notably supporting rule preconditions and indexation of unnamed elements.
ModeEE.RuleChainOptimizationData
ModelGroup	An XML Schema Model Group.
ModelGroupDefinition	A Model Group Definition: a schema component corresponding to a top-level (named) xs:group element in a schema document.
ModelGroupParticle	A reference within the content model of a complex type to a Model Group Definition.
ModePE	The Mode class for use in Saxon-PE, which may contain additional XSLT3.0 features This is subclassed in Saxon-EE to add optimisation features
ModuleURIResolver	A ModuleURIResolver is used when resolving references to query modules.
MonoIterator<T>	An iterator over a single object (typically a sub-expression of an expression)
MonotonicIntSet	Set of int values.
MotionlessFeed	A feed for an expression that typically accesses the context item but does not consume the input stream.
MultiAccumulatorWatch	This watch managers a set of accumulators in streaming mode.
MultiIndex	A MultiIndex provides fast access to the items in a sequence.
MultiIndex.SelectedItemsIterator	Iterator over a subset of the items in this IndexedValue, identified by an IntSet holding the positions of the items in the selected subset (zero-based)
MultipleNodeKindTest	An MultipleNodeKindTest is a nodetest that matches nodes belonging to any subset of possible node kinds, for example element and document nodes, or attribute and namespace nodes
MultithreadedContextMappingIterator	This class performs the same role as ContextMappingIterator, but using multiple threads.
MultithreadedFocusTrackingIterator	This is a thread-safe version of the parent class FocusTrackingIterator.
MultithreadedForEach	This instruction represents an xsl:for-each instruction using more than one thread
MultithreadedForEach.MultithreadedForEachElaborator
MultithreadedItemMappingIterator	Parallel-processing version of the ItemMappingIterator class, which executes a mapping function for each item in a sequence.
MultithreadingFactory	This class defines a number of methods that support the use of multi-threading in Saxon.
MutableDocumentInfo	Interface representing the document node of a mutable document
MutableNodeInfo	An extension of the NodeInfo interface defining a node that can be updated.
Name_1	This class supports the name() function with one argument
Name_1.NameElaborator
NameChecker	The NameChecker performs validation and analysis of XML names.
NamedTemplate	The runtime object corresponding to a named xsl:template element in the stylesheet.
NamedTemplate.LocalParamInfo
NamedTimeZone	This class attempts to identify a timezone name, given the date (including the time zone offset) and the country.
NameOfNode	An implementation of NodeName that gets the name of an existing NodeInfo object.
NamePool	A NamePool holds a collection of expanded names, each containing a namespace URI, and a local name.
NamePool.NamePoolLimitException	Unchecked Exception raised when some limit in the design of the name pool is exceeded
NamePoolConverter	This class is a filter that passes all Receiver events through unchanged, except that it changes namecodes to allow for the source and the destination using different NamePools.
NamespaceBinding	Represents the binding of a prefix to a URI.
NamespaceBindingSet	Represents a set of namespace bindings
NamespaceConstant	This class is not instantiated, it exists to hold a set of constants representing known namespaces.
NamespaceConstructor	A namespace constructor instruction.
NamespaceContextImpl	This class bridges between the JAXP 1.3 NamespaceContext interface and Saxon's equivalent NamespaceResolver interface.
NamespaceDeltaMap	Holds a set of namespace bindings as a simple immutable map from prefixes to URIs.
NamespaceDifferencer	NamespaceDifferencer is a ProxyReceiver responsible for removing duplicate namespace declarations.
NamespaceForPrefix	This class supports the function namespace-uri-for-prefix()
NamespaceMap	Holds a set of namespace bindings as a simple immutable map from prefixes to URIs.
NamespaceNode	This class represents a namespace node; it is used in several tree models.
NamespaceReducer	NamespaceReducer is a ProxyReceiver responsible for removing duplicate namespace declarations.
NamespaceResolver	Abstract class that supports lookup of a lexical QName to get the expanded QName.
NamespaceResolverWithDefault	This class is a NamespaceResolver that modifies an underyling NamespaceResolver by changing the mapping of the null prefix to be a specified namespace, rather than the one used by the underlying namespace resolver.
NamespaceTest	NodeTest is an interface that enables a test of whether a node has a particular name and type.
NamespaceUri	This class represents a URI used as a namespace name.
NamespaceUriFn_1	This class supports the namespace-uri() function
NamespaceUriFn_1.NamespaceUriFnElaborator	Elaborator for the namespace-uri() function
NameTest	NodeTest is an interface that enables a test of whether a node has a particular name and type.
NameTestUnion	NameTestUnion is new in XPath 4.0.
Navigator	The Navigator class provides helper classes for navigating a tree, irrespective of its implementation
Navigator.AncestorEnumeration	General-purpose implementation of the ancestor and ancestor-or-self axes
Navigator.AxisFilter	AxisFilter is an iterator that applies a NodeTest filter to the nodes returned by an underlying AxisIterator.
Navigator.ChildrenAsIterable	A class that delivers the children of a node as a Java Iterable
Navigator.DescendantEnumeration	General-purpose implementation of the descendant and descendant-or-self axes, in terms of the child axis.
Navigator.EmptyTextFilter	EmptyTextFilter is an iterator that applies removes any zero-length text nodes returned by an underlying AxisIterator.
Navigator.FollowingEnumeration	General purpose implementation of the following axis, in terms of the ancestor, child, and following-sibling axes
Navigator.PrecedingEnumeration	Helper method to iterate over the preceding axis, or Saxon's internal preceding-or-ancestor axis, by making use of the ancestor, descendant, and preceding-sibling axes.
Negatable	This interface is implemented by expressions that returns a boolean value, and returns an expression whose result is the negated boolean value
NegateExpression	Negate Expression: implements the unary minus operator.
NegateExpression.NegateElaborator	Elaborator for a negate expression (that is, unary minus)
NestedIntegerValue	This class represents a dot-separated sequence of numbers such as 1.12.5, typically used as a software version number.
NewAttribute	Implements the saxon:new-attribute() function.
NewComment	Implements the saxon:new-comment() function.
NewDocument	Implements the saxon:new-text() function.
NewElement	Implements the saxon:new-text() function.
NewMapStreamer	Streaming code to implement an xsl:map instruction or map constructor, where each map entry is allowed to be consuming.
NewNamespace	Implements the saxon:new-namespace() function.
NewProcessingInstruction	Implements the saxon:new-processing-instruction() function.
NewText	Implements the saxon:new-text() function.
NextIteration	Implements a xsl:next-iteration instruction within the body of xsl:iterate
NextIteration.NextIterationElaborator
NextIterationAdjunct	Compile a xsl:next-intruction instruction to streaming code.
NextIterationFeed	This class is used when one of the xsl:with-param elements within an xsl:next-iteration of an xsl:iterate consumes the streamed input
NextMatch	An xsl:next-match element in the stylesheet
NextMatchAction	Watch for an xsl:next-match instruction.
NextMatchAdjunct	Compile an xsl:next-match expression/instruction to streaming code.
Nilled_1	This class supports the nilled() function
NoCloseFeed	This feed suppresses the call on close().
NodeFactory	Interface NodeFactory.
NodeImpl	A node in the "linked" tree representing any kind of node except a namespace node.
NodeInfo	The NodeInfo interface represents a node in Saxon's implementation of the XPath 2.0 data model.
NodeKindTest	NodeTest is an interface that enables a test of whether a node has a particular name and kind.
NodeListIterator	Class ListIterator, iterates over a sequence of items held in a Java List.
NodeName	This interface represents a node name.
NodeName_1	This class supports the node-name() function with a single argument
NodeName_1.NodeNameFnElaborator	Elaborator for the fn:node-name() function
NodeOverNodeInfo	This class implements the DOM Node interface as a wrapper around a Saxon NodeInfo object.
NodePredicate	Interface representing a predicate applied to a node.
NodeSelector	A NodeTest that wraps a general Predicate applied to nodes.
NodeSetPattern	A NodeSetPattern is a pattern based on an expression that is evaluated to return a set of nodes; a node matches the pattern if it is a member of this node-set.
NodeSource	A JAXP Source object representing a Saxon NodeInfo.
NodeTest	A NodeTest is a simple kind of pattern that enables a context-free test of whether a node matches a given node kind and name.
NodeTestPattern	A NodeTestPattern is a pattern that consists simply of a NodeTest
NodeVectorTree	Interface defining methods common to the TinyTree and the Domino tree model.
NodeWrappingAxisIterator<B>	An AxisIterator that wraps a Java Iterator.
NodeWrappingFunction<B,T extends NodeInfo>	Interface to a function that wraps nodes from an external object model in a Saxon NodeInfo representation
NoDynamicContextException	This exception class is used when early (compile-time) evaluation of an expression is attempted, and the expression requires knowledge of the current dateTime or implicit timezone.
NoElementsSpaceStrippingRule	A whitespace stripping rule that retains all whitespace text nodes
NoNamespaceName	An implementation of NodeName for the common case of a name in no namespace
NonDelegatingURIResolver	This is a marker interface: if a URIResolver implements this interface and returns null from its resolve() method, then the standard URI resolver will not be invoked.
NonDeterminizedState	A state in the non-determinized finite state machine
NoOpenFeed	This feed is used for the inner loop of a for-each, where the results of multiple iterations need to be concatenated into a single sequence.
NoOpenOrCloseFeed	This feed is used for the inner loop of a for-each, where the results of multiple iterations need to be concatenated into a single sequence.
NoOpenStartTagException	Exception indicating that an attribute or namespace node has been written when there is no open element to write it to
NormalizeSpace_1	Implement the XPath normalize-space() function
NormalizeSpace_1.NormalizeSpaceFnElaborator
NormalizeUnicode	Implement the XPath normalize-unicode() function (both the 1-argument and 2-argument versions)
Notation	A Notation Declaration Schema Component
NotationSet	A set of declared notations (in the sense of XSD xs:notation)
NotationValue	An xs:NOTATION value.
NotFn	This class supports the XPath functions boolean(), not(), true(), and false()
NotFn.NotFnElaborator
NotFnStreamer	Streaming code for an fn:not() function call
NullDestination	A NullDestination is a Destination that discards all output sent to it.
Number_1	Implements the XPath fn:number() function when called with one argument.
Number_1.NumberFnElaborator
Numberer	Interface Numberer supports number formatting.
Numberer_da	Localization class for Danish.
Numberer_de	Class Numberer_de provides localization for format-date() and xsl:number with language = "de" (German)
Numberer_en	Numberer class for the English language.
Numberer_fr	Class Numberer_fr is a number formatter for french.
Numberer_frBE	Class Numberer_frBE is a number formatter for French as used in Belgium.
Numberer_he	Class Numberer_he does number formatting for language="he" (Hebrew).
Numberer_it	Localization class for Italian
Numberer_nl	Localization class for Dutch.
Numberer_nlBE	Numberer class for the Belgian-Dutch language region.
Numberer_sv	Numberer class for the Swedish language.
Numberer_tr
NumberFormatter	Class NumberFormatter defines a method to format a ArrayList of integers as a character string according to a supplied format specification.
NumberInstruction	This instruction performs the node-counting function of the xsl:number instruction.
NumberSequenceFormatter	This expression performs the formatting part of the logic of the xsl:number instruction It takes as input a sequence of integers, which may either be supplied directly as the value attribute of xsl:number, or may be computed by counting nodes.
NumericComparer	A Comparer used for comparing sort keys when data-type="number".
NumericComparer11	A Comparer used for comparing sort keys when data-type="number".
NumericComparisonOperand	Given an expression, this characteristic evaluates the set of hash keys corresponding to the string values of the items selected by that expression
NumericGroupFormatter	A NumericGroupFormatter is responsible for insertion of grouping separators into a formatted number (for example, reformatting "1234" as "1,234").
NumericType	Singleton class representing the class xs:numeric as defined in XPath 3.1: a union type whose members are xs:double, xs:decimal, and xs:float
NumericValue	NumericValue is an abstract superclass for IntegerValue, DecimalValue, FloatValue, and DoubleValue
ObjectConverter	This interface is based on the "CommonHandler" concept defined in early drafts of XQJ.
ObjectLookupExpression	Saxon extension: a lookup expression of the form X?Y where X is a Java external object and Y is a method defined on that object.
ObjectLookupExpression.ObjectLookupElaborator
ObjectMap	Extension function saxon:object-map(), which converts an external object to a map
ObjectToBeSorted	This class represents a member of a sequence that is being sorted.
ObjectValue<T>	An XPath value that encapsulates a Java object.
OccurrenceIndicator	Represents one of the possible occurrence indicators in a SequenceType.
OnDemandFunctionSet	The OnDemandFunctionSet represents a function library where the implementation classes are loaded dynamically on demand.
One<T extends Item>	A sequence containing exactly one item.
OnEmptyAdjunct	Generate streaming code for a consuming xsl:on-empty instruction
OnEmptyExpr	A compiled xsl:on-empty instruction.
OneOrMore<T extends Item>	A value that is a sequence containing one or more items.
OnNonEmptyAdjunct	Generate streaming code for a consuming xsl:on-non-empty instruction
OnNonEmptyExpr	A compiled xsl:on-non-empty instruction.
OpAtom	A match against a fixed string of any length, within a regular expression
OpBackReference	A back-reference in a regular expression
OpBOL	Beginning of Line (^) in a regular expression
OpCapture	Open paren (captured group) within a regular expression
OpCharClass	A match of a single character in the input against a set of permitted characters
OpChoice	A choice of several branches within a regular expression
OpenContentVariety	The different varieties of open content for complex types
OpEndProgram	End of program in a regular expression
OpEOL	End of Line ($) in a regular expression
Operand	Information about a sub-expression and its relationship to the parent expression
OperandArray	Defines an operand set comprising an array of operands numbered zero to N.
OperandProcessor	Interface representing a visitor of the clauses of a FLWOR expression that can process and modify the operands of each clause
OperandRole	Defines the role of a child expression relative to its parent expression.
OperandUsage	The usage of an operand defines how the containing expression makes use of the value of the operand, as defined in the XSLT 3.0 specification.
Operation	Represents an operation or instruction in the regular expression program.
Operation.ForceProgressIterator	The ForceProgressIterator is used to protect against non-termination; specifically, iterators that return an infinite number of zero-length matches.
OpFn	This class implements the function fn:op(), which is a proposed function in XPath 4.0 to return a function that implements a supplied operator
OpGreedyFixed	Handle a greedy repetition (with possible min and max) where the size of the repeated unit is fixed.
OpNothing	Match empty string within a regular expression
OpReluctantFixed	Handle a reluctant repetition (with possible min and max) where the size of the repeated unit is fixed.
OpRepeat	Handle a repetition (with possible min and max) where the size of the repeated unit is variable.
OpSequence	A sequence of multiple pieces in a regular expression
Optimizer	This class performs optimizations that vary between different versions of the Saxon product.
OptimizerEE	This class performs a number of optimizations that are specific to the Saxon-EE product.
OptimizerOptions	Defines switches that can be used to control which optimizations take place.
OptionalItemEvaluator	A SequenceEvaluator for expressions that return a sequence of zero or one items.
Optionality
OptionsParameter	This class implements the rules for options parameters, as used in functions such as parse-json, serialize, json-to-XML, map:merge.
OpTrace	Operation that wraps a base operation and traces its execution
OpUnambiguousRepeat	Handle a repetition where there is no ambiguity; if the repeated term is matched in the string, then it cannot match anything other than the repeated term.
OrderByClause	This class represents an "order by" clause in a FLWOR expression
OrderByClausePull	Represents the tuple stream delivered by an "order by" clause.
OrderByClausePush	Represents the tuple stream delivered by an "order by" clause.
OrderFacet	The saxon:order facet on a list type can be used to constrain the list to be in ascending or descending order.
OrExpression
OrExpression.OrElaborator	Elaborator for an "or" expression (A or B)
OriginalFunction	This class represents a function invoked using xsl:original from within an xs:override element.
Orphan	A node (implementing the NodeInfo interface) representing an attribute, text node, comment, processing instruction, or namespace that has no parent (and of course no children).
Outcome<T>	An Outcome represents the result of a task, which might be success or failure T is the class of the result of the task in the event that it is successful
OuterForExpression	Expression class that implements the "outer for" clause of XQuery 3.0
OuterForExpression.OuterForExprElaborator	An elaborator for a "for" expression, typically written as {for $x in SEQ return R}.
Outermost	This class implements the function fn:outermost(), which is a standard function in XPath 3.0
OutermostStreamer	Streaming code for an outermost() function call.
OuterNewlineInserter	OuterNewlineInserter: This ProxyReceiver inserts a newline after any comment or PI child of the document node that precedes the first element child, and before any comment or PI child that follows the first element child.
Outputter	Outputter: This interface represents a recipient of XML tree-walking (push) events.
OutputterEvent	An outputter event is an object representing one of the events that can be passed to an Outputter : for example, a startElement, attribute, namespace endElement, characters, or comment event.
OutputterEvent.Append	Event representing an arbitrary item being sent to the event stream in composed form.
OutputterEvent.Attribute	Event representing an attribute node
OutputterEvent.Comment	Event representing a comment node
OutputterEvent.EndDocument	Event representing end of document
OutputterEvent.EndElement	Event representing the end of an element
OutputterEvent.Namespace	Event representing a namespace node
OutputterEvent.ProcessingInstruction	Event representing a processing instruction node
OutputterEvent.StartContent	Event representing the start of element content
OutputterEvent.StartDocument	Event representing start of document
OutputterEvent.StartElement	Event representing the start of an element (including attributes or namespaces)
OutputterEvent.Text	Event representing a text node
OutputterEventBuffer	An EventBuffer is a receiver of events that records the events in memory for subsequent replay.
OutputURIResolver	This interface defines an OutputURIResolver.
OutputURIResolverWrapper	This class is an implementation of the ResultDocumentResolver interface that wraps a supplied OutputURIResolver.
PackageData	Information about a unit of compilation: in XSLT, a package; in XQuery, a module.
PackageDetails	Information about a package held in a package library; the package may or may not be loaded in memory
PackageInspector	The PackageInspector class is a Receiver that looks at an incoming stylesheet document and extracts the package name and version from the root element; parsing is then abandoned.
PackageLibrary	A PackageLibrary represents a collection of packages that can be searched, typically to satisfy an xsl:use-package declaration.
PackageLoaderEE	Saxon-EE version of PackageLoader
PackageLoaderHE	This class reads the XML exported form of a package and reconstructs the package object in memory.
PackageLoaderHE.ExpressionLoader
PackageLoaderHE.PatternLoader
PackageLoaderPE	This class reads the XML exported form of a package and reconstructs the package object in memory.
PackageVersion	A class to represent an XSLT package version such as 1.12.5 or 3.0-alpha
PackageVersionRanges	A class to handle a set of package version ranges
PairIterator<T>	An iterator over a pair of objects (typically sub-expressions of an expression)
ParameterSet	A ParameterSet is a set of parameters supplied when calling a template.
ParamKeywords	Data-only class to define the keywords used for parameters of built-in functions.
Parcel	A Parcel is a way of wrapping an arbitrary sequence as a single item.
ParcelFn	This class implements the function fn:parcel(), which is a proposed function in XPath 4.0 to wrap a sequence as a single item
ParentConstructorAdjunct	Watch factory class for an atomizer
ParentNodeConstructor	An abstract class to act as a common parent for instructions that create element nodes and document nodes.
ParentNodeImpl	ParentNodeImpl is an implementation of a non-leaf node (specifically, an Element node or a Document node)
Parse	This class implements the saxon:parse() extension function, which is specially-recognized by the system because it needs access to parts of the static context
ParsedContentType	Represents a content type as it appears in HTTP headers, parsed to extract two properties: (a) a boolean indicating whether the media type is XML, and (b) the character encoding.
ParseHtml	Supports the saxon:parse-html() or fn:parse-html, which parses HTML using nu.validator
ParseHtml.Html5Converter	This class "tweaks" the output of nu.validator to deliver what the parse-html() function expects.
ParseHtml.HTML5ErrorHandler
ParseIetfDate	This class implements the function parse-ietf-date(), which is a standard function in XPath 3.1
ParseInteger	Implements the 4.0 parse-integer() function.
ParseJsonFn	Implements the parse-json function, as defined in XPath 3.1 The parsing code, and the handling of options is shared with the json-to-xml function.
ParseOptions	This class defines options for parsing and/or validating a source document.
ParseQNameFn	This class supports the fn:parse-QName() function, new in 4.0
ParseQNameFn.QNameFnElaborator
ParserExtension	Dummy Parser extension for syntax in XPath that is accepted only in particular product variants.
ParserExtension.TemporaryXSLTVariableBinding
ParseURI	Supports the fn:build-uri function.
ParseXml
ParseXml.RetentiveErrorHandler
ParseXmlFragment
ParseXPath	This class implements the saxon:parse-XPath() extension function, which is specially-recognized by the system because it needs access to parts of the static context
PartialApply	This expression class implements the operation of currying (or performing partial application) of a function.
Particle	Represents a Particle as defined by XML Schema.
Partition	Function fn:partition, new in 4.0
Parts	Proposed XPath 4.0 function that returns the components of an atomic value as a map (for example, the components of a dateTime, a duration, or a URI).
Path_1	Implement the fn:path function with one argument
PathMaintainer	This class sits in a receiver (push) pipeline and maintains the current path.
PathMap	A PathMap is a description of all the paths followed by an expression.
PathMap.PathMapArc	An arc joining two nodes in the path map.
PathMap.PathMapNode	A node in the path map.
PathMap.PathMapNodeSet	A (mutable) set of nodes in the path map
PathMap.PathMapRoot	A root node in the path map.
PathMappedAccumulatorData	Accumulator data for a tree that is obtained by mapping the nodes in this tree to nodes in some other tree (specifically, the subtree from which this tree was originally copied with copy-accumulators=yes) and getting the accumulator value from the corresponding node in the other tree.
Pattern	A Pattern represents the result of parsing an XSLT pattern string.
PatternFacet	Represents a pattern facet on a schema-defined simple type
PatternMaker	This is a singleton class used to convert an expression to an equivalent pattern.
PatternOptimizer	A PatternOptimizer is an agent responsible for optimizing a particular class of patterns.
PatternParser	Parser for XSLT patterns.
PatternThatSetsCurrent	This class represents a pattern that sets the value of current() to the node being matched, and then wraps another pattern that uses the value of current()
PatternWatch	A Watch represents a class that is interested in looking at nodes for the purpose of evaluating uniqueness and key constraints, or for XSLT streaming; specifically, an implementation of Watch that retains a Pattern which is evaluated to see whether a particular node matches the Watch.
PatternWithPredicate	Represents a pattern with a predicate, for example item[@value=3] or .[.
Pedigree	A Pedigree is transient information relating to a map or array indicating the route by which it was reached; it thus compensates for the absence of parent pointers in a JSON-like tree, by allowing the steps used to reach a map or array in such a structure to be retraced.
PedigreeArrayItem	A PedigreeArrayItem represents an XDM array together with a Pedigree: that is, retained information about how the array was selected with a JSON-like tree.
PedigreeFn	The saxon:pedigree function, new in Saxon 9.9.
PedigreeMapItem	A PedigreeMapItem represents an XDM map together with a Pedigree: that is, retained information about how the map was selected within a JSON-like tree.
PedigreeValue	A PedigreeValue is a map or array together with a Pedigree indicating how that map or array was selected within a JSON-like tree structure.
PendingUpdateAction	A pending update action, such as is found on a pending update list
PendingUpdateList	A PendingUpdateList is created by updating expressions in XQuery Update.
PendingUpdateListImpl	Concrete implementation of the Pending Update List
PIGrabber	The PIGrabber class is a ProxyReceiver that looks for xml-stylesheet processing instructions and tests whether they match specified criteria; for those that do, it creates a Source object referring to the relevant stylesheet
Pingable	A Pingable represents an object that can receive an event with no associated information.
PIOverNodeInfo	This class is an implementation of the DOM ProcessingInstruction interface that wraps a Saxon NodeInfo representation of a text or comment node.
PipelineConfiguration	A PipelineConfiguration sets options that apply to all the operations in a pipeline.
PJConverter	This class together with its embedded subclasses handles conversion from XPath values to Java values
PJConverter.AnyURIValueToURI
PJConverter.AnyURIValueToURL
PJConverter.Atomic	Converter for use when the source object is an atomic value, but nothing more is known statically.
PJConverter.BooleanValueToBoolean
PJConverter.CalendarValueToCalendar
PJConverter.CalendarValueToDate
PJConverter.CalendarValueToInstant
PJConverter.CalendarValueToLocalDateTime
PJConverter.CalendarValueToOffsetDateTime
PJConverter.CalendarValueToZonedDateTime
PJConverter.ConditionalUnwrapExternalObject
PJConverter.DateValueToLocalDate
PJConverter.General	General-purpose converter when nothing more specific is available.
PJConverter.Identity
PJConverter.IntegerValueToBigInteger
PJConverter.IntegerValueToByte
PJConverter.IntegerValueToChar
PJConverter.IntegerValueToInt
PJConverter.IntegerValueToLong
PJConverter.IntegerValueToShort
PJConverter.NumericValueToBigDecimal
PJConverter.NumericValueToDouble
PJConverter.NumericValueToFloat
PJConverter.QualifiedNameValueToQName
PJConverter.StringItemToChar
PJConverter.StringItemToString
PJConverter.StringItemToUnicodeString
PJConverter.ToArray	Converter for use when the target class is an array
PJConverter.ToCollection	Converter for use when the target class is a collection class.
PJConverter.ToNull
PJConverter.ToOne	Converter for use when the target class is One, which constrains the value to be a singleton
PJConverter.ToOneOrMore	Converter for use when the target class is OneOrMore, which constrains the value to be a non-empty sequence
PJConverter.ToSequenceExtent
PJConverter.ToSequenceIterator
PJConverter.ToZeroOrMore	Converter for use when the target class is ZeroOrMore, which allows any sequence but is a generic (parameterized) class so there is compile-time information about the type of items
PJConverter.ToZeroOrOne	Converter for use when the target class is ZeroOrOne, which constrains the value to be a singleton or an empty sequence
PJConverter.UnwrapExternalObject
PlainType	A "plain type" is either an atomic type, or a union type that (a) imposes no restrictions other than those imposed by its member types, and (b) has exclusively plain types as its member types
Platform	This interface provides access to methods whose implementation depends on the chosen platform (typically Java or .NET)
PooledXQConnection	An object that provides hooks for connection pool management.
PositionAndLast
PositionAndLast.Last
PositionAndLast.Last.LastFnElaborator
PositionAndLast.Position
PositionAndLast.Position.PositionFnElaborator
Posture	The posture of an expression defines the relationship of the result to a streamed input document, as defined in the XSLT 3.0 specification.
PostureAndSweep	This class defines a composite property of an expression containing both the posture and sweep of the expression, as defined in the XSLT 3.0 specification.
Precondition	A Precondition is a boolean condition that must be true if a pattern is to match (but in general is not a sufficient condition for the pattern to match).
Precondition.BooleanPrecondition	A BooleanPrecondition can in principle test any boolean characteristic of a pattern.
Precondition.NumericComparisonPrecondition	A numeric comparison precondition is used for patterns containing a predicate that compares some expression E with a numeric constant.
Precondition.StringHashPrecondition	A StringHashPrecondition compares a characteristic in the form of a set of integer hash codes against a constant hash code; the precondition is satisfied if the constant hash code is present in the set.
PreconditionMatcher	This class contains the stateful part of the precondition checker.
PredicateCharacterClass	A character class represents a set of characters for regex matching purposes.
Predicates	This non-instantiable class provides a number of useful implementations of the Predicate interface, designed for use when navigating streams of XDM items.
PrefixPool	A prefix pool maintains a two-way mapping from namespace prefixes (as strings) to integer prefix codes.
PreparedSchema	A schema is a collection of schema components.
PreparedStylesheet	This PreparedStylesheet class represents a Stylesheet that has been prepared for execution (or "compiled").
PrependAxisIterator	An iterator over nodes, that prepends a given node to the nodes returned by another iterator.
PrependSequenceIterator	An iterator over nodes, that prepends a given node to the nodes returned by another iterator.
PreprocessFacet	Represents the preprocess facet on a schema-defined simple type.
PrimitiveUType
PrincipalOutputGatekeeper	This class is added to the output pipeline for the principal result destination for a transformation if the transformation uses xsl:result-document instructions.
PrincipalStylesheetModule	Represents both the stylesheet module at the root of the import tree, that is, the module that includes or imports all the others, and also the XSLT package that has this stylesheet module as its root.
PrincipalStylesheetModuleEE	This version of the StylesheetPackage class represents a "real" package, that is one with an xsl:package element, which potentially uses other packages and overrides selected components in those packages.
ProcessingInstruction	An xsl:processing-instruction element in the stylesheet, or a processing-instruction constructor in a query
Processor	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.
ProcInstImpl	ProcInstImpl is an implementation of ProcInstInfo used by the Propagator to construct its trees.
ProcInstParser	ProcInstParser is used to parse pseudo-attributes within Processing Instructions.
ProfessionalConfiguration	This class holds details of user-selected configuration options for a set of transformations and/or queries.
ProfessionalTransformerFactory	The is the JAXP TransformerFactory implementation for the professional edition of Saxon.
ProfessionalXPathFactory	An implementation of the JAXP XPath Factory that creates a Professional configuration.
Projector	This class uses a PathMap to do document projection.
ProtocolRestrictor	This class implements the rules in a property such as XMLConstants.ACCESS_EXTERNAL_SCHEMA, which constrain the set of URIs that can be used by supplying a list of permitted protocols.
ProxyOutputter
ProxyReceiver	A ProxyReceiver is an Receiver that filters data before passing it to another underlying Receiver.
PseudoExpression	A pseudo-expression is an object that can appear as a node on the expression tree, but which cannot actually be evaluated in its own right.
PublicStylesheetFunctionLibrary	A PublicStylesheetFunctionLibrary filters a StylesheetFunctionLibrary to include only those functions whose visibility is final or public.
PullConsumer	A PullConsumer consumes all the events supplied by a PullProvider, doing nothing with them.
PullElaborator	Abstract implementation of Elaborator for expressions that primarily evaluate in pull mode, that is, by returning a SequenceIterator over the result.
PullEvaluator	Interface implemented by evaluators that evaluate an expression in "pull" mode, that is, by delivering a SequenceIterator over the results.
PullEvent	Enumeration of event types that can occur in the PullProvider interface
PullFilter	PullFilter is a pass-through filter class that links one PullProvider to another PullProvider in a pipeline.
PullFromIterator	This class delivers any XPath sequence through the pull interface.
PullNamespaceReducer	PullNamespaceReducer is a PullFilter responsible for removing duplicate namespace declarations.
PullProvider	PullProvider is Saxon's pull-based interface for reading XML documents and XDM sequences.
PullPushCopier	This class copies a document by using the pull interface to read the input document, and the push interface to write the output document.
PullPushTee	PullPushTee is a pass-through filter class that links one PullProvider to another PullProvider in a pipeline, copying all events that are read into a push pipeline, supplied in the form of a Receiver.
PullSource	A PullSource is a JAXP Source that encapsulates a PullProvider - that is, an object that supplies an XML document as a sequence of events that are read under the control of the recipient.
PullToStax	This class bridges PullProvider events to XMLStreamReader (Stax) events.
PullToStax.SourceStreamLocation	Bridge a SAX SourceLocator to a javax.xml.stream.Location
PullTracer	PullTracer is a PullFilter that can be inserted into a pull pipeline for diagnostic purposes.
Push	An interface designed for applications to generate XML documents by issuing events.
PushableFunction	Interface implemented by functions that have a "push" implementation, whereby the result of the function is written incrementally to an Outputter rather than being returned as the result of a call() method.
PushElaborator	Abstract superclass for elaborators whose primary evaluation method is in push mode.
Pusher	Interface implemented by instructions that push data to an Outputter
PushEvaluator
PushToPull	This class evaluates an expression in push mode in one thread, and provides an iterator to read the results of the expression in pull mode in the original thread.
PushToReceiver
Put	Implements the fn:put() function in XQuery Update 1.0.
Put.PutFnElaborator
PutAction	A saved put() call on the pending update list.
QName	The QName class represents an instance of xs:QName, as defined in the XPath 2.0 data model.
QNameException	A QNameException represents an error condition whereby a QName (for example a variable name or template name) is malformed
QNameFn	This class supports the fn:QName() function
QNameFn.QNameFnElaborator
QNameParser	Parser to handle QNames in either lexical QName or EQName syntax, including resolving any prefix against a URIResolver.
QNameTest	Interface for tests against a QName.
QNameValue	A QName value.
QualifiedNameValue	A qualified name: this is an abstract superclass for QNameValue and NotationValue, representing the XPath primitive types xs:QName and xs:NOTATION respectively
QuantifiedExpression	A QuantifiedExpression tests whether some/all items in a sequence satisfy some condition.
QuantifiedExpression.QuantifiedExprElaborator	Elaborator for a quantified expression (some|every X in Y satisfies Z)
Query	This is a synonym of net.sf.saxon.Query, the command line interface for running XQuery.
Query	This Query class provides a command-line interface to the Saxon XQuery processor.
QueryFn	This class implements the saxon:query() extension function
QueryLibrary	A QueryLibrary represents an independently compiled set of query modules that does not include a main module.
QueryLibraryImpl	Concrete implementation of a separately-compiled XQuery library
QueryModule	This class represents a query module, and includes information about the static context of the query module.
QueryReader	This class contains static methods used to read a query as a byte stream, infer the encoding if necessary, and return the text of the query as a string; also methods to import functions and variables from one module into another, and check their consistency.
QueryResult	This utility class takes the result sequence produced by a query, and wraps it as an XML document.
QuickXPathParser	This class performs a quick parse of commonly encountered XPath expressions that conform to common syntactic patterns.
QuitParsingException	An exception used to signal that no more input is required from the parser, and that parsing can therefore be abandoned early (but without signaling any error to the user)
Random	This class implements extension functions in the http://exslt.org/random namespace.
RandomNumberGenerator	This class implements the function random-number-generator(), which is a standard function in XPath 3.1
RangeExpression	A RangeExpression is an expression that represents an integer sequence as a pair of end-points (for example "x to y").
RangeExpression.RangeElaborator
RangeIterator	This abstract class represents an iteration over the results of a range expression (A by B to C).
RangeKey	This class implements an XPath map item as a view of an XSLT key index.
RawDestination	An RawDestination is a Destination that accepts a sequence output by a stylesheet or query and returns it directly as an XdmValue, without constructing an XML tree, and without serialization.
RawResult	This class is an implementation of the JAXP Result interface.
ReadBinaryResource	Implement saxon:read-binary-resource extension function
RebasedDocument	A RebasedDocument represents a view of a real Document in which all nodes are mapped to a different base URI and/or system ID using supplied mapping functions.
RebasedNode	A RebasedNode is a view of a node, in a virtual tree that maps the base URI and/or system ID to new values
RebindingMap	A map from old bindings to new bindings, maintained during a copy() operation applied to an expression tree.
Receiver	Receiver: This interface represents a recipient of XML tree-walking (push) events.
ReceiverOption	ReceiverOption defines a set of constants representing boolean flags, which can be used in calls to methods on the Receiver interface.
ReceiverToXMLStreamWriter	ReceiverToXMLStreamWriter is a Receiver writes XML by using the XMLStreamWriter
ReceiverWithOutputProperties	Marker interface attached to a Outputter that retains serialization properties (typically, a Receiver that forms part of the serialization pipeline).
ReceivingContentHandler	ReceivingContentHandler is a glue class that provides a standard SAX ContentHandler interface to a Saxon Receiver.
ReceivingContentHandler.LocalLocator	An implementation of the Saxon Location interface that wraps the SAX Locator information.
ReceivingDestination	An implementation of Destination that simply wraps a supplied Receiver
RECompiler	A regular expression compiler class.
RecordTest	An instance of this class represents a specific record item type, for example record(x as xs:double, y as element(employee)).
RecordTest.Field	Class representing one field definition within a record type definition, used only while constructing a record definition
RecordType	An instance of this class represents a specific record type, for example record(x as xs:double, y as element(employee)).
RecoveryPolicy
REFlags	Class representing a set of regular expression flags (some combination of i, m, s, x, q).
RefSelectorWatch	This class watches the selector for a keyref constraint
RegexFunction	This class implements any of the functions matches(), replace(), tokenize(), analyze-string(), in the version where a flags argument is present in the argument list
RegexFunctionSansFlags	This class implements any of the functions matches(), replace(), tokenize(), analyze-string(), in which the final "flags" argument is omitted.
RegexGroup
RegexIterator	This interface defines an iterator that supports the evaluation of xsl:analyze-string.
RegexMatchHandler	Interface defining a call-back action for processing captured groups within a regular expression
RegexPrecondition	A precondition that must be true if a regular expression is to match
RegularExpression	This interface represents a compiled regular expression.
RegularGroupFormatter	A RegularGroupFormatter is a NumericGroupFormatter that inserts a separator at constant intervals through a number: for example, a comma after every three digits counting from the right.
RegularSequenceChecker	A RegularSequenceChecker is a filter that can be inserted into a Receiver pipeline to check that the sequence of events passed in is a regular event sequence.
RegularSequenceChecker.State
RelativeURIResolver	The standard JAXP URIResolver is given a relative URI and a base URI and returns the resource identified by this combination.
REMatcher	RE is an efficient, lightweight regular expression evaluator/matcher class.
REMatcher.State
Remove	The XPath 2.0 remove() function
Remove.RemoveIterator	An implementation of SequenceIterator that returns all items except the one at a specified position.
RemoveStreamer	Generate streaming code for a remove() function call.
RenameAction	A pending update action representing the effect of a rename expression
RenameExpression	A rename expression in XQuery Update
RepairingContentHandler	A RepairingContentHandler is a SAX filter that can be placed on the input pipeline in front of a ReceivingContentHandler for use in cases where the events supplied by the XML parser are not guaranteed to satisfy all the consistency constraints.
Replace	This class implements the replace() function for replacing substrings that match a regular expression
ReplaceAttributeAction	A pending update action representing a replace node expression applied to an attribute.
ReplaceNodeAction	A pending update action representing the effect of a "replace node" expression
ReplaceNodeExpression	A "replace node" expression in XQuery Update
ReplaceValueAction	A pending update action representing the effect of a "replace value" expression.
ReplaceValueExpression	A "replace value of" expression in XQuery Update
ReplaceWith	This class implements the saxon:replace-with() function for replacing substrings that match a regular expression by means of a callback to a user-supplied function
Replicate	The proposed XPath 4.0 replicate() function
ReportingSingletonIterator	This is a subclass of SingletonIterator that reports to a LearningEvaluator when the single target item is actually read.
REProgram	A class that holds compiled regular expressions.
ResolveQName	This class supports the resolve-QName function in XPath 2.0
ResolveURI	This class supports the resolve-uri() function in XPath 2.0
Resource	This interface defines a Resource.
ResourceCollection	This interface defines a ResourceCollection.
ResourceFactory	A ResourceFactory is used for constructing a particular type of resource
ResourceLoader	The class provides a static method for loading resources from a URL.
ResourceRequest	A bundle of information made available when requesting resource resolution.
ResourceResolver	Interface for processing a resource request to deliver a resource
ResourceResolverDelegate	Convenience class to allow a ResourceResolver to be implemented as a lambda expression.
ResourceResolverWrappingLSResourceResolver	This class implements the Saxon ResourceResolver interface as a wrapper around a DOM Level 3 LSResourceResolver.
ResourceResolverWrappingURIResolver	A ResourceResolver implemented by wrapping a supplied URIResolver
ResultDocument	The compiled form of an xsl:result-document element in the stylesheet.
ResultDocumentAdjunct	Handle an xsl:result-document expression/instruction for XSLT streaming capability.
ResultDocumentAdjunct.ResultDocumentFeed
ResultDocumentResolver	The ResultDocumentResolver interface may be implemented by a user application; it is a callback that is called whenever an xsl:result-document instruction is executed.
RESyntaxException	Exception thrown to indicate a syntax error in a regular expression.
RetainedStaticContext	This class contains the part of the static context of expressions that (a) can change from one expression to another within a query or stylesheet, and (b) are potentially needed at run-time.
ReturnClauseIterator	This iterator applies the return expression of a FLWOR expression to each of the tuples in a supplied tuple stream, returning the result as an iterator
ReturnClausePush	The class represents the final stage in a push-mode tuple pipeline.
Reverse	Implement XPath function fn:reverse()
Reverse.ReverseListIterator
ReverseStreamer
ReversibleIterator	A ReversibleIterator is an interface implemented by any SequenceIterator that is able to deliver items in reverse order (or to supply another iterator that can do so).
RoleDiagnostic	A RoleDiagnostic (formerly RoleLocator) identifies the role in which an expression is used, for example as the third argument of the concat() function.
Root_1	Implement the XPath 2.0 root() function with one argument
Root_1.RootFnElaborator
RootExpression	An expression whose value is always a set of nodes containing a single node, the document root.
RootExpression.RootExprElaborator	Elaborator for a root expression (/)
RootExpressionAdjunct	Streaming code for an expression that does not support streaming
RootStreamer
Round	This class implements the fn:round() function
Round.RoundElaborator
RoundHalfToEven	This class supports the round-to-half-even() function
RoundHalfToEven.RoundHalfToEvenElaborator
Rule	Rule: common functionality representing an abstraction of a template rule, a strip-space rule, or an accumulator rule
RuleBasedSubstringMatcher	This class wraps a RuleBasedCollator to provide a SubstringMatcher.
RuleChain	A chain of rules: actually in this incarnation just a pointer to the first rule in the chain, the others being linked together each to the next.
RuleEE	A Rule with associated preconditions
RuleManager	RuleManager maintains a set of template rules, one set for each mode
RuleSearchState	A simple class for holding stateful details of a rule search operation This is a dummy implementation for Saxon-HE which does not optimize searching a rule chain.
RuleSetWithWarnings	A set of built-in template rules that performs the same action as an underlying set of rules, but with the addition of a warning message saying that no user-defined template rules was found.
RuleTarget	The target of a rule, typically a TemplateRule.
SameNameTest	NodeTest is an interface that enables a test of whether a node has a particular name and type.
SaplingComment	A comment node in a sapling tree
SaplingDocument	A document node in a sapling tree.
SaplingElement	An element node on a sapling tree.
SaplingNode	This class represents a sapling node.
SaplingProcessingInstruction	A processing-instruction node in a sapling tree
Saplings	This is a non-instantiable class holding a number of convenience methods for creating sapling nodes of different kinds.
SaplingText
SAXDestination	This class represents a Destination (for example, the destination of the output of a transformation) in which events representing the XML document are sent to a user-supplied SAX2 ContentHandler, as if the ContentHandler were receiving the document directly from an XML parser.
Saxon6ElementFactory	A Factory for the old saxon:output extension instruction (in the old Saxon6 namespace) for the benefit of people running the docbook stylesheets.
SaxonApiException	An exception thrown by the Saxon s9api API.
SaxonApiUncheckedException	An unchecked exception thrown by the Saxon API.
SaxonAssign	saxon:assign element in stylesheet.
SaxonChange	saxon:change is an XSLT version of the XQuery Update "replace value of node" expression.
SaxonDeepEqual	Implements the saxon:deep-equal() function, a variant of fn:deep-equal that provides additional control over how the comparison is performed.
SaxonDeepUpdate	Handler for saxon:deep-update elements in stylesheet.
SaxonDelete	saxon:delete is an XSLT version of the XQuery Update "delete node" expression.
SaxonDo	Handler for saxon:do elements in stylesheet.
SaxonDoctype	A saxon:doctype element in the stylesheet.
SaxonDuration	Saxon implementation of the JAXP class javax.xml.datatype.Duration.
SaxonElementFactory	A Factory for Saxon extension nodes in the stylesheet tree.
SaxonElementFactoryEE	A Factory for Saxon extension nodes in the stylesheet tree.
SaxonEntityRef	A saxon:entity-ref element in the stylesheet.
SaxonErrorCode	The class acts as a register of Saxon-specific error codes.
SaxonImportQuery	The class implements a saxon:import-query declaration in a stylesheet.
SaxonInsert	saxon:insert is an XSLT version of the XQuery Update "insert node" expression.
SaxonOutputKeys	Provides string constants that can be used to set output properties for a Transformer, or to retrieve output properties from a Transformer or Templates object.
SaxonParam	This object represents a saxon:param element in a schema document.
SaxonPreprocess	saxon:preprocess is an implementation-defined pre-lexical facet as permitted by XML Schema 1.1.
SaxonRename	saxon:rename is an XSLT version of the XQuery Update rename expression.
SaxonReplace	saxon:replace is an XSLT version of the XQuery Update "replace node" expression.
SaxonSlice	This class implements the saxon:slice() (proposed as fn:slice() for 4.0))
SaxonSyntaxExtension	Parser extension for syntax in XPath that is accepted only in Saxon-PE and -EE.
SaxonTabulateMaps	Handler for saxon:tabulate-maps elements in stylesheet.
SaxonTransformerFactory	A SaxonTransformerFactory instance can be used to create Transformer and Template objects.
SaxonUpdate	saxon:update is an XSLT version of the XQuery Update copy-modify expression.
SaxonWhile	Handler for saxon:while elements in stylesheet.
SaxonXMLGregorianCalendar	Saxon implementation of the JAXP class javax.xml.datatype.XMLGregorianCalendar.
SaxonXQConnection	Saxon implementation of the XQL interface XQConnection.
SaxonXQDataFactory	Saxon implementation of the XQJ interface XQDataFactory.
SaxonXQDataSource	Saxon implementation of the XQJ XQDataSource interface.
SaxonXQDynamicContext	Saxon implementation of the XQJ DynamicContext interface
SaxonXQExpression	Saxon implementation of the XQJ XQExpression interface
SaxonXQForwardSequence	The class is a Saxon implementation of the XQJ interface XQResultSequence.
SaxonXQItem	This Saxon class is used to implement both the XQItem and XQResultItem interfaces in XQJ.
SaxonXQItemAccessor	All Saxon implementations of XQItemAccessor must implement this interface
SaxonXQItemType	Saxon implementation of the XQJ XQItemType interface
SaxonXQMetaData	Saxon implementation of the XQMetaData interface
SaxonXQPreparedExpression	Saxon implementation of the XQJ interface XQPreparedExpression.
SaxonXQSequence	Saxon implementation of the XQSequence interface in XQJ, which represents an XDM sequence together with a current position.
SaxonXQSequenceType	Saxon implementation of the XQJ SequenceType interface
SaxonXQStaticContext	Saxon implementation of the XQJ XQStaticContext interface
ScalarSystemFunction	A Scalar system function is a pure function that accepts a single item as its operand, returns a single atomic value as its result, typically returns an empty sequence if the argument is an empty sequence, and has no context dependencies.
SchemaAttributeTest	A NodeTest of the form schema-attribute(attribute-name)
SchemaCompiler	A SchemaCompiler is capable of reading source schema documents and converting them into collections of schema components.
SchemaComponent	This is a marker interface that represents any "schema component" as defined in the XML Schema specification.
SchemaDeclaration	This is a marker interface that acts as a surrogate for an object representing a global element or attribute declaration.
SchemaDocument	An XML document containing a module of an XML Schema.
SchemaDocumentTransformer	Class that applies a standard transformation to a schema document: specifically, the chameleon transformation or the override transformation
SchemaElement	An element in an XML Schema document.
SchemaElement.XPathStaticContext
SchemaElementTest	A NodeTest of the form schema-element(element-name)
SchemaException	An exception that identifies an error in reading, parsing, or validating a schema.
SchemaFactoryImpl	This is the Saxon implementation of the JAXP 1.3 SchemaFactory interface.
SchemaFactoryImpl.ErrorReporterWrappingErrorHandler	A JAXP ErrorReporter that wraps a SAX ErrorHandler
SchemaFn	This class implements the saxon:schema() extension function.
SchemaManager	The SchemaManager is used to load schema documents, and to set options for the way in which they are loaded.
SchemaManagerImpl	The SchemaManager is used to load schema documents, and to set options for the way in which they are loaded.
SchemaModelLoader	This class allows a compiled schema model in SCM format to be loaded into memory.
SchemaModelSerializer	This class provides services enabling a compiled schema to be serialized to disk
SchemaNodeFactory	Class SchemaNodeFactory.
SchemaNodeTest	Marker interface for schema-element() and schema-attribute() node tests
SchemaReader	A class for reading XML Schema documents.
SchemaReference	A reference to a Saxon prepared schema.
SchemaStructure	The base class for all XML Schema stuctures.
SchemaType	SchemaType is an interface implemented by all schema types: simple and complex types, built-in and user-defined types.
SchemaTypeFn	Extension function saxon:schema-type
SchemaURIResolver	A SchemaURIResolver is used when resolving references to schema documents.
SchemaValidationStatus	Internal indicator representing progress in validating components of a schema
SchemaValidator	A SchemaValidator is an object that is used for validating instance documents against a schema.
SchemaValidatorImpl	A SchemaValidator is an object that is used for validating instance documents against a schema.
ScopedBindingElement	Marker interface for elements that declare a variable which is in-scope within their body
SearchableValue	A sequence that is held in a form that permits rapid searching, typically by use of indexes.
SefFunction	Represents a system function whose implementation is written in XSLT, and which is implemented here by loading the pre-compiled code from a system SEF file.
SelectedElementsSpaceStrippingRule	A whitespace stripping rule that strips elected elements unless xml:space indicates that whitespace should be preserved.
SelectionParser	This class parses the two XPath subsets defined in XML Schema for handling the "selector" and "field" attributes of the <unique>, <key>, and <keyref> elements.
SelectorWatch	A Watch represents a class that is interested in looking at nodes for the purpose of evaluating uniqueness and key constraints.
SelfReferenceRecordTest	An instance of this class represents a self-reference within a record type, that is the ".." construct in a record test such as record(data as xs:string, next? as ..).
Sender	Sender is a helper class that sends events to a Receiver from any kind of Source object
SendMail	This class implements the extension function saxon:send-mail().
Sequence	This interface represents an XDM Value, that is, a sequence of items.
SequenceCollector	This receiver is used when writing a sequence of atomic values and nodes, that is, when xsl:variable is used with content and an "as" attribute.
SequenceCopier	Copies a sequence, supplied as a SequenceIterator, to a push pipeline, represented by a SequenceReceiver
SequenceEvaluator
SequenceExtent	A sequence value implemented extensionally.
SequenceExtent.Of<T extends Item>
SequenceInstr	A compiled xsl:sequence instruction.
SequenceInstr.SequenceInstrElaborator
SequenceInstrAdjunct
SequenceIterator	A SequenceIterator is used to iterate over any XPath 2 sequence (of values or nodes).
SequenceIteratorOverJavaIterator<J>
SequenceMapper	SequenceMapper is an implementation of MappingFunction that wraps a function typically supplied as a lambda expression.
SequenceMapper.Lambda
SequenceMatching	This class supports the two extension functions starts-with-sequence, ends-with-sequence, contains-sequence
SequenceMatching.ContainsSequence
SequenceMatching.EndsWithSequence
SequenceMatching.StartsWithSequence
SequenceModelGroup	A SequenceCompositor represents an xs:sequence element in the schema
SequenceNormalizer	Implement the "sequence normalization" logic as defined in the XSLT 3.0/XQuery 3.0 serialization spec.
SequenceNormalizerWithItemSeparator	Implement the "sequence normalization" logic as defined in the XSLT 3.0/XQuery 3.0 serialization spec.
SequenceNormalizerWithSpaceSeparator	Implement the "sequence normalization" logic as defined in the XSLT 3.0/XQuery 3.0 serialization spec, for the case where there is no item-separator.
SequenceReceiver	SequenceReceiver: this extension of the Receiver interface is used when processing a sequence constructor.
SequenceTool	Utility class for manipulating sequences.
SequenceType	A SequenceType is the combination of an ItemType and an OccurrenceIndicator
SequenceType	SequenceType: a sequence type consists of a primary type, which indicates the type of item, and a cardinality, which indicates the number of occurrences permitted.
SequenceWrapper	This class can be used in a push pipeline: it accepts any sequence as input, and generates a document in which the items of the sequence are wrapped by elements containing information about the types of the items in the input sequence.
SequenceWriter	The SequenceWriter is used when writing a sequence of items, for example, when xsl:variable is used with content and an "as" attribute.
SerializableSchemaComponent	A component that can be serialized by the SchemaSerializer.
SerializationParamsHandler	This class handles a set of serialization parameters provided in the form of an XDM instance as specified in the Serialization 3.0 definition, section 3.1
SerializationProperties	Define a set of serialization properties.
Serialize	This class implements the saxon:serialize() extension function, which is specially-recognized by the system because it needs access to parts of the static context
Serialize	Implementation of fn:serialize() as defined in XPath 3.1
Serializer	A Serializer takes a tree representation of XML and turns it into lexical XML markup.
Serializer.Property	Enumeration class defining the permitted serialization properties
SerializerFactory	Helper class to construct a serialization pipeline for a given result destination and a given set of output properties.
SerializerFactoryPE	Saxon-PE extensions to the serializer factory
Sets	This class implements extension functions in the http://exslt.org/sets namespace.
ShallowCopyAllRuleSet	The built-in shallow-copy-all rule set proposed for XSLT 4.0, which is the same as shallow-copy, except for maps and arrays.
ShallowCopyEventFeed	This event feed implements an implicit xsl:copy instruction used in a built-in template.
ShallowCopyRuleSet	The built-in rule set introduced in XSLT 3.0, which is effectively an identity template.
ShallowDescentFunctionCallAdjunct	Handle streaming for calls to user-defined functions with streamability="shallow-descent"
ShallowSkipRuleSet	A built-in set of template rules that ignores the current node and does an apply-templates to its children.
SharedAppendEvaluator	Evaluator for expressions that are evaluated in "shared append" mode.
SiblingCountingNode	Interface that extends NodeInfo by providing a method to get the position of a node relative to its siblings.
SignificantItemDetector	This receiver is inserted into the output pipeline whenever on-empty or on-non-empty is used (XSLT 3.0).
SimpleArrayItem	A simple implementation of XDM array items, in which the array is backed by a Java List.
SimpleCollation	A simple collation that just wraps a supplied Comparator
SimpleComponentReference	A reference to a named schema group within the content model of a complex type
SimpleContentFeed	This class is used when a streaming template requests evaluation of a simple content constructor in streaming mode (that is, when it constructs a text, attribute, comment, or PI node based on the contents of the streamed document).
SimpleContentValidator	This class is a filter that is used to validate that an element has simple content conforming to a given simple type.
SimpleExpression	An abstract implementation of Expression designed to make it easy to implement new expressions, in particular, expressions to support extension instructions.
SimpleExpression.SimpleExpressionElaborator
SimpleMode	A Mode is a collection of rules; the selection of a rule to apply to a given element is determined by a Pattern.
SimpleMode.RuleGroupAction	Interface used around a group of rules - principally at the group start and the group end
SimpleNodeConstructor	Common superclass for XSLT instructions whose content template produces a text value: xsl:attribute, xsl:comment, xsl:processing-instruction, xsl:namespace, and xsl:text, and their XQuery equivalents
SimpleNodeConstructorAdjunct	Generate streaming code for an xsl:value-of, xsl:comment, xsl:processing-instruction instruction, etc
SimpleNodeConstructorFeed	This class is used when a streaming template requests evaluation of a simple content constructor in streaming mode (that is, when it constructs a text, attribute, comment, or PI node based on the contents of the streamed document).
SimpleNodePushElaborator	Abstract elaborator for expressions that evaluate simple nodes (text nodes, comments, attributes, etc) in push mode.
SimplePositionalPattern	A SimplePositionalPattern is a pattern of the form A[N] where A is an axis expression using the child axis and P is a numeric literal.
SimpleStepExpression	A SimpleStepExpression is a special case of a SlashExpression in which the start expression selects a single item (or nothing), and the step expression is a simple AxisExpression.
SimpleStepExpression.SimpleStepExprElaborator	Elaborator for a simple step expression, that is X/axis::Y where X evaluates to a singleton
SimpleType	This interface represents a simple type, which may be a built-in simple type, or a user-defined simple type.
SimpleTypeComparison	This class implements equality and ordering comparisons between values of simple types: that is, atomic values, and sequences of atomic values, following the XSD-defined rules for equality and ordering comparisons.
SimpleTypeDefinition	A simple type definition holds all the information about a simpleType during the course of schema processing.
SimpleTypeIdentityComparison	This class implements equality and identity comparisons between values of simple types: that is, atomic values, and sequences of atomic values, following the XSD-defined rules for equality and identity comparisons.
SingleAtomicIterator	SingletonIterator: an iterator over a sequence of exactly one atomic value
SingleEntryMap	A key and a corresponding value to be held in a Map.
SingleItemEvaluator	A SequenceEvaluator for expressions that return a single item (exactly one, never an empty sequence).
SingleItemFilter	A SingleItemFilter is an expression that selects zero or one items from a supplied sequence
SingleNamespaceSchema	A schema (collection of schema components) that has an identifiable target namespace: typically the set of components derived from a single import or include.
SingleNodeIterator	SingleNodeIterator: an iterator over a sequence of zero or one nodes
SingletonAtomizer	A SingletonAtomizer combines the functions of an Atomizer and a CardinalityChecker: it is used to atomize a sequence of nodes, checking that the result of the atomization contains zero or one atomic values.
SingletonAtomizerAdjunct	Watch factory class for a singleton atomizer
SingletonAttributeMap	An implementation of AttributeMap for use when there is exactly one attribute
SingletonCharacterClass	A character class represents a set of characters for regex matching purposes.
SingletonClosure	A SingletonClosure represents a value that has not yet been evaluated: the value is represented by an expression, together with saved values of all the context variables that the expression depends on.
SingletonIntersectExpression	This expression is equivalent to (A intersect B) in the case where A has cardinality zero-or-one.
SingletonIntersectExpression.SingletonIntersectElaborator	Elaborator for a Venn expression: that is A union B, A intersect B, or A except B
SingletonIterator	SingletonIterator: an iterator over a sequence exactly one value
SingularityPull	The "singularity" tuple stream delivers a single empty tuple.
Sink	A Sink is a Receiver that discards all information passed to it
SinkFeed	An ItemFeed that swallows (discards) all input passed to it
SinkOutputter	An Outputter that swallows (discards) all input supplied to it
SkipValidator	This class is a filter that passes all Receiver events through unchanged, except that it removes all type annotations from element and attribute nodes.
SlashExpression	A slash expression is any expression using the binary slash operator "/".
SlashExpression.SlashExprElaborator	Elaborator for a slash expression.
Slice	This class implements the fn:slice() function in 4.0.
Slice16	A Unicode string consisting entirely of 16-bit BMP characters, implemented as a range of an underlying byte array
Slice24	A Unicode string consisting of 24-bit characters, implemented as a range of an underlying byte array holding three bytes per codepoint
Slice8	A Unicode string consisting entirely of 8-bit characters, implemented as a range of an underlying byte array
SlotManager	A SlotManager supports functions, templates, etc: specifically, any executable code that requires a stack frame containing local variables.
SlotManagerEE
SmallAttributeMap	An implementation of AttributeMap suitable for small collections of attributes (typically, up to five).
SnapshotFeed	This class provides streamed implementation of the snapshot() function
SnapshotFn	XSLT 3.0 function snapshot().
SnapshotFnStreamer	Generate streaming code for the snapshot() function
SnapshotNode	This class represents a node within a tree produced by the snapshot() function, as a virtual copy of the relevant nodes in another tree.
SomeFn	This class implements the function fn:some(), which is a proposed function for XPath 4.0
Sort_1	This class implements the function fn:sort#1, which is a standard function in XPath 3.1
Sort_1.ItemToBeSorted
Sort_2	This class implements the function fn:sort#2, according to the new XPath 3.1 spec in bug 29792
Sort_3	This class implements the function fn:sort#2, which is a higher-order function in XPath 3.1 available only in Saxon-PE and above
SortedGroupIterator	A SortedGroupIterator is a modified SortedIterator.
SortedIterator	Class to do a sorted iteration
SortExpression	Expression equivalent to the imaginary syntax expr sortby (sort-key)+
SortExpression.SortExprElaborator	Elaborator for a sort expression - sorts nodes into order based on a user-supplied sort key
SortExpressionAdjunct	Streaming code for sort expression.
SortKeyDefinition	A SortKeyDefinition defines one component of a sort key.
SortKeyDefinitionList	The class represents a list of sort key definitions in major-to-minor sort key order.
SortKeyEvaluator	Callback interface used to evaluate sort keys.
SourceBinding	Helper class for xsl:variable and xsl:param elements.
SourceBinding.BindingProperty
SourceDocument	Non-streamable implementation of the xsl:source-document instruction
SourceResolver	This interface defines a SourceResolver.
SpaceStrippedDocument	A SpaceStrippedDocument represents a view of a real Document in which selected whitespace text nodes are treated as having been stripped.
SpaceStrippedNode	A StrippedNode is a view of a node, in a virtual tree that has whitespace text nodes stripped from it.
SpaceStrippingRule	Interface for deciding whether a particular element is to have whitespace text nodes stripped
SpecificFunctionType	An instance of this class represents a specific function item type, for example function(xs:int) as xs:boolean
SQLClose	An sql:close element in the stylesheet.
SQLColumn	An sql:column element in the stylesheet.
SQLConnect	An sql:connect element in the stylesheet.
SQLConnect.ConnectInstruction
SQLConnectFn	This class implements the sql:connect() extension function.
SQLDelete	An sql:delete element in the stylesheet.
SQLDeleteFn	This class implements the sql:delete() extension function.
SQLElementFactory	Class SQLElementFactory.
SQLExecute	An sql:execute element in the stylesheet.
SQLExecuteFn	This class implements the sql:execute() extension function.
SQLFunctionSet	The SQLFunctionSet is a set of Saxon vendor-supplied extension functions designed to enable access to SQL databases
SQLInsert	An sql:insert element in the stylesheet.
SQLInsertFn	This class implements the sql:insert() extension function.
SQLPreparedQueryFn	This class implements the sql:prepared-query() extension function.
SQLPreparedStatementFn	This class implements the sql:prepared-statement() extension function.
SQLQuery	An sql:query element in the stylesheet.
SQLQueryFn	This class implements the sql:query() extension function.
SQLTable
SQLTableFn	This class implements the sql:table() extension function.
SQLUpdate	An sql:update element in the stylesheet.
SQLUpdateFn	This class implements the sql:update() extension function.
SquareArrayConstructor	An expression that delivers a fixed size array whose members are the result of evaluating corresponding expressions: [a,b,c,d]
StackFrame	This class represents a stack frame holding details of the variables used in a function or in an XSLT template.
StandardCollationURIResolver	StandardCollationURIResolver allows a Collation to be created given a URI starting with "http://saxon.sf.net/collation" followed by a set of query parameters.
StandardCollectionFinder	Default implementation of the CollectionFinder interface.
StandardDiagnostics	This class is an abstract superclass of classes such as the StandardErrorListener and StandardInvalidityHandler, and exists to provide common utility methods for these classes, and for similar user-written classes if required
StandardEnvironmentVariableResolver	Default implementation of the EnvironmentVariableResolver.
StandardErrorHandler	A default implementation of the SAX ErrorHandler interface.
StandardErrorListener	StandardErrorListener is the standard error handler for XSLT and XQuery processing errors, used if no other ErrorListener is nominated.
StandardErrorReporter	StandardErrorReporter is the standard error handler for processing XSLT and XQuery static errors, used if no other error handler is nominated.
StandardInvalidityHandler	This class StandardInvalidityHandler, despite its name, is not directly used by Saxon, and in particular it is NOT the default InvalidityHandler.
StandardLogger	The default Logger used by Saxon on the Java platform.
StandardMessageHandler	This is the default implementation of the new Saxon 11 interface for user-defined handling of xsl:message and xsl:assert output.
StandardModuleURIResolver	This class is the standard ModuleURIResolver used to implement the "import module" declaration in a Query Prolog.
StandardNames	Well-known names used in XSLT processing.
StandardObjectConverter	This class provides all the conversion methods used to convert data between XDM values and Java values in the XQJ API.
StandardOutputResolver	This class defines the default OutputURIResolver.
StandardResultDocumentResolver	This class defines the default ResultDocumentResolver.
StandardSchemaResolver	The default schema resolver used when no other is requested
StandardUnparsedTextResolver	Default implementation of the UnparsedTextURIResolver, used if no other implementation is nominated to the Configuration.
StandardURIChecker	This class checks whether a string is a valid URI.
StandardURIResolver	This class provides the service of converting a URI into an Source.
StartsWith	Implements the fn:starts-with() function, with the collation already known
State	A State is a dynamic state of the finite state machine.
StatefulSystemFunction
StaticBaseUri	Implement the XPath function static-base-uri()
StaticContext	A StaticContext contains the information needed while an expression or pattern is being parsed.
StaticContextAccessor	A StaticContextAccessor is a function that takes no arguments, but operates implicitly on the static context.
StaticContextAccessor.DefaultCollation	Implement the XPath function default-collation()
StaticError	The StaticError interface is retained in Saxon 10.0 as a marker interface so that the methods XsltCompiler.setErrorList(List) and XQueryCompiler.setErrorList(List) continue to function.
StaticFunctionCall	A call to a function that is known statically.
StaticProperty	This class contains constants identifying dependencies that an XPath expression might have on its context.
StaticQueryContext	StaticQueryContext contains information used to build a StaticContext for use when processing XQuery expressions.
StaticQueryContextEE	A version of StaticQueryContext for Saxon-EE, that extends the capability by allowing compilation of library modules.
StaticQueryContextFactory	Factory class for creating a customized instance of StaticQueryContext
StaticQueryContextPE	A version of StaticQueryContext for Saxon-PE
Statistics	Statistics on the size of TinyTree instances, kept so that the system can learn how much space to allocate to new trees
StatisticsReporter	Generates statistics relating to a validation episode
StaxBridge	This class implements the Saxon PullProvider API on top of a standard StAX parser (or any other StAX XMLStreamReader implementation)
StAXResultHandler	StAxResultHandler is a helper class
StAXResultHandlerImpl	StAxResultHandler is used to allow a transformation result to be supplied as a StAXResult.
Step<T extends XdmItem>	A Step is a function that can be applied to an item to return a stream of items.
SteppingNavigator	The SteppingNavigator is a utility class containing methods to assist with navigating a tree whose nodes implement the SteppingNode interface
SteppingNavigator.DescendantAxisIterator	An iterator over the descendant or descendant-or-self axis
SteppingNode	This interface can be implemented by an implementation of NodeInfo to take advantage of a generic implementation of the descendant axis found in class SteppingNavigator
Steps	This non-instantiable class provides a number of useful implementations of the Step interface, used to navigate XDM trees, typically as an argument to XdmValue.select(net.sf.saxon.s9api.streams.Step<T>).
Streamability	Supporting class for assessing the streamability of expressions.
StreamableUserFunction	Represents a used-defined XSLT function whose declared streamability is other than "unclassified"
StreamAvailable	This class implements the XSLT 3.0 function stream-available()
StreamerMap
StreamFn	This class implements the saxon:stream() extension function.
StreamingAdjunct	This abstract class supplements an Expression with methods used at compile-time to support streaming, by generating a Watch that allows the expression to be evaluated in push mode.
StreamingArgumentEvaluator	Elaborator for the first argument of a streamable stylesheet function
StreamingFilterImpl	StreamingFilterImpl is an XMLFilter (a SAX2 filter) that performs a transformation taking a SAX stream as input and producing a SAX stream as output, using XSLT 3.0 streaming to process the source
StreamingFunctionArgumentPattern	This is a special pattern that matches the node supplied as the first argument of a call to a streamable stylesheet function; it corresponds to the pattern match="$arg" where $arg is the first argument of the function.
StreamingPatternMaker	Factory class to make a streaming pattern from an expression.
StreamingSequenceWriter	A SequenceWriter that can be used on a streaming pipeline to direct the output of an operation to the next expression in the pipeline
StreamingTransformerFactory	The is a customized JAXP TransformerFactory implementation for the enterprise edition of Saxon.
StreamingTransformerImpl	Saxon implementation of the JAXP Transformer interface.
StreamInstr	Implementation of the xsl:source-document (streamable="yes") instruction
StreamInstr.StreamInstrElaborator
StreamWatch
StreamWriterToReceiver	This class implements the XmlStreamWriter interface, translating the events into Saxon Receiver events.
String_1	Implement XPath function string() with a single argument
String_1.StringFnElaborator
StringCollator	This interface represents a "collation" as defined in XPath, that is, a set of rules for comparing strings
StringConstants	Contains constants representing some frequently used strings, either as a UnicodeString or in some cases as a byte array.
StringConverter	A Converter that accepts a string as input.
StringConverter.StringToAnyURI	Converts string to anyURI
StringConverter.StringToBase64Binary	Converts string to base64
StringConverter.StringToBoolean	Converts a string to a boolean
StringConverter.StringToDate	Converts a string to a date
StringConverter.StringToDateTime	Converts a string to a dateTime
StringConverter.StringToDateTimeStamp	Converts a string to a dateTimeStamp
StringConverter.StringToDayTimeDuration	Converts a string to a dayTimeDuration
StringConverter.StringToDecimal	Converts a string to an xs:decimal
StringConverter.StringToDerivedStringSubtype	Converts from xs;string to a user-defined type derived from a built-in subtype of xs:string
StringConverter.StringToDuration	Converts a string to a duration
StringConverter.StringToFloat	Converts a string to xs:float
StringConverter.StringToGDay	Converts a string to a gDay
StringConverter.StringToGMonth	Converts a string to a gMonth
StringConverter.StringToGMonthDay	Converts a string to a gMonthDay
StringConverter.StringToGYear	Converts a string to a gYear
StringConverter.StringToGYearMonth	Converts a string to a gYearMonth
StringConverter.StringToHexBinary	Converts a string to hexBinary
StringConverter.StringToInteger	Converts a string to an integer
StringConverter.StringToIntegerSubtype	Converts a string to a built-in subtype of integer
StringConverter.StringToLanguage	Converts from xs:string to xs:language
StringConverter.StringToName	Converts from xs:string to xs:Name
StringConverter.StringToNCName	Converts from xs:string to xs:NCName, xs:ID, xs:IDREF, or xs:ENTITY
StringConverter.StringToNMTOKEN	Converts from xs:string to xs:NMTOKEN
StringConverter.StringToNonStringDerivedType	Converter from string to a derived type (derived from a type other than xs:string), where the derived type needs to retain the original string for validating against lexical facets such as pattern.
StringConverter.StringToNormalizedString	Converts from xs:string to xs:normalizedString
StringConverter.StringToNotation	Converts String to NOTATION
StringConverter.StringToQName	Converts String to QName
StringConverter.StringToString	Converts from xs:string or xs:untypedAtomic to xs:String
StringConverter.StringToStringSubtype	Converts from xs:string to a user-defined type derived directly from xs:string
StringConverter.StringToTime	Converts a string to a time
StringConverter.StringToToken	Converts from xs:string to xs:token
StringConverter.StringToUnionConverter	Converter from string to plain union types
StringConverter.StringToUntypedAtomic	Converts from xs:string or xs:untypedAtomic to xs:untypedAtomic
StringConverter.StringToYearMonthDuration	Converts a string to a yearMonthDuration
StringElaborator	An abstract Elaborator for expressions that evaluate their result as a single string (that is, as an instance of UnicodeString); they may also return null to indicate that the result is an empty sequence.
StringEvaluator	A StringEvaluator is a function that typically encapsulates the logic for evaluating an expression that returns a string.
StringFnStreamer	Streaming code to implement the XPath string() function
StringJoin	fn:string-join(string* $sequence, string $separator)
StringLength_1	Implement the XPath string-length() function
StringLength_1.StringLengthFnElaborator
StringLiteral	Subclass of Literal used specifically for string literals, as this is a common case
StringToCodepoints	This class supports the function string-to-codepoints()
StringToDouble	This class converts a string to an xs:double according to the rules in XML Schema 1.0
StringToDouble11	Convert a string to a double using the rules of XML Schema 1.1
StringTool
StringValue	An atomic value of type xs:string.
StringValue.Builder
StringValue.CharacterIterator	CharacterIterator is used to iterate over the characters in a string, returning them as integers representing the Unicode code-point.
StringValueFeed	This class is used when a streamed template requests evaluation of the string value of the nodes selected by a path expression, typically in response to an xsl:value-of instruction.
StringValueGatherer	A StringValueGatherer is a Receiver that computes the string value of an element in streaming mode, by copying all the text nodes to a supplied receiver.
StringView	An implementation of the UnicodeString interface that wraps an ordinary Java string.
Stripper	The Stripper class performs whitespace stripping according to the rules of the xsl:strip-space and xsl:preserve-space instructions.
Stripper.StripRuleTarget
StructuredQName	This class provides an economical representation of a QName triple (prefix, URI, and localname).
StyleElement	Abstract superclass for all element nodes in the stylesheet.
StyleElement.OnFailure
StyleNodeFactory	Class StyleNodeFactory.
StyleNodeFactoryEE	Class StyleNodeFactoryEE: Subclass of StyleNodeFactory used for Saxon-EE.
StyleNodeFactoryPE	Class StyleNodeFactoryPE: Subclass of StyleNodeFactory used for Saxon-PE.
StylesheetCache	A cache of the stylesheets (as XsltExecutables) used in calls to the fn:transform function, in a stylesheet or query.
StylesheetComponent	This interface is implemented by all top-level XSL elements that can contain local variable declarations.
StylesheetFunctionLibrary	A StylesheetFunctionLibrary contains functions defined by the user in a stylesheet.
StylesheetModule	A stylesheet module represents a module of a stylesheet.
StylesheetPackage	A (compiled) stylesheet package.
StylesheetPackageEE	Subclass of StylesheetPackage for Saxon-EE
StylesheetSpaceStrippingRule	A whitespace stripping rule that strips whitespace according to the rules defined for XSLT stylesheets
SubscriptExpression	A SubscriptExpression represents a FilterExpression of the form EXPR[n] where n is known to be singleton numeric and to be independent of the focus; it does not need to be constant
SubscriptExpression.SubscriptExprElaborator	An elaborator for a "subscript" expression, typically written as X[$n] where $n is an integer or a numeric expression.
SubscriptExpressionAdjunct	Streaming code for a subscript expression
Subsequence_2	Implements the XPath 2.0 subsequence() function with two arguments
Subsequence_3	Implements the XPath 2.0 subsequence() function with three arguments
SubsequenceIterator	A SubsequenceIterator selects a subsequence of a sequence
SubsequenceStreamer	Generate streaming code for a subsequence() function call.
SubsequenceStreamer.SubsequenceFilter
Substring	This class implements the XPath substring() function
Substring.SubstringFnElaborator
SubstringAfter	Implements the fn:substring-after() function with the collation already known
SubstringAfter.SubstringAfterFnElaborator
SubstringBefore	Implements the fn:substring-before() function with the collation already known
SubstringBefore.SubstringBeforeFnElaborator
SubstringMatcher	This interface is implemented by a collation that is capable of supporting the XPath functions that require matching of a substring: namely contains(), starts-with, ends-with, substring-before, and substring-after.
SuffixState	The state of a finite state machine that is processing "suffix" open content.
Sum	Implementation of the fn:sum function
Sum.SumFnElaborator
Sum.SumFold	Implementation of Fold class to do the summation in push mode
SuperId	The XPath id() or element-with-id() function XPath 2.0 version: accepts any sequence as the first parameter; each item in the sequence is taken as an IDREFS value, that is, a space-separated list of ID values.
SuperId.ElementWithId
SuperId.Id
SuppliedParameterReference	Supplied parameter reference: this is an internal expression used to refer to the value of the n'th parameter supplied on a template call or a call to an inline function.
SuppliedParameterReference.SuppliedParameterReferenceElaborator
Sweep	The posture of an expression defines the relationship of the result to a streamed input document, as defined in the XSLT 3.0 specification.
SwitchAdjunct	Streaming code to implement a switch expression, which results from optimizing a choose where all the branches have similar test conditions.
SwitchCaseComparer	A comparer that compares atomic values for equality, with the properties: - non-comparable types compare false - NaN compares equal to NaN Used for comparisons in XQuery Switch expressions
SwitchCaseComparison	Class to handle comparisons for XQuery switch expressions.
SwitchExpression	An optimized Choose expression in which all the branches are tests of the same expression for equality with some value.
SwitchExpression.SwitchCaseInfo	Data structure used for holding details of a switch expression
SwitchExpression.SwitchExprElaborator	Elaborator for a "Switch" expression (typically an xsl:choose that tests one expression against a list of constants: not exactly equivalent to an XQuery 3.1 switch expression).
SymbolicName	The symbolic name of a component consists of the component kind (e.g.
SymbolicName.F	Subclass of SymbolicName used for function names (including the arity)
SymbolSpace	This class holds constants used to identify the various symbol spaces defined in XML Schema: element declarations, attribute declarations, types, groups, and so on.
SystemFunction	Abstract superclass for calls to functions in the standard function library
SystemFunctionCall	A call to a system-defined function (specifically, a function implemented as an instance of SystemFunction)
SystemFunctionCall.Optimized	Subclass representing a system function call that has been optimized; this overrides the optimize() method to do nothing, thus ensuring that optimization converges.
SystemFunctionCall.SystemFunctionCallElaborator	Elaborator for a system function call, used in cases where the specific function call has no custom support
SystemFunctionWithBoundContextItem	A Callable that wraps another Callable and a Dynamic Context, in effect acting as a closure that executes the original callable with a saved context.
SystemIdMap	System IDs are not held in nodes in the tree, because they are usually the same for a whole document.
SystemLogger	An implementation of Saxon's Logger interface that writes all messages through to a supplied java.util.logging.Logger.
SystemProperty	Implementation of the XSLT system-property() function
TabulateMaps	Handler for a saxon:tabulate-maps instruction in an XSLT stylesheet.
TailCall	Interface representing a Tail Call.
TailCallLoop	A TailCallLoop wraps the body of a function that contains tail-recursive function calls.
TailCallLoop.TailCallComponent
TailCallLoop.TailCallFunction
TailCallLoop.TailCallInfo
TailExpression	A TailExpression represents a FilterExpression of the form EXPR[position() > n] Here n is usually 2, but we allow other values
TailExpression.TailExprElaborator	Elaborator for a tail expression
TailExpressionAdjunct
TailFn	This class implements the function fn:tail(), which is a standard function in XPath 3.0
TailIterator	TailIterator iterates over a base sequence starting at an element other than the first.
Talker	Interface for a simple line-based question/answer dialog with the user
TeeDestination	A TeeDestination allows writing to two destinations at once.
TeeOutputter	TeeOutputter: a SequenceReceiver that duplicates received events to two different destinations
TemplateRule	The runtime object corresponding to an xsl:template element in the stylesheet.
TemplateRuleEE	Saxon-EE version of the TemplateRule class, with added code for JIT compilation and streamability analysis
TemplateRuleInitializer	A TemplateRuleInitializer is used to prepare a template rule for execution the first time that its match pattern is matched, in cases where JIT template rule compilation is in force.
TemplateRuleTraceListener	A trace listener for XSLT that only handles invocation of template rules; enabled using saxon:trace="yes" on the xsl:mode declaration
TemplatesHandlerImpl	TemplatesHandlerImpl implements the javax.xml.transform.sax.TemplatesHandler interface.
TemplatesImpl	Saxon implementation of the JAXP Templates interface.
Term	Represents a Term in a content model as defined by XML Schema.
TerminationException	An exception thrown by xsl:message terminate="yes".
Terminator	A Terminator provides a method that can be called to cause early termination of a streaming pass over an input document, in the case where no more information from the document is needed.
TextComparer	A Comparer used for comparing sort keys when data-type="text".
TEXTEmitter	This class generates TEXT output
TextFragmentValue	This class represents a temporary tree whose root document node owns a single text node.
TextImpl	A node in the XML parse tree representing character content.
TextLinesIterator	An iterator that iterates over a file line by line, returning each line as a StringValue
TextOnlyCopyRuleSet	The built-in rule set used for 1.0 and 2.0, which for document and element nodes does an apply-templates to children, and for text nodes and attribute nodes copies the node.
TextOverAttrInfo	This class represents a DOM text node that is the child of a DOM attribute node.
TextOverNodeInfo	This class is an implementation of the DOM Text and Comment interfaces that wraps a Saxon NodeInfo representation of a text or comment node.
TextValueTemplateContext	Define the static context for expressions appearing between curly braces in a text value template.
TextValueTemplateNode	A text node in an XSLT 3.0 stylesheet that may or may not contain a text value template
ThreadManagerEE	The ThreadManager is used to manage asynchronous execution of xsl:result-document instructions in Saxon-EE.
Timer	Utility class for collecting and reporting timing information, used only under diagnostic control
TimestampFn	This class implements the saxon:timestamp() function which returns the date/time at the moment of execution
TimeValue	A value of type xs:time
TimeValue.TimeComparable
TimingCodeInjector	A code injector that wraps the body of a template or function in a TraceExpression, which causes the TimingTraceListener to be notified at the start and end of the function/template evaluation
TimingTraceListener	A trace listener that records timing information for templates and functions, outputting this information as an HTML report to a specified destination when the transformation completes.
TinyAttributeImpl	A node in the XML parse tree representing an attribute.
TinyBuilder	The TinyBuilder class is responsible for taking a stream of SAX events and constructing a Document tree, using the "TinyTree" implementation.
TinyBuilderCondensed	Variant of the TinyBuilder to create a tiny tree in which multiple text nodes or attribute nodes sharing the same string value economize on space by only holding the value once.
TinyBuilderMonitor	Monitor construction of a TinyTree.
TinyDocumentImpl	A node in the XML parse tree representing the Document itself (or equivalently, the root node of the Document).
TinyElementImpl	A node in the XML parse tree representing an XML element.
TinyNodeImpl	A node in a TinyTree representing an XML element, character content, or attribute.
TinyParentNodeImpl	TinyParentNodeImpl is an implementation of a non-leaf node (specifically, an Element node or a Document node)
TinyTextImpl	A node in the XML parse tree representing character content
TinyTextualElement	An element node in the TinyTree that has no attributes or namespace declarations and that has a single text node child.
TinyTextualElement.TinyTextualElementText	Inner class representing the text node; this is created on demand
TinyTree	A data structure to hold the contents of a tree.
Token	This class holds static constants and methods defining the lexical tokens used in XPath and XQuery, and associated keywords.
Tokenize_1	This class implements the single-argument tokenize() function introduced in XPath 3.1
Tokenize_3	This class implements the 3-argument tokenize() function for regular expression matching.
Tokenizer	Tokenizer for expressions and inputs.
TokenMatchOperand	Given an expression, this characteristic evaluates the set of hash keys corresponding to the whitespace-separated tokens in the string values of the items selected by that expression.
ToLower	Class to perform lowercase conversion.
TopDownStackIterable<T>	Provides an iterable over a stack that iterates in order from top to bottom.
TotalDigitsFacet	Eepresents the value of the totalDigits facet
ToUpper	Class to perform uppercase conversion.
Trace	This class supports the XPath 2.0 function trace().
Traceable	A construct whose execution can be notified to a TraceListener.
TraceableComponent	A construct whose execution can be notified to a TraceListener.
TraceClause	A "trace" clause in a FLWOR expression, added by a TraceCodeInjector for diagnostic tracing, debugging, profiling or similar purposes.
TraceClausePull	This class represents the tuple stream delivered as the output of a trace clause in a FLWOR expression.
TraceClausePush	This class represents the tuple stream delivered as the output of a trace clause in a FLWOR expression.
TraceCodeInjector	A code injector that wraps every expression (other than a literal) in a TraceExpression, which causes a TraceListener to be notified when the expression is evaluated
TraceEventMulticaster	A class which implements efficient and thread-safe multi-cast event dispatching for the TraceListener evants.
TraceExprAdjunct	Implement streaming of the trace instruction injected into the code when compiled with tracing enabled.
TraceExpression	A wrapper expression used to trace expressions in XSLT and XQuery.
TraceListener	This interface defines methods that are called by Saxon during the execution of a stylesheet or query, if tracing is switched on.
TraceStreamer	Implement streaming of fn:trace instruction.
TracingFilter	A filter that can be inserted into a Receiver pipeline to trace the events that pass through.
Transform	This is a synonym of the command line interface net.sf.saxon.Transform for running XSLT transformations.
Transform	This Transform class is the command-line entry point to the Saxon XSLT Processor.
TransformerFactoryImpl	A TransformerFactory instance can be used to create Transformer and Template objects.
TransformerHandlerImpl	TransformerHandlerImpl implements the javax.xml.transform.sax.TransformerHandler interface.
TransformerImpl	Saxon implementation of the JAXP Transformer interface.
TransformerReceiver	TransformerReceiver is similar in concept to the JAXP TransformerHandler, except that it implements Saxon's Receiver interface rather than the standard SAX2 interface.
TransformFn	This class implements the saxon:transform() extension function (not to be confused with the standard fn:transform() function in XPath 3.1)
TransformFn	This class implements the function transform(), which is a standard function in XPath 3.1
TransitiveClosure	Function fn:transitive-closure, proposed for 4.0 (revised simplified 2-argument form in PR 761)
Translate	Implement the XPath translate() function
Translate.TranslateFnElaborator
TransmissionAdjunct	A subclass of StreamingAdjunct used for expressions that have a sequence-valued operand with usage transmission.
TreatExpression	Treat Expression: implements "treat as data-type ( expression )".
TreatFn	This class supports the XPath 2.0 functions exactly-one(), one-or-more(), zero-or-one().
TreatFn.ExactlyOne
TreatFn.OneOrMore
TreatFn.ZeroOrOne
TreatFnStreamer	Generate streaming code for a "treat" function call (for example one-or-more)
TreeInfo	This interface represents information about a tree as a whole.
TreeModel	A TreeModel represents an implementation of the Saxon NodeInfo interface, which itself is essentially an implementation of the XDM model defined in W3C specifications (except that Saxon's NodeInfo understands the 13 XPath axes, rather than merely supporting parent and child properties).
TreeReceiver	A TreeReceiver acts as a bridge between a SequenceReceiver, which can receive events for constructing any kind of sequence, and an ordinary Receiver, which only handles events relating to the building of trees.
TreeStatistics
TreeWalker	This implementation of the Saxon pull interface starts from any NodeInfo, and returns the events corresponding to that node and its descendants (including their attributes and namespaces).
TrieKVP<K,V>
Trigger	A Trigger is a Watch that contains a pattern used for matching streamed nodes, and a WatchAction which is invoked when a matching node is found.
Trunk	This class implements the function fn:trunk(), which is proposed as a standard function in XPath 4.0
TryCatch	This class implements a try/catch expression.
TryCatch.CatchClause
TryCatchAdjunct	Streaming code for a try/catch expression
TryCatchAdjunct.TryCatchFeed
Tuple	A tuple, as it appears in an XQuery tuple stream handled by extended FLWOR expressions.
TupleExpression	A tuple expression is an expression that returns a FLWOR tuple.
TuplePull	Abtract class representing a tuple stream (used to evaluate a FLWOR expression) in pull mode (where the consumer of tuples activates the provider of those tuples)
TuplePush	Abtract class representing a tuple stream (used to evaluate a FLWOR expression) in push mode (where the provider of tuples activates the consumer of those tuples)
Twine16	Twine16 is a Unicode string consisting entirely of codepoints in the range 0-65535 (that is, the basic multilingual plane), excluding surrogates.
Twine24	Twine24 is Unicode string that accommodates any codepoint value up to 24 bits.
Twine8	Twine8 is Unicode string whose codepoints are all in the range 0-255 (that is, Latin-1).
TwineConsumer	Interface that accepts a a sequence of Unicode codepoints.
TwoItemIterator	An iterator over a pair of objects (typically sub-expressions of an expression)
Type	This class contains static information about types and methods for constructing type codes.
TypeAliasManager	Manager for xsl:item-type declarations in a stylesheet.
TypeAlternative	A TypeAlternative schema component (See XML Schema 1.1 Part 1 Working Draft)
TypeAvailable	This class supports the XSLT fn:type-available() function.
TypeChecker	This class provides Saxon's type checking capability.
TypeChecker10	This class provides type checking capability with XPath 1.0 backwards compatibility enabled.
TypeCheckingFilter	A filter on the push pipeline that performs type checking, both of the item type and the cardinality.
TypedContentHandler	This class is an extension of ContentHandlerProxy that provides access to type information, using the DOM Level 3 TypeInfo interfaces.
TypedStreamSource	A StreamSource augmented with ContentType information, which potentially provides the media type and encoding
TypedValueFeed	This class is used when a streamed template requests evaluation of the typed value of the nodes selected by a path expression.
TypeHierarchy	This class exists to provide answers to questions about the type hierarchy.
TypeHierarchyEE	Refinement of the TypeHierarchy class to handle schema-aware types such as schema-element(A).
TypeInfoImpl	This class implements the DOM TypeInfo interface as a wrapper over the Saxon SchemaType interface.
TypeReference	A reference to a simple or complex type
TypeStrippedDocument	A TypeStrippedDocument represents a view of a real Document in which all nodes are untyped
TypeStrippedNode	A TypeStrippedNode is a view of a node, in a virtual tree that has type annotations stripped from it.
UcaCollationKeyUsingIcu	This class is an implementation of Saxon collation keys based on the functionality of collation keys supplied by the ICU library.
UcaCollatorUsingIcu	This class represents a collation (for comparing strings) implemented using the ICU library.
UcaCollatorUsingJava	This class implements (an approximation to) the UCA Collation Algorithm relying solely on the built-in Java support (that is, without using the ICU library).
UnaryExpression	Unary Expression: an expression taking a single operand expression
UnboundFunctionLibrary	An UnboundFunctionLibrary is not a real function library; rather, it is used to keep track of function calls that cannot yet be bound to a known declared function, but will have to be bound when all user-declared functions are available.
UnboundFunctionLibrary.UnboundFunctionCallDetails
UncheckedXPathException	When implementing certain interfaces Saxon is not able to throw a checked exception because the interface definition does not allow it.
UncommittedSerializer	This class is used when the decision on which serialization method to use has to be delayed until the first element is read.
UndeclaredVariable	An UndeclaredVariable object is created when a reference is encountered to a variable that has not yet been declared.
UnescapeNCName	The saxon:unescape-NCName function reverses the effect of saxon:escape-NCName: it takes an NCName constructed using saxon:escape-NCName as input, and returns the string from which it was constructed.
UnfailingPullProvider	PullProvider is Saxon's pull-based interface for reading XML documents and XDM sequences.
UnicodeBlocks	This singleton class provides knowledge of the names and contents of Unicode character blocks, as referenced using the \p{IsXXXXX} construct in a regular expression.
UnicodeBuilder	Builder class to construct a UnicodeString by appending text incrementally
UnicodeChar	A UnicodeString containing a single codepoint
UnicodeNormalizer	UnicodeNormalizer: This ProxyReceiver performs unicode normalization on the contents of attribute and text nodes.
UnicodeString	A UnicodeString is a sequence of Unicode codepoints that supports codepoint addressing.
UnicodeStringEvaluator	A StringEvaluator is a function that typically encapsulates the logic for evaluating an expression that returns a string, in the form of a UnicodeString
UnicodeWriter	Interface that accepts strings in the form of UnicodeString objects, which are written to some destination.
UnicodeWriterResult	An UnicodeWriterResult encapsulates a UnicodeWriter to act as the destination for a transformation or serialization
UnicodeWriterToWriter	Implementation of UnicodeWriter that converts Unicode strings to ordinary Java strings and sends them to a supplied Writer
Unindexed	The extension function saxon:unindexed returns the value of its argument unchanged.
UnionCastableFunction	Function to test castability to a union type
UnionConstructorFunction	Function to perform a cast to a union type
UnionEnumeration	An enumeration representing a nodeset that is a union of two other NodeSets.
UnionIterator	A multi-way union delivering the sorted results obtained from a number of sorted input iterators
UnionPattern	A pattern formed as the union (or) of two other patterns
UnionQNameTest	A QNameTest that is the union of a number of supplied QNameTests
UnionType	Interface representing a union type.
Unique	This class represents an xs:unique identity constraint
UniStringConsumer	Interface that accepts a string in the form of a sequence of CharSequences, which are conceptually concatenated (though in some implementations, the final string may never be materialized in memory)
UniversalPattern	The UniversalPattern matches everything
UnknownElement	An unknown element in an XML Schema document.
UnknownResource	The class is an implementation of the generic Resource object (typically an item in a collection) representing a resource whose type is not yet known - typically because it uses an unregistered file extension.
Unordered	XPath 2.0 unordered() function
UnparcelFn	This class implements the function fn:unparcel(), which is a proposed function in XPath 4.0 to unwrap a sequence that has been wrapped as a parcel item
UnparsedEntity	Implements the unparsed-entity-uri() function defined in XSLT 1.0 and the unparsed-entity-public-id() function defined in XSLT 2.0
UnparsedEntity	This class is used to represent unparsed entities in the PullProvider interface
UnparsedEntity.UnparsedEntityPublicId
UnparsedEntity.UnparsedEntityUri
UnparsedText	Implementation of fn:unparsed-text() - with one argument or two
UnparsedTextAvailable
UnparsedTextFunction	Abstract superclass containing common code supporting the functions unparsed-text(), unparsed-text-lines(), and unparsed-text-available()
UnparsedTextIterator	Class UnparsedTextIterator, iterates over a file line by line
UnparsedTextLines
UnparsedTextResource	This class implements th interface Resource.
UnparsedTextURIResolver	An UnparsedTextURIResolver accepts an absolute URI and optionally an encoding name as input, and returns a Reader as its result.
UnprefixedElementMatchingPolicy	An enumeration defining possible strategies for resolving unprefixed element names appearing as name tests in the steps of a path expression or XSLT match pattern
UnresolvedXQueryFunctionItem
Untyped	This class has a singleton instance which represents the complex type xdt:untyped, used for elements that have not been validated.
UntypedAtomizingIterator	AtomizingIterator returns the atomization of an underlying sequence supplied as an iterator.
UntypedNumericComparer	A specialist comparer that implements the rules for comparing an untypedAtomic value (always the first operand) to a numeric value (always the second operand)
UntypedSequenceConverter	An UntypedSequenceConverter is an expression that performs a cast on each member of a supplied sequence that is an untypedAtomic value, while leaving other items unchanged
UntypedSequenceConverter.UntypedConverter	A Converter that converts untyped atomic values to the required type, while leaving other values unchanged
UntypedSequenceConverter.UntypedSequenceConverterElaborator	Elaborator for an UntypedSequenceConverter
UpdateAgent	An UpdateAgent is a callback class that is called to handle a document after it has been updated.
UpdateElaborator	Abstract evaluator for XQuery Update expressions.
UpdateEvaluator	Interface implemented by XQuery Update expressions, to evaluate an update expression by adding update primitives to a supplied pending update list.
UpdateParser	Parser utility methods for the XQuery Update extensions
UpperCase	This class implements the fn:upper-case() function
UpperCase.UpperCaseFnElaborator
URIChecker	This interface defines a method for checking whether a string is considered to be a valid URI.
UriCollection	Implement the fn:uri-collection() function (new in XQuery 3.0/XSLT 3.0).
URIFunctions	Common declarations for BuildURI and ParseURI.
URIQueryParameters	A set of query parameters on a URI passed to the collection() or document() function
URIQueryParameters.RegexFilter	A FilenameFilter that tests file names against a regular expression
UseAttributeSet	This instruction corresponds to a single QName appearing within a use-attribute-sets attribute on a literal result element, xsl:element, or xsl:copy instruction.
UseAttributeSet.UseAttributeSetElaborator
UseAttributeSetAdjunct
UsePack	Describes an xsl:use-package requirement from within a package, in terms of a name and a set of version ranges
UserAtomicType	An object belonging to this class represents an atomic type: either a built-in atomic type, or a user-defined atomic type.
UserComplexType	A user-defined complex type (that is, any complex type other than xs:anyType)
UserDefinedType	This class represents a user-defined simple type or complex type as defined in XML Schema.
UserFunction	This object represents the compiled form of a user-written function (the source can be either an XSLT stylesheet function or an XQuery function).
UserFunction.Determinism
UserFunctionCall	This class represents a call to a user-defined function in the stylesheet or query.
UserFunctionCallAdjunct	Handle streaming for calls to user-defined functions Used only for XSLT streaming capability.
UserFunctionParameter	Run-time object representing a formal argument to a user-defined function
UserFunctionReference	A UserFunctionReference is an expression in the form local:f#1 where local:f is a user-defined function.
UserFunctionReference.BoundUserFunction	A BoundUserFunction represents a user-defined function seen as a component.
UserFunctionResolvable	A reference to a function; typically a forwards reference to a user-defined function in XQuery that has not yet been compiled.
UserListType	Represents a SimpleType that is a list of a given SimpleType, known as its itemType.
UserSchemaComponent	A SchemaComponent is an object in a schema.
UserSimpleType	This class represents a used-defined simple type, as defined in the XML Schema specification.
UserUnionType	A class that represents the XML Schema simple-type with variety union.
UseWhen30FunctionSet	Function signatures (and pointers to implementations) of the functions available for use in static expressions (including use-when expressions) in XSLT 3.0 stylesheets
UseWhen40FunctionSet
UseWhenFilter	This is a filter inserted into the input pipeline for processing stylesheet modules, whose task is to evaluate use-when expressions and discard those parts of the stylesheet module for which the use-when attribute evaluates to false.
UseWhenStaticContext	This class implements the static context used for evaluating use-when and other static expressions in XSLT 3.0 A new instance of this class is created for each use-when expression encountered; there are therefore no issues with reusability.
UTF16CharacterSet	A class to hold some static constants and methods associated with processing UTF16 and surrogate pairs
UTF8CharacterSet	This class defines properties of the UTF-8 character set
UTF8Writer	Specialized buffering UTF-8 writer.
UType	A UType is a union of primitive (atomic, node, or function) item types.
Validate	This Validate class provides a command line interface that allows validation of a source document against a schema, and/or checking that a source schema is a valid schema.
ValidateFn	This class implements the saxon:validate() extension function.
ValidatingFilter	This class is used for a filter on the validation pipeline.
ValidatingInstruction	Interface implemented by instructions that have validation and type attributes
ValidatingReader	This class is a Saxon implementation of XMLReader that performs schema validation using Saxon's schema processor.
Validation	This class contains constants and static methods to manipulate the validation property of a type.
ValidationContext	This class defines information about a validation episode
ValidationException	This exception indicates a failure when validating an instance against a type defined in a schema.
ValidationFailure	This exception indicates a failure when validating an instance against a type defined in a schema.
ValidationMode	Enumeration class defining different schema validation (or construction) modes
ValidationParams	This class represents a collection of parameter values for use in schema validation; it defines values for the parameters declared using the saxon:param XSD extension.
ValidationStack	This class manages the receivers that do element content validation.
ValidationStatistics	Class for collection validation statistics produced via s9api processing
ValidationStatisticsRecipient	Defines a class that is notified of validation statistics at the end of a validation episode
ValidatorHandlerImpl	The is the Saxon implementation of the JAXP 1.3 ValidatorHandler interface.
ValidatorImpl	This class in the Saxon implementation of the JAXP 1.3 Validator "interface" (which is actually defined as an abstract class).
ValidatorImpl.InvalidityHandlerWrappingErrorHandler	Interface for reporting validation errors found during validation of an instance document against a schema.
ValueComparison	ValueComparison: a boolean expression that compares two atomic values for equals, not-equals, greater-than or less-than.
ValueComparison.ValueComparisonElaborator	Elaborator for a value comparison (such as A eq B), including the case where a general comparison is reduced to a value comparison by the optimiser
ValueConstraint	A value constraint represents the default or fixed value of an element declaration, attribute declaration, or attribute use
ValueConstraint.Variety
ValueOf	An xsl:value-of element in the stylesheet.
ValueRangeFacet	Represents any of the facets minInclusive, maxInclusive, minExclusive, maxExclusive
ValueTailIterator	ValueTailIterator iterates over a base sequence starting at an element other than the first.
Valve	A Valve is a general-purpose component for use in a pipeline of receivers.
VariableReference	Variable reference: a reference to a variable.
VariableReferenceAdjunct
VendorFunctionSetEE	The VendorFunctionLibraryEE represents additions to the set of Saxon vendor-supplied extension functions that are available only with the Saxon-EE edition
VendorFunctionSetHE	Implementation of vendor functions in the Saxon namespace, available in Saxon-HE because they are used internally.
VendorFunctionSetHE.ArrayAsSequenceOfMaps	Implementation of the function saxon:array-as-sequence-of-maps(array)
VendorFunctionSetHE.ConcatenateSequences
VendorFunctionSetHE.DynamicErrorInfoFn	Implement saxon:dynamic-error-info
VendorFunctionSetHE.HasLocalNamespaces	Implement saxon:has-local-namespaces.
VendorFunctionSetHE.HasUniformNamespaces	Implement saxon:has-uniform-namespaces.
VendorFunctionSetHE.IsWholeNumberFn	Implement saxon:is-whole-number
VendorFunctionSetHE.MapAsSequenceOfMaps	Implementation of the function saxon:map-as-sequence-of-maps(array)
VendorFunctionSetHE.YesNoBoolean
VendorFunctionSetPE	The VendorFunctionLibraryPE represents additions to the set of Saxon vendor-supplied extension functions that are available only with the Saxon-PE and Saxon-EE editions
VendorFunctionSetPE.AdjustToCivilTime
VendorFunctionSetPE.Base64BinaryToOctets
VendorFunctionSetPE.Base64BinaryToString
VendorFunctionSetPE.ColumnNumber
VendorFunctionSetPE.ConfigurationFn
VendorFunctionSetPE.ContextFn
VendorFunctionSetPE.ControllerFn
VendorFunctionSetPE.CurrentModeName
VendorFunctionSetPE.DiscardDocument	Implement the saxon:discard-document() function, which returns its argument unchanged, but with the side-effect of removing it from the document pool, making it eligible for garbage collection.
VendorFunctionSetPE.GetContext
VendorFunctionSetPE.GetPseudoAttribute
VendorFunctionSetPE.HasSameNodes
VendorFunctionSetPE.HexBinaryToOctets
VendorFunctionSetPE.HexBinaryToString
VendorFunctionSetPE.InSummerTime
VendorFunctionSetPE.IsDefaulted	Ask whether an attribute node exists as a result of the expansion of default and fixed values defined in a schema.
VendorFunctionSetPE.LineNumber
VendorFunctionSetPE.NamespaceNodeFn	Implement saxon:namespace-node extension function
VendorFunctionSetPE.OctetsToBase64Binary
VendorFunctionSetPE.OctetsToHexBinary
VendorFunctionSetPE.ParseDateTime
VendorFunctionSetPE.PrintStack
VendorFunctionSetPE.StringToBase64BinaryFn
VendorFunctionSetPE.StringToHexBinaryFn
VendorFunctionSetPE.StringToUTF8	Implement saxon:string-to-utf8 extension function
VendorFunctionSetPE.SystemId
VendorFunctionSetPE.TunnelParamsFn	Implement saxon:tunnel-params extension function.
VendorFunctionSetPE.TypeAnnotationFn	Extension function saxon:type-annotation, which returns the type annotation of a node or atomic value as an xs:QName value.
VendorFunctionSetPE.UnparsedEntities	Implement saxon:unparsed-entities extension function
VendorFunctionSetPE.ValidCharacter	Implement saxon:valid-character extension function
VennExpression	An expression representing a nodeset that is a union, difference, or intersection of two other NodeSets
VennExpression.VennElaborator	Elaborator for a Venn expression: that is A union B, A intersect B, or A except B
VennExpressionAdjunct	Class to handle streaming of union, intersect, and except expressions
VennPattern	Abstract pattern formed as the union, intersection, or difference of two other patterns; concrete subclasses are used for the different operators.
Verifier	A helper class for EnterpriseConfiguration that handles license keys as issued for the Java platform.
Verifier.License
Version	The Version class holds the SAXON version information.
VersionControlFilter	This is a filter inserted into the input pipeline for processing schema documents, whose task is to examine attributes such as vc:maxVersion and discard those parts of the schema document that are to be ignored because of those attributes.
VersionedPackageName	This class represents the combination of an XSLT package name (that is, a URI) and a version number
VirtualAccumulatorData	Holds the values of an accumulator function for a virtual copy of a document (where the accumulator values are copies of those on the underlying document)
VirtualCopy	This class represents a node that is a virtual copy of another node: that is, it behaves as a node that's the same as another node, but has different identity.
VirtualCopy.VirtualCopier	VirtualCopier implements the XPath axes as applied to a VirtualCopy node.
VirtualNode	This interface is implemented by NodeInfo implementations that act as wrappers on some underlying tree.
VirtualTreeInfo	Implementation of TreeInfo for a Virtual Copy tree
VirtualUntypedCopy	This class represents a virtual copy of a node with type annotations stripped
Visibility	Enumeration class giving the different visibility levels defined for components in XSLT 3.0
VisibilityProvenance	Indicates where the visibility property of a component came from
VoidFn	This class implements the function fn:void(), which is a proposed function for XPath 4.0.
Watch	A Watch represents a class that is interested in looking at nodes passing down a push pipeline.
WatchMaker	A WatchMaker is a factory class for creating a Watch.
WatchManager	This class sits on a push pipeline and evaluates the passing element and attribute nodes.
WatchManager.ClosedownAction
WatchManager.GroupingScope
WhereClause	A "where" clause in a FLWOR expression
WhereClausePull	This class represents the tuple stream delivered as the output of a where clause in a FLWOR expression: that is, it returns all the tuples in its input stream that satisfy a specified predicate.
WhereClausePush	This class represents the tuple stream delivered as the output of a where clause in a FLWOR expression: that is, it supplies all the tuples in its input stream that satisfy a specified predicate.
WherePopulated	A compiled xsl:where-populated instruction (formerly xsl:conditional-content).
WherePopulatedAdjunct	Generate streaming code for an xsl:where-populated instruction.
WherePopulatedOutputter	This class acts as a filter on a push pipeline, allowing through only those items that are deemed non-empty according to the rules of the xsl:where-populated instruction.
While	Handler for saxon:while elements in stylesheet.
While.WhileElaborator
Whitespace	This class provides helper methods and constants for handling whitespace
Whitespace.Tokenizer	An iterator that splits a string on whitespace boundaries, corresponding to the XPath 3.1 function tokenize#1
WhitespaceFacet	Represents a whitespace facet on a schema-defined simple type
WhitespaceString	This abstract class represents a couple of different implementations of strings containing whitespace only.
WhitespaceStrippingPolicy	WhitespaceStrippingPolicy is class defining the possible policies for handling whitespace text nodes in a source document.
WhitespaceTextImpl	A node in the XML parse tree representing a text node with compressed whitespace content
Wildcard	A class that represents an XML Schema Wildcard.
WindowClause	Implements an XQuery 3.0 sliding or tumbling window clause within a FLWOR expression
WindowClause.Window	Information about a window: the items making up the window, as well as the variables relating to the start and end of the window, and the status of the winoow in relation to the processing of the current input sequence.
WindowClausePull	Implement a sliding or tumbling window clause of a FLWOR expression in tuple-pull mode.
WindowClausePush	Implement a sliding or tumbling window clause of a FLWOR expression in tuple-push mode.
WithParam	An object derived from a xsl:with-param element in the stylesheet.
WithPedigree	The saxon:with-pedigree function, new in Saxon 9.9.
WrappingFunction	Callback to create a VirtualNode that wraps a given NodeInfo
WrappingIterator	A WrappingIterator delivers wrappers for the nodes delivered by its underlying iterator.
WrappingJavaIterator<T extends Item>	A Java Iterator which wraps a supplied unfailing SequenceIterator
XdmArray	An array in the XDM data model.
XdmAtomicType
XdmAtomicValue	The class XdmAtomicValue represents an item in an XPath sequence that is an atomic value.
XdmCollectors	This class contains a number of static methods that deliver implementations of the Collector interface suitable for use with streams processing XDM nodes and other items.
XdmCollectors.MultipleItemException	Unchecked exception that occurs when a collector method such as XdmCollectors.asAtomic() or XdmCollectors.asOptionalNode() is called, and the sequence contains more than one item.
XdmDestination	An XdmDestination is a Destination in which an XdmNode is constructed to hold the output of a query or transformation: that is, a tree using Saxon's implementation of the XDM data model
XdmEmptySequence	The class XdmEmptySequence represents an empty sequence in the XDM Data Model.
XdmExternalObject	The class XdmExternalObject represents an XDM item that wraps an external (Java or .NET) object.
XdmFunctionItem	The class XdmFunctionItem represents a function item
XdmItem	The class XdmItem represents an item in a sequence, as defined by the XDM data model.
XdmMap	A map in the XDM data model.
XdmNode	This class represents a node in the XDM data model.
XdmNodeKind	Enumeration class defining the seven kinds of node defined in the XDM model
XdmSequenceIterator<T extends XdmItem>	An iterator over an XPath sequence.
XdmStream<T extends XdmItem>	XdmStream extends the capabilities of the standard JDK Stream class.
XdmToJsonFn	Implementation of the fn:xdm-to-json function proposed for 4.0
XdmValue	A value in the XDM data model.
XHTML1Emitter	XHTMLEmitter is an Emitter that generates XHTML 1 output.
XHTML5Emitter	XHTML5Emitter is an Emitter that generates XHTML 5 output.
XHTMLPrefixRemover	Filter to change elements in the XHTML, SVG, or MathML namespaces so they have no prefix (that is, to make these the default namespace).
XHTMLURIEscaper	This class performs URI escaping for the XHTML output method.
XML10ContentChecker	This class is used on the serialization pipeline to check that the document conforms to XML 1.0 rules.
XMLCharacterData	This module contains data regarding the classification of characters in XML 1.0 and XML 1.1, and a number of interrogative methods to support queries on this data.
XMLEmitter	XMLEmitter is an Emitter that generates XML output to a specified destination.
XMLIndenter	XMLIndenter: This ProxyReceiver indents elements, by adding character data where appropriate.
XMLIndenterPE	XMLIndenter with extra functionality for Saxon-PE and Saxon-EE
XMLNamespaceSchema	This module constructs synthetically (that is, without reading an XML schema document) the schema components for the XML namespace
XmlProcessingAbort	An unchecked exception, triggered when a user-supplied ErrorReporter requests that processing should be aborted
XmlProcessingError	The XmlProcessingError class contains information about an error detected during compilation or execution of a stylesheet, query, XPath expression, or schema
XmlProcessingException	The XmlProcessingException class is a concrete implementation of the XmlProcessingError interface that wraps an XPathException object.
XmlProcessingIncident	The XmlProcessingIncident class is a concrete implementation of the XmlProcessingError interface that holds all the required information internally.
XmlResource	The class is an implementation of the generic Resource object (typically an item in a collection) representing an XML document
XMLStreamWriterDestination	XMLStreamWriterDestination is a s9api Destination that writes output to a supplied XMLStreamWriter
XMLToJsonFn	Implement the XML to JSON conversion as a built-in function - fn:xml-to-json()
XmlToJsonFnStreamer	Streaming code for the xml-to-json() function
XOMDocumentWrapper	The root node of an XPath tree.
XOMNodeWrapper	A node in the XML parse tree representing an XML element, character content, or attribute.
XOMObjectModel	This interface must be implemented by any third-party object model that can be wrapped with a wrapper that implements the Saxon Object Model (the NodeInfo interface).
XOMWriter	XOMWriter is a Receiver that constructs a XOM document from the stream of events
XPath20FunctionSet	Function signatures (and pointers to implementations) of the functions defined in XPath 2.0
XPath30FunctionSet	Function signatures (and pointers to implementations) of the functions defined in XPath 3.0 without the Higher-Order-Functions feature
XPath31FunctionSet	Function signatures (and pointers to implementations) of the functions defined in XPath 3.1 without the Higher-Order-Functions feature
XPath40FunctionSet	Function signatures (and pointers to implementations) of the functions defined in XPath 4.0
XPathComparable	This interface sometimes represents an XPath atomic value where the Java comparison semantics (using the compareTo method) match the XPath equality and ordering semantics; and sometimes it represents a surrogate for an XPath atomic value, chosen so that the Java comparison semantics match the XPath rules.
XPathCompiler	An XPathCompiler object allows XPath queries to be compiled.
XPathContext	This class represents a context in which an XPath expression is evaluated.
XPathContextMajor	This class represents a "major context" in which an XPath expression is evaluated: a "major context" object allows all aspects of the dynamic context to change, whereas a "minor context" only allows changes to the focus and the destination for push output.
XPathContextMajor.ThreadManager	The ThreadManager is used to manage asynchronous execution of xsl:result-document instructions in Saxon-EE.
XPathContextMinor	This class represents a minor change in the dynamic context in which an XPath expression is evaluated: a "major context" object allows all aspects of the dynamic context to change, whereas a "minor context" only allows changes to the focus and the destination for push output.
XPathContextMinor.LastValue	Container for cached value of the last() function.
XPathDynamicContext	This object represents the dynamic XPath execution context for use in the free-standing Saxon XPath API.
XPathEvaluator	This class provides a native Saxon API for free-standing evaluation of XPath expressions.
XPathEvaluator	XPathEvaluator implements the JAXP API for standalone XPath processing (that is, executing XPath expressions in the absence of an XSLT stylesheet).
XPathException	XPathException is used to indicate an error (static or dynamic) in an XPath expression, or in a query or stylesheet.
XPathException.Circularity	Subclass of XPathException used to report circularities
XPathException.StackOverflow	Subclass of XPathException used to report stack overflow
XPathExecutable	An XPathExecutable represents the compiled form of an XPath expression.
XPathExpression	This class is a representation of an XPath Expression for use with the XPathEvaluator class.
XPathExpressionImpl	The JAXP XPathExpression interface represents a compiled XPath expression that can be repeatedly evaluated.
XPathFactoryImpl	Saxon implementation of the JAXP 1.3 XPathFactory
XPathFunctionCall	This class is an expression that calls an external function supplied using the JAXP XPathFunction interface
XPathFunctionLibrary	The XPathFunctionLibrary is a FunctionLibrary that supports binding of XPath function calls to instances of the JAXP XPathFunction interface returned by an XPathFunctionResolver.
XPathParser	Parser for XPath expressions and XSLT patterns.
XPathParser.Accelerator
XPathParser.InlineFunctionDetails
XPathParser.NestedLocation	A nested location: for use with XPath expressions and queries nested within some larger document.
XPathParser.ParsedLanguage
XPathSelector	An XPathSelector represents a compiled and loaded XPath expression ready for execution.
XPathStaticContext	This interface defines methods that must be provided when Saxon's free-standing XPath API is used.
XPathVariable	An object representing an XPath variable for use in the standalone XPath API.
XQCancelledException	XQCancelledException is an exception to indicate that the current XQuery processing is cancelled by the application through a cancel() request.
XQConnection	A connection (session) with a specific XQuery engine.
XQConnectionEvent	An event object that provides information about the source of a connection-related event.
XQConnectionEventListener	An object that registers to be notified of events generated by a PooledXQConnection object.
XQConstants	XQConstants class provides constants that can be used in the XQJ API.
XQDataFactory	This interface represents a factory to obtain sequences, item objects and types.
XQDataSource	An XQDataSource is a factory for XQConnection objects.
XQDynamicContext	XQDynamicContext provides access to the dynamic context as defined in 2.1.2 Dynamic Context, XQuery 1.0: An XML Query Language.
XQException	An exception that provides information on XQJ, XQuery or other errors reported by an XQJ implementation.
XQExpression	This interface describes the execute immediate functionality for expressions.
XQItem	This interface represents an item in the XDM.
XQItemAccessor	This interface represents a common interface for accessing the values of an XQuery item.
XQItemType	The XQItemType interface represents an item type as defined in XQuery 1.0: An XML Query language.
XQMetaData	XQMetaData interface provides information about the data source, in various aspects, such as the product name and version identification, supported features, specific behaviors, user information, product limits and so forth.
XQPreparedExpression	This interface describes an expression that can be prepared for multiple subsequent executions.
XQQueryException	An exception that provides information on errors occurring during the evaluation of an xquery.
XQResultItem	This interface represents an immutable item object obtained from an XQResultSequence using the getItem method.
XQResultSequence	This interface represents a sequence of items obtained as a result of evaluation XQuery expressions.
XQSequence	This interface represents a sequence of items as defined in the XDM.
XQSequenceType	The XQSequenceType interface represents a sequence type as XQuery 1.0: An XML Query language.
XQStackTraceElement	This class represents a frame in a stack trace, akin to the java.lang.StackTraceElement but for XQuery callstacks instead of Java.
XQStackTraceVariable	This class represents the list of variables and their values in an error stack.
XQStaticContext	An XQStaticContext represents default values for various XQuery Static Context Components.
XQueryCompiler	An XQueryCompiler object allows XQuery 1.0 queries to be compiled.
XQueryEmitter	The XQueryEmitter is designed to serialize an XQuery that was originally embedded in an XML document.
XQueryEvaluator	An XQueryEvaluator represents a compiled and loaded query ready for execution.
XQueryExecutable	An XQueryExecutable represents the compiled form of a query.
XQueryExpression	XQueryExpression represents a compiled query.
XQueryExpressionEE	Saxon-EE version of XQueryExpression.
XQueryFn	This class implements the saxon:xquery() extension function
XQueryFunction	A user-defined function in an XQuery module
XQueryFunctionAnnotationHandler	Function annotation handler for annotations in the built-in namespace http://www.w3.org/2012/xquery.
XQueryFunctionBinder	XQueryFunctionBinder is an extension of the FunctionLibrary interface used for function libraries that contain user-written XQuery functions.
XQueryFunctionLibrary	An XQueryFunctionLibrary is a function library containing all the user-defined functions available for use within a particular XQuery module: that is, the functions declared in that module, and the functions imported from other modules.
XQueryFunctionLibrary.UnresolvedCallable	Inner class containing information about a reference to a function whose declaration has not yet been encountered.
XQueryParser	This class defines extensions to the XPath parser to handle the additional syntax supported in XQuery
XQueryParser.Unescaper
XQueryParserExtensionEE	Parser extension for syntax in XQuery Update and/or XQuery 3.0 that is supported only in -EE.
XQueryParserExtensionPE	Parser extension for syntax in XQuery Update and/or XQuery 3.0 that is supported only in Saxon-PE or -EE.
XQueryTraceCodeInjector	A code injector designed to support the -T tracing option in XQuery
XQueryTraceListener	A Simple trace listener for XQuery that writes messages (by default) to System.err
XQUpdate10FunctionSet	Function signatures (and pointers to implementations) of the functions defined in XQuery Update 1.0
XSDAlternative	An xs:alternative element in a schema (see draft XML Schema 1.1 Part 1)
XSDAnnotation	An xs:annotation element in an XML Schema document
XSDAny	An xs:any element in an XML Schema document
XSDAnyAttribute	An xs:anyAttribute element in an XML Schema document
XSDAssert	An xs:assert or xs:assertion element in a schema (see draft XML Schema 1.1 Part 1)
XSDAssert.CustomizedXPath	Define a customized XPath evaluator which injects code into the XPath code generation; this has the effect for a complex-type XSDAssert of modifying the expression so that instead of returning a boolean, it returns a list of nodes that contribute to the invalidity of the assertion.
XSDAttribute	An xs:attribute element in a schema document
XSDAttributeGroup	An xs:attributeGroup element in an XML Schema document
XSDComplexContent	An xs:complexContent element in an XML Schema Document
XSDComplexContentRestriction	An xs:restriction element that is a child of xs:complexContent within an XML Schema document
XSDComplexType	An xs:complexType element in an XML Schema document
XSDCompositor	An xs:sequence, xs:choice, or xs:all element in an XML Schema document
XSDDefaultOpenContent	An element in an XML Schema document defining the default open content
XSDDocumentation	An xs:documentation or xs:appinfo element in an XML Schema document
XSDElement	An xs:element element in a schema document
XSDExtension	An xs:extension element in a schema document
XSDFacet	An element in an XML Schema document representing a facet, for example minLength or pattern or enumeration: any facet except assertion, which is represented by the XSDAssert class
XSDFieldOrSelector	An xs:field or xs:selector element in an XML Schema document
XSDGroup	An xs:group element in an XML Schema document
XSDIdentityConstraint	An xs:unique, xs:key, or xs:keyref element in an XML Schema document
XSDImport	An xs:import element in an XML Schema document
XSDInclude	An xs:include element in an XML Schema document
XSDList	This class represents an xs:list element in a schema document.
XSDNotation	An element in an XML Schema document representing a notation declaration
XSDOpenContent	An element in an XML Schema document defining the default open content
XSDOverride	An xs:override element in an XML Schema Document
XSDRedefine	An xs:redefine element in an XML Schema Document
XSDSchema	An xs:schema element in an XML Schema document
XSDSimpleContent	An xs:simpleContent element in an XML Schema document
XSDSimpleContentRestriction	An xs:restriction element in an XML Schema document that appears as a child of an xs:simpleContent element
XSDSimpleType	An xs:simple-type element in an XML Schema document
XSDSimpleTypeRestriction	An xs:restriction element in an XML Schema Document, whose parent element is an xs:simpleType
XSDUnion	An xs:union element in an XML Schema document
XSIAttributeHandler	This class processes attributes such as xsi:schemaLocation and xsi:type.
XSINamespaceSchema	This module constructs synthetically (that is, without reading an XML schema document) the schema components for the XML namespace
XSLAccept	Represents an xsl:accept element in an XSLT 3.0 package manifest.
XSLAcceptExpose	Handler for xsl:accept and xsl:expose elements in stylesheet.
XSLAccumulator	Handler for xsl:accumulator elements in a stylesheet (XSLT 3.0).
XSLAccumulatorRule	Handler for xsl:accumulator-rule elements in a stylesheet (XSLT 3.0).
XSLAnalyzeString	An xsl:analyze-string elements in the stylesheet.
XSLApplyImports	An xsl:apply-imports element in the stylesheet
XSLApplyTemplates	An xsl:apply-templates element in the stylesheet
XSLArray	xsl:array element in stylesheet - proposed XSLT 4.0 instruction The xsl:array element has the same content model as xsl:sequence.
XSLArrayMember	xsl:array-member element in stylesheet - originally a Saxon extension now retained for backwards compatibility, for the time being.
XSLAssert	An xsl:assert element in an XSLT 3.0 stylesheet.
XSLAttribute	xsl:attribute element in stylesheet.
XSLAttributeSet	An xsl:attribute-set element in the stylesheet.
XSLBreak	A xsl:break element in the stylesheet
XSLBreakOrContinue	Abstract class containing functionality common to xsl:break and xsl:next-iteration
XSLCallTemplate	An xsl:call-template element in the stylesheet
XSLCatch	Handler for xsl:catch elements in stylesheet.
XSLCharacterMap	An xsl:character-map declaration in the stylesheet.
XSLChoose	An xsl:choose element in the stylesheet.
XSLChooseOrSwitch	An xsl:choose or xsl:switch element in the stylesheet.
XSLComment	An xsl:comment elements in the stylesheet.
XSLContextItem	An xsl:context-item element in the stylesheet.
XSLCopy	Handler for xsl:copy elements in stylesheet.
XSLCopyOf	An xsl:copy-of element in the stylesheet.
XSLDecimalFormat	Handler for xsl:decimal-format elements in stylesheet.
XSLDocument	An xsl:document instruction in the stylesheet.
XSLElement	An xsl:element element in the stylesheet.
XSLEvaluate	Handler for xsl:evaluate elements in XSLT 3.0 stylesheet.
XSLExpose	Represents an xsl:expose element in an XSLT 3.0 package manifest.
XSLFallback	xsl:fallback element in stylesheet.
XSLForEach	Handler for xsl:for-each elements in stylesheet.
XSLForEachGroup	Handler for xsl:for-each-group elements in stylesheet.
XSLFork	Handler for xsl:fork elements in XSLT 3.0 stylesheet.
XSLFunction	Handler for xsl:function elements in stylesheet (XSLT 2.0).
XSLGeneralIncorporate	Abstract class to represent an xsl:include or xsl:import element in the stylesheet.
XSLGeneralVariable	This class defines common behaviour across xsl:variable, xsl:param, and xsl:with-param
XSLGlobalContextItem	An xsl:global-context-item declaration in the stylesheet
XSLGlobalParam	An xsl:param element representing a global parameter (stylesheet parameter) in the stylesheet.
XSLGlobalVariable	Handler for xsl:variable elements appearing as a child of xsl:stylesheet.
XSLIf	Handler for xsl:if elements in stylesheet.
XSLImport	xsl:import element in the stylesheet.
XSLImportSchema	Compile-time representation of an xsl:import-schema declaration in a stylesheet
XSLInclude	xsl:include element in the stylesheet.
XSLItemType	The class implements a xsl:item-type declaration in a stylesheet.
XSLIterate	Handler for xsl:iterate elements in stylesheet.
XSLKey	Handler for xsl:key elements in stylesheet.
XSLLeafNodeConstructor	Common superclass for XSLT elements whose content template produces a text value: xsl:text, xsl:value-of, xsl:attribute, xsl:comment, xsl:namespace, and xsl:processing-instruction
XSLLocalParam	An xsl:param element representing a local parameter (template or function parameter) in the stylesheet.
XSLLocalVariable	Handler for xsl:variable elements acting as local variable declarations in a stylesheet.
XSLMap	Handler for xsl:map instructions in an XSLT 3.0 stylesheet.
XSLMapEntry	Handler for xsl:map-entry instructions in an XSLT 3.0 stylesheet.
XSLMatchingSubstring	Handler for xsl:matching-substring and xsl:non-matching-substring elements in stylesheet.
XSLMerge	Handler for xsl:merge elements in stylesheet.
XSLMergeAction
XSLMergeKey	An xsl:merge-key element in the stylesheet.
XSLMergeSource	Implements the xsl:merge-source element available in XSLT 3.0 as a child of xsl:merge.
XSLMessage	An xsl:message element in the stylesheet.
XSLMode	Handler for xsl:mode elements in stylesheet.
XSLModuleRoot	Class representing xsl:stylesheet, xsl:transform, or xsl:package
XSLNamespace	An xsl:namespace element in the stylesheet.
XSLNamespaceAlias	An xsl:namespace-alias element in the stylesheet.
XSLNextIteration	An xsl:next-iteration element in the stylesheet
XSLNextMatch	An xsl:next-match element in the stylesheet
XSLNumber	An xsl:number element in the stylesheet.
XSLOnCompletion	An xsl:on-completion element in the stylesheet (XSLT 3.0).
XSLOnEmpty	An xsl:on-empty element in the stylesheet.
XSLOnNonEmpty	An xsl:on-non-empty element in the stylesheet.
XSLOriginalLibrary	A function library that recognizes the function name "xsl:original", which may appear within xsl:override
XSLOtherwise	Handler for xsl:otherwise elements in stylesheet.
XSLOutput	An xsl:output element in the stylesheet.
XSLOutputCharacter	An xsl:output-character element in the stylesheet.
XSLOverride	Represents an xsl:override element in a package manifest.
XSLPackage	Handler for xsl:package elements.
XSLPerformSort	Handler for xsl:perform-sort elements in stylesheet (XSLT 2.0).
XSLPreserveSpace	An xsl:preserve-space or xsl:strip-space elements in stylesheet.
XSLProcessingInstruction	An xsl:processing-instruction element in the stylesheet.
XSLResultDocument	An xsl:result-document element in the stylesheet.
XSLSequence	An xsl:sequence element in the stylesheet.
XSLSort	An xsl:sort element in the stylesheet.
XSLSortOrMergeKey
XSLSourceDocument	Handler for xsl:source-document element in XSLT 3.0 stylesheet.
XSLStylesheet	An xsl:stylesheet or xsl:transform element in the stylesheet.
XSLSwitch	An xsl:switch element in the stylesheet (XSLT 4.0).
XSLT30FunctionSet	Function signatures (and pointers to implementations) of the functions defined in XSLT 3.0.
Xslt30Transformer	An Xslt30Transformer represents a compiled and loaded stylesheet ready for execution.
XSLT40FunctionSet	Function signatures (and pointers to implementations) of the functions defined in XSLT 4.0.
XsltCompiler	An XsltCompiler object allows XSLT stylesheets to be compiled.
XsltController	This class is an extension of the Controller class, used when executing XSLT stylesheets.
XSLTemplate	An xsl:template element in the style sheet.
XsltExecutable	An XsltExecutable represents the compiled form of a stylesheet.
XsltExecutable.ParameterDetails	Inner class containing information about a global parameter to a compiled stylesheet
XSLText	Handler for xsl:text elements in stylesheet.
XsltPackage	An XsltPackage object represents the result of compiling an XSLT 3.0 package, as represented by an XML document containing an xsl:package element.
XSLTry	Handler for xsl:try elements in stylesheet.
XSLTTraceCodeInjector	A code injector that wraps every expression (other than a literal) in a TraceExpression, which causes a TraceListener to be notified when the expression is evaluated
XSLTTraceListener	A Simple trace listener for XSLT that writes messages (by default) to System.err
XsltTransformer	An XsltTransformer represents a compiled and loaded stylesheet ready for execution.
XSLUsePackage	Handler for xsl:use-package elements in stylesheet.
XSLValueOf	An xsl:value-of element in the stylesheet.
XSLWhen	Handler for xsl:when elements in stylesheet.
XSLWherePopulated	An xsl:where-populated element in the stylesheet.
XSLWithParam	An xsl:with-param element in the stylesheet.
YearMonthDurationValue	A value of type xs:yearMonthDuration (or a subtype thereof).
ZenoChain<T>	An implementation of sequences as a list-of-lists, where the sublists at the end of the master list tend to be small, and the sublists at the start tend to be larger (or the other way around if the list is built by prepending items rather than appending them).
ZenoChainIterator<U>	A (Java) Iterator over a ZenoChain
ZenoSequence	An immutable XDM sequence implemented as a ZenoChain.
ZenoSequence.ZenoSequenceIterator	A SequenceIterator over a ZenoSequence
ZenoString	A ZenoString is an implementation of UnicodeString that comprises a list of segments representing substrings of the total string.
ZeroOrMore<T extends Item>	A sequence value implemented extensionally.
ZeroOrOne<T extends Item>	A value that is a sequence containing zero or one items.