PhoenixmlDb.Core API Reference

Type	Description
`ContainerId`	A lightweight, strongly-typed identifier for a container within a PhoenixmlDb database.
`ContainerInfo`	Summary information about a container, returned by `IDocumentDatabase.ListContainersAsync`.
`ContainerNotFoundException`	Thrown when a container with the specified name does not exist in the database.
`ContainerOptions`	Configuration options for an `IContainer`, controlling indexing, namespace bindings, validation, and whitespace handling.
`ContentType`	Specifies the content format of a stored document.
`DatabaseStatistics`	Aggregate statistics for a PhoenixmlDb database.
`DocumentExistsException`	Thrown when attempting to store a document with a name that already exists and `DocumentOptions.Overwrite` is set to `false`.
`DocumentId`	A lightweight, strongly-typed identifier for a document within a container.
`DocumentInfo`	Lightweight summary information about a stored document, returned by `IContainer.ListDocumentsAsync` and `IContainer.QueryMetadataAsync`.
`DocumentInput`	One document to write in a batch: name, content, and optional per-document options.
`DocumentNotFoundException`	Thrown when a document with the specified name does not exist in the container.
`DocumentOptions`	Options controlling how a document is stored when calling `IContainer.PutDocumentAsync`.
`DocumentParseException`	Thrown when document content cannot be parsed as well-formed XML or valid JSON.
`FullTextIndexDefinition`	Defines a full-text index that tokenizes text content for `ft:contains()` search.
`FullTextIndexOptions`	Controls tokenization and text analysis for full-text indexes created via `IndexConfiguration.AddFullTextIndex`.
`IContainer`	Primary interaction surface for storing, retrieving, querying, and managing documents within a PhoenixmlDb container.
`IDocument`	Represents a stored document retrieved from a container, providing access to its content, parsed XDM node tree, and application-defined metadata.
`IDocumentDatabase`	Root entry point for all PhoenixmlDb operations.
`IReadTransaction`	A read-only transaction that provides MVCC snapshot isolation over the database.
`IWriteTransaction`	A read-write transaction providing full ACID guarantees for atomic multi-document operations.
`IXdmNode`	Represents a node in the XQuery Data Model (XDM) tree — the parsed, structured representation of a stored XML or JSON document.
`IndexConfiguration`	Provides a fluent API for defining the indexes that accelerate XQuery and metadata queries on a container's documents.
`IndexDefinition`	Abstract base type for all index definitions. Each concrete subtype represents a different index strategy.
`MetadataIndexDefinition`	Defines a metadata index that enables efficient queries by document metadata key-value pairs.
`NameIndexDefinition`	Defines a name index that accelerates element and attribute name lookups.
`NamespaceId`	A lightweight, strongly-typed identifier for an interned namespace URI.
`NamespaceRegistry`	The single source of truth mapping well-known `NamespaceId` values to their URIs and conventional prefixes.
`NodeId`	A lightweight, strongly-typed identifier for a node within a document's XDM tree.
`PathIndexDefinition`	Defines a path index that accelerates evaluation of XPath path expressions.
`QName`	Represents a qualified name (QName) consisting of a namespace, a local name, and an optional prefix — the XDM representation of element and attribute names.
`TransactionException`	Thrown when a transaction operation fails due to an invalid state or internal error.
`TransactionTimeoutException`	Thrown when a write transaction cannot be acquired within the specified timeout period.
`ValidationMode`	Specifies how documents should be validated when stored in a container.
`ValueIndexDefinition`	Defines a value index that stores typed values for range queries and comparisons.
`XQueryException`	Thrown when an XQuery expression fails to parse or encounters a runtime error during execution.
`XdmNodeKind`	Enumerates the seven node kinds defined by the XQuery Data Model (XDM) specification, plus `XdmNodeKind.None` as a sentinel value.
`XdmValueType`	Enumerates the XDM (XQuery Data Model) value types that can be used for typed index definitions in `IndexConfiguration.AddValueIndex` and `IndexConfiguration.AddMetadataIndex`.
`XmlDbException`	Base exception for all PhoenixmlDb errors. Catch this type to handle any database-related error in a single handler.

Type	Description
`DcTerms`	Dublin Core Terms (`http://purl.org/dc/terms/`), the standard document-metadata vocabulary.
`MetadataCollection`	All metadata for one document, keyed by qualified name.
`MetadataCollectionExtensions`	Typed access to a `MetadataCollection`.
MetadataProperty`1	A typed, discoverable handle on one metadata name in one namespace.
`PhxMeta`	Engine-reserved document metadata (`https://schemas.phoenixml.dev/2026/meta`).

Type	Description
`CompiledSchema`	A schema compiled from one or more root documents and everything they include, import or redefine. It does not change: a schema whose documents change is compiled again, into a new instance.
`ISchemaAccessGate`	The one route by which a schema document that the host did not supply is read: a root schema named by URI, and every document reached from any schema by `xs:include`, `xs:import` or `xs:redefine`.
`OpenFilePath`	The path of a file that is already open, with every link resolved, where the operating system can report it. Deciding on that path, and not on the name a file was opened by, leaves no gap between the check and the open.
`SchemaAccessGate`	The gates the layer provides.
`SchemaCache`	Keeps compiled schemas, so that a schema is compiled once and used until one of its documents changes.
`SchemaCacheOptions`	How a `SchemaCache` keeps and re-examines what it holds.
`SchemaCompilationException`	A schema could not be loaded or does not compile.
`SchemaCompileOptions`	Limits on what one schema compilation reads, and how it reads it.
`SchemaCompiler`	Compiles a schema from root documents, reading every document of it through one `ISchemaAccessGate` or from the `SchemaSource` documents the host supplies.
`SchemaDiagnostic`	One thing a schema compilation or a validation reports, in the same shape whoever asks.
`SchemaDocumentContent`	A schema document as a gate opened it.
`SchemaDocumentRequest`	A schema document the layer needs to read.
`SchemaDocumentVersion`	One document of a compiled schema, and the version of it that was compiled.
`SchemaMessageIds`	Which of the schema processor's messages a diagnostic is, and the validation rule of the XSD specification it reports, where one message means one rule.
`SchemaPatternCharacters`	Rewrites a pattern facet so that everything in it that stands for one character matches one character as XML Schema counts it: a code point. System.Xml hands the pattern to a .NET expression, which counts UTF-16 units, so a character outside the Basic Multilingual Plane (a surrogate pair) was two characters to ".", to a negated class and to a negated category, and no character at all to a category it belongs to.
`SchemaPatternGuard`	Bounds the regular expressions behind XSD `pattern` facets. System.Xml builds them with no match timeout of its own, so a pattern that backtracks catastrophically runs for as long as the value makes it, in a cast to a schema type, in validation, and while the schema compiles (which checks the schema's own enumeration, default and fixed values against its patterns).
`SchemaSeverity`	How serious a `SchemaDiagnostic` is.
`SchemaSource`	A schema document the host supplies itself: an absolute URI that names it, and its content.
`SchemaValidationOptions`	What one validation checks, and when it stops.
`SchemaValidationResult`	What a validation found.
`SchemaValidator`	Validates an instance document against a `CompiledSchema`, with one result shape whoever asks.
`XmlCatalog`	An OASIS XML Catalog (XML Catalogs 1.1): a table that says where the document a URI names is really to be read from. A schema that refers to `http://www.w3.org/2001/xml.xsd` can so be compiled from a local copy, with nothing fetched from the network.
`Xsd11Compatibility`	Makes a schema document written for XSD 1.1 loadable by the XSD 1.0 processor the layer uses (System.Xml's), in the two ways the specification and practice allow.

Type	Description
`Closure`	The first step: the documents of one compilation, each read once.
`LoadedOnlyResolver`	Gives the schema compiler the documents that were read, and nothing else.
`LoadedSchemaDocuments`	The documents of one schema, read and checked, not yet in any schema set.

Type	Description
`RangeSet`	A set of characters above U+FFFF, as sorted ranges that do not touch.

Type	Description
`LengthBounds`	The length a string type asks for, in characters: what the length facets of one restriction said before they were turned into a pattern.

Type	Description
`Entry`	One entry. `PreferPublic` is the `prefer` setting in force where a `public` or `delegatePublic` entry stands; a delegate entry has the catalog it names in `Delegated` and no target.

Type	Description
`IXmlResourceResolver`	Host-injectable seam for resolving the resources referenced by an XInclude `xi:include` element (`href`, optionally combined with `parse`).
`LocalFileResourceResolver`	Default `IXmlResourceResolver` implementation: resolves `file:` (local filesystem) URIs directly and, unless `LocalFileResourceResolver.AllowRemote` is set, blocks any other scheme (e.g. `http:`, `https:`) as a security precaution against server-side-request-forgery via `xi:include href`.
`XIncludeErrorKind`	Classifies an `XIncludeException` so callers (and the XSLT/XQuery engine wirings) can map a failure to the appropriate engine error and tests can assert the cause.
`XIncludeException`	Thrown when XInclude processing (`xi:include` resolution) fails.
`XIncludeLimiter`	Enforces XInclude expansion resource limits (descent depth, produced-node budget) and carries the `xpath1()` evaluation timeout. One instance is created per `XIncludeProcessor.Expand` call and threaded through every recursive path, so a bound cannot be silently skipped on one path (the root cause of the resource-safety audit findings). Single-threaded; not reusable.
`XIncludeOptions`	Configures XInclude 1.0 (`xi:include`) processing.
`XIncludeProcessor`	XInclude 1.0 processor: expands `xi:include` elements with `parse="xml"` (structural inclusion) or `parse="text"` (textual inclusion, SP2) and an `href`, resolving each reference against the in-scope base URI, recursing into included content, and detecting cyclic / over-deep inclusion.
`XPointerEvaluator`	Resolves an XInclude `xpointer`/`fragid` value against a target `XmlDocument`, per the W3C XPointer Framework: shorthand (barename), `element()`, `xmlns()`, and `xpath1()` schemes. `xpath1()` uses System.Xml's built-in XPath 1.0 engine. Returns the selected nodes in document order (empty if nothing is selected); throws a fatal `XIncludeException` for a grammar-invalid pointer or an invalid `xpath1()` expression.

Type	Description
`DayTimeDuration`	Represents an `xs:dayTimeDuration` value as a total seconds count using `Decimal` precision, supporting arbitrarily large durations.
`ImplicitTimezone`	The implicit timezone of the dynamic context (XPath 3.1 §2.1.2): the timezone a date, time or dateTime with none of its own is taken to be in when it is compared with one that has one. It is the timezone of the machine unless the host says otherwise.
`ImplicitTimezoneScope`	Puts back the implicit timezone that was in effect before `ImplicitTimezone.Use`.
`NamespaceBinding`	A namespace prefix-to-URI binding, representing a single `xmlns:prefix="uri"` declaration on an element.
`TextNodeItem`	Lightweight text node marker for XSLT sequence accumulators, distinguishing text nodes from atomic string values.
`XdmQName`	Represents an expanded QName (namespace URI + local name + optional prefix), as used throughout the XDM for node names, type names, and function names.
`XdmSequence`	An ordered sequence of XDM items — the public wire-format for passing values between transformations and queries without serializing through XML markup.
`XdmType`	Enumeration of XDM atomic value types, corresponding to the XML Schema (XSD) type hierarchy.
`XdmTypeName`	Represents an XSD type name used for type annotations on elements and attributes.
`XdmValue`	Represents an XDM atomic value — a typed, immutable value from the XPath/XQuery type system.
`XsAnyUri`	Wrapper type for `xs:anyURI` values, distinguishing them from plain strings at the CLR type level.
`XsDate`	Represents an `xs:date` value with optional timezone and support for extended years.
`XsDateTime`	Represents an `xs:dateTime` value with explicit timezone tracking and support for extended years outside the .NET `DateTimeOffset` range.
`XsDuration`	Represents an `xs:duration` value with both month and day-time components, preserving the full XSD duration semantics that `TimeSpan` cannot.
`XsGDay`	Represents an `xs:gDay` value (e.g., `---25`), stored as its lexical form.
`XsGMonth`	Represents an `xs:gMonth` value (e.g., `--12`), stored as its lexical form.
`XsGMonthDay`	Represents an `xs:gMonthDay` value (e.g., `--12-25`), stored as its lexical form.
`XsGYear`	Represents an `xs:gYear` value (e.g., `2005`), stored as its lexical form.
`XsGYearMonth`	Represents an `xs:gYearMonth` value (e.g., `2005-10`), stored as its lexical form.
`XsTime`	Represents an `xs:time` value with optional timezone and sub-second precision.
`XsTypedInteger`	Tags an integer-typed atomic value with its declared XSD type name so `instance of` can distinguish between e.g. xs:long, xs:nonNegativeInteger, xs:positiveInteger, etc. Without this wrapper, all integer subtypes collapse to CLR `long`, so `xs:long(1) instance of xs:nonNegativeInteger` incorrectly returns `true` (the value fits in range, but the declared types are siblings under xs:integer, not parent/child).
`XsTypedString`	Wrapper for XSD string-derived types (xs:normalizedString, xs:token, xs:language, xs:NMTOKEN, xs:Name, xs:NCName, xs:ID, xs:IDREF, xs:ENTITY) that preserves the declared type name for correct `instance of` semantics.
`XsUntypedAtomic`	Wrapper type for `xs:untypedAtomic` values, distinguishing them from `xs:string` at the CLR type level.
`YearMonthDuration`	Represents an `xs:yearMonthDuration` value as a count of months, implementing correct XML Schema semantics for month-based date arithmetic.

Type	Description
`XdmAttribute`	Represents an XML attribute node in the XDM tree.
`XdmComment`	Represents an XML comment node (`<!-- ... -->`) in the XDM tree.
`XdmDocument`	Represents an XML document root node in the XDM tree.
`XdmElement`	Represents an XML element node in the XDM tree, including its attributes, children, and namespace declarations.
`XdmNamespace`	Represents a namespace node in the XDM tree, corresponding to an in-scope namespace binding on an element.
`XdmNode`	Abstract base class for all XDM (XPath Data Model) nodes, representing the in-memory structure of XML and JSON documents as defined by the W3C XDM specification.
`XdmProcessingInstruction`	Represents an XML processing instruction (`<?target data?>`) in the XDM tree.
`XdmText`	Represents a text node containing character data content in the XDM tree.

Type	Description
`XdmStringValueResolver`	Computes the string value of a node whose value was not known at construction time.

Type	Description
`ParseResult`	The result of parsing an XML document via `XmlDocumentParser`.
`XmlDocumentParser`	Parses XML content (strings, streams, or readers) into an XDM node tree.
`XmlSerializer`	Serializes XDM node trees back to XML text, completing the round-trip from `XmlDocumentParser` (parse) to in-memory XDM to XML output.

Type	Description
`Utf8StringWriter`	A `StringWriter` that reports its encoding as UTF-8.

#PhoenixmlDb.Core API Reference

#PhoenixmlDb.Core

#PhoenixmlDb.Core.Metadata

#PhoenixmlDb.Core.Schema

#PhoenixmlDb.Core.Schema.SchemaCompiler

#PhoenixmlDb.Core.Schema.SchemaPatternCharacters

#PhoenixmlDb.Core.Schema.SchemaPatternGuard

#PhoenixmlDb.Core.Schema.XmlCatalog

#PhoenixmlDb.Core.Xml

#PhoenixmlDb.Xdm

#PhoenixmlDb.Xdm.Nodes

#PhoenixmlDb.Xdm.Nodes.XdmNode

#PhoenixmlDb.Xdm.Parsing

#PhoenixmlDb.Xdm.Parsing.XmlSerializer