@versionzero/schema 1.0.0

package/types/schema.d.ts

@@ -0,0 +1,586 @@
+/** @import { ValueProcessor, ValueProcessorFunction, ValueProcessorSpec } from './value-processor/value-processor.js' */
+/** @import { ISchemaMetadata, ISchemaOptions, SchemaData, ISchema, } from './types.js' */
+/** @typedef {ISchemaOptions} SchemaOptions */
+/** @typedef {ISchemaMetadata} SchemaMetadata */
+/** @typedef {{[key:string]: ISchema}} SchemaProperties */
+/** @typedef {{[key:string]: ISchema}} SchemaUnionSchemas */
+/**
+ * @typedef {object} SchemaHandlers
+ * @property {Array<ValueProcessorSpec>} [normalizers]
+ * @property {Array<ValueProcessorSpec>} [transformers]
+ * @property {Array<ValueProcessorSpec>} [finalizers]
+ * @property {Array<ValueProcessorSpec>} [validators]
+ * @property {Array<ValueProcessorSpec>} [serializers]
+ * @property {Array<ValueProcessorSpec>} [conditions]
+ * @property {Array<ValueProcessorSpec>} [discriminators]
+ */
+/**
+ * Schema - allows the definition of structure and rules for data
+ *
+ * Essentially acts as a fluent builder; must be compiled by SchemaCompiler for use.
+ *
+ * @typedef {import("./types.js").ISchema} ISchema
+ * @augments {ISchema}
+ */
+export class Schema {
+    /**
+     * Create a new Schema from something schema-shaped
+     *
+     * @param {ISchema|SchemaData|string} model
+     * @param {Map<any,any>} [seen]
+     * @returns {Schema}
+     */
+    static createFromModel(model: ISchema | SchemaData | string, seen?: Map<any, any>): Schema;
+    /**
+     * Static schema factory (useful for aliasing to reduce typing!)
+     *
+     * Prefer using fluent setters over passing options/metadata to this call
+     *
+     * @param {string|ISchema|SchemaData|Schema|CompiledSchema} [base] - schema
+     * @param {object} [options] - schema options
+     * @param {ISchemaMetadata} [metadata] - schema metadata
+     * @returns {Schema}
+     */
+    static create(base?: string | ISchema | SchemaData | Schema | CompiledSchema, options?: object, metadata?: ISchemaMetadata): Schema;
+    /**
+     * Static schema factory for special schemas that ignore assignments and produce a single defined value
+     *
+     * Prefer using fluent setters over passing options/metadata to this call
+     *
+     * @param {any} literalValue - the value this schema will always emit
+     * @param {object} [options] - additional options
+     * @param {ISchemaMetadata} [metadata] - additional metadata
+     * @returns {Schema}
+     */
+    static literal(literalValue: any, options?: object, metadata?: ISchemaMetadata): Schema;
+    /**
+     * Static schema factory for creating a schema that inherits its value from the first parent with the property name.
+     * If no property name is provided, the inherit schema's property name is used, so it will look for the same name
+     * higher in the schema hierarchy.
+     *
+     * TODO - restore compilation hook for checking whether this is a legal setup
+     *
+     * @returns {Schema}
+     * @param {string} [propertyName]
+     * @internal
+     */
+    static inherit(propertyName?: string): Schema;
+    /**
+     * Static schema factory for creating a schema that gets its value from another location based on a path.
+     *
+     * By default, `path` is interpreted as an absolute path from the root.  If the `relative` flag is
+     * set or navigation metacharacters start the path, it will be relative to the current schema.
+     * - An absolute path prefixed with `/` starts at the root.
+     * - A path prefixed with `^` navigates up one level from the current schema path.
+     *
+     * TODO - restore hook for checking whether the provided path is known at compilation time
+     *
+     * @param {string} path
+     * @param {boolean} [relative]
+     * @returns {Schema}
+     * @internal
+     */
+    static reference(path: string, relative?: boolean): Schema;
+    /**
+     * Construct a Schema.
+     *
+     * Pass a string name of a registered schema to resolve as the base, or pass a schema-shaped object to extend.
+     *
+     * Prefer the fluent setters over passing in options/metadata or attributes.
+     *
+     * @param {string|ISchema|SchemaData} [base] - schema type or base to extend
+     * @param {object} [options] - schema options (also supports "attribute" shorthand syntax, but prefer being explicit)
+     * @param {ISchemaMetadata} [metadata] - schema metadata
+     */
+    constructor(base?: string | ISchema | SchemaData, options?: object, metadata?: ISchemaMetadata);
+    set base(base: string | undefined);
+    /**
+     * Name of a schema registered in SchemaResolver that this schema extends
+     *
+     * @type {string|undefined}
+     */
+    get base(): string | undefined;
+    /**
+     * Properties are named child schemas.
+     *
+     * Use the property setter rather than direct access to ensure data consistency.
+     *
+     * @type {SchemaProperties}
+     */
+    get properties(): SchemaProperties;
+    /**
+     * Handlers are grouped lists of value processors.
+     *
+     * Assign using the individual value processor setters.
+     *
+     * @type {SchemaHandlers}
+     */
+    get handlers(): SchemaHandlers;
+    /**
+     * Options are settings that define how the schema behaves.
+     *
+     * @returns {SchemaOptions}
+     */
+    get options(): SchemaOptions;
+    /**
+     * Metadata defines settings that describe how the schema should interact with users.
+     *
+     * @type {SchemaMetadata}
+     */
+    get metadata(): SchemaMetadata;
+    /**
+     * Unions are sets of alternative schemas; a discriminator selects which to use.
+     *
+     * @type {SchemaUnionSchemas}
+     */
+    get unionSchemas(): SchemaUnionSchemas;
+    /**
+     * Extract the contents of this schema and its children as a regular object.
+     *
+     * @returns {SchemaData}
+     */
+    toData(): SchemaData;
+    /**
+     * Attributes were initially a convenient shorthand for constructing schemas, but now just add confusion.
+     *
+     * @deprecated
+     * @param {string} attributeName
+     * @param {any} attributeValue
+     * @returns {Schema}
+     * @internal
+     */
+    _setAttribute(attributeName: string, attributeValue: any): Schema;
+    /**
+     * Attributes were initially a convenient shorthand for constructing schemas, but now just add confusion.
+     *
+     * @deprecated
+     * @param {object} attributes
+     * @returns {Schema}
+     * @internal
+     */
+    _setAttributes(attributes?: object): Schema;
+    /**
+     * Attach a named child schema
+     *
+     * @param {string} propertyName - property name
+     * @param {Schema|CompiledSchema|string|undefined} propertySchema - schema to associate with the property, undefined to delete current
+     * @returns {Schema} - returns self for fluent chaining
+     */
+    property(propertyName: string, propertySchema: Schema | CompiledSchema | string | undefined): Schema;
+    /**
+     * Bulk-add properties
+     *
+     * @param {SchemaProperties} properties - property name
+     * @param {symbol} [policy] - specify whether to overwrite or only initialize
+     * @returns {Schema} - returns self for fluent chaining
+     * @internal
+     */
+    addProperties(properties: SchemaProperties, policy?: symbol): Schema;
+    /**
+     * Define a schema option
+     *
+     * Options are settings that define how the schema behaves.
+     *
+     * @param {string} option - option
+     * @param {any} [value] - option value
+     * @returns {Schema} - returns self for fluent chaining
+     */
+    option(option: string, value?: any): Schema;
+    /**
+     * Bulk add options
+     *
+     * @param {object} options
+     * @param {symbol} [policy]
+     * @returns {Schema}
+     * @internal
+     */
+    addOptions(options: object, policy?: symbol): Schema;
+    /**
+     * Helper function for the fluent handler api calls
+     *
+     * @param {string} handlerName
+     * @param {Array<ValueProcessorSpec>} specs
+     * @param {symbol} [policy]
+     * @returns {Schema}
+     * @private
+     */
+    private handler;
+    /**
+     * Bulk add handlers
+     *
+     * @param {object} handlers
+     * @param {symbol} [policy]
+     * @returns {Schema}
+     * @internal
+     */
+    addHandlers(handlers: object, policy?: symbol): Schema;
+    /**
+     * Define schema metadata (like options, but for humans and ConfigurationSource hints) - todo: locale-aware
+     *
+     * (Note: named "meta" instead of "metadata" to differentiate from the object getter)
+     *
+     * @param {string} meta - metadata key
+     * @param {any} [value] - option value
+     * @returns {Schema} - returns self for fluent chaining
+     */
+    meta(meta: string, value?: any): Schema;
+    /**
+     * Bulk-add metadata
+     *
+     * @param {object} metadata
+     * @param {symbol} [policy]
+     * @returns {Schema}
+     * @internal
+     */
+    addMetadata(metadata: object, policy?: symbol): Schema;
+    /**
+     * The discriminator handler returns the key or schema of the union member that should be used
+     * This function appends a single value processor to the handler pipeline.
+     *
+     * @param {ValueProcessorSpec} spec
+     * @returns {Schema} - returns self for fluent chaining
+     */
+    unionDiscriminator(spec: ValueProcessorSpec): Schema;
+    /**
+     * The discriminator handler returns the key or schema of the union member that should be used
+     * This function applies multiple value processors to the handler pipeline.
+     * (Note that it would be highly unusual to want more than one!)
+     *
+     * @param {Array<ValueProcessorSpec>} specs
+     * @param {symbol} [policy]
+     * @returns {Schema} - returns self for fluent chaining
+     */
+    unionDiscriminators(specs: Array<ValueProcessorSpec>, policy?: symbol): Schema;
+    /**
+     * Add a schema as an alternative member of this schema's union.
+     *
+     * @param {string} key - union schema key (used by some discriminators to select this schema)
+     * @param {Schema|CompiledSchema} unionSchema - schema that the discriminator selects, or true/false override if a group
+     * @returns {Schema}
+     */
+    unionSchema(key: string, unionSchema: Schema | CompiledSchema): Schema;
+    /**
+     * Bulk-add union schemas
+     *
+     * @param {SchemaUnionSchemas} unionSchemas
+     * @param {symbol} [policy]
+     * @returns {Schema}
+     * @internal
+     */
+    addUnionSchemas(unionSchemas: SchemaUnionSchemas, policy?: symbol): Schema;
+    /**
+     * Mark this schema as containing (and only permitting) storage of union keys.
+     *
+     * @param {boolean} [value]
+     * @returns {Schema}
+     */
+    unionKey(value?: boolean): Schema;
+    /**
+     * Mark this schema as a selector.
+     *
+     * Selectors are a convenience wrapper for controlling selection conditions that only are true when
+     * the selector contains the correct selection value.
+     *
+     * @param {boolean} [value]
+     * @returns {Schema}
+     */
+    selector(value?: boolean): Schema;
+    /**
+     * Mark this schema as a selection.
+     *
+     * A selection schema automatically creates a condition that only activates the schema if the corresponding
+     * selector has the correct value.
+     *
+     * With the default argument, the selection schema condition uses the property name as the selector value.
+     *
+     * @param {NonNullable<any>} [value]
+     * @returns {Schema}
+     */
+    selection(value?: NonNullable<any>): Schema;
+    /**
+     * Mark this schema as defining a required value (or not)
+     *
+     * Schema requirements are enforced during validation.
+     *
+     * Requirements are shallow; this can be changed via the deep() option.
+     *
+     * @param {boolean} [value]
+     * @returns {Schema}
+     */
+    required(value?: boolean): Schema;
+    /**
+     * Mark this schema as defining an optional value (or not); the default is optional.
+     *
+     * (Syntactic sugar to negate required())
+     * Schema requirements are enforced during validation.
+     *
+     * Requirements are shallow; this can be changed via the deep() option.
+     *
+     * @param {boolean} [value]
+     * @returns {Schema}
+     */
+    optional(value?: boolean): Schema;
+    /**
+     * Define a default value for this schema to use if there is no input.
+     *
+     * Defaults are shallow and will not cause children of undefined inputs to populate;
+     * this can be changed via the deep() option.
+     *
+     * @param {NonNullable<any>|ValueProcessorFunction|ValueProcessor} value
+     * @returns {Schema}
+     */
+    default(value: NonNullable<any> | ValueProcessorFunction | ValueProcessor): Schema;
+    /**
+     * Indicate that this schema should be deeply traversed even if the input is empty
+     * (e.g. to enable deep defaults and requirements)
+     *
+     * @param {boolean} [value]
+     * @returns {Schema}
+     */
+    deep(value?: boolean): Schema;
+    /**
+     * Mark this array/string as allowing empty values.
+     *
+     * @param {boolean} [value]
+     * @returns {Schema}
+     */
+    allowEmpty(value?: boolean): Schema;
+    /**
+     * Mark this schema as allowing incremental assignment to children.
+     *
+     * (The default is true for any schema with children, so most of the time you'd be disabling it.)
+     *
+     * Deprecated; use the "opaque" option as it more clearly indicates the actual intent.
+     *
+     * @param {boolean} [value]
+     * @returns {Schema}
+     * @deprecated
+     */
+    allowIncremental(value?: boolean): Schema;
+    /**
+     * Mark this schema as defining a value whose internal structure is hidden after transformation.
+     *
+     * This has implications both for assignment processing and validation.
+     *
+     * Deep property assignments usually result in any mid-path containers being automatically created
+     * (normalized and transformed) and property values are incrementally assigned.
+     *
+     * Opaque schemas do not allow incremental assignments, so they only create normalized mid-path containers
+     * that are staged until all relevant assignments are complete.  The transform is then run, and passed
+     * the staged normalized container contents as input.
+     *
+     * Validators for opaque schemas only run on the value itself, and do not traverse into any child properties.
+     * Opaque schemas thus generally require custom validators that know how to properly handle the value.
+     *
+     * @param {boolean} [value]
+     * @returns {Schema}
+     */
+    opaque(value?: boolean): Schema;
+    /**
+     * Mark this schema as requiring strict enforcement (the default)
+     *
+     * Strict mode means that the data cannot have any extra data, and exactly matches the schema definition.
+     * Lax mode allows a more "fuzzy" interpretation of the data, but the data still must pass all value processors
+     * including the validation phases.  (To prevent exceptions during validation, wrap the processors in a
+     * $filter, which will just return undefined.)
+     *
+     * @param {boolean} [value]
+     * @returns {Schema}
+     */
+    strict(value?: boolean): Schema;
+    /**
+     * Syntactic sugar for the opposite of strict
+     *
+     * @param {boolean} [value]
+     * @returns {Schema}
+     */
+    lax(value?: boolean): Schema;
+    /**
+     * Mark this schema as implicit in the transformed output (so no need to assign or check)
+     *
+     * @param {boolean} [value]
+     * @returns {Schema}
+     */
+    implicit(value?: boolean): Schema;
+    /**
+     * Define a legal input value this schema will accept.
+     *
+     * Values will be normalized for comparison.
+     *
+     * @param {NonNullable<any>} v
+     * @returns {Schema}
+     */
+    value(v: NonNullable<any>): Schema;
+    /**
+     * Define a list of one or more legal values this schema will accept
+     *
+     * Values will be normalized for comparison.
+     *
+     * @param {Array<NonNullable<any>>} va
+     * @param {symbol} [policy]
+     * @returns {Schema}
+     */
+    values(va?: Array<NonNullable<any>>, policy?: symbol): Schema;
+    /**
+     * The condition handler determines if the schema should be processed at all.
+     * This function appends a single value processor to the handler pipeline
+     *
+     * @param {ValueProcessorSpec} spec
+     * @returns {Schema}
+     */
+    condition(spec: ValueProcessorSpec): Schema;
+    /**
+     * The condition handler determines if the schema should be processed at all.
+     * This call applies one or more value processors to the handler pipeline (default policy = append)
+     *
+     * @param {Array<ValueProcessorSpec>} specs
+     * @param {symbol} [policy]
+     * @returns {Schema}
+     */
+    conditions(specs: Array<ValueProcessorSpec>, policy?: symbol): Schema;
+    /**
+     * The normalizer handler ensures input is in a format that the transformer can handle.
+     * This call appends a single value processor to the handler pipeline.
+     *
+     * @param {ValueProcessorSpec} spec
+     * @returns {Schema}
+     */
+    normalizer(spec: ValueProcessorSpec): Schema;
+    /**
+     * The normalizer handler ensures input is in a format that the transformer can handle.
+     * This call applies one or more value processors to the handler pipeline.
+     *
+     * @param {Array<ValueProcessorSpec>} specs
+     * @param {symbol} [policy]
+     * @returns {Schema}
+     */
+    normalizers(specs: Array<ValueProcessorSpec>, policy?: symbol): Schema;
+    /**
+     * The transformer handler converts a normalized input value into the final output value for the schema.
+     * This call appends a single value processor to the handler pipeline.
+     *
+     * @param {ValueProcessorSpec} spec
+     * @returns {Schema}
+     */
+    transformer(spec: ValueProcessorSpec): Schema;
+    /**
+     * The transformer handler converts a normalized input value into the final output value for the schema.
+     * This call applies one or more value processors to the handler pipeline.
+     *
+     * @param {Array<ValueProcessorSpec>} specs
+     * @param {symbol} [policy]
+     * @returns {Schema}
+     */
+    transformers(specs: Array<ValueProcessorSpec>, policy?: symbol): Schema;
+    /**
+     * The finalizer handler performs any required post-processing of a transformed value.
+     *
+     * @param {ValueProcessorSpec} spec
+     * @returns {Schema}
+     */
+    finalizer(spec: ValueProcessorSpec): Schema;
+    /**
+     * The finalizer handler does any required post-processing of a transformed value.
+     * This call applies one or more value processors to the handler pipeline.
+     *
+     * @param {Array<ValueProcessorSpec>} specs
+     * @param {symbol} [policy]
+     * @returns {Schema}
+     */
+    finalizers(specs: Array<ValueProcessorSpec>, policy?: symbol): Schema;
+    /**
+     * The validator handler ensures an input value matches the schema, and returns a (potentially enhanced) fully validated output value.
+     * This call appends a single value processor to the handler pipeline.
+     *
+     * @param {ValueProcessorSpec} spec
+     * @returns {Schema}
+     */
+    validator(spec: ValueProcessorSpec): Schema;
+    /**
+     * The validator handler ensures an input value matches the schema, and returns a (potentially enhanced) fully validated output value.
+     * This call applies one or more value processors to the handler pipeline.
+     *
+     * @param {Array<ValueProcessorSpec>} specs
+     * @param {symbol} [policy]
+     * @returns {Schema}
+     */
+    validators(specs: Array<ValueProcessorSpec>, policy?: symbol): Schema;
+    /**
+     * The serialize handler restores a configuration value to its pre-transform normalized form.
+     * This call appends a single value processor to the handler pipeline.
+     *
+     * @param {ValueProcessorSpec} spec
+     * @returns {Schema}
+     */
+    serializer(spec: ValueProcessorSpec): Schema;
+    /**
+     * The serialize handler restores a configuration value to its pre-transform normalized form.
+     * This call applies one or more value processors to the handler pipeline.
+     *
+     * @param {Array<ValueProcessorSpec>} specs
+     * @param {symbol} [policy]
+     * @returns {Schema}
+     */
+    serializers(specs: Array<ValueProcessorSpec>, policy?: symbol): Schema;
+    /**
+     * Use another schema to extend the current one without overwriting.
+     *
+     * @param {ISchema|SchemaData} otherSchema - source schema
+     * @param {Map<any,any>} [seen]
+     * @returns {Schema} - returns self
+     */
+    extend(otherSchema: ISchema | SchemaData, seen?: Map<any, any>): Schema;
+    /**
+     * Make a copy of this schema
+     *
+     * @returns {Schema}
+     */
+    clone(): Schema;
+    #private;
+}
+/**
+ * Policies for fine-grained control of composite schema internals
+ */
+export type SchemaPolicy = symbol;
+/**
+ * Policies for fine-grained control of composite schema internals
+ * @readonly
+ * @enum {symbol}
+ */
+export const SchemaPolicy: Readonly<{
+    INITIALIZE: symbol;
+    OVERWRITE: symbol;
+    APPEND: symbol;
+    PREPEND: symbol;
+}>;
+export type SchemaOptions = ISchemaOptions;
+export type SchemaMetadata = ISchemaMetadata;
+export type SchemaProperties = {
+    [key: string]: ISchema;
+};
+export type SchemaUnionSchemas = {
+    [key: string]: ISchema;
+};
+export type SchemaHandlers = {
+    normalizers?: any[] | undefined;
+    transformers?: any[] | undefined;
+    finalizers?: any[] | undefined;
+    validators?: any[] | undefined;
+    serializers?: any[] | undefined;
+    conditions?: any[] | undefined;
+    discriminators?: any[] | undefined;
+};
+/**
+ * Schema - allows the definition of structure and rules for data
+ *
+ * Essentially acts as a fluent builder; must be compiled by SchemaCompiler for use.
+ */
+export type ISchema = import("./types.js").ISchema;
+import type { SchemaData } from './types.js';
+import { CompiledSchema } from './compiled-schema.js';
+import type { ValueProcessorSpec } from './value-processor/value-processor.js';
+import type { ValueProcessorFunction } from './value-processor/value-processor.js';
+import type { ValueProcessor } from './value-processor/value-processor.js';
+import type { ISchema } from './types.js';
+import type { ISchemaMetadata } from './types.js';
+import type { ISchemaOptions } from './types.js';

package/types/traversal/executors/check-condition.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Check whether we have a passing condition.
+ *
+ * @param {TraversalState} state
+ * @returns {TraversalState|null|undefined|Promise<TraversalState|null|undefined>}
+ */
+export function checkCondition(state: TraversalState): TraversalState | null | undefined | Promise<TraversalState | null | undefined>;
+import { TraversalState } from '../traversal-state.js';

package/types/traversal/executors/check-input.d.ts

@@ -0,0 +1,6 @@
+/**
+ * @param {TraversalState} state
+ * @returns {TraversalState|null|undefined}
+ */
+export function checkInput(state: TraversalState): TraversalState | null | undefined;
+import { TraversalState } from '../traversal-state.js';

package/types/traversal/executors/check-required.d.ts

@@ -0,0 +1,6 @@
+/**
+ * @param {TraversalState} state
+ * @returns {TraversalState}
+ */
+export function checkRequired(state: TraversalState): TraversalState;
+import { TraversalState } from '../traversal-state.js';

package/types/traversal/executors/check-schema.d.ts

@@ -0,0 +1,7 @@
+/**
+ *
+ * @param {TraversalState} state
+ * @returns {TraversalState|undefined|null}
+ */
+export function checkSchema(state: TraversalState): TraversalState | undefined | null;
+import { TraversalState } from '../traversal-state.js';

package/types/traversal/executors/defaults.d.ts

@@ -0,0 +1,8 @@
+/**
+ * If the input is undefined but the schema defines a default, use that value
+ *
+ * @param {TraversalState} state
+ * @returns {TraversalState}
+ */
+export function defaults(state: TraversalState): TraversalState;
+import { TraversalState } from "../traversal-state.js";

package/types/traversal/executors/enter-existing.d.ts

@@ -0,0 +1,6 @@
+/**
+ * @param {TraversalState} state
+ * @returns {TraversalState|null|undefined}
+ */
+export function enterExisting(state: TraversalState): TraversalState | null | undefined;
+import { TraversalState } from "../traversal-state.js";

package/types/traversal/executors/enter-input.d.ts

@@ -0,0 +1,8 @@
+/**
+ *
+ *
+ * @param {TraversalState} state
+ * @returns {TraversalState|null|undefined}
+ */
+export function enterInput(state: TraversalState): TraversalState | null | undefined;
+import { TraversalState } from '../traversal-state.js';

package/types/traversal/executors/enter.d.ts

@@ -0,0 +1,7 @@
+/**
+ *
+ * @param {TraversalState} state
+ * @returns {TraversalState|undefined|null}
+ */
+export function enter(state: TraversalState): TraversalState | undefined | null;
+import { TraversalState } from '../traversal-state.js';

package/types/traversal/executors/exit.d.ts

@@ -0,0 +1,6 @@
+/**
+ * @param {TraversalState} state
+ * @returns {TraversalState|null|undefined|Promise<TraversalState|null|undefined>}
+ */
+export function exit(state: TraversalState): TraversalState | null | undefined | Promise<TraversalState | null | undefined>;
+import { TraversalState } from '../traversal-state.js';

package/types/traversal/executors/finalize.d.ts

@@ -0,0 +1,6 @@
+/**
+ * @param {TraversalState} state
+ * @returns {TraversalState|undefined|Promise<TraversalState|undefined>}
+ */
+export function finalize(state: TraversalState): TraversalState | undefined | Promise<TraversalState | undefined>;
+import { TraversalState } from '../traversal-state.js';

package/types/traversal/executors/index.d.ts

@@ -0,0 +1,15 @@
+export const PROCESS_ENTER: Executor<TraversalState>;
+export const PROCESS_EXIT: Executor<TraversalState>;
+export const PROCESS_EXECUTOR: TraversalStateExecutor;
+export const VALIDATE_ENTER: Executor<TraversalState>;
+export const VALIDATE_EXIT: Executor<TraversalState>;
+export const VALIDATE_EXECUTOR: TraversalStateExecutor;
+export const SERIALIZE_ENTER: Executor<TraversalState>;
+export const SERIALIZE_EXIT: Executor<TraversalState>;
+export const SERIALIZE_EXECUTOR: TraversalStateExecutor;
+export const PRELOAD_ENTER: Executor<TraversalState>;
+export const PRELOAD_EXIT: Executor<TraversalState>;
+export const PRELOAD_EXECUTOR: TraversalStateExecutor;
+import { Executor } from "../../executor/executor.js";
+import { TraversalState } from "../traversal-state.js";
+import { TraversalStateExecutor } from './traversal-state-executor.js';