All Classes and Interfaces
Class
Description
Implementations of this class represent a temporal value which may not have a
timezone making it ambiguous as a point/window in time.
Provides a common implementation for all atomic types that have an underlying
value.
AbstractAssemblyInstance<PARENT extends IContainerModel,DEFINITION extends IAssemblyDefinition,INSTANCE extends IAssemblyInstance,PARENT_DEFINITION extends IAssemblyDefinition>
A base class for an assembly that is a member of a containing model.
Provides base functionality for atomic item implementations.
An abstract implementation of an atomic type.
Maintains a byte buffer representation of a byte stream.
An abstract base class for Metaschema modules bound to Java classes.
AbstractChoiceGroupInstance<PARENT extends IAssemblyDefinition,NAMED_MODEL extends INamedModelInstanceGrouped,FIELD extends IFieldInstanceGrouped,ASSEMBLY extends IAssemblyInstanceGrouped>
A base class for a choice group that is a member of a containing model.
AbstractChoiceInstance<PARENT extends IAssemblyDefinition,MODEL extends IModelInstanceAbsolute,NAMED_MODEL extends INamedModelInstanceAbsolute,FIELD extends IFieldInstanceAbsolute,ASSEMBLY extends IAssemblyInstanceAbsolute>
A base class for a choice that is a member of a containing model.
A base class for implementation that perform the operation supported by a
command.
AbstractConfigurableMessageConstraintBuilder<T extends AbstractConfigurableMessageConstraintBuilder<T,R>,R extends IConfigurableMessageConstraint>
Provides builder methods for the core data elements of an
IConstraint.Provides a complete, abstract implementation of a generalized feature.
Provides builder methods for the core data elements of an
IConstraint.A common implementation for a set of constraints targeted at the contents of
a Metaschema module.
Provides messaging for constraint violations.
AbstractContainerModelSupport<MI extends IModelInstance,NMI extends INamedModelInstance,FI extends IFieldInstance,AI extends IAssemblyInstance>
Supports model instance operations on assembly model instances.
Base class for a content validator.
Used by implementing classes to provide a content conversion command.
Used by implementing classes to provide for execution of a conversion
command.
A common base implementation of a custom Java object providing an underlying
implementation of a data type.
AbstractCustomJavaDataTypeAdapter<TYPE extends ICustomJavaDataType<TYPE>,ITEM_TYPE extends IAnyAtomicItem>
Provides a Java type adapter implementation for data types that are based on
ICustomJavaDataType.Provides a basic Java type adapter implementation.
A base implementation of an
IDataTypeProvider, supporting dynamic
loading of Metaschema data type extensions at runtime.A base implementation of a node item backed by a Metaschema definition.
The base class of all format-specific deserializers.
Supports working with duration-based data values.
Records information about the exit status of a CLI command.
AbstractFieldInstance<PARENT extends IContainerModel,DEFINITION extends IFieldDefinition,INSTANCE extends IFieldInstance,PARENT_DEFINITION extends IAssemblyDefinition>
A base class for a field that is a member of a containing model.
AbstractFlagInstance<PARENT extends IModelDefinition,DEFINITION extends IFlagDefinition,INSTANCE extends IFlagInstance>
A base class for a flag that is a member of a containing model.
A
INodeItem supported by a IFlagInstance.AbstractGenerationState<WRITER,DATATYPE_MANAGER extends dev.metaschema.schemagen.datatype.IDatatypeManager>
Provides a common base implementation for schema generation state management.
Represents a collection of allowed values with a flag indicating whether the
value set is closed (no other values allowed) or open.
AbstractGlobalAssemblyDefinition<MODULE extends IModule,INSTANCE extends IAssemblyInstance,FLAG extends IFlagInstance,MODEL extends IModelInstanceAbsolute,NAMED_MODEL extends INamedModelInstanceAbsolute,FIELD extends IFieldInstanceAbsolute,ASSEMBLY extends IAssemblyInstanceAbsolute,CHOICE extends IChoiceInstance,CHOICE_GROUP extends IChoiceGroupInstance>
A base class for an assembly definition defined globally within a Metaschema
module.
A base class for definitions defined globally within a Metaschema module.
Provides a callback for generating a qualified name from a name.
Represents a node item based on a global definition from a Metaschema.
AbstractGlobalFieldDefinition<MODULE extends IModule,INSTANCE extends IFieldInstance,FLAG extends IFlagInstance>
A base class for a field definition defined globally within a Metaschema
module.
A base class for a flag definition defined globally within a Metaschema
module.
AbstractInlineAssemblyDefinition<PARENT extends IContainerModel,DEFINITION extends IAssemblyDefinition,INSTANCE extends IAssemblyInstance,PARENT_DEFINITION extends IAssemblyDefinition,FLAG extends IFlagInstance,MODEL extends IModelInstanceAbsolute,NAMED_MODEL extends INamedModelInstanceAbsolute,FIELD extends IFieldInstanceAbsolute,ASSEMBLY extends IAssemblyInstanceAbsolute,CHOICE extends IChoiceInstance,CHOICE_GROUP extends IChoiceGroupInstance>
A base class for an assembly instance defined inline.
AbstractInlineFieldDefinition<PARENT extends IContainerModel,DEFINITION extends IFieldDefinition,INSTANCE extends IFieldInstance,PARENT_DEFINITION extends IAssemblyDefinition,FLAG extends IFlagInstance>
A base class for an assembly instance defined inline.
AbstractInlineFlagDefinition<PARENT extends IModelDefinition,DEFINITION extends IFlagDefinition,INSTANCE extends IFlagInstance>
A base class for an assembly instance defined inline.
Base implementation of
IInstance providing parent container
management.AbstractInstanceNodeItem<D extends IDefinition,I extends INamedInstance,P extends IModelNodeItem<? extends IModelDefinition,? extends INamedInstance>>
A base implementation of a node item backed by a Metaschema instance.
Provides a common base class for integer-based data types.
Provides builder methods for the core data elements of an
IConstraint
that supports a custom message.Base implementation of
ILoader providing resource loading with
caching and cycle detection.The common base for all markup implementations.
Provides a set of callbacks used when iterating over model elements in a
directed graph.
An abstract base class for managing collection information for model
instances.
An abstract base class for reading model instance collections.
An abstract base class for writing model instance collections.
AbstractModule<M extends IModuleExtended<M,D,FL,FI,A>,D extends IModelDefinition,FL extends IFlagDefinition,FI extends IFieldDefinition,A extends IAssemblyDefinition>
Provides a common, abstract implementation of a
IModule.Provides methods to load a Metaschema expressed in XML.
Provides basic module loading capabilities.
Base implementation of
INamedInstance providing qualified name
management.AbstractNamedModelInstance<PARENT extends IContainerModel,PARENT_DEFINITION extends IAssemblyDefinition>
A base class for name members of a containing model.
A common base class for node item implementations.
A base implementation of a node item factory that creates node items for
Metaschema definitions and instances.
Used by implementations of this class to visit a sequence of node items in a
directed graph, using depth-first ordering.
A base implementation of a node item for a Metaschema definition that exists
without a parent context (orphaned).
A base class for a command that supports hierarchical command structure with
child commands.
Abstract base class for problem handlers that can validate required fields
during deserialization.
A node item visitor that prevents infinite recursion when traversing assembly
nodes by detecting and avoiding cycles in the node hierarchy.
Base implementation of
IResourceResolver providing URI resolution
support.AbstractSchemaGenerator<T extends AutoCloseable,D extends dev.metaschema.schemagen.datatype.IDatatypeManager,S extends AbstractGenerationState<T,D>>
Thsi abstract class provides a common implementation shared by all schema
generators.
The base class of all format-specific serializers.
Provides a common base class for string-based data types.
Provides an base implementation for a set of constraints that target a
definition using a target Metapath expression.
A base class for terminal commands in the command processing hierarchy.
This abstract implementation dynamically produces JUnit tests based on a test
suite definition.
A base class for untyped atomic items.
Used by implementing classes to provide a content validation command.
Provides processing hooks for a set of validation results.
Provides the means to aggregate multiple validation result sets into a single
result set.
This annotation provides an enumerated value that is used as part of an
AllowedValues annotation.This annotation defines a set of values permitted to be used in the context
of the containing annotation.
Represents a date value which may not have a timezone making it ambiguous as
a window in time.
Represents a date/time value which may not have a timezone making it
ambiguous as a point in time.
Represents a date value which may not have a timezone making it ambiguous as
a window in time.
Any Additional Content.
Represents an error that occurred while performing mathematical operations.
Implements the XPath 3.1 array:append
function.
Implements the XPath 3.1 array:flatten
function.
Implements the XPath 3.1 array:get
function.
Implements the XPath 3.1 array:head
function.
Implements the XPath 3.1 array:insert-before
function.
Implements the XPath 3.1 array:join
function.
Implements the XPath 3.1 array:put
function.
Implements the XPath 3.1 array:remove
function.
Implements the XPath 3.1 array:reverse
function.
Implements the XPath 3.1 array:size
function.
Implements the XPath 3.1 array:subarray
function.
Implements the XPath 3.1 array:tail
function.
Defines constraints that apply to assembly definitions.
A binding class for the
assembly-constraints definition.Represents a container of rules constraining the effective model of a
Metaschema assembly data instance.
A binding class for the
assembly-model definition.Choice.
Choice Grouping.
Grouping Assembly Reference.
Inline Assembly Definition.
Inline Field Definition.
Grouping Field Reference.
Assembly Reference.
A set of constraints targeting a
IAssemblyDefinition based on a
target Metapath expression.Wraps a resource to make it
AutoCloseable.A callback interface representing a close operation.
Maintains a byte buffer backed representation of a byte stream parsed from a
BASE64 encoded string.
Loads Metaschema constraints from external constraint files using data
binding.
Used to report exceptional conditions related to processing bound objects.
Loads Metaschema modules from XML or YAML sources using data binding.
Support for the Metaschema boolean
data type.
Identifies that the annotation target is a bound property that references a
Module assembly.
Identifies that the annotation target is a bound property that participates
in a Metaschema choice.
Identifies that the annotation target is a bound property that references a
collection of model instances of varying types.
Identifies that the annotation target is a bound property that references a
Module field.
Identifies a field on a class annotated with the
MetaschemaField
annotation as the Module field's value.Identifies that the annotation target is a bound property that represents a
Module flag.
Identifies that the annotation target is a bound property that references a
Module assembly.
Identifies that the annotation target is a bound property that references a
Module field.
Represents an immutable execution context for function calls in Metapath
expressions.
Records information about the command line options and called command
hierarchy.
Implements the XPath 3.1
casting
functions.
FOCA: Exceptions related to type casting.
An inline strategy that inlines definitions unless they are contained within
a choice block.
A variety of utility methods for normalizing Java class related names.
The main entry point for the CLI application.
Processes command line arguments and dispatches called commands.
Provides a collection of utilities for handling Java collections and
iterators.
For use in commands to short-circut command execution.
A service that loads commands using SPI.
An XML event filter that excludes comment events from the event stream.
A collection of comparison functions supporting value and general
comparisons.
Comparison operators.
Generates shell completion scripts for Bash and Zsh.
Supported shell types.
Registry for mapping Java types to their shell completion behavior.
Identifies that an unexpected error occurred while initializing or using
constraints associated with a Metaschema-based model.
Constraint Let Expression.
Indicates a constraint validation failure.
Represents an individual constraint validation issue.
Implements a builder pattern for creating constraint findings.
Allowed Value Enumeration.
err:MPDY0002: It
is a dynamic
error if evaluation of an expression relies on some part of the
dynamic
context that is
absent.
This command implementation supports the conversion of a content instance
between supported formats based on a provided Metaschema module.
Provides a variety of collector and other stream utilities.
A handler that supports resolving duplicate keys while inserting values into
a map.
An abstract implementation of an atomic type backed by a data type adapter.
This class provides a singleton service to allow data types to be discovered
within the system based on an SPI provided by
IDataTypeProvider.Support for the Metaschema date
data type.
Support for the Metaschema date-time
data type.
FODT: Exceptions related to Date/Time/Duration errors.
Support for the Metaschema date-time-with-timezone
data type.
Support for the Metaschema date-with-timezone
data type.
Support for the Metaschema day-time-duration
data type.
A JUnit 5 extension that detects deadlocks and dumps thread information when
tests fail or are aborted (e.g., due to timeout).
Support for the Metaschema decimal
data type.
DefaultAssemblyModelBuilder<MI extends IModelInstance,NMI extends INamedModelInstance,FI extends IFieldInstance,AI extends IAssemblyInstance,CI extends IChoiceInstance,CGI extends IChoiceGroupInstance>
An assembly model builder.
Default implementation of
IBindingConfiguration that provides binding
configuration for Java class generation from Metaschema modules.Holds binding configurations for a specific Metaschema module.
The implementation of a
IBindingContext provided by this library.A default implementation of an
IBoundLoader.Default implementation of
IChoiceGroupBindingConfiguration.DefaultChoiceGroupModelBuilder<NMI extends INamedModelInstance,FI extends IFieldInstance,AI extends IAssemblyInstance>
A choice group model builder.
DefaultChoiceModelBuilder<MI extends IModelInstance,NMI extends INamedModelInstance,FI extends IFieldInstance,AI extends IAssemblyInstance>
A choice model builder.
Provides a basic configuration management implementation that allows mutable
access to configuration state.
Used to perform constraint validation over one or more node items.
Default implementation of
IMutableDefinitionBindingConfiguration that
provides mutable binding configuration for a specific Metaschema definition.A basic implementation of a
IDiagramNodeVisitor.A default implementation of the
ExtraArgument interface that
represents a named command-line argument which can be marked as required or
optional.Provides a concrete implementation of a function call executor.
Provides built-in Metapath functions based on the XPath 3.1
function
specification.
Produces a textual representation of a Metapath sequence.
Provides support for reading JSON-based data based on a bound Metaschema
module.
This problem handler implementation handles common issues when parsing
JSON-based Metaschema module instances.
Provides support for serializing bound Java objects to JSON format based on a
Metaschema module definition.
Default implementation of
IModuleBindingGenerator that generates and
compiles Java classes for a Metaschema module.Default implementation of
IMutablePropertyBindingConfiguration.A collection of constraints to apply to a given module identified by the
module's namespace and short name.
Provides support for reading XML-based data based on a bound Metaschema
module.
Handles problems identified in the parsed XML.
Provides support for serializing bound Java objects to XML format based on a
Metaschema module definition.
Deserializes YAML content into bound Java objects.
Serializes bound Java objects to YAML content.
Supports walking a portion of a metaschema model collecting a set of
definitions that match the provided filter.
Used to perform cleanup on shutdown.
Configuration features that control the deserialization behavior of
Metaschema-bound object readers.
FODC: Exceptions representing document related errors.
The implementation of a Metapath
dynamic context.
MPDY: Exceptions related to the Metapath dynamic context and dynamic
evaluation.
Support for the Metaschema email-address
data type.
A factory that produces qualified names.
Provides a callback for resolving namespace prefixes.
Example.
Provides a means for throwing important checked exceptions over non-checked
methods, e.g. lambda invocations.
A runtime exception that wraps a checked exception, allowing it to be thrown
from contexts that do not allow checked exceptions (such as lambda
expressions).
An enumeration of supported exit code values.
Implementations provide details around the result of processing a set of
command line arguments.
This annotation defines an expected condition to be met in the context of the
containing annotation.
A module loading post processor that integrates applicable external
constraints into a given module when loaded.
A representation of an extra, non-option command line argument.
A binding class for the
field-constraints definition.Field Reference.
A set of constraints targeting a
IFieldDefinition based on a target
Metapath expression.A validation result handler that collects the resulting findings for later
retrieval using the
FindingCollectingConstraintValidationHandler.getFindings() method.Allowed Values Constraint.
A binding class for the
flag-constraints definition.Default implementation of
IFlagContainerBuilder.Expect Condition Constraint.
Index Has Key Constraint.
A utility class for filtering flag instances during schema generation.
Value Matches Constraint.
Flag Reference.
Report Condition Constraint.
A set of constraints targeting a
IFlagDefinition based on a target
Metapath expression.Provides factory methods for Flexmark processing to support HTML-to-markdown
and markdown-to-HTML conversion.
Implements the XPath 3.1
fn:abs
function.
Implements the XPath 3.1 fn:adjust-dateTime-to-timezone
function.
Implements the XPath 3.1 fn:adjust-date-to-timezone
function.
Implements the XPath 3.1 fn:adjust-time-to-timezone
function.
Implements the XPath 3.1
fn:avg
function.
Implements the XPath 3.1 fn:base-uri
functions.
Implements the XPath 3.1 fn:boolean
function.
Implements the XPath 3.1 fn:ceiling
function.
Implements the XPath 3.1 fn:compare
function.
Implements the XPath 3.1 fn:concat
function.
Implements the XPath 3.1 fn:contains
function.
Implements the XPath 3.1
fn:count
function.
Implements the XPath 3.1 fn:current-date
function.
Implements the XPath 3.1 fn:current-dateTime
function.
Implements the XPath 3.1 fn:current-time
function.
Implements the XPath 3.1
fn:data
functions.
Implements the XPath 3.1 fn:dateTime
function.
Implements the XPath 3.1 fn:day-from-date.
Implements the XPath 3.1 fn:day-from-dateTime.
Implements the XPath 3.1 fn:days-from-duration.
/** Implements fn:deep-equal
functions.
Implements the XPath 3.1 fn:default-language
function.
Implements fn:distinct-values
functions.
Implements the XPath 3.1
fn:doc
function.
Implements the XPath 3.1 fn:doc-available
function.
Implements the XPath 3.1 fn:document-uri
functions.
Implements the XPath 3.1
fn:empty
function.
Implements the XPath 3.1 fn:ends-with
function.
Implements the XPath 3.1 fn:exactly-one
function.
Implements the XPath 3.1 fn:exists
function.
Implements the XPath 3.1
fn:false
function.
/** Implements fn:function-arity
functions.
/** Implements fn:function-lookup
functions.
/** Implements fn:function-name
functions.
/** Implements fn:has-children
functions.
Implements the XPath 3.1
fn:head
function.
Implements the XPath 3.1 fn:hours-from-dateTime.
Implements the XPath 3.1 fn:hours-from-duration.
Implements the XPath 3.1 fn:hours-from-time.
Implements fn:implicit-timezone.
/** Implements fn:index-of
functions.
Implements fn:innermost
functions.
Implements the XPath 3.1 fn:insert-before
function.
Implements
fn:last.
/** Implements fn:local-name
functions.
Based on the XPath 3.1 fn:lower-case
functions.
Implements the XPath 3.1 fn:matches
functions.
Implements the XPath 3.1 fn:minutes-from-dateTime.
Implements the XPath 3.1 fn:minutes-from-duration.
Implements the XPath 3.1 fn:minutes-from-time.
Implements the XPath 3.1 fn:month-from-date.
Implements the XPath 3.1 fn:month-from-dateTime.
Implements the XPath 3.1 fn:months-from-duration.
/** Implements
fn:name
functions.
/** Implements fn:namespace-uri
functions.
Implements the XPath 3.1 fn:normalize-space
functions.
Implements the XPath 3.1
fn:not
function.
Implements the XPath 3.1 fn:one-or-more
function.
/** Implements fn:outermost
functions.
Implements the XPath 3.1
fn:path
functions.
Implements fn:position.
/** Implements
fn:QName
functions.
Implements the XPath 3.1 fn:remove
function.
Implements the XPath 3.1 resolve-ur
functions.
Implements the XPath 3.1 fn:reverse
function.
/** Implements
fn:root
functions.
Implements the XPath 3.1
fn:round
functions.
Implements the XPath 3.1 fn:seconds-from-dateTime.
Implements the XPath 3.1 fn:seconds-from-duration.
Implements the XPath 3.1 fn:seconds-from-time.
Implements the XPath 3.1 fn:starts-with
function.
Implements the XPath 3.1 fn:static-base-uri
function.
Implements the XPath 3.1 fn:string
function.
Implements the XPath 3.1 fn:string-join
function.
Implements the XPath 3.1 fn:string-length
functions.
Implements the XPath 3.1 fn:substring
functions.
Implements the XPath 3.1 fn:substring-after
function.
Implements the XPath 3.1 fn:substring-before
function.
Implements the XPath 3.1
fn:sum
functions.
Implements the XPath 3.1
fn:tail
function.
Implements the XPath 3.1 fn:timezone-from-date
function.
Implements the XPath 3.1 fn:timezone-from-dateTime
function.
Implements the XPath 3.1 fn:timezone-from-time
function.
Implements the XPath 3.1 fn:tokenize
function.
Implements the XPath 3.1
fn:true
function.
Based on the XPath 3.1 fn:upper-case
functions.
Implements the XPath 3.1 fn:year-from-date.
Implements the XPath 3.1 fn:year-from-dateTime.
Implements the XPath 3.1 fn:years-from-duration.
Implements the XPath 3.1 fn:zero-or-one
function.
Represents the focus context for Metapath evaluation, containing the context
item, position, and size as defined in the
XPath 3.1 evaluation
context.
Selections of serialization formats.
Provides a means to analyze content to determine what
Format the data
is represented as.Represents the result of format detection, providing access to the detected
format and the data stream for further processing.
Provides a catalog of registered function implementations.
Represents an error that occurs during Metapath function evaluation.
Supports looking up named Metapath functions that are loaded using the
ServiceLoader interface.A collection of utility functions for use in implementing Metapath functions.
This command implementation supports generation of a diagram depicting the
objects and relationships within a provided Metaschema module.
Defines schema generation parameters and expected results.
This command implementation supports generation of schemas in a variety of
formats based on a provided Metaschema module.
A schema generation comparison test case.
Defines how a collection of model instances should be grouped.
Group As.
This annotation defines cardinality condition(s) to be met in the context of
the containing annotation.
Maintains a byte buffer backed representation of a byte stream parsed from a
base64 encoded string.
Support for the Metaschema hostname
data type.
Adds support for the use of "q" tags in HTML to replace quotation marks.
A Flexmark node implementation representing a quotation mark.
Represents an individual enumerated value associated with an
IAllowedValuesConstraint.Represents a rule requiring the value of a field or flag to match the name of
one entry in a set of enumerated values.
Provides a builder pattern for constructing a new
IAllowedValuesConstraint.Indicates how an allowed values constraint can be extended, or if it can be.
The interface shared by all atomic items, representing indivisible data
values that serve as the fundamental building blocks for complex data
structures in the Metaschema framework.
An atomic Metapath item containing a URI data value.
Represents a single function argument signature.
Used to create an argument's signature using a builder pattern.
A representation of a Metapath array item type.
Declares the expected type information for an
IArrayItem.A marker interface for an information element that is an assembly model type.
Represents an assembly definition in a Metaschema module.
Represents an assembly instance within another assembly definition.
Represents an assembly instance that appears directly within an assembly
definition.
Represents an assembly instance that appears within a choice or other
grouping construct.
Represents a Metapath assembly node item for a grouped assembly instance.
A Metapath node valued item representing a Metaschema module assembly.
Provides type information for an atomic type.
A callback used to perform a casting operation.
This marker interface identifies a valued
IItem type that has an
associated IAnyAtomicItem value.Represents a Metapath node item that has an atomic value.
A marker interface for implementations that supports the mapping of a
namespace valued key to a set of values.
Represents a property key based on a name and a namespace.
An atomic Metapath item containing a Base64 encoded data value.
Provides configuration for Java class binding generation from Metaschema
modules.
Provides information supporting a binding between a set of Module models and
corresponding Java classes.
Enables building a
IBindingContext using common configuration options
based on the builder pattern.Implementations of this interface provide a means by which a bound class can
be found that corresponds to an XML element, JSON property, or YAML item
name.
A behavioral class used by the binding context to load Metaschema modules.
Provides schema validation capabilities.
Represents a Metaschema model definition loaded via data binding.
Represents a Metaschema assembly definition loaded via data binding.
Represents a Metaschema instance loaded via data binding.
Represents a Metaschema model instance loaded via data binding.
Represents a Metaschema module loaded via data binding.
Represents a Metaschema model element loaded via data binding.
Loader interface for Metaschema modules using data binding.
An atomic Metapath item with a boolean value.
A Metaschema definition (flag, field, or assembly) bound to Java data.
Represents a flag definition/instance bound to Java field.
Represents a field or assembly instance bound to Java data.
Represents an assembly definition bound to a Java class.
Represents a field or assembly instance bound to Java class.
Represents a field definition bound to Java data.
Represents a field definition bound to a Java class.
Represents the bound value of a field definition.
Represents a Metaschema module instance bound to Java data.
Represents a flag instance bound to Java data.
Represents an assembly or field instance bound to Java data.
Represents an assembly instance bound to Java field.
Represents a choice group instance bound to Java field.
Represents a field instance bound to a Java field.
Represents a bound field instance that contains complex (non-scalar) data,
such as an object with flags and a value.
Represents a bound field instance that contains scalar (simple) data, such as
a string or number value.
Represents an assembly model instance that is a member of a choice group
instance.
Represents a field model instance that is a member of a choice group
instance.
Represents a model instance that is a member of a choice group instance.
Represents a bound model instance that is named and can be addressed by that
name in the Metaschema model.
A common interface for loading Module based instance resources.
A Metaschema model element bound to Java data.
Represents a binding of Java data to a Metaschema module construct, i.e.
Represents a bound Metaschema module that provides access to its field and
assembly definitions through Java class bindings.
A common interface found bound objects that have a complex model consisting
of flags, fields, or assemblies.
Represents a bound property on a Metaschema definition.
An
IMapItem key based on an ICalendarTemporalItem.A temporal valued item related to a
ZonedDateTime.Represents a rule requiring a Metaschema assembly data instance to have
elements with a minimum and/or maximum occurrence.
Provides a builder pattern for constructing a new
ICardinalityConstraint.Provides binding configuration for a choice group within an assembly
definition.
An Metaschema model instance representing a grouped set of objects consisting
of heterogeneous object types.
A marker interface for a choice of allowed instances in a Metachema.
A data value that can be a value in a Metapath array or map.
A command line interface command.
An abstract base class that implements the
ICommandExecutor
interface, providing common functionality for command execution
implementations.This functional interface represents a method that is used to execute a
command operation.
Provides shell completion code for a specific type.
Represents a constraint that allows a configurable message.
Base interface for constraints with configurable messages.
The base interface for getting the configuration of processors and parsers in
this library.
The common interface that all configuration features must implement.
Represents a rule constraining the model of a Metaschema assembly, field or
flag.
The degree to which a constraint violation is significant.
The type of constraint.
Base interface for all constraint bindings.
Provides loading capabilities for Metaschema constraint sets.
A set of constraints targeted at the contents of a Metaschema module.
Provides a set of callback methods used to process the result of evaluating a
constraint.
This interface provides an entry point for performing validations over
Metapath items associated with a Metaschema model.
Supports a visitor pattern over constraint instances.
Represents a model element that can contain child instances.
Provides support for managing the flag contents of a
IModelDefinition.Indicates that the Metaschema type that has a complex model that can contain
field and assembly instances.
Represents a model container with absolute (non-grouped) instances.
Represents a model container for assembly definitions.
IContainerModelAssemblySupport<MI extends IModelInstance,NMI extends INamedModelInstance,FI extends IFieldInstance,AI extends IAssemblyInstance,CI extends IChoiceInstance,CGI extends IChoiceGroupInstance>
Common interface for model container support classes.
Represents a model container with grouped instances.
IContainerModelSupport<MI extends IModelInstance,NMI extends INamedModelInstance,FI extends IFieldInstance,AI extends IAssemblyInstance>
Common interface for model container support classes.
A common interface for validation of Metaschema module-based content.
The common interface for all data type implementations supported by a custom
Java class.
A marker interface used to identify an
IAssemblyNodeItem as the head
of a cycle of item that loop back to the head.Represents a data type implementation.
A service interface used to provide implementations of data types represented
as
IDataTypeAdapter instances.An atomic Metapath item representing a date value in the Metapath system with
or without an explicit time zone.
An atomic Metapath item representing a date/time value in the Metapath
system.
An atomic Metapath item representing a date/time value in the Metapath system
with an explicit time zone.
An atomic Metapath item containing a date data value that has an explicit
timezone.
An atomic Metapath item containing a duration data value in days, hours, and
seconds.
An atomic Metapath item containing a decimal data value.
An
IMapItem key based on an IDecimalItem.A marker interface for Metaschema constructs that can have a default value.
Represents a definition of a flag, field, or assembly in a Metaschema module.
Describes the visibility of a definition to other modules.
Provides binding configuration for a specific Metaschema definition.
Represents a Metapath node item that is based on an underlying Metaschema
module definition and instance.
Represents a model element that has a formal name and description.
Provides methods used during deserialization to perform additional actions
before and after data is loaded into a bound object.
Implementations of this interface are able to read structured data into a
bound object instance of the parameterized type.
Represents a Metaschema module
IModelDefinition node that is part of
a model diagram.Represents a scalar-valued data point associated with a node.
Represents a relationship between a subject node and a target node.
The nature of a relationship between two nodes.
A visitor for processing edges in a diagram node model.
Represents a Metapath node item that is associated with a document.
Supports loading documents referenced in Metapath expressions.
A node item that represents the root of a tree of nodes associated with a
document resource.
An atomic Metapath item representing a duration data value.
An atomic Metapath item containing an email address data value.
An efficient cache-backed representation of a qualified name.
Provides a callback for resolving namespace prefixes.
Provides a callback for resolving namespace prefixes.
Provides an error code that identifies the type of message.
Represents a rule requiring a Metaschema assembly, field, or flag data
instance to pass a Metapath-based test.
Provides a builder pattern for constructing a new
IExpectConstraint.The common interface of all Metapath expression nodes.
Represents a node item for a Metaschema model instance the is always a child
of another item in the Metaschema model.
A feature interface for handling complex item values during binding
operations.
Represents a definition that may contain flags.
IFeatureContainerModelAbsolute<MI extends IModelInstanceAbsolute,NMI extends INamedModelInstanceAbsolute,FI extends IFieldInstanceAbsolute,AI extends IAssemblyInstanceAbsolute>
Common interface for model container support classes.
IFeatureContainerModelAssembly<MI extends IModelInstanceAbsolute,NMI extends INamedModelInstanceAbsolute,FI extends IFieldInstanceAbsolute,AI extends IAssemblyInstanceAbsolute,CI extends IChoiceInstance,CGI extends IChoiceGroupInstance>
Provides assembly-specific container model functionality through delegation.
IFeatureContainerModelGrouped<NMI extends INamedModelInstanceGrouped,FI extends IFieldInstanceGrouped,AI extends IAssemblyInstanceGrouped>
Provides grouped container model functionality through delegation.
A trait indicating that the implementation is a localized definition that is
declared in-line as an instance.
Represents an instance that references a definition.
This mixin interface indicates that the implementation is a
INodeItem
that is based on an IModelDefinition.Provides an abstract implementation of a model that contains a collection of
flags.
Provides access to a Java field that is bound to a Metaschema instance.
A marker interface for a Metaschema model construct (i.e. assembly, field)
that can be constrained using Metaschema constraints.
This mixin interface indicates that the implementation is a
INodeItem
that may have both flag and model children.Provides an abstract implementation of a lazy loaded model.
A feature interface representing an atomic-valued item that has no associated
value data.
This feature interface represents an item that has no associated value data.
A mixin interface used to identify that the implementation is a
IDefinitionNodeItem that is based on a IDefinition that is an
orphan in it's hierarchy.A feature interface for handling scalar item values during binding
operations.
A marker interface for a Metaschema valued construct (i.e. flag, field) that
can be constrained using Metaschema constraints.
Represents an instance that has no value.
A marker interface for an information element that is a field model type.
Represents a field definition in a Metaschema module.
Represents a field instance within an assembly definition.
Represents a field instance that appears directly within an assembly
definition.
Represents a field instance that appears within a choice or other grouping
construct.
A Metapath node valued item representing a Metaschema module field.
A marker interface for an information element that is an flag model type.
Builder for constructing flag container instances.
Represents a flag definition in a Metaschema module.
Represents a flag instance within a field or assembly definition.
A Metapath node valued item representing a Metaschema module flag.
A common interface for all Metapath functions.
Used to create a function's signature using a builder pattern.
Details specific characteristics of a function.
This functional interface provides a dispatch method for executing a function
call.
Provides access to a collection of Metapath function signatures.
Resolves Metapath function signatures based on name and arity.
Provides information about a generated Java class file.
Represents a generated Java class for a Metaschema definition.
Provides information about a generated Java class that represents a Module
module.
Represents the state information used during schema generation.
Indicates that the property is to be ignored by the Module binding system.
This behavioral interface represents an instance that supports grouped
values.
A data object to record the group as selections.
An atomic Metapath item containing a Base64 encoded data value.
An atomic Metapath item containing a hostname data value.
Represents a rule that generates a key-based index containing references to
data items found in a Metaschema data instance.
Provides a builder pattern for constructing a new
IIndexConstraint.Represents a rule that checks that a key generated for a Metaschema data
object exists in a named index that was generated using an
IIndexConstraint.Provides a builder pattern for constructing a new
IIndexHasKeyConstraint.A strategy for determining whether a definition should be inlined in the
generated schema or referenced as a separate type definition.
This marker interface indicates that this object is an instance.
Represents an instance with an absolute path and an associated value.
An atomic Metapath item containing an integer data value.
An atomic Metapath item representing an IP address data value.
An atomic Metapath item containing an IPv4 address data value.
An atomic Metapath item containing an IPv6 address data value.
The base interface inherited by all Metapath item implementations.
Handler interface for reading bound items during deserialization.
Provides type information that be used to discover type information for,
test, and cast various item objects.
Handler interface for processing bound item values.
Use to visit the major types of items.
Handler interface for writing bound items during serialization.
Supports writing different types of items using a visitor pattern.
Represents a model instance that has a JSON property name.
Represents a model element that has a JSON property name.
Provides the parsing context for reading JSON-based Metaschema module
instances.
A reader for processing JSON instances using the item read handler pattern.
Handles common issues resulting from parsing JSON content.
Provides the writing context for serializing Java objects to JSON format.
A common interface used for constraints oriented around key-based indexes.
Represents a component of a key used in a key-based index.
A common interface for all key specifier implementations.
Provides type information that be used to discover type information for,
test, and cast various node-based item objects.
Represents a variable assignment for use in Metaschema module constraints.
Provides loading capabilities for resources of type
T.Represents a mapping of
IMapKey keys to values.The key value used in an
IMapItem.Declares the expected type information for a
IMapItem.An atomic Metapath item representing a Markup data value.
An atomic Metapath item representing a single line of Markup.
An atomic Metapath item representing multiple lines of Markup.
The common interface for all markup implementations.
Represents a rule requiring the value of a field or flag to match a pattern
and/or conform to an identified data type.
Provides a builder pattern for constructing a new
IMatchesConstraint.Supports compiling and executing Metapath expressions.
Identifies the expected type for a Metapath evaluation result.
Represents a model element that can be queried using Metapath expressions.
Represents data associated with a Metaschema module.
Represents a loaded Metaschema module.
Represents a container of rules constraining the effective model of a
Metaschema assembly data instance.
Base interface for model-level constraint bindings.
Represents a Metaschema definition for a complex object that may contain
flags.
A marker interface for Metaschema constructs that can be members of a
Metaschema definition's model.
Represents a model element that can be visited using the visitor pattern.
Provides a set of callbacks used when iterating over node items in a directed
graph.
This marker interface is used to identify a field or assembly instance that
is a member of an assembly's model.
Represents a model instance with an absolute path and an associated value.
Provides information about the collection type for a model instance.
Handler interface for reading model instance collections during
deserialization.
Handler interface for writing model instance collections during
serialization.
Represents a Metapath node item for a Metaschema model instance (assembly or
field).
Represents a Metaschema module.
A functional interface for generating bound Java classes from a Metaschema
module.
IModuleExtended<M extends IModuleExtended<M,D,FL,FI,A>,D extends IModelDefinition,FL extends IFlagDefinition,FI extends IFieldDefinition,A extends IAssemblyDefinition>
The API for accessing information about a given Metaschema module.
Provides loading capabilities for Metaschema modules.
Used to define a post-processing operation to perform on a module.
Supports querying of global definitions and associated instances in a
Metaschema module by effective name.
This interface provides methods for retrieving and updating the configuration
of processors and parsers in this library.
A mutable extension of
IPropertyBindingConfiguration that allows
setting property binding configuration values.Represents a model element that has a name and associated naming properties.
This marker interface indicates that the instance has a flag, field, or
assembly name associated with it which will be used in JSON/YAML or XML to
identify the data.
A marker interface for Metaschema constructs that can be members of a
Metaschema module's model that have a name and other identifying
characteristics.
Represents a named instance of a field or assembly within a model.
Represents a named model instance with absolute positioning and JSON
serialization support.
Represents an arbitrary grouping of Metaschema model instances.
Deprecated, for removal: This API element is subject to removal in a future version.
This annotation defines a unqiue index over the contents of the assembly
represented by the containing
MetaschemaAssembly annotation.This annotation defines a rule that requires that the target contents of the
assembly, represented by the containing
MetaschemaAssembly
annotation, reference items in a name index defined by the Index
constraint.err:FOAY0001:
This error is raised when an integer used to select a member of an array is
outside the range of values for that array.
Inline Assembly Definition.
Inline Field Definition.
Inline Flag Definition.
Represents a Metapath model node.
The type of node.
This factory interface is used to create
INodeItem objects of various
types.Generates child node items for Metapath node items.
Marks a node item as visitable by a
INodeItemVisitor.Provides a set of callbacks used when iterating over node items in a directed
graph.
An atomic Metapath item containing a non-negative integer data value.
Extension that adds support for insert anchors, used in OSCAL statements, and
applicable more generally in other Metaschema-based models.
The flexmark node for an insert anchor.
Used to collect insert nodes.
Support for the Metaschema integer
data type.
Represents an atomic Metapath item containing a numeric data value, which can
be either an integer or decimal.
Thrown when an option argument is found to be invalid during parsing of a
command-line.
FORG: Exceptions related to argument types.
An exception to be raised when a Metapath is not a valid instance of the
Metapath grammar.
Raised when a Metapath treat expression fails because the sequence does not
match the required type.
FOTY: Exceptions related to type errors.
Provides a convenient way to raise a
TypeMetapathException.INVALID_TYPE_ERROR.FORG0001: Thrown when a cast operation fails because the supplied value
cannot be converted to the target datatype.
Represents a map key with no special handling based on the key value's data
type.
Provides information about a generated package-info.java class, that
represents a collection of Module constructs generated from one or more
Module modules.
Provides objects used for parsing data associated with a specific format.
This interface provides an implementation contract for all path formatters.
A named segment of a path that can be formatted.
An atomic Metapath item containing a positive integer data value.
Implementations support handling common parsing issues.
Information about Java classes generated for a collection of Module modules.
Provides binding configuration for a specific property (field or assembly
instance) within a definition.
Support for the Metaschema ip-v4-address
data type.
Support for the Metaschema ip-v6-address
data type.
An atomic Metapath item with a namespace qualified name value.
Represents a rule reporting a condition when a Metaschema assembly, field, or
flag data instance matches a Metapath-based test.
Provides a builder pattern for constructing a new
IReportConstraint.Represents a location within a resource.
A common interface for implementation classes that load data resources.
A marker interface used to expose root node functionality for an assembly
node that has root information.
Provides the capability to generate a schema from a Metaschema module.
Identifies the supported schema generation formats.
Represents a set of target constraints that apply to a given Metaschema
module namespace and short name.
Represents an ordered collection of Metapath expression results.
Supports
sequence
type testing.
Implementations of this interface are able to write data in a bound object
instance of the parameterized type to a structured data format.
A descriptor that identifies where a given constraint was defined.
The relative location of the source.
An atomic Metapath item containing a text data value.
An
IMapItem key based on a text value.This annotation defines a rule that requires uniqueness among the target
contents of the assembly represented by the containing
MetaschemaAssembly annotation.Base interface for targeted constraint bindings.
Represents a set of constraints that target a given definition using a target
Metapath expression.
An atomic Metapath item containing a temporal data value.
An
IMapItem key based on an ITemporalItem value.Provides a variety of utilities for working with Metapath items.
An atomic Metapath item representing a time value in the Metapath system.
An atomic Metapath item representing a time value in the Metapath system with
an explicit time zone.
An atomic Metapath item containing a text token data value.
Represents a rule that requires all matching data items found in a Metaschema
data instance to have a unique key.
Provides a builder pattern for constructing a new
IUniqueConstraint.An atomic Metapath item containing an untyped atomic data value.
An atomic Metapath item containing a URI reference data value that complies
with RFC2396.
Provides URI resolution capabilities for Metaschema resources.
An atomic Metapath item containing a UUID data value.
Provides information about an individual finding that is the result of a
completed content validation.
The finding type.
Provides data that is the result of a completed content validation.
Represents a container of rules constraining the effective model of a
Metaschema field or flag data instance.
Base interface for value-level constraint bindings.
A marker interface for Metaschema constructs that can have a value.
This marker interface identifies Metaschema definition types that have
associated values (i.e., field, flag).
Represents a Metaschema instance that has an associated value (i.e., field or
flag instance).
Extends
IValued to provide the ability to set a value on a parent
object.Base interface for targeted value constraint bindings.
Provides version information for a runtime dependency or application.
Provides the context for writing bound objects to a specific output format.
A functional interface for writing object properties.
Provides the context for parsing XML content into bound objects.
Handles problems encountered during XML parsing, such as unknown attributes
or elements.
Provides the writing context for serializing Java objects to XML format.
An atomic Metapath item containing a duration data value in years, months,
and days.
Provides support for compiling Java source files using the system Java
compiler.
Contains the result of a compilation operation.
A logging interface for compilation messages.
Provides methods for generating Java classes based on a single or a
collection of Metaschemas.
A factory for creating and configuring
JsonFactory instances with
standard Metaschema settings.Indicates that the target of this annotation is a flag whose value should be
the property/item name of the field's value in JSON or YAML.
FOJS: Exceptions related to JSON function operations in XPath.
Defines how repeated instances are grouped in JSON/YAML representations.
Indicates that the target of this annotation is a Java property that is to be
used as the JSON or YAML property/item name in for a collection of similar
objects/items.
Used in JSON (and similar formats) to identify a flag that will be used as
the property name in an object hold a collection of sibling objects.
An
IPathFormatter that produces RFC 6901 compliant JSON Pointer
paths.Validates JSON content against a JSON schema.
Records an identified individual validation result found during JSON schema
validation.
Generates JSON Schema documents from Metaschema modules.
Provides utility functions to support reading and writing JSON, and for
producing error and warning messages.
Flag Used as the Field Value's JSON Property Name.
Defines the type of JSON value key used to identify data values.
Key Constraint.
Identifies a Metapath expression referencing a value that is used in
generating a key as part of a
IsUnique, Index, or
IndexHasKey constraint annotation.Represents a constraint let statement used to assign the result of a Metapath
expression to a variable.
Supports logging constraint findings to the configured Log4J2 instance.
Supports logging validation findings to the console using ANSI color codes to
improve the visibility of warnings and errors.
Implements the XPath 3.1 map:contains
function.
Implements the XPath 3.1 map:entry
function.
Implements the XPath 3.1 map:find
function.
Implements the XPath 3.1 map:for-each
function.
Implements the XPath 3.1
map:get
function.
Implements the XPath 3.1 map:keys
function.
Implements the XPath 3.1 map:merge
functions.
Implements the XPath 3.1
map:put
function.
Implements the XPath 3.1 map:remove
function.
Implements the XPath 3.1 map:size
function.
Provides for runtime discovery of built-in implementations of the markup
Metaschema data types.
Supports a data value which is a single line of markup.
Support for the Metaschema markup-line
data type.
Supports a data value which may be multiple lines of markup.
Support for the Metaschema markup-multiline
data type.
This annotation defines a rule that requires matching patterns and/or data
types among the target contents of the assembly represented by the containing
MetaschemaAssembly annotation.Generates a mermaid diagram from a Metaschema
IModule.An
ExitStatus implementation with an associated message.A set of constraints, which are targeted at the contents of a Metaschema
module within specific contexts.
A nestable context, targeted by a set of metapath expressions, to apply
constraints within.
This sub-command implementation contains all command that relate to Metapath
execution.
Provides constant values for use in Metapath.
A binding class for the
metapath-context definition.Provides a mechanism to configure Metapath evaluation settings.
MetapathException is the superclass of all exceptions that can be
thrown during the compilation and evaluation of a Metapath.An
IPathFormatter that produces a Metapath expression for the path to
a given INodeItem.Assigns a Metapath namespace to a prefix for use in a Metapath expression in
a lexical qualified name.
Reference to a metaschema module to load.
A declaration of the Metaschema module.
In XML, an element with structured element content.
Provides a root name, for when the definition is used as the root of a node
hierarchy.
Global Field Definition.
Global Flag Definition.
Imports a set of Metaschema modules contained in another resource.
This annotation indicates that the target class represents a Module assembly.
The root element for a set of metaschema binding customizations.
Defines a binding for a given metaschema identified by a relative URL.
Provides binding configurations for a given defined assembly within the
parent metaschema.
Provides binding configuration for a choice group within the parent assembly.
A fully qualified Java type for collection items.
Field and assembly binding configurations for Java bound classes.
Provides binding configurations for a property within the parent definition.
Java-specific binding configuration for a property.
Provides binding configurations for a given defined field within the parent
metaschema.
Field and assembly binding configurations for Java bound classes.
Provides binding configurations for a property within the parent definition.
Java-specific binding configuration for a property.
Defines binding configurations that apply to a whole model described by a
namespace.
Java-specific binding configuration for a model namespace.
Metaschema Binding Configuration
This class provides a variety of utility methods for processing
Metaschema-related commands.
A collection of constant values related to Metaschema handling.
Provides runtime discovery of built-in implementations of the core Metaschema
data types.
Indicates an error related to Metaschema processing.
This annotation indicates that the target class represents a Module field.
Supports reading JSON-based Metaschema module instances.
Provides support for writing Metaschema-bound Java objects to JSON format.
Defines constraint rules to be applied to an existing set of Metaschema
module-based models.
A binding class for the
definition-context definition.Declares a set of Metaschema constraints from an out-of-line resource to
import, supporting composition of constraint sets.
A Metapath expression identifying the model node that the constraints will be
applied to.
Provides commonly used QName constants for Metaschema model elements.
Metaschema Model
Marks a class as a Metaschema module definition.
Defines constraint rules to be applied to an existing set of Metaschema
module-based models.
Declares a set of Metaschema constraints from an out-of-line resource to
import, supporting composition of constraint sets.
A binding class for the
scope definition.A binding class for the
assembly definition.A binding class for the
field definition.A binding class for the
flag definition.Associates Metaschema module classes with a package.
Metaschema Test Suite
Supports reading XML-based Metaschema module instances.
Provides support for writing Metaschema-bound Java objects to XML format.
Provides a means to analyze content to determine what type of bound data it
contains.
Describes the result of detecting which model a resource is described by.
Identifies that an unexpected error occurred while initializing or using a
Metaschema-based model.
Represents a set of constraints targeted at model definitions using Metapath
expressions.
An enumeration that identifies the type of a Metaschema construct.
Utility methods for processing Metaschema binding annotations.
Walks a Metaschema model.
This class provides methods to generate and dynamically compile Java code
based on a Module.
Indexes definitions from a Metaschema module for use in schema generation.
Represents an entry in the module index for a single definition.
Performs post-processing on a loaded module.
Provides utility methods for parsing qualified names within Metaschema
modules.
Provides a new Metapath function that decodes provided encoded text using
base64.
Provides a new Metapath function that encodes provided text using base64.
Provides new Metapath functions that evaluate a Metapath recursively over
sequences generated by evaluating that expression.
An integer-based cache of namespaces to reduce the memory footprint of
namespaces used by reusing instances with the same namespace.
Deprecated.
err:FOAY0001:
This error is raised when an integer used to select a member of an array is
outside the range of values for that array.
Provides methods for comparing nodes according to the
Metapath
specification.
This enumeration provides a listing of the available kinds of
INodeItem implementations.An
ExitStatus implementation that represents a status without an
associated message.Support for the Metaschema non-negative-integer
data type.
Defines a namespace prefix binding for Metapath expressions.
Used to mark a Java type that has no configured adapter.
A placeholder atomic item type that throws unsupported operation exceptions
for all operations.
Provides a generic implementation of methods defined by XPath 3.1
Functions on numeric values.
Implementations of this interface are used to execute a numeric opertaion on
the provided item.
A collection of utilities for checking and managing Java objects.
Identifies the occurrence of a sequence used a function argument or return
value.
Used to check that a provided sequence matches an associated occurrence
value.
A collection of utilities for handling command line options.
Configuration for parallel constraint validation.
Enumeration of path format selection options for validation output.
A lightweight utility for tracking the current path during parsing.
Support for the Metaschema positive-integer
data type.
A module loader strategy that applies post-processors to loaded modules.
Defines a name-value property for a Metaschema definition or instance.
Property.
Support for the Metaschema qname
data type.
Provides a cache for managing commonly reused qualified names, represented
using the
IEnhancedQName interface.Analyzes a Metaschema module to identify assembly definitions that are
recursive.
Records information about an assembly definition, including whether it is
recursive and where it is used.
Utility methods for regular expression processing in Metapath functions.
MPRX: Exceptions related to regular expression processing in Metapath
functions.
Any explanatory or helpful information to be provided about the remarks
parent.
This annotation defines a report condition in the context of the containing
annotation.
Supports building a Static Analysis Results Interchange Format (SARIF)
document based on a set of validation findings.
Indicates an unrecoverable error occurred during schema generation.
Configuration options for schema generation.
The default implementation of a constraint set sourced from an external
constraint resource.
Configuration features that control the serialization behavior of
Metaschema-bound object writers.
A command that generates shell completion scripts for Bash and Zsh.
Supported shell types.
A simple module loader strategy that supports optional dynamic code
generation.
A simple implementation of
IMetaschemaData that stores location
information from various parser sources.An implementation of the Metapath
static context.
A builder used to generate the static context.
MPST: Exceptions related to the Metapath static context and static
evaluation.
Support for the Metaschema string
data type.
Provides a collection of utilities for checking and managing strings.
Allowed Values Constraint.
Expect Condition Constraint.
Targeted Cardinality Constraint.
Targeted Index Constraint.
Targeted Index Has Key Constraint.
Targeted Unique Constraint.
Value Matches Constraint.
Report Condition Constraint.
A collection of test scenarios located at a specific path.
A test scenario that validates a metaschema and its content.
The root element containing a collection of test collections.
Support for the Metaschema date
data type.
Support for the Metaschema date-time-with-timezone
data type.
Support for the Metaschema token
data type.
MPTY: Exceptions related to Metapath type errors.
FOER0000: Thrown when an unidentified error occurs during function
evaluation.
Support for the Metaschema uri data
type.
FONS: Exceptions related to function namespaces.
Support for the Metaschema uri-reference
data type.
A collection of methods for manipulating uniform resource identifiers (URIs),
providing functionality for URI resolution, relativization, and path
manipulation.
This model walker can be used to gather metaschema definitions that are
defined globally.
Allows the name of the definition to be overridden.
Support for the Metaschema uuid
data type.
This command implementation supports validation of a content instance based
on a provided Metaschema module.
This command implementation supports validation of a Metaschema module.
A content validation test case.
Provides contextual information for validation errors during parsing.
A set of configurable features that adjust Metaschema constraint validation
behavior.
Defines value-level constraints for field and flag definitions.
A container of rules constraining the effective model of a Metaschema field
or flag data instance.
Maintains a mapping between well known namespace URIs and associated
prefixes.
Provides utility functions to support reading and writing XML stream events,
and for producing error and warning messages.
Defines how repeated instances are grouped in XML representations.
Provides utility functions to support reading and writing XML, and for
producing error and warning messages.
Used to identify the XML namespace to use for a set of annotated Java
classes.
Specifies the namespace qualification behavior for XML elements.
This annotation provides package-level Module information.
Supports validating an XML resource using an XML schema.
Records an identified individual validation result found during XML schema
validation.
Generates XML Schema (XSD) documents from Metaschema modules.
Provides utility methods for working with XML sources and streams.
An
IPathFormatter that produces XPath 3.1 expressions with
namespace-qualified names using the EQName format (e.g.,
Q{namespace}localname).Utility methods for YAML parsing and conversion operations.
Support for the Metaschema year-month-duration
data type.