@markuplint/ml-core 4.13.2 → 5.0.0-alpha.0

package/lib/ml-dom/node/text.js

@@ -6,6 +6,14 @@ import { UnexpectedCallError } from './unexpected-call-error.js';
  * @see https://html.spec.whatwg.org/multipage/syntax.html#raw-text-elements
  */
 const rawTextElements = new Set(['script', 'style']);
+/**
+ * Represents a DOM Text node wrapper in the markuplint DOM tree.
+ * Wraps an AST text token and provides text-specific operations such as
+ * detecting raw text element content and whitespace-only nodes.
+ *
+ * @template T - The rule configuration value type
+ * @template O - The rule options type
+ */
 export class MLText extends MLCharacterData {
     /**
      * **IT THROWS AN ERROR WHEN CALLING THIS.**
@@ -16,6 +24,15 @@ export class MLText extends MLCharacterData {
     get assignedSlot() {
         throw new UnexpectedCallError('Not supported  "assignedSlot" property');
     }
+    /**
+     * Returns `true` if this text node originated from an invalid (bogus) AST
+     * node, such as an orphaned end tag.
+     *
+     * @implements `@markuplint/ml-core` API: `MLText`
+     */
+    get isBogus() {
+        return this._astToken.isBogus ?? false;
+    }
     /**
      * Returns a string appropriate for the type of node as `Text`
      *
@@ -45,12 +62,16 @@ export class MLText extends MLCharacterData {
      *
      * @implements `@markuplint/ml-core` API: `MLText`
      * @see https://html.spec.whatwg.org/multipage/syntax.html#raw-text-elements
+     * @returns True if this text node is the content of a raw text element
      */
     isRawTextElementContent() {
         return this.parentElement ? rawTextElements.has(this.parentElement.nodeName.toLowerCase()) : false;
     }
     /**
+     * Checks whether this text node contains only whitespace characters.
+     *
      * @implements `@markuplint/ml-core` API: `MLText`
+     * @returns True if the raw content is composed entirely of whitespace
      */
     isWhitespace() {
         return /^\s+$/.test(this.raw);

package/lib/ml-dom/node/types.d.ts

@@ -9,30 +9,91 @@ import type { MLText } from './text.js';
 import type { MLToken } from '../token/token.js';
 import type { MLASTAttr, MLASTComment, MLASTDoctype, MLASTElement, MLASTInvalid, MLASTParentNode, MLASTPreprocessorSpecificBlock, MLASTText, MLASTToken as MLASTToken } from '@markuplint/ml-ast/';
 import type { PlainData, PretenderARIA, RuleConfigValue } from '@markuplint/ml-config';
+/**
+ * Maps an AST node type to its corresponding markuplint DOM node wrapper type.
+ *
+ * @template N - The AST node type to map from
+ * @template T - The rule configuration value type
+ * @template O - The rule options type
+ */
 export type MappedNode<N, T extends RuleConfigValue, O extends PlainData = undefined> = N extends MLASTElement ? MLElement<T, O> : N extends MLASTParentNode ? MLElement<T, O> : N extends MLASTComment ? MLComment<T, O> : N extends MLASTText ? MLText<T, O> : N extends MLASTDoctype ? MLDocumentType<T, O> : N extends MLASTPreprocessorSpecificBlock ? MLBlock<T, O> : N extends MLASTAttr ? MLAttr<T, O> : N extends MLASTInvalid ? MLText<T, O> : N extends MLASTToken ? MLToken : never;
+/**
+ * Resolves a numeric node type constant to its corresponding markuplint DOM node class type.
+ * Used for type narrowing via the `is()` method on nodes.
+ *
+ * @template NT - The numeric node type constant
+ * @template T - The rule configuration value type
+ * @template O - The rule options type
+ */
 export type NodeTypeOf<NT extends NodeType, T extends RuleConfigValue, O extends PlainData = undefined> = NT extends ElementNodeType ? MLElement<T, O> : NT extends CommentNodeType ? MLComment<T, O> : NT extends TextNodeType ? MLText<T, O> : NT extends DocumentNodeType ? MLDocument<T, O> : NT extends DocumentTypeNodeType ? MLDocumentType<T, O> : NT extends DocumentFragmentNodeType ? MLDocumentFragment<T, O> : NT extends MarkuplintPreprocessorBlockType ? MLBlock<T, O> : NT extends AttributeNodeType ? MLAttr<T, O> : never;
+/** Numeric constant representing an Element node (corresponds to DOM `Node.ELEMENT_NODE`). */
 export type ElementNodeType = 1;
+/** Numeric constant representing an Attribute node (corresponds to DOM `Node.ATTRIBUTE_NODE`). */
 export type AttributeNodeType = 2;
+/** Numeric constant representing a Text node (corresponds to DOM `Node.TEXT_NODE`). */
 export type TextNodeType = 3;
+/** Numeric constant representing a CDATA Section node (corresponds to DOM `Node.CDATA_SECTION_NODE`). */
 export type CDATASectionNodeType = 4;
+/** Numeric constant representing a Processing Instruction node (corresponds to DOM `Node.PROCESSING_INSTRUCTION_NODE`). */
 export type ProcessingInstructionNodeType = 7;
+/** Numeric constant representing a Comment node (corresponds to DOM `Node.COMMENT_NODE`). */
 export type CommentNodeType = 8;
+/** Numeric constant representing a Document node (corresponds to DOM `Node.DOCUMENT_NODE`). */
 export type DocumentNodeType = 9;
+/** Numeric constant representing a DocumentType node (corresponds to DOM `Node.DOCUMENT_TYPE_NODE`). */
 export type DocumentTypeNodeType = 10;
+/** Numeric constant representing a DocumentFragment node (corresponds to DOM `Node.DOCUMENT_FRAGMENT_NODE`). */
 export type DocumentFragmentNodeType = 11;
+/** Numeric constant representing a markuplint preprocessor block node, used for template engine constructs. */
 export type MarkuplintPreprocessorBlockType = 101;
+/**
+ * Union of all supported node type constants in the markuplint DOM,
+ * including standard DOM node types and the markuplint-specific preprocessor block type.
+ */
 export type NodeType = ElementNodeType | AttributeNodeType | TextNodeType | CDATASectionNodeType | ProcessingInstructionNodeType | CommentNodeType | DocumentNodeType | DocumentTypeNodeType | DocumentFragmentNodeType | MarkuplintPreprocessorBlockType;
+/**
+ * Represents the pretender context for an element, which can be either
+ * a pretender (an element acting as another) or a pretended element (the original).
+ *
+ * @template N - The element type
+ * @template T - The rule configuration value type
+ * @template O - The rule options type
+ */
 export type PretenderContext<N extends MLElement<T, O>, T extends RuleConfigValue, O extends PlainData = undefined> = PretenderContextPretender<N, T, O> | PretenderContextPretended<N, T, O>;
+/**
+ * Context for an element that is pretending to be another element.
+ * Contains the target element it is pretending to be and optional ARIA overrides.
+ *
+ * @template N - The element type
+ * @template T - The rule configuration value type
+ * @template O - The rule options type
+ */
 export type PretenderContextPretender<N extends MLElement<T, O>, T extends RuleConfigValue, O extends PlainData = undefined> = {
     readonly type: 'pretender';
     readonly as: N;
     readonly aria?: PretenderARIA;
 };
+/**
+ * Context for the original element that has been pretended by another element.
+ * Contains a reference back to the pretending origin element.
+ *
+ * @template N - The element type
+ * @template T - The rule configuration value type
+ * @template O - The rule options type
+ */
 export type PretenderContextPretended<N extends MLElement<T, O>, T extends RuleConfigValue, O extends PlainData = undefined> = {
     readonly type: 'origin';
     readonly origin: N;
 };
+/**
+ * Represents the computed accessibility properties for a node,
+ * which may be clearly resolved or unknown.
+ */
 export type AccessibilityProperties = ClearlyAccessibilityProperties | UnknownAccessibilityProperties;
+/**
+ * Resolved accessibility properties for a node, including its ARIA role,
+ * accessible name, focusability, and related ARIA property values.
+ */
 export type ClearlyAccessibilityProperties = {
     unknown: false;
     exposedToTree: boolean;
@@ -46,9 +107,16 @@ export type ClearlyAccessibilityProperties = {
     focusable?: boolean;
     props?: Record<string, AccessibilityProperty>;
 };
+/**
+ * Represents accessibility properties that could not be resolved,
+ * typically when the element or its role is not recognized.
+ */
 export type UnknownAccessibilityProperties = {
     unknown: true;
 };
+/**
+ * A single ARIA property with its computed value and whether it is required for the role.
+ */
 export type AccessibilityProperty = {
     value: string | null;
     required: boolean;

package/lib/ml-dom/token/token.d.ts

@@ -1,47 +1,89 @@
 import type { MLASTToken } from '@markuplint/ml-ast';
+/**
+ * Represents a single token in the markuplint AST.
+ * Wraps an AST token with positional information (line, column, offset)
+ * and provides both raw and fixed string representations.
+ *
+ * @template A - The AST token type this token wraps
+ */
 export declare class MLToken<A extends MLASTToken = MLASTToken> {
     #private;
+    /**
+     * The unique identifier for this token.
+     */
     readonly uuid: string;
+    /**
+     * The underlying AST token that this token wraps.
+     */
     protected readonly _astToken: A;
+    /**
+     * Creates a new MLToken instance from an AST token.
+     *
+     * @param astToken - The AST token to wrap
+     */
     constructor(astToken: A);
     /**
+     * The ending column number (1-based) of this token in the source.
+     *
      * @implements `@markuplint/ml-core` API: `MLDOMToken`
      */
     get endCol(): number;
     /**
+     * The ending line number (1-based) of this token in the source.
+     *
      * @implements `@markuplint/ml-core` API: `MLDOMToken`
      */
     get endLine(): number;
     /**
+     * The ending character offset (0-based) of this token in the source.
+     *
      * @implements `@markuplint/ml-core` API: `MLDOMToken`
      */
     get endOffset(): number;
     /**
+     * The fixed (potentially modified) string content of this token.
+     *
      * @implements `@markuplint/ml-core` API: `MLDOMToken`
      */
     get fixed(): string;
     /**
+     * The original raw string content of this token from the source.
+     *
      * @implements `@markuplint/ml-core` API: `MLDOMToken`
      */
     get raw(): string;
     /**
+     * The starting column number (1-based) of this token in the source.
+     *
      * @implements `@markuplint/ml-core` API: `MLDOMToken`
      */
     get startCol(): number;
     /**
+     * The starting line number (1-based) of this token in the source.
+     *
      * @implements `@markuplint/ml-core` API: `MLDOMToken`
      */
     get startLine(): number;
     /**
+     * The starting character offset (0-based) of this token in the source.
+     *
      * @implements `@markuplint/ml-core` API: `MLDOMToken`
      */
     get startOffset(): number;
     /**
+     * Replaces the fixed content of this token with the given string,
+     * used when applying lint fixes.
+     *
      * @implements `@markuplint/ml-core` API: `MLDOMToken`
+     * @param raw - The new string content to set as the fixed value
      */
     fix(raw: string): void;
     /**
+     * Returns the string representation of this token.
+     *
      * @implements `@markuplint/ml-core` API: `MLDOMToken`
+     * @param fixed - When true, returns the fixed content; otherwise returns the original raw content
+     * @returns The string content of this token
      */
     toString(fixed?: boolean): string;
 }

package/lib/ml-dom/token/token.js

@@ -1,95 +1,115 @@
-var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
-    if (kind === "m") throw new TypeError("Private method is not writable");
-    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
-    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
-    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
-};
-var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
-    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
-    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
-    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
-};
-var _MLToken_endCol, _MLToken_endLine, _MLToken_endOffset, _MLToken_fixed, _MLToken_raw, _MLToken_startCol, _MLToken_startLine, _MLToken_startOffset;
+import { getEndCol, getEndLine } from '@markuplint/parser-utils/location';
+/**
+ * Represents a single token in the markuplint AST.
+ * Wraps an AST token with positional information (line, column, offset)
+ * and provides both raw and fixed string representations.
+ *
+ * @template A - The AST token type this token wraps
+ */
 export class MLToken {
+    #fixed;
+    #raw;
+    /**
+     * The unique identifier for this token.
+     */
+    uuid;
+    /**
+     * The underlying AST token that this token wraps.
+     */
+    _astToken;
+    /**
+     * Creates a new MLToken instance from an AST token.
+     *
+     * @param astToken - The AST token to wrap
+     */
     constructor(astToken) {
-        _MLToken_endCol.set(this, void 0);
-        _MLToken_endLine.set(this, void 0);
-        _MLToken_endOffset.set(this, void 0);
-        _MLToken_fixed.set(this, void 0);
-        _MLToken_raw.set(this, void 0);
-        _MLToken_startCol.set(this, void 0);
-        _MLToken_startLine.set(this, void 0);
-        _MLToken_startOffset.set(this, void 0);
         this._astToken = astToken;
-        __classPrivateFieldSet(this, _MLToken_raw, astToken.raw, "f");
-        __classPrivateFieldSet(this, _MLToken_fixed, astToken.raw, "f");
+        this.#raw = astToken.raw;
+        this.#fixed = astToken.raw;
         this.uuid = astToken.uuid;
-        __classPrivateFieldSet(this, _MLToken_startLine, astToken.startLine, "f");
-        __classPrivateFieldSet(this, _MLToken_endLine, astToken.endLine, "f");
-        __classPrivateFieldSet(this, _MLToken_startCol, astToken.startCol, "f");
-        __classPrivateFieldSet(this, _MLToken_endCol, astToken.endCol, "f");
-        __classPrivateFieldSet(this, _MLToken_startOffset, astToken.startOffset, "f");
-        __classPrivateFieldSet(this, _MLToken_endOffset, astToken.endOffset, "f");
     }
     /**
+     * The ending column number (1-based) of this token in the source.
+     *
      * @implements `@markuplint/ml-core` API: `MLDOMToken`
      */
     get endCol() {
-        return __classPrivateFieldGet(this, _MLToken_endCol, "f");
+        return getEndCol(this.fixed, this.startCol);
     }
     /**
+     * The ending line number (1-based) of this token in the source.
+     *
      * @implements `@markuplint/ml-core` API: `MLDOMToken`
      */
     get endLine() {
-        return __classPrivateFieldGet(this, _MLToken_endLine, "f");
+        return getEndLine(this.fixed, this.startLine);
     }
     /**
+     * The ending character offset (0-based) of this token in the source.
+     *
      * @implements `@markuplint/ml-core` API: `MLDOMToken`
      */
     get endOffset() {
-        return __classPrivateFieldGet(this, _MLToken_endOffset, "f");
+        return this.startOffset + this.fixed.length;
     }
     /**
+     * The fixed (potentially modified) string content of this token.
+     *
      * @implements `@markuplint/ml-core` API: `MLDOMToken`
      */
     get fixed() {
-        return __classPrivateFieldGet(this, _MLToken_fixed, "f");
+        return this.#fixed;
     }
     /**
+     * The original raw string content of this token from the source.
+     *
      * @implements `@markuplint/ml-core` API: `MLDOMToken`
      */
     get raw() {
-        return __classPrivateFieldGet(this, _MLToken_raw, "f");
+        return this.#raw;
     }
     /**
+     * The starting column number (1-based) of this token in the source.
+     *
      * @implements `@markuplint/ml-core` API: `MLDOMToken`
      */
     get startCol() {
-        return __classPrivateFieldGet(this, _MLToken_startCol, "f");
+        return this._astToken.col;
     }
     /**
+     * The starting line number (1-based) of this token in the source.
+     *
      * @implements `@markuplint/ml-core` API: `MLDOMToken`
      */
     get startLine() {
-        return __classPrivateFieldGet(this, _MLToken_startLine, "f");
+        return this._astToken.line;
     }
     /**
+     * The starting character offset (0-based) of this token in the source.
+     *
      * @implements `@markuplint/ml-core` API: `MLDOMToken`
      */
     get startOffset() {
-        return __classPrivateFieldGet(this, _MLToken_startOffset, "f");
+        return this._astToken.offset;
     }
     /**
+     * Replaces the fixed content of this token with the given string,
+     * used when applying lint fixes.
+     *
      * @implements `@markuplint/ml-core` API: `MLDOMToken`
+     * @param raw - The new string content to set as the fixed value
      */
     fix(raw) {
-        __classPrivateFieldSet(this, _MLToken_fixed, raw, "f");
+        this.#fixed = raw;
     }
     /**
+     * Returns the string representation of this token.
+     *
      * @implements `@markuplint/ml-core` API: `MLDOMToken`
+     * @param fixed - When true, returns the fixed content; otherwise returns the original raw content
+     * @returns The string content of this token
      */
     toString(fixed = false) {
-        return fixed ? __classPrivateFieldGet(this, _MLToken_fixed, "f") : __classPrivateFieldGet(this, _MLToken_raw, "f");
+        return fixed ? this.#fixed : this.#raw;
     }
 }
-_MLToken_endCol = new WeakMap(), _MLToken_endLine = new WeakMap(), _MLToken_endOffset = new WeakMap(), _MLToken_fixed = new WeakMap(), _MLToken_raw = new WeakMap(), _MLToken_startCol = new WeakMap(), _MLToken_startLine = new WeakMap(), _MLToken_startOffset = new WeakMap();

package/lib/ml-rule/create-rule.d.ts

@@ -1,3 +1,19 @@
 import type { RuleSeed } from './types.js';
 import type { PlainData, RuleConfigValue } from '@markuplint/ml-config';
-export declare function createRule<T extends RuleConfigValue, O extends PlainData = undefined>(seed: Readonly<RuleSeed<T, O>>): Readonly<RuleSeed<T, O>>;
+/**
+ * Factory function for creating a type-safe rule seed.
+ * Returns the seed object as-is; primarily used for type inference.
+ *
+ * When `T` is `boolean` (or includes `boolean`), `defaultValue` is optional because
+ * the runtime default is `true`. For all other value types, `defaultValue` is required
+ * so that the rule always has a well-typed default.
+ *
+ * @see https://github.com/markuplint/markuplint/issues/808
+ * @template T - The type of the rule's configuration value
+ * @template O - The type of the rule's options
+ * @param seed - The rule seed definition containing verify/fix functions and defaults
+ * @returns The same seed object, now fully typed
+ */
+export declare function createRule<T extends RuleConfigValue, O extends PlainData = undefined>(seed: Readonly<RuleSeed<T, O>> & (boolean extends T ? {} : {
+    readonly defaultValue: T;
+})): Readonly<RuleSeed<T, O>>;

package/lib/ml-rule/ml-rule-context.js

@@ -1,21 +1,18 @@
-var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
-    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
-    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
-    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
-};
-var _MLRuleContext_reports;
 import { translator } from '@markuplint/i18n';
 export class MLRuleContext {
+    document;
+    locale;
+    #reports = [];
+    translate;
     constructor(
     // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
     document, locale) {
-        _MLRuleContext_reports.set(this, []);
         this.document = document;
         this.translate = translator(locale);
         this.locale = locale.locale;
     }
     get reports() {
-        return __classPrivateFieldGet(this, _MLRuleContext_reports, "f").map(report => ({
+        return this.#reports.map(report => ({
             ...report,
             message: finish(report.message, this.locale),
         }));
@@ -41,12 +38,11 @@ export class MLRuleContext {
         this._push(report);
     }
     _push(report) {
-        if (!__classPrivateFieldGet(this, _MLRuleContext_reports, "f").some(r => is(r, report))) {
-            __classPrivateFieldGet(this, _MLRuleContext_reports, "f").push(report);
+        if (!this.#reports.some(r => is(r, report))) {
+            this.#reports.push(report);
         }
     }
 }
-_MLRuleContext_reports = new WeakMap();
 function finish(message, locale = 'en') {
     switch (locale) {
         case 'en': {

package/lib/ml-rule/ml-rule.d.ts

@@ -2,16 +2,54 @@ import type { RuleSeed } from './types.js';
 import type { MLDocument } from '../ml-dom/node/document.js';
 import type { Ruleset } from '../ruleset/index.js';
 import type { LocaleSet } from '@markuplint/i18n';
-import type { GlobalRuleInfo, PlainData, Rule, RuleConfigValue, RuleInfo, Severity, Violation } from '@markuplint/ml-config';
+import type { GlobalRuleInfo, SpecConformance, PlainData, Rule, RuleConfigValue, RuleInfo, Severity, Violation } from '@markuplint/ml-config';
+/**
+ * Represents a single markuplint rule that can verify documents and report violations.
+ *
+ * @template T - The type of the rule's configuration value
+ * @template O - The type of the rule's options
+ */
 export declare class MLRule<T extends RuleConfigValue, O extends PlainData = undefined> {
     #private;
+    /**
+     * For virtual rules, the name of the base rule whose verify/fix logic is reused.
+     * When set, violations report this as `ruleId` for backwards compatibility.
+     */
+    readonly baseRuleId?: string;
     readonly defaultOptions: O;
     readonly defaultSeverity: Severity;
     readonly defaultValue: T;
+    /**
+     * For multi-entry named nodeRules, the group name shared by all derived virtual rules.
+     * Allows `rules["groupName"]: false` to disable all rules in the group.
+     */
+    readonly groupName?: string;
     readonly name: string;
+    /**
+     * The spec conformance classification of this rule, based on RFC 2119 keyword strength.
+     * Set on virtual rules derived from named nodeRules in presets.
+     */
+    readonly specConformance?: SpecConformance;
     constructor(o: Readonly<RuleSeed<T, O>> & {
         readonly name: string;
+        readonly baseRuleId?: string;
+        readonly specConformance?: SpecConformance;
+        readonly groupName?: string;
     });
+    /**
+     * Creates a virtual rule that reuses this rule's verify/fix logic
+     * under a different name (alias). Used by named nodeRules to produce
+     * independent rule instances that can be individually configured.
+     *
+     * @param aliasName - The alias name (must contain `/`)
+     * @param options - Override options for the virtual rule
+     * @returns A new MLRule instance sharing the same verify/fix logic
+     */
+    createAlias(aliasName: string, options?: {
+        readonly defaultSeverity?: Severity;
+        readonly specConformance?: SpecConformance;
+        readonly groupName?: string;
+    }): MLRule<T, O>;
     /**
      * The following getter is unused internally,
      * only for extending from 3rd party library
@@ -22,9 +60,36 @@ export declare class MLRule<T extends RuleConfigValue, O extends PlainData = und
      * only for extending from 3rd party library
      */
     protected get v(): RuleSeed<T, O>['verify'];
+    /**
+     * Resolves the full rule information from a ruleset, including node-level
+     * and child-node-level overrides.
+     *
+     * @param ruleSet - The ruleset containing rule definitions and overrides
+     * @param ruleName - The name of this rule
+     * @returns The global rule info with node and child-node overrides
+     */
     getRuleInfo(ruleSet: Ruleset, ruleName: string): GlobalRuleInfo<T, O>;
+    /**
+     * Normalizes a raw rule setting into a fully resolved {@link RuleInfo} object,
+     * applying defaults for any unspecified fields.
+     *
+     * @param configSettings - The raw rule configuration value
+     * @returns The resolved rule info with defaults applied
+     */
     optimizeOption(configSettings: Rule<T, O> | null | undefined): RuleInfo<T, O>;
+    /**
+     * Executes this rule's verify (and optionally fix) function against a document,
+     * then collects and returns the resulting violations.
+     *
+     * @param document - The parsed document to verify
+     * @param locale - The locale set for translating violation messages
+     * @param fix - Whether to also run the fix function
+     * @returns An array of violations found by this rule
+     */
     verify(document: MLDocument<T, O>, locale: LocaleSet, fix: boolean): Promise<Violation[]>;
     private _optimize;
 }
+/**
+ * An MLRule with any value and option types. Used when the specific types are not known.
+ */
 export type AnyMLRule = MLRule<RuleConfigValue, PlainData>;