@stxt-lang/core 0.5.2 → 0.5.3

package/out/schema/SchemaParser.js

@@ -8,32 +8,39 @@ const ValidationException_1 = require("../exceptions/ValidationException");
 const RuntimeException_1 = require("../exceptions/RuntimeException");
 const NameNamespaceParser_1 = require("../core/NameNamespaceParser");
 const TypeRegistry_1 = require("./TypeRegistry");
+/**
+ * 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.
+ */
 function transformNodeToSchema(node) {
     // Node name
     const nodeName = node.getNormalizedName();
     const namespaceSchema = node.getNamespace();
-    // Obtenemos name y namespace
+    // Get the name and the namespace
     if (nodeName !== "schema" || namespaceSchema !== Schema_1.Schema.SCHEMA_NAMESPACE) {
-        throw new ValidationException_1.ValidationException(node.getLine(), "NOT_STXT_SCHEMA", `Se espera schema(${Schema_1.Schema.SCHEMA_NAMESPACE}) y es ${nodeName}(${namespaceSchema})`);
+        throw new ValidationException_1.ValidationException(node.getLine(), "NOT_STXT_SCHEMA", `Expected schema(${Schema_1.Schema.SCHEMA_NAMESPACE}) but got ${nodeName}(${namespaceSchema})`);
     }
-    // Obtenemos description
+    // Get the description
     const descrip = node.getChild("description")?.getText();
     const schema = new Schema_1.Schema(node.getValue(), node.getLine(), descrip);
-    // Para validar
-    const allNames = new Set(); // Para validar que existan los childs
-    // Obtenemos los nodos
+    // Used to check that every child is defined
+    const allNames = new Set();
+    // Get the nodes
     for (const n of node.getChildrenByName("node")) {
         const schNode = createFrom(n, schema.getNamespace());
         schema.addNodeDefinition(schNode);
         allNames.add(schNode.getNormalizedName());
     }
-    // Validamos que todos los nombres estén definidos
+    // Check that every name is defined
     for (const schNode of schema.getNodes().values()) {
         for (const schChild of schNode.getChildren().values()) {
-            // Sólo validamos del mismo namespace
+            // Only names of the same namespace are checked
             if (schChild.getNamespace() === schema.getNamespace()) {
-                // Ojo: en Java aquí se usa schChild.getNormalizedName(), pero ChildDefinition no lo expone.
-                // Para mantener el comportamiento, se recomienda añadir getNormalizedName() a ChildDefinition.
+                // Defensive leftover from the Java port: ChildDefinition does expose
+                // getNormalizedName(), so this check can never fail with the current class.
                 const childNorm = schChild.getNormalizedName?.();
                 if (!childNorm) {
                     throw new RuntimeException_1.RuntimeException("CHILD_DEFINITION_API_MISMATCH", "ChildDefinition.getNormalizedName() is missing in TypeScript version. Add it to ChildDefinition.");
@@ -46,6 +53,7 @@ function transformNodeToSchema(node) {
     }
     return schema;
 }
+/** Builds the definition of a node from a `Node:` entry of the schema document. */
 function createFrom(n, namespace) {
     const name = n.getValue();
     let type = "INLINE";
@@ -57,7 +65,7 @@ function createFrom(n, namespace) {
     const result = new NodeDefinition_1.NodeDefinition(name, type, n.getLine(), description);
     const children = n.getChild("children");
     if (children) {
-        // Error de schema 13.5: Children en un Node cuyo tipo no admite hijos
+        // Schema error 13.5: Children in a Node whose type does not admit children
         if (!TypeRegistry_1.TypeRegistry.admitsChildren(type)) {
             throw new ValidationException_1.ValidationException(children.getLine(), "CHILDREN_NOT_ALLOWED_FOR_TYPE", `Type ${type} does not allow children (node ${name})`);
         }
@@ -65,7 +73,7 @@ function createFrom(n, namespace) {
             putChildToSchemaNode(result, child, namespace);
         }
     }
-    // Miramos values
+    // Look at the values
     let valuesNodes = n.getChildrenByName("values");
     if (valuesNodes && valuesNodes.length > 0) {
         if (type !== "ENUM") {
@@ -79,29 +87,31 @@ function createFrom(n, namespace) {
         for (const v of values) {
             result.addValue(v.getValue(), v.getLine());
         }
-        // Para la comprobación final de ENUM
+        // For the final ENUM check
         valuesNodes = values;
     }
-    // Miramos enum
+    // Look at the enum
     if (type === "ENUM" && (!valuesNodes || valuesNodes.length === 0)) {
         throw new ValidationException_1.ValidationException(n.getLine(), "VALUES_EMPTY_FOR_ENUM", "ENUM Type must include values");
     }
     return result;
 }
+/** Adds to a node definition the expected child a `Child:` entry declares. */
 function putChildToSchemaNode(schemaNode, child, defNamespace) {
-    // Obtenemos name y namespace
+    // Get the name and the namespace
     const ns = NameNamespaceParser_1.NameNamespaceParser.parse(child.getValue(), defNamespace, child.getLine(), child.getValue());
     const name = ns.getName();
     const namespace = ns.getNamespace();
     const min = getInteger(child, "min");
     const max = getInteger(child, "max");
-    // Cardinalidad inválida si Min > Max (STXT-SCHEMA-SPEC 10 y 13.7)
+    // Invalid cardinality when Min > Max (STXT-SCHEMA-SPEC 10 and 13.7)
     if (min !== null && max !== null && min > max) {
         throw new ValidationException_1.ValidationException(child.getLine(), "MIN_GREATER_THAN_MAX", `Min ${min} greater than Max ${max}`);
     }
     const schemaChild = new ChildDefinition_1.ChildDefinition(name, namespace, min, max, child.getLine());
     schemaNode.addChildDefinition(schemaChild);
 }
+/** Reads an integer child (`Min`, `Max`) of a node, or null when it is not there. */
 function getInteger(node, name) {
     const n = node.getChild(name);
     if (!n) {

package/out/schema/SchemaProvider.d.ts

@@ -1,4 +1,11 @@
 import { Schema } from "./Schema";
+/** Resolves the {@link Schema} that applies to a namespace. Composable implementations (memory, meta-schema...). */
 export interface SchemaProvider {
+    /**
+     * Resolves the schema that applies to a namespace.
+     *
+     * @param namespace namespace whose schema is wanted.
+     * @returns the schema of the namespace, or null/undefined if there is none for that namespace.
+     */
     getSchema(namespace: string): Schema | null | undefined;
 }

package/out/schema/SchemaProviderMemory.d.ts

@@ -1,11 +1,38 @@
 import { Schema } from "./Schema";
 import { SchemaProvider } from "./SchemaProvider";
+/**
+ * In-memory {@link SchemaProvider}: it keeps the schemas added with {@link SchemaProviderMemory.addSchema}
+ * indexed by namespace, and falls back to a parent provider (the meta-schema by default) for the
+ * namespaces it does not know.
+ */
 export declare class SchemaProviderMemory implements SchemaProvider {
     private readonly parentSchema;
+    /**
+     * Creates an empty provider.
+     *
+     * @param parent provider to fall back to when a namespace is not registered here; the
+     *        meta-schema provider when omitted.
+     */
     constructor(parent?: SchemaProvider | null | undefined);
     protected readonly schemas: Map<string, Schema>;
+    /**
+     * Resolves the schema that applies to a namespace, delegating to the parent provider when it
+     * is not registered here.
+     *
+     * @param namespace namespace whose schema is wanted.
+     * @returns the schema of the namespace, or null/undefined if neither this provider nor its parent has one.
+     */
     getSchema(namespace: string): Schema | undefined | null;
+    /**
+     * Parses a schema document, validates it against the meta-schema and registers it under its
+     * own namespace.
+     *
+     * @param txt text of the `@stxt.schema` document.
+     * @throws ParseException or ValidationException if the document is not a valid schema.
+     */
     addSchema(txt: string): void;
+    /** Removes every schema registered in this provider (the parent one is left untouched). */
     clear(): void;
+    /** @returns every schema registered in this provider, in registration order. */
     getAllSchemas(): ReadonlyArray<Schema>;
 }

package/out/schema/SchemaProviderMemory.js

@@ -6,7 +6,18 @@ const StringUtils_1 = require("../core/StringUtils");
 const SchemaParser_1 = require("./SchemaParser");
 const SchemaProviderMeta_1 = require("./SchemaProviderMeta");
 const SchemaValidator_1 = require("./SchemaValidator");
+/**
+ * In-memory {@link SchemaProvider}: it keeps the schemas added with {@link SchemaProviderMemory.addSchema}
+ * indexed by namespace, and falls back to a parent provider (the meta-schema by default) for the
+ * namespaces it does not know.
+ */
 class SchemaProviderMemory {
+    /**
+     * Creates an empty provider.
+     *
+     * @param parent provider to fall back to when a namespace is not registered here; the
+     *        meta-schema provider when omitted.
+     */
     constructor(parent) {
         this.schemas = new Map();
         if (!parent) {
@@ -16,6 +27,13 @@ class SchemaProviderMemory {
             this.parentSchema = parent;
         }
     }
+    /**
+     * Resolves the schema that applies to a namespace, delegating to the parent provider when it
+     * is not registered here.
+     *
+     * @param namespace namespace whose schema is wanted.
+     * @returns the schema of the namespace, or null/undefined if neither this provider nor its parent has one.
+     */
     getSchema(namespace) {
         const key = StringUtils_1.StringUtils.lowerCase(namespace);
         let result = this.schemas.get(key);
@@ -24,6 +42,13 @@ class SchemaProviderMemory {
         }
         return result;
     }
+    /**
+     * Parses a schema document, validates it against the meta-schema and registers it under its
+     * own namespace.
+     *
+     * @param txt text of the `@stxt.schema` document.
+     * @throws ParseException or ValidationException if the document is not a valid schema.
+     */
     addSchema(txt) {
         const parser = new Parser_1.Parser();
         const node = parser.parse(txt)[0];
@@ -33,9 +58,11 @@ class SchemaProviderMemory {
         const key = schema.getNamespace();
         this.schemas.set(key, schema);
     }
+    /** Removes every schema registered in this provider (the parent one is left untouched). */
     clear() {
         this.schemas.clear();
     }
+    /** @returns every schema registered in this provider, in registration order. */
     getAllSchemas() {
         return Array.from(this.schemas.values());
     }

package/out/schema/SchemaProviderMeta.d.ts

@@ -1,8 +1,24 @@
 import { Schema } from "./Schema";
 import { SchemaProvider } from "./SchemaProvider";
+/**
+ * {@link SchemaProvider} that defines in code the meta-schema of the schema language itself
+ * (`@stxt.schema`), so that a loaded schema can validate itself.
+ */
 export declare class SchemaProviderMeta implements SchemaProvider {
     private static readonly META_TEXT;
     private readonly meta;
+    /**
+     * Parses the meta-schema and keeps it ready to be served.
+     *
+     * @throws ValidationException with code `META_SCHEMA_INVALID` if the meta-schema does not produce exactly one document.
+     */
     constructor();
+    /**
+     * Serves the meta-schema of the schema language.
+     *
+     * @param namespace namespace whose schema is wanted; only `@stxt.schema` is served.
+     * @returns the meta-schema of the schema language.
+     * @throws RuntimeException with code `RESOURCE_NOT_FOUND` if any other namespace is asked for.
+     */
     getSchema(namespace: string): Schema;
 }

package/out/schema/SchemaProviderMeta.js

@@ -6,7 +6,16 @@ const Parser_1 = require("../core/Parser");
 const ValidationException_1 = require("../exceptions/ValidationException");
 const RuntimeException_1 = require("../exceptions/RuntimeException");
 const SchemaParser_1 = require("./SchemaParser");
+/**
+ * {@link SchemaProvider} that defines in code the meta-schema of the schema language itself
+ * (`@stxt.schema`), so that a loaded schema can validate itself.
+ */
 class SchemaProviderMeta {
+    /**
+     * Parses the meta-schema and keeps it ready to be served.
+     *
+     * @throws ValidationException with code `META_SCHEMA_INVALID` if the meta-schema does not produce exactly one document.
+     */
     constructor() {
         const parser = new Parser_1.Parser();
         const nodes = parser.parse(SchemaProviderMeta.META_TEXT);
@@ -15,6 +24,13 @@ class SchemaProviderMeta {
         }
         this.meta = (0, SchemaParser_1.transformNodeToSchema)(nodes[0]);
     }
+    /**
+     * Serves the meta-schema of the schema language.
+     *
+     * @param namespace namespace whose schema is wanted; only `@stxt.schema` is served.
+     * @returns the meta-schema of the schema language.
+     * @throws RuntimeException with code `RESOURCE_NOT_FOUND` if any other namespace is asked for.
+     */
     getSchema(namespace) {
         if (namespace !== Schema_1.Schema.SCHEMA_NAMESPACE) {
             throw new RuntimeException_1.RuntimeException("RESOURCE_NOT_FOUND", `Not found '${namespace}' in namespace: ${Schema_1.Schema.SCHEMA_NAMESPACE}`);

package/out/schema/SchemaValidator.d.ts

@@ -3,11 +3,31 @@ import { ValidationException } from "../exceptions/ValidationException";
 import { Validator } from "../processors/Validator";
 import { SchemaProvider } from "./SchemaProvider";
 import { Schema } from "./Schema";
+/** {@link Validator} that, for each node, resolves its {@link Schema} through a {@link SchemaProvider} and validates type and cardinality. */
 export declare class SchemaValidator implements Validator {
     private readonly schemaProvider;
     private readonly recursiveValidation;
+    /**
+     * Creates a validator that resolves schemas through the given provider.
+     *
+     * @param schemaProvider where to resolve the schema of each namespace from.
+     * @param recursive whether the children of each node are validated recursively too.
+     */
     constructor(schemaProvider: SchemaProvider, recursive?: boolean);
+    /**
+     * Validates a node against the schema of its namespace.
+     *
+     * @param node already closed node to validate.
+     * @returns the validation errors found, or an empty array if the node is valid.
+     */
     validate(node: Node): ValidationException[];
+    /**
+     * Validates a node against an already resolved schema: existence, value type and cardinalities of its children.
+     *
+     * @param node node to validate.
+     * @param schema schema to validate against.
+     * @returns the validation errors found, empty if the node is valid.
+     */
     validateAgainstSchema(node: Node, schema: Schema): ValidationException[];
     private static validateChildrenDeclared;
     private static validateValue;

package/out/schema/SchemaValidator.js

@@ -3,23 +3,36 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.SchemaValidator = void 0;
 const ValidationException_1 = require("../exceptions/ValidationException");
 const TypeRegistry_1 = require("./TypeRegistry");
+/** {@link Validator} that, for each node, resolves its {@link Schema} through a {@link SchemaProvider} and validates type and cardinality. */
 class SchemaValidator {
+    /**
+     * Creates a validator that resolves schemas through the given provider.
+     *
+     * @param schemaProvider where to resolve the schema of each namespace from.
+     * @param recursive whether the children of each node are validated recursively too.
+     */
     constructor(schemaProvider, recursive = false) {
         this.schemaProvider = schemaProvider;
         this.recursiveValidation = recursive;
     }
+    /**
+     * Validates a node against the schema of its namespace.
+     *
+     * @param node already closed node to validate.
+     * @returns the validation errors found, or an empty array if the node is valid.
+     */
     validate(node) {
         const errors = [];
-        // Obtenemos namespace
+        // Get the namespace
         const namespace = node.getNamespace();
         const schema = this.schemaProvider.getSchema(namespace);
         if (!schema) {
             errors.push(new ValidationException_1.ValidationException(node.getLine(), "SCHEMA_NOT_FOUND", `Not found schema: ${namespace}`));
             return errors;
         }
-        // Validamos nodo
+        // Validate the node
         errors.push(...this.validateAgainstSchema(node, schema));
-        // Validamos children
+        // Validate the children
         if (this.recursiveValidation) {
             for (const childNode of node.getChildren()) {
                 errors.push(...this.validate(childNode));
@@ -27,6 +40,13 @@ class SchemaValidator {
         }
         return errors;
     }
+    /**
+     * Validates a node against an already resolved schema: existence, value type and cardinalities of its children.
+     *
+     * @param node node to validate.
+     * @param schema schema to validate against.
+     * @returns the validation errors found, empty if the node is valid.
+     */
     validateAgainstSchema(node, schema) {
         const errors = [];
         const schemaNode = schema.getNodeDefinition(node.getNormalizedName());
@@ -40,8 +60,8 @@ class SchemaValidator {
         errors.push(...SchemaValidator.validateCount(schemaNode, node));
         return errors;
     }
-    // Modelo de contenido cerrado (STXT-SCHEMA-SPEC, sección 6): solo se permiten
-    // los hijos directos declarados en la definición del padre; sin Children, cierre total
+    // Closed content model (STXT-SCHEMA-SPEC, section 6): only the direct children declared
+    // in the definition of the parent are allowed; with no Children, nothing is
     static validateChildrenDeclared(nodeDef, node) {
         const errors = [];
         for (const child of node.getChildren()) {
@@ -101,9 +121,9 @@ class SchemaValidator {
             errors.push(new ValidationException_1.ValidationException(node.getLine(), "INVALID_NUMBER", `${childCount} nodes of '${childDef.getQualifiedName()}' and min is ${min}`));
         }
         if (max !== null && childCount > max) {
-            // Error en el parent
+            // Error on the parent
             errors.push(new ValidationException_1.ValidationException(node.getLine(), "INVALID_NUMBER", `${childCount} nodes of '${childDef.getQualifiedName()}' and max is ${max}`));
-            // Error en cada nodo hijo que excede el máximo permitido
+            // Error on each child node beyond the allowed maximum
             for (const child of children) {
                 errors.push(new ValidationException_1.ValidationException(child.getLine(), "INVALID_NUMBER", `Too many '${childDef.getQualifiedName()}' nodes: found ${childCount}, max is ${max}`));
             }

package/out/schema/Type.d.ts

@@ -1,6 +1,15 @@
 import { Node } from "../core/Node";
 import { NodeDefinition } from "./NodeDefinition";
+/** Value type of a node (TEXT, INTEGER, URL...). Each type lives in `src/schema/type` as a singleton. */
 export interface Type {
+    /**
+     * Validates the value of a node against this type.
+     *
+     * @param nodeDef definition of the node in the schema.
+     * @param node node to validate.
+     * @throws ValidationException if the value of the node does not match the type.
+     */
     validate(nodeDef: NodeDefinition, node: Node): void;
+    /** @returns the name of the type, as used in the schemas (e.g. `"TEXT"`). */
     getName(): string;
 }

package/out/schema/TypeRegistry.d.ts

@@ -1,8 +1,21 @@
 import { Type } from "./Type";
+/** Static registry of the STXT value types, indexed by name. Adding a new type: a new {@link Type} + `register(...)` here. */
 export declare class TypeRegistry {
     private static readonly REGISTRY;
     private static readonly _init;
+    /**
+     * Tells whether nodes of a type may have children.
+     *
+     * @param nodeType name of the type.
+     * @returns true if nodes of this type may have children (only INLINE and GROUP).
+     */
     static admitsChildren(nodeType: string): boolean;
+    /**
+     * Looks up a registered type by name.
+     *
+     * @param nodeType name of the type to look for.
+     * @returns the {@link Type} registered under that name, or undefined if it does not exist.
+     */
     static get(nodeType: string): Type | undefined;
     private static register;
 }

package/out/schema/TypeRegistry.js

@@ -21,13 +21,26 @@ const BASE64_1 = require("./type/BASE64");
 const GROUP_1 = require("./type/GROUP");
 const ENUM_1 = require("./type/ENUM");
 const MARKDOWN_1 = require("./type/MARKDOWN");
+/** Static registry of the STXT value types, indexed by name. Adding a new type: a new {@link Type} + `register(...)` here. */
 class TypeRegistry {
-    // STXT-SCHEMA-SPEC 9 / STXT-TEMPLATE-SPEC 15: sólo INLINE y GROUP admiten hijos
+    // STXT-SCHEMA-SPEC 9 / STXT-TEMPLATE-SPEC 15: only INLINE and GROUP admit children
+    /**
+     * Tells whether nodes of a type may have children.
+     *
+     * @param nodeType name of the type.
+     * @returns true if nodes of this type may have children (only INLINE and GROUP).
+     */
     static admitsChildren(nodeType) {
         return nodeType === "INLINE" || nodeType === "GROUP";
     }
+    /**
+     * Looks up a registered type by name.
+     *
+     * @param nodeType name of the type to look for.
+     * @returns the {@link Type} registered under that name, or undefined if it does not exist.
+     */
     static get(nodeType) {
-        // fuerza que se ejecute _init al cargar la clase (por si el bundler hiciera cosas raras)
+        // force _init to run when the class is loaded (in case a bundler does something odd)
         void this._init;
         return this.REGISTRY.get(nodeType);
     }
@@ -41,12 +54,12 @@ class TypeRegistry {
 }
 exports.TypeRegistry = TypeRegistry;
 TypeRegistry.REGISTRY = new Map();
-// Inicialización estática (sin INSTANCE)
+// Static initialization (no INSTANCE)
 TypeRegistry._init = (() => {
-    // Tipos principales
+    // Main types
     TypeRegistry.register(INLINE_1.INLINE);
     TypeRegistry.register(BLOCK_1.BLOCK);
-    // Subtipos
+    // Subtypes
     TypeRegistry.register(TEXT_1.TEXT);
     TypeRegistry.register(BOOLEAN_1.BOOLEAN);
     TypeRegistry.register(URL_1.URL);

package/out/schema/type/BASE64.d.ts

@@ -1,2 +1,3 @@
 import { Type } from "../Type";
+/** `BASE64` type: checks that the content is valid Base64. */
 export declare const BASE64: Type;

package/out/schema/type/BASE64.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.BASE64 = void 0;
 const ValidationException_1 = require("../../exceptions/ValidationException");
 const binaryValue_1 = require("./binaryValue");
+/** `BASE64` type: checks that the content is valid Base64. */
 exports.BASE64 = {
     getName() {
         return "BASE64";
@@ -10,12 +11,12 @@ exports.BASE64 = {
     validate(ndef, n) {
         const raw = (0, binaryValue_1.binaryValue)(n);
         try {
-            // Intentamos decodificar
+            // Try to decode it
             const buf = Buffer.from(raw, "base64");
-            // Re-encode para verificar consistencia
-            // (evita aceptar cadenas parcialmente válidas)
+            // Re-encode to check consistency
+            // (this keeps partially valid strings out)
             const reencoded = buf.toString("base64");
-            // Normalizamos padding para comparar
+            // Normalize the padding before comparing
             const normalizedInput = raw.replace(/=+$/, "");
             const normalizedReencoded = reencoded.replace(/=+$/, "");
             if (normalizedInput !== normalizedReencoded) {

package/out/schema/type/BINARY.d.ts

@@ -1,2 +1,3 @@
 import { Type } from "../Type";
+/** `BINARY` type: checks that the content is a string of zeros and ones (`[01]+`). */
 export declare const BINARY: Type;

package/out/schema/type/BINARY.js

@@ -3,11 +3,12 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.BINARY = void 0;
 const ValidationException_1 = require("../../exceptions/ValidationException");
 const binaryValue_1 = require("./binaryValue");
+/** `BINARY` type: checks that the content is a string of zeros and ones (`[01]+`). */
 exports.BINARY = {
     getName() {
         return "BINARY";
     },
-    // STXT-SCHEMA-SPEC 9.5: cadena [01]+
+    // STXT-SCHEMA-SPEC 9.5: [01]+ string
     validate(ndef, n) {
         const value = (0, binaryValue_1.binaryValue)(n);
         if (!/^[01]+$/.test(value)) {

package/out/schema/type/BLOCK.d.ts

@@ -1,2 +1,3 @@
 import { Type } from "../Type";
+/** `BLOCK` type: text block node (`>>`), with no further restriction on the content. */
 export declare const BLOCK: Type;

package/out/schema/type/BLOCK.js

@@ -2,12 +2,13 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.BLOCK = void 0;
 const ValidationException_1 = require("../../exceptions/ValidationException");
+/** `BLOCK` type: text block node (`>>`), with no further restriction on the content. */
 exports.BLOCK = {
     getName() {
         return "BLOCK";
     },
     validate(nodeDef, node) {
-        // Forma del valor BLOCK (STXT-SCHEMA-SPEC 9.2): sólo bloque '>>', no forma inline
+        // BLOCK value form (STXT-SCHEMA-SPEC 9.2): block '>>' only, no inline form
         if (!node.isTextNode()) {
             throw new ValidationException_1.ValidationException(node.getLine(), "BLOCK_FORM_REQUIRED", `Node ${node.getQualifiedName()} requires block form '>>'`);
         }

package/out/schema/type/BOOLEAN.d.ts

@@ -1 +1,2 @@
+/** `BOOLEAN` type: checks that the value is `true` or `false`. */
 export declare const BOOLEAN: import("../Type").Type;

package/out/schema/type/BOOLEAN.js

@@ -2,5 +2,6 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.BOOLEAN = void 0;
 const regexType_1 = require("./regexType");
+/** `BOOLEAN` type: checks that the value is `true` or `false`. */
 exports.BOOLEAN = (0, regexType_1.regexType)("BOOLEAN", /^(true|false)$/, "Invalid boolean");
 //# sourceMappingURL=BOOLEAN.js.map

package/out/schema/type/DATE.d.ts

@@ -1 +1,2 @@
+/** `DATE` type: checks the `YYYY-MM-DD` format. */
 export declare const DATE: import("../Type").Type;

package/out/schema/type/DATE.js

@@ -2,5 +2,6 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.DATE = void 0;
 const regexType_1 = require("./regexType");
+/** `DATE` type: checks the `YYYY-MM-DD` format. */
 exports.DATE = (0, regexType_1.regexType)("DATE", /^\d{4}-\d{2}-\d{2}$/, "Invalid date");
 //# sourceMappingURL=DATE.js.map

package/out/schema/type/EMAIL.d.ts

@@ -1 +1,2 @@
+/** `EMAIL` type: checks that the value looks like an e-mail address. */
 export declare const EMAIL: import("../Type").Type;

package/out/schema/type/EMAIL.js

@@ -2,5 +2,6 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.EMAIL = void 0;
 const regexType_1 = require("./regexType");
+/** `EMAIL` type: checks that the value looks like an e-mail address. */
 exports.EMAIL = (0, regexType_1.regexType)("EMAIL", /^(?=.{1,256}$)(?=.{1,64}@.{1,255}$)(?=.{1,64}@.{1,63}\..{1,63}$)[A-Za-z0-9!#$%&'*+/=?^_`{|}~.-]+@[A-Za-z0-9.-]+\.[A-Za-z]{2,}$/, "Invalid email");
 //# sourceMappingURL=EMAIL.js.map

package/out/schema/type/ENUM.d.ts

@@ -1,2 +1,3 @@
 import { Type } from "../Type";
+/** `ENUM` type: checks that the value is one of those declared in {@link NodeDefinition.getValues}. */
 export declare const ENUM: Type;

package/out/schema/type/ENUM.js

@@ -2,12 +2,13 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ENUM = void 0;
 const ValidationException_1 = require("../../exceptions/ValidationException");
+/** `ENUM` type: checks that the value is one of those declared in {@link NodeDefinition.getValues}. */
 exports.ENUM = {
     getName() {
         return "ENUM";
     },
     validate(nodeDef, node) {
-        // Forma del valor INLINE (STXT-SCHEMA-SPEC 9.3): no admite bloque '>>'
+        // INLINE value form (STXT-SCHEMA-SPEC 9.3): the block '>>' form is not allowed
         if (node.isTextNode()) {
             throw new ValidationException_1.ValidationException(node.getLine(), "NOT_ALLOWED_TEXT", `Not allowed text in node ${node.getQualifiedName()}`);
         }

package/out/schema/type/GROUP.d.ts

@@ -1,2 +1,3 @@
 import { Type } from "../Type";
+/** `GROUP` type: container node with no value of its own, accepting children just like INLINE. */
 export declare const GROUP: Type;

package/out/schema/type/GROUP.js

@@ -2,12 +2,13 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.GROUP = void 0;
 const ValidationException_1 = require("../../exceptions/ValidationException");
+/** `GROUP` type: container node with no value of its own, accepting children just like INLINE. */
 exports.GROUP = {
     getName() {
         return "GROUP";
     },
     validate(nodeDef, node) {
-        // Forma del valor NONE (STXT-SCHEMA-SPEC 9.2): ni valor inline ni bloque '>>'
+        // NONE value form (STXT-SCHEMA-SPEC 9.2): neither an inline value nor a '>>' block
         if (node.getValue().length > 0 || node.isTextNode()) {
             throw new ValidationException_1.ValidationException(node.getLine(), "INVALID_VALUE", `Node '${node.getName()}' has to be empty`);
         }

package/out/schema/type/HEXADECIMAL.d.ts

@@ -1,2 +1,3 @@
 import { Type } from "../Type";
+/** `HEXADECIMAL` type: checks a hexadecimal string (`[0-9A-Fa-f]+`), with no prefix and no mandatory even length. */
 export declare const HEXADECIMAL: Type;