All Classes

Class	Description
AbsentExtensionElement	This element is a surrogate for an extension element (or indeed an xsl element) for which no implementation is available.
AbstractTraceListener	This is the standard trace listener used when the -T option is specified on the command line.
Adjust	This class implements the XPath 2.0 functions adjust-date-to-timezone(), adjust-time-timezone(), and adjust-dateTime-timezone().
Aggregate	This class implements the sum(), avg(), count() functions,
AllElementStripper	The AllElementStripper refines the Stripper class to do stripping of all whitespace nodes in a document
AlphanumericComparer	A Comparer that treats strings as an alternating sequence of alpha parts and numeric parts.
AnalyzeString	An xsl:analyze-string elements in the stylesheet.
AncestorEnumeration	This class enumerates the ancestor:: or ancestor-or-self:: axes, starting at a given node.
AncestorEnumeration
AnyChildNodePattern	An AnyChildNodePattern is the pattern node(), which matches any node except a root node, an attribute node, or a namespace node: in other words, any node that is the child of another node.
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.
AnyURIValue	An XPath value of type xs:anyURI.
AppendIterator	Iterator that concatenates the results of two supplied iterators
ApplyImports	An xsl:apply-imports element in the stylesheet
ApplyTemplates	An instruction representing an xsl:apply-templates element in the stylesheet
ArithmeticExpression	Arithmetic Expression: an expression using one of the operators plus, minus, multiply, div, idiv, mod.
ArithmeticExpression.DateAndDuration	Inner class to handle addition or subtraction of a Date (or Time, or DateTime) and a Duration
ArithmeticExpression.DateDifference	Inner class to handle subtraction of a Date (or Time, or DateTime) from another, to return a Duration
ArithmeticExpression.DurationAddition	Inner class to handle addition and subtraction of two durations
ArithmeticExpression.DurationDivision	Inner class to handle division of two durations to give a number
ArithmeticExpression.DurationMultiplication	Inner class to handle multiplication (or division) of a duration by a number
ArithmeticExpression.NumericArithmetic	Inner class to handle numeric arithmetic expressions
ArrayIterator	ArrayIterator is used to enumerate items held in an array.
ASCIICharacterSet	This class defines properties of the US-ASCII character set
Assign	saxon:assign element in stylesheet.
Assignation	Assignation is an abstract superclass for the kinds of expression that declare range variables: for, some, and every.
AtomicComparer	Interface representing an object that can be used to compare two XPath atomic values for equality or for ordering.
AtomicSequenceConverter	An AtomicSequenceConverter is an expression that performs a cast on each member of a supplied sequence
AtomicSortComparer	A Comparator used for comparing atomic values of arbitrary item types.
AtomicType	Marker 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.
AtomizableIterator	A SequenceIterator is used to iterate over a sequence.
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.AtomizingFunction	Implement the mapping function.
Attribute	An instruction derived from an xsl:attribute element in stylesheet, or from an attribute constructor in XQuery
AttributeCollection	AttributeCollection represents the collection of attributes available on a particular element node.
AttributeCollectionImpl	AttributeCollectionImpl is an implementation of both the SAX2 interface Attributes and the Saxon equivalent AttributeCollection.
AttributeEnumeration	AttributeEnumeration is an iterator over all the attribute nodes of an Element.
AttributeEnumeration	AttributeEnumeration is an enumeration of all the attribute nodes of an Element.
AttributeImpl	A node in the XML parse tree representing an attribute.
AttributeSet	The compiled form of an xsl:attribute-set element in the stylesheet.
AttributeValueTemplate	This class represents an attribute value template.
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 wraps a JAXP Source object to provide an extended Source object that contains options indicating how the Source should be processed: for example, whether or not it should be validated against a schema.
Available	This class supports the XSLT element-available and function-available functions.
Axis	An axis, that is a direction of navigation in the document structure.
AxisExpression	An AxisExpression is always obtained by simplifying a PathExpression.
AxisIterator	A SequenceIterator is used to iterate over a sequence.
AxisIteratorImpl	A SequenceIterator is used to iterate over a sequence.
Base64BinaryValue	A value of type xs:base64Binary
BaseURI	This class supports the base-uri() functions in XPath 2.0
Big5CharacterSet
BigIntegerValue	An integer value: note this is a subtype of decimal in XML Schema, not a primitive type.
BinaryExpression	Binary Expression: a numeric or boolean expression consisting of the two operands and an operator
Bindery	The Bindery class holds information about variables and their values.
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	Implements an imaginary xsl:block instruction which simply evaluates its contents.
BooleanExpression	Boolean expression: two truth values combined using AND or OR.
BooleanFn	This class supports the XPath functions boolean(), not(), true(), and false()
BooleanValue	A boolean XPath value
BuggyCharacterSet	This class establishes properties of a character set that is known to the Java VM but not specifically known to Saxon.
Builder	The abstract Builder class is responsible for taking a stream of SAX events and constructing a Document tree.
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 xdt:dayTimeDuration).
BuiltInListType	This class is used to implement the built-in list types NMTOKENS, ENTITIES, IDREFS.
BuiltInSchemaFactory	This class is used to construct Schema objects containing all the built-in types: that is, the types defined in the "xs" and "xdt" namespaces.
CalendarValue	Abstract superclass for Date, Time, and DateTime.
CalendarValueComparer	A comparer specifically for comparing two date, time, or dateTime values
CallTemplate	Instruction representing an xsl:call-template element in the stylesheet.
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
CaseVariants	This 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 )".
CDATAFilter	CDATAFilter: This ProxyEmitter converts character data to CDATA sections, if the character data belongs to one of a set of element types to be handled this way.
CharacterMapExpander	CharacterMapExpander: This ProxyReceiver expands characters occurring in a character map, as specified by the XSLT 2.0 xsl:character-map declaration
CharacterSet	This interface defines properties of a character set, built in to the Saxon product.
CharacterSetFactory	This class creates a CharacterSet object for a given named encoding.
CharSlice	This is an implementation of the JDK 1.4 CharSequence interface: it implements a CharSequence as a view of an array.
ChildEnumeration
Choose	Compiled representation of an xsl:choose or xsl:if element in the stylesheet.
ClosingAction	A ClosingAction is an action that can be performed by a ClosingIterator when the end of a sequence is reached
ClosingIterator	A closing iterator returns the items delivered by an underlying iterator unchanged, and calls a user-supplied function when the underlying iterator hits the end of the sequence.
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.
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	XPath 2.0 codepoint-equal() function.
CollatingAtomicComparer	An AtomicComparer used for comparing strings, untypedAtomic values, and URIs using a collation.
CollatingFunction	Abstract superclass for all functions that take an optional collation argument
CollationMap	This object maps collation URIs to collations.
CollationURIResolver	A CollationURIResolver accepts a collation name as input, and returns a collation (represented by a Comparator) as output.
Collection	Implement the fn:collection() function.
CollectionURIResolver	This interface defines a CollectionURIResolver.
CombinedNodeTest	A CombinedNodeTest combines two nodetests using one of the operators union (=or), intersect (=and), difference (= "and not").
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.
Common	This class implements extension functions in the http://exslt.org/common namespace.
ComparableAtomicValueComparer	A comparer for comparing two "ordinary" atomic values, where the values implement the Comparable interface and the equals() method with the appropriate XPath semantics.
Compare	XSLT 2.0 compare() function
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.
ComparisonExpression	Interface implemented by expressions that perform a comparison
ComparisonKey	An object used as a comparison key.
Compile	This Compile class provides a command-line interface allowing a stylesheet to be compiled.
CompilerInfo	This class exists to hold information associated with a specific XSLT compilation episode.
CompileTimeFunction	Abtract class representing a function call that is always rewritten at compile-time: it can never be executed
ComplexContentOutputter	This class is used for generating complex content, that is, the content of an element or document node.
ComplexType	A complex type as defined in XML Schema: either a user-defined complex type, or xs:anyType.
Component	This class supports the get_X_from_Y functions defined in XPath 2.0
CompressedWhitespace	This class provides a compressed representation of a sequence of whitespace characters.
ComputedElement	An instruction representing an xsl:element element in an XSLT stylesheet, or a computed element constructor in XQuery.
ComputedExpression	This class is an abstract superclass for different kinds of expression.
Concat
Configuration	This class holds details of user-selected configuration options for a transformation or query.
ConstructorFunctionLibrary	The ConstructorFunctionLibrary represents the collection of constructor functions for atomic types.
Container	A Container is something that can act as the parent of an expression.
Contains	This class implements the contains(), starts-with(), ends-with(), substring-before(), and substring-after() functions
ContentHandlerProxy	A ContentHandlerProxy is a Receiver that converts events into the form expected by an underlying SAX2 ContentHandler.
ContentHandlerProxyLocator	Implementation of Locator, used to supply location information to the ContentHandler.
ContentTypeTest	NodeTest is an interface that enables a test of whether a node matches particular conditions.
ContextItemExpression	This class represents the expression "(dot)", which always returns the context item.
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.
Controller	The Controller is Saxon's implementation of the JAXP Transformer class, and represents an executing instance of a transformation or query.
Copy	Handler for xsl:copy elements in stylesheet.
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.
CP1250CharacterSet	This class defines properties of the cp1250 Central Europe character set, as defined at http://www.microsoft.com/globaldev/reference/sbcs/1250.htm.
CP1251CharacterSet	This class defines properties of the CP1251 Cyrillic character set, as defined at http://www.microsoft.com/globaldev/reference/sbcs/1251.htm.
CP1252CharacterSet	This class defines properties of the CP1252 (Latin 1) character set, as defined at http://www.microsoft.com/globaldev/reference/sbcs/1252.htm.
CP852CharacterSet	This package defines character set CP852
Current	Implement the XSLT current() function
CurrentDateTime	This class implements the XPath 2.0 functions current-date(), current-time(), and current-dateTime(), as well as the function implicit-timezone().
CurrentGroup	Implements the XSLT functions current-group() and current-grouping-key()
CurrentItemExpression	The expression is generated when compiling the current() function in XSLT.
Data	Implement XPath function fn:data()
DataElement	This element represents a top-level element in a user-defined namespace, or a child/descendant of such an element.
Date	This class implements extension functions in the http://exslt.org/dates-and-times namespace.
DateTimeConstructor	This class supports the dateTime($date, $time) function
DateTimeValue	A value of type DateTime
DateValue	A value of type Date.
Debugger	This interface may be implemented by an external debugging tool
DecimalFormatManager	DecimalFormatManager manages the collection of named and unnamed decimal formats
DecimalSortComparer	A Comparator 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	A decimal value
Declaration	This interface represents the union of global variable declarations and function declarations in XQuery modules
DeclaredPrefixIterator	An iterator supplying the prefixes of the declared namespaces for an element node in a TinyTree
DeepEqual	XSLT 2.0 deep-equal() function.
DefaultCollation	Implement the XPath 2.0 default-collation() function
DescendantEnumeration	This class supports both the descendant:: and descendant-or-self:: axes, which are identical except for the route to the first candidate node.
DescendantEnumeration
DescendingComparer	A Comparer used for comparing descending keys.
DifferenceEnumeration	An enumeration representing a nodeset that is teh difference of two other NodeSets.
DistinctValues	The XPath 2.0 distinct-values() function
DistinctValues.DistinctIterator	Iterator class to return the distinct values in a sequence
Doc	Implement the fn:doc() function - a simplified form of the Document function
Doctype	A saxon:doctype element in the stylesheet.
Document	Implements the XSLT document() function
DocumentBuilderFactoryImpl	Implementation of JAXP 1.1 DocumentBuilderFactory.
DocumentBuilderImpl	This class implements the JAXP DocumentBuilder interface, allowing a Saxon TinyTree to be constructed using standard JAXP parsing interfaces.
DocumentEventIgnorer	This is a filter that can be added to a pull pipeline to remove START_DOCUMENT and END_DOCUMENT events.
DocumentImpl	A node in the XML parse tree representing the Document itself (or equivalently, the root node of the Document).
DocumentInfo	This interface represents a document node as defined in the XPath 2.0 data model.
DocumentInstr	An instruction to create a document node.
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.
DocumentSender	Sends an entire document to a Receiver.
DocumentSorter	A DocumentSorter is an expression that sorts a sequence of nodes into document order.
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 document node of a tree implemented as a wrapper around a DOM Document.
DocumentWrapper	The root node of an XPath tree.
DocumentWrapper	The root node of an XPath tree.
DocumentWrapper	The root node of an XPath tree.
DOM4JObjectModel	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).
DOMAttributeMap	Implementation of DOM NamedNodeMap used to represent the attributes of an element, for use when Saxon element and attribute nodes are accessed using the DOM API.
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).
DOMImplementationImpl	A simple implementation of the DOMImplementation interface, for use when accessing Saxon tree structure using the DOM API.
DOMNodeList	This class wraps a list of nodes as a DOM NodeList
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 a DOM Document
DoubleSortComparer	A Comparator 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.
DurationValue	A value of type xs:duration
DynamicError	Subclass of XPathException used for dynamic errors
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.
EarlyEvaluationContext	This class is an implementation of XPathContext used when evaluating constant sub-expressions at compile time.
ElementCreator	An instruction that creates an element node.
ElementImpl	ElementImpl implements an element with no attributes or namespace declarations.
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.
ElementWithAttributes	A node in the XML parse tree representing an XML element.
Emitter	Emitter: This abstract class defines methods that must be implemented by components that format SAXON output.
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.
EmptyIterator	EmptyIterator: an iterator over an empty sequence.
EmptyNamespaceDeclarationList	A class representing an empty set of namespace declarations
EmptySequence	An EmptySequence object represents a sequence containing no members.
Err	Class containing utility methods for handling error messages
Error	Implement XPath function fn:error()
ErrorExpression	Error expression: this expression is generated when the supplied expression cannot be parsed, and the containing element enables forwards-compatible processing.
EscapeURI	This class supports the functions encode-for-uri() and iri-to-uri()
EucJPCharacterSet
EucKRCharacterSet
Evaluate	This class implements the saxon:evaluate(), saxon:expression(), and saxon:eval() extension functions, which are specially-recognized by the system because they need access to parts of the static context
Evaluate.PreparedExpression	Inner class PreparedExpression represents a compiled XPath expression together with the standard variables $p1 ..
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.
Existence	Implement the exists() and empty() functions
Expression	Interface supported by an XPath expression.
ExpressionContext	An ExpressionContext represents the context for an XPath expression written in the stylesheet.
ExpressionLocation	Class to hold details of the location of an expression, of an error in a source file, etc.
ExpressionParser	Parser for XPath expressions and XSLT patterns.
ExpressionParser.ForClause
ExpressionParser.TemporaryContainer
ExpressionTool	This class, ExpressionTool, contains a number of useful static methods for manipulating expressions.
ExtendedNodeInfo	This interface contains methods that extend NodeInfo: the extra methods will be added to the NodeInfo interface at some time in the future.
ExtensionElementFactory	Interface ExtensionElementFactory.
ExtensionFunctionCall	This class acts as a container for an extension function defined to call a method in a user-defined class.
ExtensionFunctionFactory	This class acts as a factory for creating expressions that call Java extension functions.
ExtensionInstruction	Abstract class representing an extension instruction
Extensions	This class implements functions that are supplied as standard with SAXON, but which are not defined in the XSLT or XPath specifications.
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 Java object returned by an extension function, or supplied as an external variable/parameter.
FastStringBuffer	A simple implementation of a class similar to StringBuffer.
FeatureKeys	FeatureKeys defines a set of constants, names of Saxon configuration options which can be supplied to the Saxon implementations of the JAXP interfaces TransformerFactory, SchemaFactory, Validator, and ValidationHandler.
Filter	Filter is an XMLFilter (a SAX2 filter) that performs a transformation taking a SAX stream as input and producing a SAX stream as output.
FilterExpression	A FilterExpression contains a base expression and a filter predicate, which may be an integer expression (positional filter), or a boolean expression (qualifier)
FilterIterator	A FilterIterator filters an input sequence using a filter expression.
FilterIterator.Leading	Subclass to support the extension function saxon:leading, which terminates the iteration at the first item whose predicate is false
FilterIterator.NonNumeric	Subclass to handle the common special case where it is statically known that the filter cannot return a numeric value
FingerprintedNode	This is a marker interface used to identify nodes that contain a namepool fingerprint.
FirstItemExpression	A FirstItemExpression returns the first item in the sequence returned by a given base expression
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.
FloatingPointConverter	This is a utility class that handles formatting of numbers as strings.
FloatValue	A numeric (single precision floating point) value
FollowingEnumeration	Iterate over the following axis starting at a given node.
FollowingEnumeration
FollowingSiblingEnumeration
ForceCase	This class implements the upper-case() and lower-case() functions
ForEach	Handler for xsl:for-each elements in a stylesheet.
ForEachGroup	Handler for xsl:for-each-group elements in stylesheet.
ForExpression	A ForExpression maps an expression over a sequence.
FormatDate	Implement the format-date() function in XPath 2.0
FormatNumber2	XSLT 2.0 implementation of format-number() function - removes the dependence on the JDK.
FunctionCall	Abstract superclass for calls to system-defined and user-defined functions
FunctionLibrary	A FunctionLibrary handles the binding of function calls in XPath (or XQuery) expressions.
FunctionLibraryList	A FunctionLibraryList is a list of FunctionLibraries.
GB2312CharacterSet
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.
GeneralComparison10	GeneralComparison10: a boolean expression that compares two expressions for equals, not-equals, greater-than or less-than.
GeneralVariable	This class defines common behaviour across xsl:variable, xsl:param, and xsl:with-param; also saxon:assign
GenericAtomicComparer	A Comparator used for comparing atomic values of arbitrary item types.
GenericSorter	Generically sorts arbitrary shaped data (for example multiple arrays, 1,2 or 3-d matrices, and so on) using a quicksort or mergesort.
GlobalOrderComparer	A Comparer used for comparing nodes in document order.
GlobalParam	The compiled form of a global xsl:param element in the 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.
GlobalVariableDefinition	Class to hold compile-time information about an XQuery global variable or parameter
GMonthDayValue	Implementation of the xs:gYear data type
GMonthValue	Implementation of the xs:gMonth data type
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 returned a SequenceValue containing all the items in the sequence.
GroupAdjacentIterator	A GroupAdjacentIterator iterates over a sequence of groups defined by xsl:for-each-group group-adjacent="x".
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".
GroupIterator	A GroupIterator is an iterator that iterates over a sequence of groups.
GroupStartingIterator	A GroupStartingIterator iterates over a sequence of groups defined by xsl:for-each-group group-starting-with="x".
GYearMonthValue	Implementation of the xs:gYearMonth data type
GYearValue	Implementation of the xs:gYear data type
HexBinaryValue	A value of type xs:hexBinary
HTMLEmitter	This class generates HTML output
HTMLIndenter	HTMLIndenter: This ProxyEmitter indents HTML elements, by adding whitespace character data where appropriate.
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
Id	The XPath 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.
IdentityComparison	IdentityComparison: a boolean expression that compares two nodes for equals, not-equals, greater-than or less-than based on identity and document ordering
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.
IDPattern	An IDPattern is a pattern of the form id("literal") or id($variable)
Idref
IdrefTest	NodeTest is an interface that enables a test of whether a node matches particular conditions.
IfExpression	An IfExpression returns the value of either the "then" part or the "else" part, depending on the value of the condition
ImplicitResultChecker	This filter is inserted into the serializer pipeline when serializing an implicit XSLT result tree, that is, one that is created without use of xsl:result-document.
ImportedFunctionLibrary	This implementation of FunctionLibrary contains all the functions imported into a Query Module.
IndependentContext	An IndependentContext provides a context for parsing an expression or pattern appearing in a context other than a stylesheet.
IndexOf	The XPath 2.0 index-of() function
InscopeNamespaceResolver	A NamespaceResolver that resolves namespace prefixes by reference to a node in a document for which those namespaces are in-scope.
InScopePrefixes	This class supports fuctions get-in-scope-prefixes()
Insert	The XPath 2.0 insert-before() function
Insert.InsertIterator
InstanceOfExpression	InstanceOf Expression: implements "Expr instance of data-type"
Instruction	Abstract superclass for all instructions in the compiled stylesheet.
InstructionDetails	Details about an instruction, used when reporting errors and when tracing
InstructionInfo	Information about an instruction in the stylesheet, made available at run-time to a TraceListener
InstructionInfoProvider	An InstructionInfoProvider is an object that is capable of providing an InstructionInfo object which provides diagnostic information about an instruction or other construct such as a function, template, expression, or pattern.
IntArraySet	Set of int values.
IntegerRange	This class represents a sequence of consecutive ascending integers, for example 1 to 50.
IntegerRangeTest	An IntegerRangeTest is an expression of the form E = N to M where E, N, and M are all expressions of type integer.
IntegerValue	An integer value: note this is a subtype of decimal in XML Schema, not a primitive type.
IntersectionEnumeration	An enumeration representing a nodeset that is an intersection of two other NodeSets.
IntHashMap	A hash table that maps int keys to Object values.
IntHashSet	Set of int values.
IntIterator	An iterator over a sequence of unboxed int values
IntToIntHashMap	A hash table that maps int keys to int values.
IsLastExpression	A position() eq last() expression, generated by the optimizer.
ISO88591CharacterSet	This class defines properties of the ISO-8859-1 character set
ISO88592CharacterSet	This class defines properties of the ISO-8859-2 character set
ISO88595CharacterSet	Description: This class implements the CharacterSet to support ISO-8859-5 (Latin/Cyrillic) encoding.
ISO88597CharacterSet
ISO88598CharacterSet
ISO88599CharacterSet
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
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.
ItemType	ItemType is an interface that allows testing of whether an Item conforms to an expected type.
JavaCollationFactory	A JavaCollationFactory allows a Collation to be created given a set of properties that the collation should have.
JavaExtensionLibrary	The JavaExtensionLibrary is a FunctionLibrary that binds XPath function calls to calls on Java methods (or constructors, or fields).
JavaPlatform	Implementation of the Platform class containing methods specific to the Java platform (as distinct from .NET)
JAXPVariable	An object representing an XPath variable for use in the JAXP XPath API.
JDK14RegexTranslator	This class translates XML Schema regex syntax into JDK 1.4 regex syntax.
JDK14RegexTranslator.BackReference
JDK14RegexTranslator.CharClass
JDK14RegexTranslator.CharRange
JDK14RegexTranslator.Complement
JDK14RegexTranslator.Dot
JDK14RegexTranslator.Empty
JDK14RegexTranslator.Property
JDK14RegexTranslator.Range
JDK14RegexTranslator.SimpleCharClass
JDK14RegexTranslator.SingleChar
JDK14RegexTranslator.Subtraction
JDK14RegexTranslator.Union
JDK14RegexTranslator.WideSingleChar
JDK15RegexTranslator	This class translates XML Schema regex syntax into JDK 1.5 regex syntax.
JDK15RegexTranslator.BackReference
JDK15RegexTranslator.CharClass
JDK15RegexTranslator.CharRange
JDK15RegexTranslator.Complement
JDK15RegexTranslator.Empty
JDK15RegexTranslator.Property
JDK15RegexTranslator.Range
JDK15RegexTranslator.SimpleCharClass
JDK15RegexTranslator.SingleChar
JDK15RegexTranslator.Subtraction
JDK15RegexTranslator.Union
JDOMObjectModel	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).
JDOMQuery	Variant of command line net.sf.saxon.Transform do build the source document in JDOM and then proceed with the transformation.
JDOMTransform	Variant of command line net.sf.saxon.Transform do build the source document in JDOM and then proceed with the transformation.
JRegexIterator	Class JRegexIterator - provides an iterator over matched and unmatched substrings.
JRegularExpression	A compiled regular expression implemented using the Java JDK regex package
JTokenIterator	A JTokenIterator is an iterator over the strings that result from tokenizing a string using a regular expression
KeyDefinition	Corresponds to a single xsl:key declaration.
KeyFn
KeyManager	KeyManager manages the set of key definitions in a stylesheet, and the indexes associated with these key definitions.
KeyPattern	A KeyPattern is a pattern of the form key(keyname, keyvalue)
KOI8RCharacterSet	This class defines properties of the KO18R Cyrillic character set
Lang
LargeStringBuffer	This is an implementation of the JDK 1.4 CharSequence interface: it implements a CharSequence as a list of arrays of characters (the individual arrays are known as segments).
Last	Implement the XPath 1.0 function last()
LastPositionFinder	A LastPositionFinder is an interface implemented by any SequenceIterator that is able to return the position of the last item in the sequence.
LazyExpression	A LazyExpression is an expression that forces lazy evaluation: it must not be evaluated eagerly, because a failure must not be reported unless the value is actually referenced.
LetExpression	A LetExpression is modelled on the XQuery syntax let $x := expr return expr.
LineNumberMap	Line numbers are not held in nodes in the tree, because they are not usually needed.
ListIterator	Class ListIterator, iterates over a sequence of items held in a Java ArrayList, or indeed in any other kind of List
ListType	Interface representing a simple type of variety List
LiteralResultElement	This class represents a literal result element in the style sheet (typically an HTML element to be output).
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 in the stylesheet or an external variable in a Query.
LocalVariable	Handler for local xsl:variable elements in stylesheet.
LocalVariableReference	Variable reference: a reference to a local variable.
Location	This class holds constants identifying different kinds of location in a source stylesheet or query.
LocationCopier	A Receiver that can be inserted into an event pipeline to copy location information.
LocationMap	A LocationMap allocates integer codes to (systemId, lineNumber) pairs.
LocationPathPattern	A LocationPathPattern represents a path, for example of the form A/B/C...
LocationProvider	LocationProvider: this interface represents an object that provides the location of elements in a source document or instructions in a stylesheet or query.
LookaheadIterator	A SequenceIterator is used to iterate over a sequence.
LowercaseFirstComparer	A Comparer used for comparing keys
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.
Matches	This class implements the matches() function for regular expression matching
Math	This class implements extension functions in the http://exslt.org/math namespace.
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.
Message	An xsl:message element in the stylesheet.
MessageEmitter	MessageEmitter is the default Emitter for xsl:message output.
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
Minimax	This class implements the min() and max() functions
Mode	A Mode is a collection of rules; the selection of a rule to apply to a given element is determined by a Pattern.
ModuleURIResolver	A ModuleURIResolver is used when resolving references to query modules.
MonoIterator	An iterator over a single object (typically a sub-expression of an expression)
MonthDurationValue	A value of type xsd:yearMonthDuration
MultiIterator	An iterator that combines the results of a sequence of iterators
Name10Checker	The class checks names and characters against the rules of the XML 1.0 and XML Namespaces 1.0 specification
Name11Checker	The class checks names against the rules of the XML 1.1 and XML Namespaces 1.1 specification
NameChecker	A NameChecker performs validation and analysis of XML names.
NamePart	This class supports the name(), local-name(), and namespace-uri() functions from XPath 1.0, and also the XSLT generate-id() function
NamePool	An object representing a collection of XML names, each containing a Namespace URI, a Namespace prefix, and a local name; plus a collection of namespaces, each consisting of a prefix/URI pair.
NamePool.NamePoolLimitException
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.
Namespace	An xsl:namespace element in the stylesheet.
NamespaceConstant	This class is not instantiated, it exists to hold a set of constants representing known namespaces.
NamespaceContextImpl	This class bridges between the JAXP 1.3 NamespaceContext interface and Saxon's equivalent NamespaceResolver interface.
NamespaceDeclarations	This interface represents a collection of namespace declarations or undeclarations, typically those appearing together in an element start tag.
NamespaceDeclarationsImpl	An implementation of the NamespaceDeclarations interface, based on encapsulating an array of namespace codes.
NamespaceException	A NamespaceException represents an error condition whereby a QName (for example a variable name or template name) uses a namespace prefix that is not declared
NamespaceForPrefix	This class supports the function namespace-uri-for-prefix()
NamespaceIterator	This class provides an implementation of the namespace axis over any implementation of the data model.
NamespaceIterator.NamespaceNodeImpl	Inner class: a model-independent representation of a namespace node
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.
NamespaceResolverAsDeclarations	An implentation of NamespaceDeclarations that contains all the inscope namespaces made available by a NamespaceResolver.
NamespaceTest	NodeTest is an interface that enables a test of whether a node has a particular name and type.
NameTest	NodeTest is an interface that enables a test of whether a node has a particular name and type.
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.BaseEnumeration	BaseEnumeration is an abstract implementation of an AxisIterator, it simplifies the implementation of the underlying AxisIterator by requiring it to provide only two methods: advance(), and getAnother().
Navigator.DescendantEnumeration	General-purpose implementation of the descendant and descendant-or-self axes, in terms of the child axis.
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.
NextMatch	An xsl:next-match element in the stylesheet
Nilled	This class supports the nilled() function
NodeFactory	Interface NodeFactory.
NodeImpl	A node in the XML parse tree representing an XML element, character content, or attribute.
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.
NodeOrderComparer	A Comparer used for comparing nodes in document order
NodeOverNodeInfo	This class implements the DOM Node interface as a wrapper around a Saxon NodeInfo object.
NodeTest	A NodeTest is a simple kind of pattern that enables a context-free test of whether a node has a particular name.
NodeTestPattern	A NodeTestPattern is a pattern that consists simply of a NodeTest.
NodeWrapper	A node in the XML parse tree representing an XML element, character content, or attribute.
NodeWrapper	A node in the XML parse tree representing an XML element, character content, or attribute.
NodeWrapper	A node in the XML parse tree representing an XML element, character content, or attribute.
NodeWrapper	A node in the XML parse tree representing an XML element, character content, or attribute.
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.
NoNodeTest	NodeTest is an interface that enables a test of whether a node has a particular name and type.
NoOpenStartTagException	Exception indicating that an attribute or namespace node has been written when there is no open element to write it to
Normalizer	Implements Unicode Normalization Forms C, D, KC, KD.
NormalizerData	Accesses the Normalization Data used for Forms C and D.
NormalizeSpace	Implement the XPath normalize-space() function
NormalizeUnicode	Implement the XPath normalize-unicode() function
NotationValue	An xs:NOTATION value.
Numberer	Interface Numberer supports number formatting.
Numberer_de	Class Numberer_de is designed simply to demonstrate how to write a number formatter for a different language.
Numberer_en	Class Numberer_en does number formatting for language="en".
Numberer_fr	Class Numberer_fr is a number formatter for french.
NumberFn	Implements the XPath number() function.
NumberFormatter	Class NumberFormatter defines a method to format a ArrayList of integers as a character string according to a supplied format specification.
NumberInstruction	An xsl:number element in the stylesheet.
NumericComparer	A Comparer used for comparing sort keys when data-type="number".
NumericPromoter	A NumericPromoter performs numeric promotion on each item in a supplied sequence
NumericValue	NumericValue is an abstract superclass for IntegerValue, DecimalValue, FloatValue, and DoubleValue
ObjectValue	An XPath value that encapsulates a Java object.
Optimizer	This class doesn't actually do any optimization itself, despite the name.
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).
OutputURIResolver	This interface defines an OutputURIResolver.
PairIterator	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.
ParentNodeConstructor	An abstract class to act as a common parent for instructions that create element nodes and document nodes.
ParentNodeExpression	Class ParentNodeExpression represents the XPath expression ".." or "parent::node()"
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
PathExpression	An expression that establishes a set of nodes by following relationships between nodes in the document.
Pattern	A Pattern represents the result of parsing an XSLT pattern string.
PatternSponsor	The PatternSponsor class allows a Pattern to be treated like an expression.
PIGrabber	The PIGrabber class is a Receiver that looks for xml-stylesheet processing instructions and tests whether they match specified criteria; for those that do, it creates an InputSource object referring to the relevant stylesheet
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.
Platform	This interface provides access to methods whose implementation depends on the chosen platform (typically Java or .NET)
PluggableCharacterSet	This interface defines properties of a pluggable character set, that is, a user-supplied character set.
Position
PositionIterator	A PositionIterator selects a subsequence of a sequence
PositionRange	PositionRange: a boolean expression that tests whether the position() is within a certain range.
PrecedingEnumeration	Enumerate all the nodes on the preceding axis from a given start node.
PrecedingEnumeration
PrecedingOrAncestorEnumeration
PrecedingSiblingEnumeration	This class supports the preceding-sibling axis.
PrecedingSiblingEnumeration
PreparedStylesheet	This PreparedStylesheet class represents a Stylesheet that has been prepared for execution (or "compiled").
PrependIterator	An iterator over nodes, that prepends a given node to the nodes returned by another iterator.
Procedure	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).
ProcessingInstruction	An xsl:processing-instruction element in the stylesheet.
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
PromotionOffer	PromotionOffer is an object used transiently during compilation of an expression.
ProxyReceiver	A ProxyReceiver is an Receiver that filters data before passing it to another underlying Receiver.
PullConsumer	A PullConsumer consumes all the events supplied by a PullProvider, doing nothing with them.
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.
PullTracer	PullTracer is a PullFilter that can be inserted into a pull pipeline for diagnostic purposes.
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 (previously named fn:expanded-QName())
QNameValue	A QName value.
QuantifiedExpression	A QuantifiedExpression tests whether some/all items in a sequence satisfy some condition.
Query	This Query class provides a command-line interface to the Saxon XQuery processor.
QueryParser	This class defines extensions to the XPath parser to handle the additional syntax supported in XQuery
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.
QuerySimpleContentConstructor	This class implements the rules for an XQuery simple content constructor, which are used in constructing the string value of an attribute node, text node, comment node, etc, from the value of the select expression or the contained sequence constructor.
QuickSort	This is a generic version of C.A.R Hoare's Quick Sort algorithm.
Random	This class implements extension functions in the http://exslt.org/random namespace.
RangeExpression	A RangeExpression is an expression that represents an integer sequence as a pair of end-points (for example "x to y").
RangeIterator	Iterator that produces numeric values in a monotonic sequence, ascending or descending.
RangeVariableDeclaration	Represents the defining occurrence of a variable declared for local use within an expression, for example the $x in "for $x in ...".
Receiver	Receiver: This interface represents a recipient of XML tree-walking (push) events.
ReceiverOptions	ReceiverOptions defines a set of constants, which can be used in calls to methods on the Receiver interface.
ReceivingContentHandler	ReceivingContentHandler is a glue class that provides a standard SAX ContentHandler interface to a Saxon Receiver.
RegexGroup
RegexIterator	This class is an interator that supports the evaluation of xsl:analyze-string.
RegexSyntaxException	Thrown when an syntactically incorrect regular expression is detected.
RegularExpression	This interface represents a compiled regular expression
RelativeURIResolver	The standard JAXP URIResolver is given a relative URI and a base URI and returns the resource identified by this combination.
Remove	The XPath 2.0 remove() function
Replace	This class implements the replace() function for replacing substrings that match a regular expression
ResolveQName	This class supports the resolve-QName function in XPath 2.0
ResolveURI	This class supports the resolve-uri() functions in XPath 2.0
RestrictedStringValue	A value conforming to one of the built-in subtypes of String, specifically normalizedString, token, language, Name, NCName, ID, IDREF, ENTITY, NMTOKEN.
ResultDocument	The compiled form of an xsl:result-document element in the stylesheet.
Reverse	Implement XPath function fn:reverse()
ReverseArrayIterator	ReverseArrayIterator is used to enumerate items held in an array in reverse order.
Reverser	A Reverser is an expression that reverses the order of a sequence of items.
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).
RoleLocator	A RoleLocator identifies the role in which an expression is used, for example as the third argument of the concat() function.
Root	Implement the XPath 2.0 root() function
RootExpression	An expression whose value is always a set of nodes containing a single node, the document root.
Rounding	This class supports the ceiling(), floor(), round(), and round-to-half-even() functions, and also the abs() function
Rule	Rule: a template rule, or a strip-space rule used to support the implementation
RuleBasedSubstringMatcher	This class wraps a RuleBasedCollator to provide a SubstringMatcher.
RuleManager	RuleManager maintains a set of template rules, one set for each mode
SavedNamespaceContext	An object representing a list of Namespaces.
SaxonAssign	saxon:assign element in stylesheet.
SaxonCallTemplate	A saxon:call-template element in the stylesheet.
SaxonCollation	A saxon:collation element in the style sheet: this is a top-level element that defines details of a named collation.
SaxonDoctype	A saxon:doctype element in the stylesheet.
SaxonDuration	Saxon implementation of the JAXP class javax.xml.datatype.Duration.
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.
SaxonLocator	SaxonLocator: this interface exists to unify the SAX Locator and JAXP SourceLocator interfaces, which are identical.
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.
SaxonScript	A saxon:script element in the stylesheet.
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	Created by IntelliJ IDEA.
SaxonXQExpression
SaxonXQForwardSequence	The class is a Saxon implementation of the XQJ interface XQResultSequence.
SaxonXQItem
SaxonXQItemType
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	Created by IntelliJ IDEA.
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.
SchemaException	An exception that identifies an error in reading, parsing, or validating a schema.
SchemaType	SchemaType is an interface implemented by all schema types: simple and complex types, built-in and user-defined types.
SchemaURIResolver	A SchemaURIResolver is used when resolving references to schema documents.
SecondsDurationValue	A value of type xsd:dayTimeDuration
Sender	Sender is a helper class that sends events to a Receiver from any kind of Source object
SequenceCopier	Copies a sequence, supplied as a SequenceIterator, to a push pipeline, represented by a SequenceReceiver
SequenceExtent	A sequence value implemented extensionally.
SequenceIterator	A SequenceIterator is used to iterate over any XPath 2 sequence (of values or nodes).
SequenceOutputter	This outputter is used when writing a sequence of atomic values and nodes, that is, when xsl:variable is used with content and an "as" attribute.
SequenceReceiver	SequenceReceiver: this extension of the Receiver interface is used when processing a sequence constructor.
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	This outputter is used when writing a sequence of atomic values and nodes, for example, when xsl:variable is used with content and an "as" attribute.
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
SerializerFactory	Helper class to construct a serialization pipeline for a given result destination and a given set of output properties.
Sets	This class implements extension functions in the http://exslt.org/sets namespace.
ShareableSequence	A sequence value implemented extensionally using an extensible List whose leading part can be shared with other sequence values.
ShiftJISCharacterSet
SiblingCountingNode	Interface that extends NodeInfo by providing a method to get the position of a node relative to its siblings.
SiblingEnumeration	This class supports both the child:: and following-sibling:: axes, which are identical except for the route to the first candidate node.
SimpleContentConstructor	This class implements the rules for an XSLT simple content constructor, which are used in constructing the string value of an attribute node, text node, comment node, etc, from the value of the select expression or the contained sequence constructor.
SimpleExpression	An abstract implementation of Expression designed to make it easy to implement new expressions, in particular, expressions to support extension instructions.
SimpleMappingExpression	A simple mapping expression is an expression A/B where B has a static type that is an atomic type.
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
SimpleType	This interface represents a simple type, which may be a built-in simple type, or a user-defined simple type.
SingleNodeExpression	A node set expression that will always return 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.
SingletonComparison	Class to handle comparisons of singletons.
SingletonIterator	SingletonIterator: an iterator over a sequence of zero or one values
SingletonNode	A value that is a sequence containing zero or one nodes
Sink	A Sink is an Receiver that discards all information passed to it
SliceExpression	A SliceExpression represents a FilterExpression of the form EXPR[position() > n and position() < m], where n and m are not necessarily constants
SlotManager	A SlotManager supports functions, templates, etc: specifically, any executable code that requires a stack frame containing local variables.
Sortable	A Sortable is an object that can be sorted using the QuickSort method.
SortedGroupIterator	A SortedGroupIterator is a modified SortedIterator.
SortedIterator	Class to do a sorted iteration
SortedTupleIterator	A SortedTupleIterator is a modified SortedIterator.
SortExpression	Expression equivalent to the imaginary syntax expr sortby (sort-key)+
SortKeyDefinition	A SortKeyDefinition defines one component of a sort key.
SourceLocationProvider	A SourceLocationProvider is a LocationProvider that represents locations in the source document from which the events are derived (as distinct from locations in a query or stylesheet of the instructions causing the events)
SourceResolver	This interface defines a SourceResolver.
SQLClose	An sql:close element in the stylesheet.
SQLColumn	An sql:column element in the stylesheet.
SQLColumn.ColumnInstruction
SQLConnect	An sql:connect element in the stylesheet.
SQLDelete	An sql:delete element in the stylesheet.
SQLElementFactory	Class SQLElementFactory.
SQLInsert	An sql:insert element in the stylesheet.
SQLQuery	An sql:query element in the stylesheet.
SQLUpdate	An sql:update element in the stylesheet.
StackFrame	This class represents a stack frame holding details of the variables used in a function or in an XSLT template.
StandaloneContext	A StandaloneContext provides a context for parsing an XPath expression in a context other than a stylesheet.
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.
StandardCollectionURIResolver	This class implements the default collection URI Resolver.
StandardDOMHandler	Implementation of XQCommonHandler that performs the mappings between Java and XPath as defined in the XQJ specification.
StandardErrorHandler
StandardErrorListener	StandardErrorListener is the standard error handler for XSLT processing errors, used if no other ErrorListener is nominated.
StandardFunction	This class contains static data tables defining the properties of standard functions.
StandardFunction.Entry	An entry in the table describing the properties of a function
StandardModuleURIResolver	This class is the standard ModuleURIResolver used to implement the "import module" declaration in a Query Prolog.
StandardNames
StandardOutputResolver	This class defines the default OutputURIResolver.
StandardURIResolver	This class provides the service of converting a URI into an InputSource.
StartTagBuffer	StartTagBuffer is a ProxyReceiver that buffers attributes and namespace events within a start tag.
StaticBaseURI	This class supports the static-base-uri() function in XPath 2.0 (added by the working groups on 24 August 2004)
StaticContext	A StaticContext contains the information needed while an expression or pattern is being parsed.
StaticError	Exception used for static errors in XPath, XSLT, or XQuery
StaticProperty	This class contains constants identifying dependencies that an XPath expression might have on its context.
StaticQueryContext	StaticQueryContext is the implementation of StaticContext used when processing XQuery expressions.
StaxBridge	This class implements the Saxon PullProvider API on top of a standard StAX parser (or any other StAX XMLStreamReader implementation)
StringFn	Implement XPath function string()
StringJoin	xf:string-join(string* $sequence, string $separator)
StringLength	Implement the XPath string-length() function
StringTokenIterator	StringTokenIterator: breaks a string up into tokens, and returns the tokens as a sequence of strings.
StringValue	An atomic value of type xs:string
StrippedDocument	A StrippedDocument represents a view of a real Document in which selected whitespace text nodes are treated as having been stripped.
StrippedNode	A StrippedNode is a view of a node, in a virtual tree that has whitespace text nodes stripped from it.
Stripper	The Stripper class maintains details of which elements need to be stripped.
StyleElement	Abstract superclass for all element nodes in the stylesheet.
StyleNodeFactory	Class StyleNodeFactory.
StylesheetFunctionLibrary	A StylesheetFunctionLibrary contains functions defined by the user in a stylesheet.
StylesheetProcedure	This interface is implemented by all XSL elements that can contain local variable declarations.
StylesheetStripper	The StylesheetStripper refines the Stripper class to do stripping of whitespace nodes on a stylesheet.
Subsequence	Implements the XPath 2.0 subsequence() function
SubstitutionGroupTest	NodeTest is an interface that enables a test of whether a node has a particular name and type.
Substring	This class implements the XPath substring() function
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.
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 (apply-templates).
SystemFunction	Abstract superclass for system-defined and user-defined functions
SystemFunctionLibrary	The SystemFunctionLibrary represents the collection of functions in the fn: namespace.
SystemIdMap	System IDs are not held in nodes in the tree, because they are usually the same for a whole document.
SystemProperty
TailCall	Interface representing a Tail Call.
TailCallLoop	A TailCallLoop wraps the body of a function that contains tail-recursive function calls.
TailCallReturner	This interface represents an expression that is capable of being processed leaving tail calls for the calling instruction to deal with.
TailExpression	A TailExpression represents a FilterExpression of the form EXPR[position() > n] Here n is usually 2, but we allow other values
TailExpression.TailIterator
TeeOutputter	TeeOutputter: a SequenceReceiver that duplicates received events to two different destinations
Template	An xsl:template element in the style sheet.
TemplatesHandlerImpl	TemplatesHandlerImpl implements the javax.xml.transform.sax.TemplatesHandler interface.
TerminationException	An exception thrown by xsl:message terminate="yes".
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
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.
TimedTraceListener	A Simple trace listener that writes messages to System.err
TimeValue	A value of type xs:time
TinyAttributeCollection	An implementation of the AttributeCollection interface based directly on the TinyTree data structure.
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.
TinyCommentImpl	TinyCommentImpl is an implementation of CommentInfo
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)
TinyProcInstImpl	TProcInstImpl is an implementation of ProcInstInfo
TinyTextImpl	A node in the XML parse tree representing character content
TinyTree	A data structure to hold the contents of a tree.
TinyTreeWalker	This implementation of the Saxon pull interface starts from a document, element, text, comment, or processing-instruction node in a TinyTree, and returns the events corresponding to that node and its descendants (including their attributes and namespaces).
Token	This class holds static constants and methods defining the lexical tokens used in XPath and XQuery, and associated keywords.
Tokenize	This class implements the tokenize() function for regular expression matching.
Tokenizer	Tokenizer for expressions and inputs.
Trace	This class supports the XPath 2.0 function trace().
TraceEventMulticaster	A class which implements efficient and thread-safe multi-cast event dispatching for the TraceListener evants.
TraceExpression	A subclass of TraceWrapper used to trace expressions in XPath and XQuery.
TraceInstruction	A run-time instruction which wraps a real instruction and traces its entry and exit to the TraceListener
TraceListener	This interface defines methods that are called by Saxon during the execution of a stylesheet, if tracing is switched on.
TraceWrapper	This class is a tracing wrapper around any expression: it delivers the same result as the wrapped expression, but traces its evaluation to a TraceListener
TracingFilter	A filter that can be inserted into a Receiver pipeline to trace the events that pass through
Transform	This Transform class is the entry point to the Saxon XSLT Processor.
TransformerFactoryImpl	A TransformerFactoryImpl instance can be used to create Transformer and Template objects.
TransformerHandlerImpl	TransformerHandlerImpl implements the javax.xml.transform.sax.TransformerHandler 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.
Translate
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().
TreeBuilder	The Builder class is responsible for taking a stream of SAX events and constructing a Document tree.
TreeEnumeration
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.
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).
TupleExpression	A tuple expression is an expression that returns a tuple.
TupleSorter	A TupleSorter is an expression that sorts a stream of tuples.
Type	This class contains static information about types and methods for constructing type codes.
TypeChecker	This class provides Saxon's type checking capability.
TypeCheckingFilter	A filter on the push pipeline that performs type checking, both of the item type and the cardinality.
TypeHierarchy	This class exists to provide answers to questions about the type hierarchy.
TypeInfoImpl	This class implements the DOM TypeInfo interface as a wrapper over the Saxon SchemaType interface.
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.
UncheckedXPathException	When tree construction is deferred, innocuous methods such as NodeInfo#getLocalName() may trigger a dynamic error.
UncommittedSerializer	This class is used when the decision on which serialization method to use has to be delayed until the first element is read.
UnconstructedDocument	A document node whose construction is deferred.
UnconstructedElement	An element node whose construction is deferred.
UnconstructedParent	This class represents a virtual element node, the result of an element constructor that (in general) hasn't been fully evaluated.
UndeclaredVariable	An UndeclaredVariable object is created when a reference is encountered to a variable that has not yet been declared.
Unicode	This class supports the two functions string-to-codepoints() and codepoints-to-string()
UnicodeCharacterSet	This class defines properties of the Unicode character set
UnicodeData
UnicodeDataGenerator	This class reads the Unicode character database, extracts information needed to perform unicode normalization, and writes this information out in the form of the Java "source" module UnicodeData.java.
UnicodeDataParser	This class reads the data compiled into class UnicodeData, and builds hash tables that can be used by the Unicode normalization routines.
UnicodeNormalizer	UnicodeNormalizer: This ProxyReceiver performs unicode normalization on the contents of attribute and text nodes.
UnionEnumeration	An enumeration representing a nodeset that is a union of two other NodeSets.
UnionPattern	A pattern formed as the union (or) of two other patterns
UnknownCharacterSet	This class establishes properties of a character set that is known to the Java VM but not specifically known to Saxon
Unordered	XPath 2.0 unordered() function
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
UnparsedText
UnresolvedReferenceException	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.
Untyped	This class has a singleton instance which represents the complex type xdt:untyped, used for elements that have not been validated.
UntypedAtomicConverter	An UntypedAtomicConverter is an expression that converts any untypedAtomic items in a sequence to a specified type
UntypedAtomicValue	An Untyped Atomic value.
UppercaseFirstComparer	A Comparer used for comparing strings, with upper case collated before lower case if the strings are otherwise equal.
URIQueryParameters	A set of query parameters on a URI passed to the collection() or document() function
URIQueryParameters.RegexFilter
UseAttributeSets	This instruction corresponds to a use-attribute-sets attribute on a literal result element, xsl:element, or xsl:copy.
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).
UserFunctionCall	This class represents a call to a function defined in the stylesheet or query.
UserFunctionParameter	Run-time object representing a formal argument to a user-defined function
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 expressions in XSLT 2.0
Validation	This class contains constants and static methods to manipulate the validation property of a type.
ValidationErrorValue	A ValidationErrorValue is a pseudo-value representing the result of a validation failure.
ValidationException	This exception indicates a failure when validating an instance against a type defined in a schema.
Value	A value is the result of an expression but it is also an expression in its own right.
ValueComparison	ValueComparison: a boolean expression that compares two atomic values for equals, not-equals, greater-than or less-than.
ValueOf	An xsl:value-of element in the stylesheet.
ValueRepresentation	A ValueRepresentation is a representation of a Value.
Variable	An object representing an XPath variable for use in the standalone XPath API.
VariableDeclaration	Generic interface representing a variable declaration in the static context of an XPath expression.
VariableReference	Variable reference: a reference to a variable.
VendorFunctionLibrary	The VendorFunctionLibrary represents specially-recognized functions in the Saxon namespace.
VennExpression	An expression representing a nodeset that is a union, difference, or intersection of two other NodeSets
Version	The Version class holds the SAXON version information.
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.
VirtualDocumentCopy	A virtual copy of a document node
VirtualNode	This interface is implemented by NodeInfo implementations that act as wrappers on some underlying tree.
VirtualTreeWalker	A virtual tree walker provides a sequence of pull events describing the structure and content of a tree that is conceptually being constructed by expressions in a query or stylesheet; in fact the tree is not necessarily constructed in memory, and exists only as this stream of pull events.
While	Handler for saxon:while elements in stylesheet.
Whitespace	This class provides helper methods and constants for handling whitespace
WhitespaceTextImpl	A node in the XML parse tree representing a text node with compressed whitespace content
WithParam	An instruction derived from a xsl:with-param element in the stylesheet.
XHTMLEmitter	XHTMLEmitter is an Emitter that generates XHTML output.
XHTMLIndenter	XHTMLIndenter: This class indents XHTML elements, by adding whitespace character data where appropriate.
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.
XML11Char	This class defines the basic properties of characters in XML 1.1.
XMLChar	This class defines the basic XML character properties.
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.
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).
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.XSLTContext	An XSLTContext object holds all the additional dynamic context items used in XSLT.
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.
XPathEvaluator	This is a cut-down version of the XPathEvaluator in the net.sf.saxon.xpath package.
XPathEvaluator	XPathEvaluator provides a simple 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 in an XPath expression.
XPathException.Circularity	Subclass used to report circularities
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.
XQCancelledException	XQJ interfaces reconstructed from version 0.5 documentation
XQCommonHandler	XQJ interfaces reconstructed from version 0.5 documentation
XQConnection	XQJ interfaces reconstructed from version 0.5 documentation
XQConstants	XQJ interfaces reconstructed from version 0.5 documentation
XQDataFactory	XQJ interfaces reconstructed from version 0.5 documentation
XQDataSource	XQJ interfaces reconstructed from version 0.5 documentation
XQDynamicContext	XQJ interfaces reconstructed from version 0.5 documentation
XQException	XQJ interfaces reconstructed from version 0.5 documentation
XQExpression	XQJ interfaces reconstructed from version 0.5 documentation
XQItem	XQJ interfaces reconstructed from version 0.5 documentation
XQItemAccessor	XQJ interface reconstructed from version 0.5 documentation
XQItemType	XQJ interfaces reconstructed from version 0.5 documentation
XQMetaData	XQJ interfaces reconstructed from version 0.5 documentation
XQPreparedExpression	XQJ interfaces reconstructed from version 0.5 documentation
XQQueryException	XQJ interfaces reconstructed from version 0.5 documentation
XQResultItem	XQJ interfaces reconstructed from version 0.5 documentation
XQResultSequence	XQJ interfaces reconstructed from version 0.5 documentation
XQSequence	XQJ interfaces reconstructed from version 0.5 documentation
XQSequenceType	XQJ interfaces reconstructed from version 0.5 documentation
XQStackTraceElement	XQJ interfaces reconstructed from version 0.5 documentation
XQStackTraceVariable	XQJ interfaces reconstructed from version 0.5 documentation
XQStaticContext	XQJ interfaces reconstructed from version 0.5 documentation
XQueryExpression	XQueryExpression represents a compiled query.
XQueryFunction
XQueryFunctionBinder
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.
XQueryTraceListener	A Simple trace listener for XQuery that writes messages (by default) to System.err
XQWarning	XQJ interfaces reconstructed from version 0.5 documentation
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
XSLAttribute	xsl:attribute element in stylesheet.
XSLAttributeSet	An xsl:attribute-set element in the stylesheet.
XSLCallTemplate	An xsl:call-template element in the stylesheet
XSLCharacterMap	An xsl:character-map declaration in the stylesheet.
XSLChoose	An xsl:choose elements in the stylesheet.
XSLComment	An xsl:comment elements 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.
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.
XSLFunction	Handler for xsl:function elements in stylesheet (XSLT 2.0).
XSLGeneralIncorporate	Abstract class to represent xsl:include or xsl:import element in the stylesheet.
XSLGeneralVariable	This class defines common behaviour across xsl:variable, xsl:param, and xsl:with-param
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.
XSLKey	Handler for xsl:key elements in stylesheet.
XSLMatchingSubstring	Handler for xsl:matching-substring and xsl:non-matching-substring elements in stylesheet.
XSLMessage	An xsl:message element in the stylesheet.
XSLNamespace	An xsl:namespace element in the stylesheet.
XSLNamespaceAlias	An xsl:namespace-alias element in the stylesheet.
XSLNextMatch	An xsl:next-match element in the stylesheet
XSLNumber	An xsl:number element in the stylesheet.
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.
XSLParam	An xsl:param element in the stylesheet.
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.
XSLStringConstructor	Common superclass for XSLT elements whose content template produces a text value: xsl:attribute, xsl:comment, and xsl:processing-instruction
XSLStylesheet	An xsl:stylesheet or xsl:transform element in the stylesheet.
XSLTemplate	An xsl:template element in the style sheet.
XSLText	Handler for xsl:text elements in stylesheet.
XSLTFunction	This is a marker interface used to identify functions that are defined in XSLT rather than in XPath
XSLTStaticContext	Extends the standard XPath static context with information that is available for XPath expressions invoked from XSLT
XSLTTraceListener	A Simple trace listener for XSLT that writes messages (by default) to System.err
XSLValueOf	An xsl:value-of element in the stylesheet.
XSLVariable	Handler for xsl:variable elements in stylesheet.
XSLVariableDeclaration	Generic class for xsl:variable and xsl:param elements.
XSLWhen	Handler for xsl:when elements in stylesheet.
XSLWithParam	An xsl:with-param element in the stylesheet.