@astrale-os/kernel-dsl 0.2.0-beta.1 → 0.2.0-beta.10

package/dist/v1/language/value/evaluate/preparation.js

@@ -0,0 +1,135 @@
+import { isValueObject as isJsonObject } from '../model/object.js';
+import { collectResourceClosure, locationKey, } from '../reference/closure.js';
+import { indexRegistry } from '../reference/registry.index.js';
+import { compilePattern } from '../regexp/compile.js';
+import { loadPattern } from '../regexp/matcher.js';
+import { appendPointer } from '../syntax/pointer.js';
+import { walkSchema } from '../syntax/walk.js';
+/** Prepare reference and linear-regexp state without generating executable source. */
+export function prepareValueSchema(schema, registry, pointer) {
+    const indexed = indexRegistry(registry, pointer);
+    if (indexed.diagnostics.length > 0)
+        return failed(indexed.diagnostics);
+    const closure = collectResourceClosure(schema, 'callable-input', indexed.index, pointer);
+    if (closure.diagnostics.length > 0)
+        return failed(closure.diagnostics);
+    const locations = new Map();
+    const matchers = new Map();
+    for (const resource of closure.resources.values()) {
+        walkSchema(resource.schema, (location) => {
+            const key = locationKey(resource.key, location.pointer);
+            locations.set(key, {
+                key,
+                pointer: location.pointer,
+                resource,
+                schema: location.schema,
+            });
+            if (!isJsonObject(location.schema))
+                return;
+            rememberMatcher(matchers, location.schema.pattern);
+            rememberMatcher(matchers, location.schema.fullMatch);
+            if (isJsonObject(location.schema.patternProperties)) {
+                for (const pattern of Object.keys(location.schema.patternProperties)) {
+                    rememberMatcher(matchers, pattern);
+                }
+            }
+        });
+    }
+    const initial = closure.resources.values().next().value;
+    const root = initial === undefined ? undefined : locations.get(locationKey(initial.key, ''));
+    if (root === undefined) {
+        return { compiled: false, message: 'The root value schema is absent from its closure.' };
+    }
+    return {
+        compiled: true,
+        value: {
+            root,
+            locations,
+            resolutions: closure.resolutions,
+            program: () => portableProgram(root, locations, closure.resolutions),
+            child(location, keyword, member) {
+                const keywordPointer = appendPointer(location.pointer, keyword);
+                const pointer = member === undefined ? keywordPointer : appendPointer(keywordPointer, member);
+                const child = locations.get(locationKey(location.resource.key, pointer));
+                if (child === undefined) {
+                    throw new TypeError(`Admitted value schema child ${pointer} is absent from its closure.`);
+                }
+                return child;
+            },
+            reference(location) {
+                const resolved = closure.resolutions.get(location.key);
+                return resolved === undefined
+                    ? undefined
+                    : locations.get(locationKey(resolved.resource.key, resolved.pointer));
+            },
+            matcher(source) {
+                const matcher = matchers.get(source);
+                if (matcher === undefined) {
+                    throw new TypeError('Value schema uses an unprepared I-Regexp source.');
+                }
+                return matcher;
+            },
+        },
+    };
+}
+function portableProgram(root, locations, resolutions) {
+    const ordered = [...locations.values()];
+    const indices = new Map(ordered.map((location, index) => [location.key, index]));
+    const patterns = new Map();
+    const nodes = ordered.map((location) => {
+        const children = {};
+        walkSchema(location.schema, (child) => {
+            if (child.depth !== 1)
+                return;
+            const target = indices.get(locationKey(location.resource.key, `${location.pointer}${child.pointer}`));
+            if (target !== undefined)
+                children[childKey(child.pointer)] = target;
+        });
+        rememberPattern(patterns, location.schema);
+        const resolved = resolutions.get(location.key);
+        const reference = resolved === undefined
+            ? undefined
+            : indices.get(locationKey(resolved.resource.key, resolved.pointer));
+        if (resolved !== undefined && reference === undefined) {
+            throw new TypeError('Prepared value schema reference target is absent.');
+        }
+        return Object.freeze({
+            schema: location.schema,
+            children: Object.freeze(children),
+            ...(reference === undefined ? {} : { reference }),
+        });
+    });
+    return Object.freeze({
+        root: indices.get(root.key),
+        nodes: Object.freeze(nodes),
+        patterns: Object.freeze([...patterns.values()]),
+    });
+}
+function rememberPattern(patterns, schema) {
+    if (!isJsonObject(schema))
+        return;
+    for (const source of [schema.pattern, schema.fullMatch]) {
+        if (typeof source === 'string' && !patterns.has(source))
+            patterns.set(source, compilePattern(source));
+    }
+    if (isJsonObject(schema.patternProperties)) {
+        for (const source of Object.keys(schema.patternProperties)) {
+            if (!patterns.has(source))
+                patterns.set(source, compilePattern(source));
+        }
+    }
+}
+export function childKey(pointer) {
+    return pointer.slice(1);
+}
+function rememberMatcher(matchers, input) {
+    if (typeof input === 'string' && !matchers.has(input)) {
+        matchers.set(input, loadPattern(compilePattern(input)));
+    }
+}
+function failed(diagnostics) {
+    return {
+        compiled: false,
+        message: diagnostics.map(({ code, message }) => `${code}: ${message}`).join('; '),
+    };
+}

package/dist/v1/language/value/evaluate/program.d.ts

@@ -0,0 +1,3 @@
+import type { Diagnostic } from '../../validation/diagnostic.js';
+import type { ValueProgram } from '../compile/model.js';
+export declare function validateValueProgram(program: ValueProgram, input: unknown, roots?: readonly number[]): readonly Diagnostic[];

package/dist/v1/language/value/evaluate/program.js

@@ -0,0 +1,16 @@
+import { loadValueProgram } from '../compile/load.js';
+import { validateCanonicalJsonDomain } from '../profile/json.validate.js';
+import { evaluateInstance } from './evaluator.js';
+export function validateValueProgram(program, input, roots = [program.root]) {
+    const canonical = validateCanonicalJsonDomain(input, '');
+    if (canonical.length > 0)
+        return canonical;
+    return roots.flatMap((root) => {
+        const result = evaluateInstance(loadValueProgram({ ...program, root }), input);
+        return result.failures.map((failure) => ({
+            code: 'VALUE_SCHEMA_INSTANCE_INVALID',
+            pointer: failure.instancePointer,
+            message: `Value does not satisfy its complete V1 schema at ${failure.keyword}: ${failure.message}`,
+        }));
+    });
+}

package/dist/v1/{schema/value/instance → language/value/evaluate}/types.d.ts

@@ -1,7 +1,8 @@
 import type { Value as JsonValue } from '@astrale-os/kernel-dsl/value';
-import type { IRegexpMatcher } from '../regexp/linear.js';
-import type { ResolvedSchemaReference, SchemaResource } from '../resources/references.js';
-import type { JsonSchema } from '../schema.js';
+import type { ValueProgram } from '../compile/model.js';
+import type { JsonSchema } from '../model/schema.js';
+import type { ResolvedAddressReference, SchemaResource } from '../reference/references.js';
+import type { IRegexpMatcher } from '../regexp/matcher.js';
 export interface InstanceFailure {
     readonly instancePointer: string;
     readonly keyword: string;
@@ -16,7 +17,10 @@ export interface SchemaLocation {
 export interface CompiledInstanceSchema {
     readonly root: SchemaLocation;
     readonly locations: ReadonlyMap<string, SchemaLocation>;
-    readonly resolutions: ReadonlyMap<string, ResolvedSchemaReference>;
+    readonly resolutions: ReadonlyMap<string, ResolvedAddressReference>;
+    program(): ValueProgram;
+    child(location: SchemaLocation, keyword: string, member?: string | number): SchemaLocation;
+    reference(location: SchemaLocation): SchemaLocation | undefined;
     matcher(source: string): IRegexpMatcher;
 }
 export interface Evaluation {
@@ -30,4 +34,3 @@ export interface Evaluation {
 export type Instance = JsonValue;
 export declare function evaluation(failures?: readonly InstanceFailure[], properties?: ReadonlySet<string>, items?: ReadonlySet<number>): Evaluation;
 export declare function mergeAnnotations(targetProperties: Set<string>, targetItems: Set<number>, source: Pick<Evaluation, 'properties' | 'items'>): void;
-//# sourceMappingURL=types.d.ts.map

package/dist/v1/{schema/value/instance → language/value/evaluate}/types.js

@@ -7,4 +7,3 @@ export function mergeAnnotations(targetProperties, targetItems, source) {
     for (const item of source.items)
         targetItems.add(item);
 }
-//# sourceMappingURL=types.js.map

package/dist/v1/{schema/value/instance.validate.d.ts → language/value/evaluate/validate.d.ts}

@@ -1,7 +1,7 @@
 import type { Value as JsonValue } from '@astrale-os/kernel-dsl/value';
-import type { DomainDiagnostic } from '../diagnostic.js';
-import type { ValueSchemaRegistry } from './registry.js';
-import type { JsonSchema } from './schema.js';
+import type { Diagnostic } from '../../validation/diagnostic.js';
+import type { JsonSchema } from '../model/schema.js';
+import type { ValueSchemaRegistry } from '../reference/registry.js';
 /**
  * Validate one complete portable value with the admitted V1 Draft 2020-12 profile.
  *
@@ -9,5 +9,4 @@ import type { JsonSchema } from './schema.js';
  * resolution or dynamic source generation, and every admitted I-Regexp executes through RE2JS.
  * `format` remains annotation-only; the graph NodePath codec performs its separate locator check.
  */
-export declare function validateJsonInstance(schema: JsonSchema, value: JsonValue, registry: ValueSchemaRegistry, pointer?: string): DomainDiagnostic[];
-//# sourceMappingURL=instance.validate.d.ts.map
+export declare function validateJsonInstance(schema: JsonSchema, value: JsonValue, registry: ValueSchemaRegistry, pointer?: string): Diagnostic[];

package/dist/v1/{schema/value/instance.validate.js → language/value/evaluate/validate.js}

@@ -1,7 +1,7 @@
-import { diagnostic } from '../diagnostic.js';
-import { compileInstanceSchema } from './instance/compiler.js';
-import { evaluateInstance } from './instance/evaluator.js';
-import { validateCanonicalJsonDomain } from './profile/json.validate.js';
+import { diagnostic } from '../../validation/diagnostic.js';
+import { validateCanonicalJsonDomain } from '../profile/json.validate.js';
+import { evaluateInstance } from './evaluator.js';
+import { prepareValueSchema } from './preparation.js';
 const validatorCache = new WeakMap();
 /**
  * Validate one complete portable value with the admitted V1 Draft 2020-12 profile.
@@ -34,11 +34,10 @@ function preparedInstanceValidator(schema, registry, pointer) {
     const cached = bySchema.get(schema);
     if (cached !== undefined)
         return cached;
-    const compilation = compileInstanceSchema(schema, registry, pointer);
+    const compilation = prepareValueSchema(schema, registry, pointer);
     const prepared = compilation.compiled
         ? { kind: 'validator', compiled: compilation.value }
         : { kind: 'error', message: compilation.message };
     bySchema.set(schema, prepared);
     return prepared;
 }
-//# sourceMappingURL=instance.validate.js.map

package/dist/v1/language/value/index.d.ts

@@ -0,0 +1,11 @@
+/** Complete V1 inline value language. Named Type Definitions do not exist. */
+export type { JsonSchema as ValueSchema, JsonSchemaObject as ValueSchemaObject, PathAnnotation, PropertyObjectSchema, ValueSchemaContext, } from './model/schema.js';
+export { JSON_SCHEMA_DIALECT, VALUE_SCHEMA_DIALECT, VALUE_SCHEMA_VOCABULARY, } from './model/schema.js';
+export { instant, isInstantValue } from './model/instant.js';
+export { classifyOrdering, type OrderingKind } from './ordering.js';
+export { canonicalizeValueSchema } from './profile/canonicalize.js';
+export { validateValueSchema } from './profile/validate.js';
+export { validateJsonInstance } from './evaluate/validate.js';
+export { prepareValueSchema, type InstanceSchemaCompilation } from './evaluate/preparation.js';
+export type { ValueProgram } from './compile/model.js';
+export type { ValueSchemaRegistry, ValueSchemaDomainRegistry } from './reference/registry.js';

package/dist/v1/language/value/index.js

@@ -0,0 +1,8 @@
+/** Complete V1 inline value language. Named Type Definitions do not exist. */
+export { JSON_SCHEMA_DIALECT, VALUE_SCHEMA_DIALECT, VALUE_SCHEMA_VOCABULARY, } from './model/schema.js';
+export { instant, isInstantValue } from './model/instant.js';
+export { classifyOrdering } from './ordering.js';
+export { canonicalizeValueSchema } from './profile/canonicalize.js';
+export { validateValueSchema } from './profile/validate.js';
+export { validateJsonInstance } from './evaluate/validate.js';
+export { prepareValueSchema } from './evaluate/preparation.js';

package/dist/v1/{schema/value → language/value/model}/instant.d.ts

@@ -1,4 +1,5 @@
 /** Exact portable UTC millisecond Instant used by the V1 value-schema dialect. */
+/** Canonical value-language annotation for an Instant string. */
 export declare const INSTANT_VALUE_KIND: 'instant';
 export declare const instant: Readonly<{
     readonly type: 'string';
@@ -6,4 +7,3 @@ export declare const instant: Readonly<{
 }>;
 /** Test the exact proleptic-Gregorian V1 Instant lexical and calendar domain. */
 export declare function isInstantValue(input: unknown): input is string;
-//# sourceMappingURL=instant.d.ts.map

package/dist/v1/{schema/value → language/value/model}/instant.js

@@ -1,4 +1,5 @@
 /** Exact portable UTC millisecond Instant used by the V1 value-schema dialect. */
+/** Canonical value-language annotation for an Instant string. */
 export const INSTANT_VALUE_KIND = 'instant';
 export const instant = Object.freeze({
     type: 'string',
@@ -34,4 +35,3 @@ function daysInMonth(year, month) {
 function isLeapYear(year) {
     return year % 4 === 0 && (year % 100 !== 0 || year % 400 === 0);
 }
-//# sourceMappingURL=instant.js.map

package/dist/v1/{schema/value → language/value/model}/object.d.ts

@@ -1,5 +1,5 @@
 import type { Object as ValueObject, Value } from '@astrale-os/kernel-dsl/value';
 /** Internal shape refinement for values that have already crossed portable-value admission. */
+/** Return whether an unknown value is a portable JSON object. */
 export declare function isValueObject(value: unknown): value is ValueObject;
 export declare function isValueObject(value: Value): value is ValueObject;
-//# sourceMappingURL=object.d.ts.map

package/dist/v1/{schema/value → language/value/model}/object.js

@@ -1,4 +1,3 @@
 export function isValueObject(value) {
     return value !== null && typeof value === 'object' && !Array.isArray(value);
 }
-//# sourceMappingURL=object.js.map

package/dist/v1/{schema/value → language/value/model}/schema.d.ts

@@ -1,5 +1,5 @@
 import type { Object as JsonObject, Value as JsonValue } from '@astrale-os/kernel-dsl/value';
-import type { DefinitionRef } from '../reference.js';
+import type { ClassRef } from '../../../addressing/index.js';
 /** Standard dialect on which the Astrale value-schema dialect is based. */
 export declare const JSON_SCHEMA_DIALECT: 'https://json-schema.org/draft/2020-12/schema';
 /** Required V1 dialect for every embedded Astrale value schema. */
@@ -19,8 +19,7 @@ export interface PropertyObjectSchema extends JsonSchemaObject {
 export interface PathAnnotation {
     readonly target: 'node';
     readonly cardinality: 'one';
-    readonly accepts: readonly DefinitionRef[];
+    readonly accepts: readonly ClassRef[];
 }
-export declare const VALUE_SCHEMA_CONTEXTS: readonly ['named-type', 'property-facet', 'callable-input', 'callable-output'];
+export declare const VALUE_SCHEMA_CONTEXTS: readonly ['property-facet', 'callable-input', 'callable-output'];
 export type ValueSchemaContext = (typeof VALUE_SCHEMA_CONTEXTS)[number];
-//# sourceMappingURL=schema.d.ts.map

package/dist/v1/{schema/value → language/value/model}/schema.js

@@ -5,9 +5,7 @@ export const VALUE_SCHEMA_DIALECT = 'https://schemas.astrale.ai/dsl/v1/value-sch
 /** Required vocabulary carried by the V1 value-schema dialect. */
 export const VALUE_SCHEMA_VOCABULARY = 'https://schemas.astrale.ai/dsl/v1/value-schema/vocabulary';
 export const VALUE_SCHEMA_CONTEXTS = [
-    'named-type',
     'property-facet',
     'callable-input',
     'callable-output',
 ];
-//# sourceMappingURL=schema.js.map

package/dist/v1/{schema → language}/value/ordering.d.ts

@@ -1,5 +1,6 @@
-import type { ValueSchemaRegistry } from './registry.js';
-import type { JsonSchema } from './schema.js';
+import type { ValueProgram } from './compile/model.js';
+import type { JsonSchema } from './model/schema.js';
+import type { ValueSchemaRegistry } from './reference/registry.js';
 export type OrderingKind = 'boolean' | 'number' | 'string' | 'instant';
 /**
  * Classify a schema only when every value it can admit belongs to one sortable scalar domain.
@@ -8,4 +9,5 @@ export type OrderingKind = 'boolean' | 'number' | 'string' | 'instant';
  * instead of guessing from annotations, examples, formats, or current data.
  */
 export declare function classifyOrdering(contract: JsonSchema, registry: ValueSchemaRegistry): OrderingKind | undefined;
-//# sourceMappingURL=ordering.d.ts.map
+/** Recompute the scalar ordering classification from one admitted portable value program. */
+export declare function classifyValueProgramOrdering(program: ValueProgram): OrderingKind | undefined;

package/dist/v1/{schema → language}/value/ordering.js

@@ -1,5 +1,5 @@
-import { compileInstanceSchema } from './instance/compiler.js';
-import { locationKey } from './resources/closure.js';
+import { loadValueProgram } from './compile/load.js';
+import { prepareValueSchema } from './evaluate/preparation.js';
 const ALL_JSON_KINDS = new Set([
     'null',
     'boolean',
@@ -15,7 +15,7 @@ const ALL_JSON_KINDS = new Set([
  * instead of guessing from annotations, examples, formats, or current data.
  */
 export function classifyOrdering(contract, registry) {
-    const prepared = compileInstanceSchema(contract, registry, '');
+    const prepared = prepareValueSchema(contract, registry, '');
     if (!prepared.compiled)
         return undefined;
     const candidates = new OrderingClassifier(prepared.value).classify(prepared.value.root);
@@ -26,6 +26,17 @@ export function classifyOrdering(contract, registry) {
         ? kind
         : undefined;
 }
+/** Recompute the scalar ordering classification from one admitted portable value program. */
+export function classifyValueProgramOrdering(program) {
+    const compiled = loadValueProgram(program);
+    const candidates = new OrderingClassifier(compiled).classify(compiled.root);
+    if (candidates.size !== 1)
+        return undefined;
+    const [kind] = candidates;
+    return kind === 'boolean' || kind === 'number' || kind === 'string' || kind === 'instant'
+        ? kind
+        : undefined;
+}
 class OrderingClassifier {
     compiled;
     active = new Set();
@@ -72,10 +83,7 @@ class OrderingClassifier {
             candidates = intersect(candidates, normalize(new Set(schema.enum.map(kindOfValue))));
         }
         if (Object.hasOwn(schema, '$ref')) {
-            const resolved = this.compiled.resolutions.get(location.key);
-            if (resolved === undefined)
-                return new Set();
-            const target = this.compiled.locations.get(locationKey(resolved.resource.key, resolved.pointer));
+            const target = this.compiled.reference(location);
             if (target === undefined)
                 return new Set();
             candidates = intersect(candidates, this.classify(target));
@@ -99,12 +107,7 @@ class OrderingClassifier {
         return candidates;
     }
     child(location, keyword, index) {
-        const suffix = index === undefined ? `/${keyword}` : `/${keyword}/${index}`;
-        const child = this.compiled.locations.get(`${location.key}${suffix}`);
-        if (child === undefined) {
-            throw new TypeError('Prepared value schema child is absent from its closure.');
-        }
-        return child;
+        return this.compiled.child(location, keyword, index);
     }
 }
 function typesOf(input) {
@@ -169,4 +172,3 @@ function normalize(input) {
 function schemaList(input) {
     return Array.isArray(input) ? input : undefined;
 }
-//# sourceMappingURL=ordering.js.map

package/dist/v1/{schema → language}/value/profile/canonicalize.d.ts

@@ -1,5 +1,4 @@
-import type { ValueSchemaRegistry } from '../registry.js';
-import type { JsonSchema, ValueSchemaContext } from '../schema.js';
+import type { JsonSchema, ValueSchemaContext } from '../model/schema.js';
+import type { ValueSchemaRegistry } from '../reference/registry.js';
 /** Canonicalizes syntax without rewriting the schema's algebra. Validate first. */
 export declare function canonicalizeValueSchema(schema: JsonSchema, context?: ValueSchemaContext, registry?: ValueSchemaRegistry): JsonSchema;
-//# sourceMappingURL=canonicalize.d.ts.map

package/dist/v1/{schema → language}/value/profile/canonicalize.js

@@ -1,7 +1,7 @@
 import { json } from '@astrale-os/kernel-dsl/value';
-import { isValueObject as isJsonObject } from '../object.js';
-import { compareSchemaRefs, compareUnicode } from '../../reference.js';
-import { SCHEMA_ARRAY_KEYWORDS, SCHEMA_MAP_KEYWORDS, SCHEMA_SINGLE_KEYWORDS, } from '../location/keywords.js';
+import { compareDefinitionRefs, compareUnicode } from '../../../addressing/ordering.js';
+import { isValueObject as isJsonObject } from '../model/object.js';
+import { SCHEMA_ARRAY_KEYWORDS, SCHEMA_MAP_KEYWORDS, SCHEMA_SINGLE_KEYWORDS, } from '../syntax/keywords.js';
 const TYPE_ORDER = ['null', 'boolean', 'integer', 'number', 'string', 'array', 'object'];
 const TYPE_RANK = new Map(TYPE_ORDER.map((name, index) => [name, index]));
 const encoder = new TextEncoder();
@@ -17,8 +17,6 @@ function canonicalizeSchema(schema, root, context) {
     for (const keyword of Object.keys(schema).sort()) {
         if (root && keyword === '$schema')
             continue;
-        if (root && context === 'named-type' && keyword === '$id')
-            continue;
         const value = schema[keyword];
         if (keyword === 'required' && Array.isArray(value)) {
             assertUnique(value, String, 'required');
@@ -82,7 +80,7 @@ function canonicalizePathAnnotation(value) {
         if (key === 'accepts' && Array.isArray(entry)) {
             const accepts = entry.map(canonicalizeJson);
             assertUnique(accepts, json.serialize, 'x-astrale-path.accepts');
-            result[key] = accepts.sort((left, right) => compareSchemaRefs(left, right));
+            result[key] = accepts.sort((left, right) => compareDefinitionRefs(left, right));
         }
         else
             result[key] = canonicalizeJson(entry);
@@ -130,4 +128,3 @@ function assertUnique(values, keyOf, name) {
 function isJsonSchema(value) {
     return typeof value === 'boolean' || isJsonObject(value);
 }
-//# sourceMappingURL=canonicalize.js.map

package/dist/v1/language/value/profile/json.validate.d.ts

@@ -0,0 +1,2 @@
+import type { Diagnostic } from '../../validation/diagnostic.js';
+export declare function validateCanonicalJsonDomain(value: unknown, pointer: string): readonly Diagnostic[];

package/dist/v1/{schema → language}/value/profile/json.validate.js

@@ -1,5 +1,5 @@
-import { accept as acceptJsonValue, BoundaryError as JsonBoundaryError } from '@astrale-os/kernel-dsl/value';
-import { diagnostic } from '../../diagnostic.js';
+import { accept as acceptJsonValue, BoundaryError as JsonBoundaryError, } from '@astrale-os/kernel-dsl/value';
+import { diagnostic } from '../../validation/diagnostic.js';
 export function validateCanonicalJsonDomain(value, pointer) {
     try {
         acceptJsonValue(value);
@@ -12,4 +12,3 @@ export function validateCanonicalJsonDomain(value, pointer) {
         return [diagnostic('VS_META_SCHEMA', pointer, 'Value is outside the JSON data model.')];
     }
 }
-//# sourceMappingURL=json.validate.js.map

package/dist/v1/language/value/profile/meta-schema.compiled.d.ts

@@ -0,0 +1,78 @@
+export declare const validate: typeof validate20;
+export default validate20;
+declare function validate20(data: any, { instancePath, parentData, parentDataProperty, rootData, dynamicAnchors }?: {
+    dynamicAnchors?: {} | undefined;
+    instancePath?: string | undefined;
+    rootData?: any;
+}): boolean;
+declare namespace validate20 {
+    var evaluated: {
+        props: {
+            fullMatch: boolean;
+            "x-astrale-path": boolean;
+            definitions: boolean;
+            dependencies: boolean;
+            $recursiveAnchor: boolean;
+            $recursiveRef: boolean;
+            contentEncoding: boolean;
+            contentMediaType: boolean;
+            contentSchema: boolean;
+            format: boolean;
+            title: boolean;
+            description: boolean;
+            default: boolean;
+            deprecated: boolean;
+            readOnly: boolean;
+            writeOnly: boolean;
+            examples: boolean;
+            type: boolean;
+            const: boolean;
+            enum: boolean;
+            multipleOf: boolean;
+            maximum: boolean;
+            exclusiveMaximum: boolean;
+            minimum: boolean;
+            exclusiveMinimum: boolean;
+            maxLength: boolean;
+            minLength: boolean;
+            pattern: boolean;
+            maxItems: boolean;
+            minItems: boolean;
+            uniqueItems: boolean;
+            maxContains: boolean;
+            minContains: boolean;
+            maxProperties: boolean;
+            minProperties: boolean;
+            required: boolean;
+            dependentRequired: boolean;
+            unevaluatedItems: boolean;
+            unevaluatedProperties: boolean;
+            prefixItems: boolean;
+            items: boolean;
+            contains: boolean;
+            additionalProperties: boolean;
+            properties: boolean;
+            patternProperties: boolean;
+            dependentSchemas: boolean;
+            propertyNames: boolean;
+            if: boolean;
+            then: boolean;
+            else: boolean;
+            allOf: boolean;
+            anyOf: boolean;
+            oneOf: boolean;
+            not: boolean;
+            $id: boolean;
+            $schema: boolean;
+            $ref: boolean;
+            $anchor: boolean;
+            $dynamicRef: boolean;
+            $dynamicAnchor: boolean;
+            $vocabulary: boolean;
+            $comment: boolean;
+            $defs: boolean;
+        };
+        dynamicProps: boolean;
+        dynamicItems: boolean;
+    };
+}