Every value manipulated by XPath, XQuery, or XSLT is a sequence comprising zero or more items.
[Definition: A sequence type constrains the set of permitted sequences, by defining the permitted item types and the permitted number of items in the sequence (exactly zero, exactly one, zero-or-more, one-or-more, zero-or-one).]
Every item is an instance of one or more item types:
All items are instances of the type item(). There are three kinds of item: atomic items, generic nodes (GNodes), and function items.
Every atomic item is an instance of a specific atomic type determined by its type annotation; it is also an instance of every type from which that type is derived by restriction (directly or indirectly), and of every union type that includes that type as a member type.
A generic node (GNode) is either an XNode (for "XML node"), or a JNode (for "JSON node"). For continuity reasons, throughout these specifications the term node, when used without qualification, means an XNode; furthermore the item type node() refers exclusively to an XNode. The term XNode is used only when there is a need to distinguish clearly from JNodes.
XNodes represent the constructs found in an XML document. Every node (that is, every XNode) is an instance of the type node(), and more specifically it is an instance of one of seven node kinds: document(), element(*), attribute(*), text(), comment(), processing-instruction(), or namespace(). Nodes may also be instances of more specific types characterized by the node name and type annotation.
JNodes are newly introduced in 4.0 for the purpose of navigating trees of maps and arrays, typically derived by parsing JSON. A JNode wraps a value (which may be any sequence).
Every function item is an instance of the generic type function(*), and also of a specific function type defining the types of the function's parameters and the type of the result.
A map item, as well as being a function, is also an instance of the generic map type map(*), of more specific map types map(K, V) defining the types of the keys and values, and perhaps of one or more record types that associate a type with specific key values.
An array item, as well as being a function, is also an instance of the generic array type array(*), and also of more specific array types array(M) defining the type of the array's members.
This section describes how item types relate to each other.
The diagrams below show how nodes, functions, primitive simple types, and user defined types fit together into a type system. In the diagrams, connecting lines represent relationships between derived types and the types from which they are derived; the latter are always higher and to the left of the latter.
The xs:IDREFS, xs:NMTOKENS, xs:ENTITIES types, and xs:numeric, and both the user-defined list types and user-defined union types are special types in that these types are lists or unions rather than types derived by extension or restriction.
The first diagram illustrates the relationship of various item types. Item types in the data model form a directed graph, rather than a hierarchy or lattice: in the relationship defined by the derived-from(A, B) function, some types are derived from more than one other type. Examples include functions (function(xs:string) as xs:int is substitutable for function(xs:NCName) as xs:int and also for function(xs:string) as xs:decimal), and union types (A is substitutable for the union type (A | B) and also for the union type (A | C)). In XDM, item types include node types, function types, and built-in atomic types. The list, which shows only hierarchic relationships, is therefore a simplification of the full model.
The XPath Data Model is the abstraction over which XPath expressions are evaluated. Historically, all of the items in the data model could be derived directly (nodes) or indirectly (typed values, sequences) from an XML document. However, as the XPath expression language has matured, new features have been added which require additional types of items to appear in the data model. These items have no direct XML serialization, but they are never the lessnevertheless part of the data model.
The next diagram shows all of the atomic types, including the primitive simple types and the built-in types derived from the primitive simple types. This includes all the built-in datatypes defined in [Schema Part 2]. Atomic types act both as item types (meaning they can be used to declare the types of variables and function arguments), and as schema types (meaning they can be used as type annotations on nodes).
For further detail regarding atomic items see 5 Atomic Items.