@stxt-lang/core 0.5.2 → 0.5.3

package/out/runtime/ConditionalValidator.d.ts

@@ -2,8 +2,23 @@ import { Node } from "../core/Node";
 import { Validator } from "../processors/Validator";
 import { SchemaValidator } from "../schema/SchemaValidator";
 import { ValidationException } from "../exceptions/ValidationException";
+/**
+ * Wrapper around a {@link SchemaValidator} that only validates namespaced nodes, so that a
+ * document mixing schema-bound and free nodes does not report the free ones as unknown.
+ */
 export declare class ConditionalValidator implements Validator {
     private readonly schemaValidator;
+    /**
+     * Creates a validator that delegates to a schema validator.
+     *
+     * @param schemaValidator validator the namespaced nodes are handed over to.
+     */
     constructor(schemaValidator: SchemaValidator);
+    /**
+     * Validates a node when it has a namespace, and lets it through otherwise.
+     *
+     * @param node already closed node to validate.
+     * @returns the validation errors found, or an empty array if the node is valid or has no namespace.
+     */
     validate(node: Node): ValidationException[];
 }

package/out/runtime/ConditionalValidator.js

@@ -1,13 +1,27 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ConditionalValidator = void 0;
-// Wrapper del validador que solo valida nodos con namespace
+/**
+ * Wrapper around a {@link SchemaValidator} that only validates namespaced nodes, so that a
+ * document mixing schema-bound and free nodes does not report the free ones as unknown.
+ */
 class ConditionalValidator {
+    /**
+     * Creates a validator that delegates to a schema validator.
+     *
+     * @param schemaValidator validator the namespaced nodes are handed over to.
+     */
     constructor(schemaValidator) {
         this.schemaValidator = schemaValidator;
     }
+    /**
+     * Validates a node when it has a namespace, and lets it through otherwise.
+     *
+     * @param node already closed node to validate.
+     * @returns the validation errors found, or an empty array if the node is valid or has no namespace.
+     */
     validate(node) {
-        // Solo validar si tiene namespace
+        // Only validate the node when it has a namespace
         if (node.getNamespace() !== "") {
             return this.schemaValidator.validate(node);
         }

package/out/runtime/NodeWriter.d.ts

@@ -1,11 +1,29 @@
 import { Node } from "../core/Node";
+/** Indentation style to use when writing. */
 export declare enum IndentStyle {
+    /** One tab character per level. */
     TABS = "TABS",
+    /** Four spaces per level. */
     SPACES_4 = "SPACES_4"
 }
+/** Serializes a {@link Node} (or a list of root nodes) back to STXT text. */
 export declare class NodeWriter {
     private constructor();
+    /**
+     * Serializes a node to STXT text.
+     *
+     * @param node node to serialize (along with its children).
+     * @param style indentation style to use; tabs by default.
+     * @returns the node serialized to STXT text.
+     */
     static toSTXT(node: Node, style?: IndentStyle): string;
+    /**
+     * Serializes a list of root nodes to STXT text, separated by a blank line.
+     *
+     * @param docs root nodes to serialize.
+     * @param style indentation style to use; tabs by default.
+     * @returns the documents serialized to STXT text.
+     */
     static toSTXTDocs(docs: ReadonlyArray<Node>, style?: IndentStyle): string;
     private static writeNode;
     private static indent;

package/out/runtime/NodeWriter.js

@@ -1,18 +1,36 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.NodeWriter = exports.IndentStyle = void 0;
+/** Indentation style to use when writing. */
 var IndentStyle;
 (function (IndentStyle) {
+    /** One tab character per level. */
     IndentStyle["TABS"] = "TABS";
+    /** Four spaces per level. */
     IndentStyle["SPACES_4"] = "SPACES_4";
 })(IndentStyle || (exports.IndentStyle = IndentStyle = {}));
+/** Serializes a {@link Node} (or a list of root nodes) back to STXT text. */
 class NodeWriter {
     constructor() { }
+    /**
+     * Serializes a node to STXT text.
+     *
+     * @param node node to serialize (along with its children).
+     * @param style indentation style to use; tabs by default.
+     * @returns the node serialized to STXT text.
+     */
     static toSTXT(node, style = IndentStyle.TABS) {
         const out = [];
         NodeWriter.writeNode(out, node, 0, style, "");
         return out.join("");
     }
+    /**
+     * Serializes a list of root nodes to STXT text, separated by a blank line.
+     *
+     * @param docs root nodes to serialize.
+     * @param style indentation style to use; tabs by default.
+     * @returns the documents serialized to STXT text.
+     */
     static toSTXTDocs(docs, style = IndentStyle.TABS) {
         const out = [];
         for (let i = 0; i < docs.length; i++) {

package/out/runtime/UnifiedSchemaProvider.d.ts

@@ -1,22 +1,40 @@
 import { Schema } from "../schema/Schema";
 import { SchemaProvider } from "../schema/SchemaProvider";
 /**
- * Provider unificado que maneja tanto schemas como templates.
- * Detecta automáticamente el tipo según el namespace del nodo raíz:
- * - @stxt.template => procesa como template
- * - @stxt.schema => procesa como schema
- * - otros => no hace nada
+ * Unified provider that handles both schemas and templates.
+ * It detects which one it is from the namespace of the root node:
+ * - @stxt.template => processed as a template
+ * - @stxt.schema => processed as a schema
+ * - anything else => ignored
  */
 export declare class UnifiedSchemaProvider implements SchemaProvider {
     private readonly schemas;
     private readonly schemaMeta;
     private readonly templateMeta;
+    /** Creates an empty provider, with the two meta-schemas already loaded. */
     constructor();
+    /**
+     * Resolves the schema that applies to a namespace, serving the meta-schemas of the two
+     * reserved namespaces itself.
+     *
+     * @param namespace namespace whose schema is wanted.
+     * @returns the schema of the namespace, or null/undefined if none has been registered for it.
+     */
     getSchema(namespace: string): Schema | undefined | null;
+    /**
+     * Parses a document and registers every schema or template it defines, each one under its own
+     * namespace. Documents of any other namespace are ignored.
+     *
+     * @param text text of the document to load.
+     * @throws ParseException if the document cannot be parsed, or the first ValidationException if
+     *         a schema or a template does not validate against its meta-schema.
+     */
     addFile(text: string): void;
     private addTemplateNode;
     private addSchemaNode;
     private static throwIfInvalid;
+    /** Removes every schema and template registered in this provider. */
     clear(): void;
+    /** @returns every schema registered in this provider, in registration order. */
     getAllSchemas(): ReadonlyArray<Schema>;
 }

package/out/runtime/UnifiedSchemaProvider.js

@@ -9,18 +9,26 @@ const SchemaValidator_1 = require("../schema/SchemaValidator");
 const MetaTemplateSchemaProvider_1 = require("../template/MetaTemplateSchemaProvider");
 const TemplateParser_1 = require("../template/TemplateParser");
 /**
- * Provider unificado que maneja tanto schemas como templates.
- * Detecta automáticamente el tipo según el namespace del nodo raíz:
- * - @stxt.template => procesa como template
- * - @stxt.schema => procesa como schema
- * - otros => no hace nada
+ * Unified provider that handles both schemas and templates.
+ * It detects which one it is from the namespace of the root node:
+ * - @stxt.template => processed as a template
+ * - @stxt.schema => processed as a schema
+ * - anything else => ignored
  */
 class UnifiedSchemaProvider {
+    /** Creates an empty provider, with the two meta-schemas already loaded. */
     constructor() {
         this.schemas = new Map();
         this.schemaMeta = new SchemaProviderMeta_1.SchemaProviderMeta();
         this.templateMeta = new MetaTemplateSchemaProvider_1.MetaTemplateSchemaProvider();
     }
+    /**
+     * Resolves the schema that applies to a namespace, serving the meta-schemas of the two
+     * reserved namespaces itself.
+     *
+     * @param namespace namespace whose schema is wanted.
+     * @returns the schema of the namespace, or null/undefined if none has been registered for it.
+     */
     getSchema(namespace) {
         const key = StringUtils_1.StringUtils.lowerCase(namespace);
         if (namespace === "@stxt.template") {
@@ -32,6 +40,14 @@ class UnifiedSchemaProvider {
         let result = this.schemas.get(key);
         return result;
     }
+    /**
+     * Parses a document and registers every schema or template it defines, each one under its own
+     * namespace. Documents of any other namespace are ignored.
+     *
+     * @param text text of the document to load.
+     * @throws ParseException if the document cannot be parsed, or the first ValidationException if
+     *         a schema or a template does not validate against its meta-schema.
+     */
     addFile(text) {
         const parser = new Parser_1.Parser();
         const nodes = parser.parse(text);
@@ -46,32 +62,34 @@ class UnifiedSchemaProvider {
         }
     }
     addTemplateNode(node) {
-        // Validar contra el meta-schema de templates
+        // Validate against the meta-schema of templates
         const schemaValidator = new SchemaValidator_1.SchemaValidator(this.templateMeta, true);
         UnifiedSchemaProvider.throwIfInvalid(schemaValidator.validate(node));
-        // Transformar el template a schema
+        // Transform the template into a schema
         const schema = (0, TemplateParser_1.transformTemplateNodeToSchema)(node);
         const key = StringUtils_1.StringUtils.lowerCase(schema.getNamespace());
         this.schemas.set(key, schema);
     }
     addSchemaNode(node) {
-        // Validar contra el meta-schema de schemas
+        // Validate against the meta-schema of schemas
         const schemaValidator = new SchemaValidator_1.SchemaValidator(this.schemaMeta, true);
         UnifiedSchemaProvider.throwIfInvalid(schemaValidator.validate(node));
-        // Transformar el nodo a schema
+        // Transform the node into a schema
         const schema = (0, SchemaParser_1.transformNodeToSchema)(node);
         const key = StringUtils_1.StringUtils.lowerCase(schema.getNamespace());
         this.schemas.set(key, schema);
     }
-    // Un schema/template que no valida contra su meta-schema no debe cargarse
+    // A schema/template that does not validate against its meta-schema must not be loaded
     static throwIfInvalid(errors) {
         if (errors.length > 0) {
             throw errors[0];
         }
     }
+    /** Removes every schema and template registered in this provider. */
     clear() {
         this.schemas.clear();
     }
+    /** @returns every schema registered in this provider, in registration order. */
     getAllSchemas() {
         return Array.from(this.schemas.values());
     }

package/out/schema/ChildDefinition.d.ts

@@ -1,16 +1,34 @@
+/** Definition of an expected child inside a {@link NodeDefinition}: name, namespace and min/max cardinality. */
 export declare class ChildDefinition {
     private readonly normalizedName;
     private readonly name;
     private readonly namespace;
     private readonly min;
     private readonly max;
+    /**
+     * Creates the definition of an expected child.
+     *
+     * @param name name of the expected child.
+     * @param namespace namespace of the expected child (may be null/undefined).
+     * @param min minimum cardinality, or null if there is no minimum.
+     * @param max maximum cardinality, or null if there is no maximum.
+     * @param numLine line number, for the error messages.
+     * @throws ValidationException with code `INVALID_NODE_NAME` if the name is not valid.
+     */
     constructor(name: string, namespace: string | null | undefined, min: number | null, max: number | null, numLine: number);
+    /** @returns the name of the expected child, as it appears in the schema. */
     getName(): string;
+    /** @returns the canonical name of the expected child. */
     getNormalizedName(): string;
+    /** @returns the namespace of the expected child, or the empty string if it has none. */
     getNamespace(): string;
+    /** @returns the minimum cardinality, or null if there is no minimum. */
     getMin(): number | null;
+    /** @returns the maximum cardinality, or null if there is no maximum. */
     getMax(): number | null;
+    /** @returns the canonical name prefixed by its namespace, used as the key in {@link NodeDefinition.getChildren}. */
     getQualifiedName(): string;
+    /** @returns a plain object with the definition, so that JSON.stringify serializes it. */
     toJSON(): {
         name: string;
         normalizedName: string;

package/out/schema/ChildDefinition.js

@@ -4,7 +4,18 @@ exports.ChildDefinition = void 0;
 const NamespaceValidator_1 = require("../core/NamespaceValidator");
 const ValidationException_1 = require("../exceptions/ValidationException");
 const StringUtils_1 = require("../core/StringUtils");
+/** Definition of an expected child inside a {@link NodeDefinition}: name, namespace and min/max cardinality. */
 class ChildDefinition {
+    /**
+     * Creates the definition of an expected child.
+     *
+     * @param name name of the expected child.
+     * @param namespace namespace of the expected child (may be null/undefined).
+     * @param min minimum cardinality, or null if there is no minimum.
+     * @param max maximum cardinality, or null if there is no maximum.
+     * @param numLine line number, for the error messages.
+     * @throws ValidationException with code `INVALID_NODE_NAME` if the name is not valid.
+     */
     constructor(name, namespace, min, max, numLine) {
         this.name = StringUtils_1.StringUtils.compactSpaces(name);
         this.normalizedName = StringUtils_1.StringUtils.normalize(name);
@@ -16,26 +27,33 @@ class ChildDefinition {
             throw new ValidationException_1.ValidationException(numLine, "INVALID_NODE_NAME", `Node name not valid: ${name}`);
         }
     }
+    /** @returns the name of the expected child, as it appears in the schema. */
     getName() {
         return this.name;
     }
+    /** @returns the canonical name of the expected child. */
     getNormalizedName() {
         return this.normalizedName;
     }
+    /** @returns the namespace of the expected child, or the empty string if it has none. */
     getNamespace() {
         return this.namespace;
     }
+    /** @returns the minimum cardinality, or null if there is no minimum. */
     getMin() {
         return this.min;
     }
+    /** @returns the maximum cardinality, or null if there is no maximum. */
     getMax() {
         return this.max;
     }
+    /** @returns the canonical name prefixed by its namespace, used as the key in {@link NodeDefinition.getChildren}. */
     getQualifiedName() {
         return this.namespace.length === 0
             ? this.normalizedName
             : `${this.namespace}:${this.normalizedName}`;
     }
+    /** @returns a plain object with the definition, so that JSON.stringify serializes it. */
     toJSON() {
         return {
             name: this.getName(),

package/out/schema/NodeDefinition.d.ts

@@ -1,4 +1,8 @@
 import { ChildDefinition } from "./ChildDefinition";
+/**
+ * Definition of a node inside a {@link Schema}: its name, its value type, the children it expects
+ * ({@link ChildDefinition}) and, for ENUM, the values it allows.
+ */
 export declare class NodeDefinition {
     private readonly name;
     private readonly normalizedName;
@@ -6,17 +10,57 @@ export declare class NodeDefinition {
     private description;
     private readonly children;
     private readonly values;
+    /**
+     * Creates the definition of a node.
+     *
+     * @param name name of the node.
+     * @param type name of the type (see {@link TypeRegistry}).
+     * @param line line number, for the error message.
+     * @param description optional description of the node.
+     * @throws ValidationException with code `INVALID_NODE_NAME` if the name is not valid.
+     */
     constructor(name: string, type: string, line: number, description: string | undefined);
+    /** @returns the name of the node, as it appears in the schema. */
     getName(): string;
+    /** @returns the canonical name of the node. */
     getNormalizedName(): string;
+    /** @returns the name of the value type of this node (see {@link TypeRegistry}). */
     getType(): string;
+    /** @returns the definitions of the expected children, indexed by their qualified canonical name. */
     getChildren(): ReadonlyMap<string, ChildDefinition>;
+    /** @returns the optional description of the node, or undefined if it has none. */
     getDescription(): string | undefined;
+    /**
+     * Sets the optional description of the node.
+     *
+     * @param description new optional description of the node.
+     */
     setDescription(description: string): void;
+    /**
+     * Adds the definition of an expected child.
+     *
+     * @param childDefinition definition of the child to add.
+     * @throws ValidationException with code `CHILD_DEF_ALREADY_DEFINED` if a definition for that child already existed.
+     */
     addChildDefinition(childDefinition: ChildDefinition): void;
+    /**
+     * Adds a value to the list of values allowed for this node.
+     *
+     * @param value value to add to the list of allowed values.
+     * @param line line number, for the error message.
+     * @throws ValidationException with code `VALUE_DUPLICATED` if the value (once trimmed) had already been added.
+     */
     addValue(value: string, line?: number): void;
+    /**
+     * Tells whether a value is allowed for this node.
+     *
+     * @param value value to check.
+     * @returns true if no restricted values are defined, or if the value is among the allowed ones.
+     */
     isAllowedValue(value: string): boolean;
+    /** @returns the values allowed for this node (ENUM), or empty if there is no restriction. */
     getValues(): ReadonlySet<string>;
+    /** @returns a plain object with the definition, so that JSON.stringify serializes it. */
     toJSON(): {
         name: string;
         normalizedName: string;

package/out/schema/NodeDefinition.js

@@ -3,7 +3,20 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.NodeDefinition = void 0;
 const ValidationException_1 = require("../exceptions/ValidationException");
 const StringUtils_1 = require("../core/StringUtils");
+/**
+ * Definition of a node inside a {@link Schema}: its name, its value type, the children it expects
+ * ({@link ChildDefinition}) and, for ENUM, the values it allows.
+ */
 class NodeDefinition {
+    /**
+     * Creates the definition of a node.
+     *
+     * @param name name of the node.
+     * @param type name of the type (see {@link TypeRegistry}).
+     * @param line line number, for the error message.
+     * @param description optional description of the node.
+     * @throws ValidationException with code `INVALID_NODE_NAME` if the name is not valid.
+     */
     constructor(name, type, line, description) {
         this.children = new Map();
         this.values = new Set();
@@ -15,24 +28,40 @@ class NodeDefinition {
             throw new ValidationException_1.ValidationException(line, "INVALID_NODE_NAME", `Node name not valid: ${name}`);
         }
     }
+    /** @returns the name of the node, as it appears in the schema. */
     getName() {
         return this.name;
     }
+    /** @returns the canonical name of the node. */
     getNormalizedName() {
         return this.normalizedName;
     }
+    /** @returns the name of the value type of this node (see {@link TypeRegistry}). */
     getType() {
         return this.type;
     }
+    /** @returns the definitions of the expected children, indexed by their qualified canonical name. */
     getChildren() {
         return this.children;
     }
+    /** @returns the optional description of the node, or undefined if it has none. */
     getDescription() {
         return this.description;
     }
+    /**
+     * Sets the optional description of the node.
+     *
+     * @param description new optional description of the node.
+     */
     setDescription(description) {
         this.description = description;
     }
+    /**
+     * Adds the definition of an expected child.
+     *
+     * @param childDefinition definition of the child to add.
+     * @throws ValidationException with code `CHILD_DEF_ALREADY_DEFINED` if a definition for that child already existed.
+     */
     addChildDefinition(childDefinition) {
         const qname = childDefinition.getQualifiedName();
         if (this.children.has(qname)) {
@@ -40,9 +69,16 @@ class NodeDefinition {
         }
         this.children.set(qname, childDefinition);
     }
-    // STXT-SCHEMA-SPEC 13.9 / STXT-TEMPLATE-SPEC 14.14: no puede haber valores duplicados
-    // tras la normalización por trim. Mismo código que ChildLineParser: es la misma condición
-    // por la otra puerta de entrada.
+    // STXT-SCHEMA-SPEC 13.9 / STXT-TEMPLATE-SPEC 14.14: there can be no duplicated values
+    // after the trim normalization. Same code as ChildLineParser: it is the same condition
+    // coming through the other entry point.
+    /**
+     * Adds a value to the list of values allowed for this node.
+     *
+     * @param value value to add to the list of allowed values.
+     * @param line line number, for the error message.
+     * @throws ValidationException with code `VALUE_DUPLICATED` if the value (once trimmed) had already been added.
+     */
     addValue(value, line) {
         const trimmed = value?.trim() ?? "";
         if (this.values.has(trimmed)) {
@@ -50,15 +86,23 @@ class NodeDefinition {
         }
         this.values.add(trimmed);
     }
+    /**
+     * Tells whether a value is allowed for this node.
+     *
+     * @param value value to check.
+     * @returns true if no restricted values are defined, or if the value is among the allowed ones.
+     */
     isAllowedValue(value) {
         if (this.values.size === 0) {
             return true;
         }
         return this.values.has(value);
     }
+    /** @returns the values allowed for this node (ENUM), or empty if there is no restriction. */
     getValues() {
         return this.values;
     }
+    /** @returns a plain object with the definition, so that JSON.stringify serializes it. */
     toJSON() {
         return {
             name: this.getName(),

package/out/schema/Schema.d.ts

@@ -1,14 +1,39 @@
 import { NodeDefinition } from "./NodeDefinition";
+/** Schema of a namespace: the set of {@link NodeDefinition} valid for the nodes of that namespace. */
 export declare class Schema {
+    /** Namespace of the schema language itself, `@stxt.schema`. */
     static readonly SCHEMA_NAMESPACE = "@stxt.schema";
     private readonly nodes;
     private readonly namespace;
     private readonly description;
+    /**
+     * Creates an empty schema for a namespace.
+     *
+     * @param namespace namespace this schema applies to.
+     * @param line line number, for the error message.
+     * @param description optional description of the schema.
+     * @throws ParseException if the namespace is not well formed.
+     */
     constructor(namespace: string | null | undefined, line: number, description: string | undefined);
+    /** @returns the node definitions, indexed by their canonical name. */
     getNodes(): ReadonlyMap<string, NodeDefinition>;
+    /**
+     * Looks up the definition of a node by name.
+     *
+     * @param name name of the node to look for.
+     * @returns the definition of the node with that name, or undefined if it is not defined in this schema.
+     */
     getNodeDefinition(name: string): NodeDefinition | undefined;
+    /**
+     * Adds the definition of a node to this schema.
+     *
+     * @param nodeDefinition node definition to add.
+     * @throws ValidationException with code `NODE_DEF_ALREADY_DEFINED` if there already was a node definition with the same name.
+     */
     addNodeDefinition(nodeDefinition: NodeDefinition): void;
+    /** @returns the namespace this schema applies to. */
     getNamespace(): string;
+    /** @returns a plain object with the schema, so that JSON.stringify serializes it. */
     toJSON(): {
         namespace: string;
         nodes: {
@@ -26,5 +51,6 @@ export declare class Schema {
             values: string[];
         }[];
     };
+    /** @returns the schema as pretty-printed JSON, for debugging. */
     toString(): string;
 }

package/out/schema/Schema.js

@@ -4,19 +4,41 @@ exports.Schema = void 0;
 const NamespaceValidator_1 = require("../core/NamespaceValidator");
 const StringUtils_1 = require("../core/StringUtils");
 const ValidationException_1 = require("../exceptions/ValidationException");
+/** Schema of a namespace: the set of {@link NodeDefinition} valid for the nodes of that namespace. */
 class Schema {
+    /**
+     * Creates an empty schema for a namespace.
+     *
+     * @param namespace namespace this schema applies to.
+     * @param line line number, for the error message.
+     * @param description optional description of the schema.
+     * @throws ParseException if the namespace is not well formed.
+     */
     constructor(namespace, line, description) {
         this.nodes = new Map();
         this.namespace = StringUtils_1.StringUtils.lowerCase(namespace);
         this.description = description;
         NamespaceValidator_1.NamespaceValidator.validateNamespaceFormat(this.namespace, line);
     }
+    /** @returns the node definitions, indexed by their canonical name. */
     getNodes() {
         return this.nodes;
     }
+    /**
+     * Looks up the definition of a node by name.
+     *
+     * @param name name of the node to look for.
+     * @returns the definition of the node with that name, or undefined if it is not defined in this schema.
+     */
     getNodeDefinition(name) {
         return this.nodes.get(StringUtils_1.StringUtils.normalize(name));
     }
+    /**
+     * Adds the definition of a node to this schema.
+     *
+     * @param nodeDefinition node definition to add.
+     * @throws ValidationException with code `NODE_DEF_ALREADY_DEFINED` if there already was a node definition with the same name.
+     */
     addNodeDefinition(nodeDefinition) {
         const qname = nodeDefinition.getNormalizedName();
         if (this.nodes.has(qname)) {
@@ -24,20 +46,23 @@ class Schema {
         }
         this.nodes.set(qname, nodeDefinition);
     }
+    /** @returns the namespace this schema applies to. */
     getNamespace() {
         return this.namespace;
     }
-    // Dentro de la clase Schema
+    /** @returns a plain object with the schema, so that JSON.stringify serializes it. */
     toJSON() {
         return {
             namespace: this.namespace,
             nodes: Array.from(this.nodes.values()).map(n => n.toJSON()),
         };
     }
+    /** @returns the schema as pretty-printed JSON, for debugging. */
     toString() {
         return JSON.stringify(this, null, 2); // pretty print
     }
 }
 exports.Schema = Schema;
+/** Namespace of the schema language itself, `@stxt.schema`. */
 Schema.SCHEMA_NAMESPACE = "@stxt.schema";
 //# sourceMappingURL=Schema.js.map

package/out/schema/SchemaParser.d.ts

@@ -1,3 +1,10 @@
 import { Schema } from "./Schema";
 import { Node } from "../core/Node";
+/**
+ * Turns the tree of an already parsed `@stxt.schema` document into a {@link Schema}.
+ *
+ * @param node root node of the schema document, `Schema (@stxt.schema): ...`.
+ * @returns the schema the document defines.
+ * @throws ValidationException if the document is not a valid `@stxt.schema` one.
+ */
 export declare function transformNodeToSchema(node: Node): Schema;