@herb-tools/linter 0.7.5 → 0.8.0

package/dist/types/linter.d.ts

@@ -1,20 +1,89 @@
-import type { RuleClass, Rule, LexerRule, SourceRule, LintResult, LintOffense, LintContext } from "./types.js";
+import type { RuleClass, Rule, LexerRule, SourceRule, LintResult, LintOffense, UnboundLintOffense, LintContext, AutofixResult } from "./types.js";
 import type { HerbBackend } from "@herb-tools/core";
+import type { RuleConfig, Config } from "@herb-tools/config";
+export interface LinterOptions {
+    /**
+     * Array of rule classes to use. If not provided, uses default rules.
+     */
+    rules?: RuleClass[];
+    /**
+     * Whether to load custom rules from the project.
+     * Defaults to false for backward compatibility.
+     */
+    loadCustomRules?: boolean;
+    /**
+     * Base directory to search for custom rules.
+     * Defaults to current working directory.
+     */
+    customRulesBaseDir?: string;
+    /**
+     * Custom glob patterns to search for rule files.
+     */
+    customRulesPatterns?: string[];
+    /**
+     * Whether to suppress custom rule loading errors.
+     * Defaults to false.
+     */
+    silentCustomRules?: boolean;
+}
 export declare class Linter {
     protected rules: RuleClass[];
+    protected allAvailableRules: RuleClass[];
     protected herb: HerbBackend;
     protected offenses: LintOffense[];
+    protected config?: Config;
+    /**
+     * Creates a new Linter instance with automatic rule filtering based on config.
+     *
+     * @param herb - The Herb backend instance for parsing and lexing
+     * @param config - Optional full Config instance for rule filtering, severity overrides, and path-based filtering
+     * @param customRules - Optional array of custom rules to include alongside built-in rules
+     * @returns A configured Linter instance
+     */
+    static from(herb: HerbBackend, config?: Config, customRules?: RuleClass[]): Linter;
     /**
      * Creates a new Linter instance.
+     *
+     * For most use cases, prefer `Linter.from()` which handles config-based filtering.
+     * Use this constructor directly when you need explicit control over rules.
+     *
      * @param herb - The Herb backend instance for parsing and lexing
      * @param rules - Array of rule classes (Parser/AST or Lexer) to use. If not provided, uses default rules.
+     * @param config - Optional full Config instance for severity overrides and path-based rule filtering
+     * @param allAvailableRules - Optional array of ALL available rules (including disabled) for herb:disable validation
+     */
+    constructor(herb: HerbBackend, rules?: RuleClass[], config?: Config, allAvailableRules?: RuleClass[]);
+    /**
+     * Filters rules based on default config and optional user config overrides.
+     *
+     * Priority:
+     * 1. User config override (if rule config exists in userRulesConfig)
+     * 2. Default config from rule's defaultConfig getter
+     *
+     * @param allRules - All available rule classes to filter from
+     * @param userRulesConfig - Optional user configuration for rules
+     * @returns Filtered array of rule classes that should be enabled
      */
-    constructor(herb: HerbBackend, rules?: RuleClass[]);
+    static filterRulesByConfig(allRules: RuleClass[], userRulesConfig?: Record<string, RuleConfig>): RuleClass[];
     /**
      * Returns the default set of rule classes used by the linter.
-     * @returns Array of rule classes
+     * These are the rules enabled when no custom rules are provided.
+     * Filters all available rules to only include those enabled by default.
+     * @returns Array of default rule classes
      */
     protected getDefaultRules(): RuleClass[];
+    /**
+     * Returns all available rule classes that can be referenced in herb:disable comments.
+     * This includes all rules that exist, regardless of whether they're currently enabled.
+     * Includes both built-in rules and any loaded custom rules.
+     * @returns Array of all available rule classes
+     */
+    protected getAvailableRules(): RuleClass[];
+    /**
+     * Meta-linting rules for herb:disable comments cannot be disabled
+     * This ensures that invalid herb:disable comments are always caught
+     */
+    protected get nonExcludableRules(): string[];
     getRuleCount(): number;
     /**
      * Type guard to check if a rule is a LexerRule
@@ -24,10 +93,37 @@ export declare class Linter {
      * Type guard to check if a rule is a SourceRule
      */
     protected isSourceRule(rule: Rule): rule is SourceRule;
+    /**
+     * Execute a single rule and return its unbound offenses.
+     * Handles rule type checking (Lexer/Parser/Source) and isEnabled checks.
+     */
+    private executeRule;
+    private filterOffenses;
     /**
      * Lint source code using Parser/AST, Lexer, and Source rules.
      * @param source - The source code to lint
      * @param context - Optional context for linting (e.g., fileName for distinguishing files vs snippets)
      */
     lint(source: string, context?: Partial<LintContext>): LintResult;
+    /**
+     * Bind severity to unbound offenses based on rule's defaultConfig and user config overrides.
+     *
+     * Priority:
+     * 1. User config severity override (if specified in config)
+     * 2. Rule's default severity (from defaultConfig.severity)
+     *
+     * @param unboundOffenses - Array of offenses without severity
+     * @param ruleName - Name of the rule that produced the offenses
+     * @returns Array of offenses with severity bound
+     */
+    protected bindSeverity(unboundOffenses: UnboundLintOffense[], ruleName: string): LintOffense[];
+    /**
+     * Automatically fix offenses in the source code.
+     * Uses AST mutation for parser rules and token mutation for lexer rules.
+     * @param source - The source code to fix
+     * @param context - Optional context for linting (e.g., fileName)
+     * @param offensesToFix - Optional array of specific offenses to fix. If not provided, all fixable offenses will be fixed.
+     * @returns AutofixResult containing the corrected source and lists of fixed/unfixed offenses
+     */
+    autofix(source: string, context?: Partial<LintContext>, offensesToFix?: LintOffense[]): AutofixResult;
 }

package/dist/types/loader.d.ts

@@ -0,0 +1,20 @@
+export * from "./index.js";
+export { CustomRuleLoader } from "./custom-rule-loader.js";
+export type { CustomRuleLoaderOptions } from "./custom-rule-loader.js";
+import type { RuleClass } from "./types.js";
+/**
+ * Loads custom rules from the filesystem.
+ * Only available in Node.js environments.
+ */
+export declare function loadCustomRules(options?: {
+    baseDir?: string;
+    patterns?: string[];
+    silent?: boolean;
+}): Promise<{
+    rules: RuleClass[];
+    ruleInfo: Array<{
+        name: string;
+        path: string;
+    }>;
+    warnings: string[];
+}>;

package/dist/types/rules/erb-comment-syntax.d.ts

@@ -1,7 +1,14 @@
-import { ParserRule } from "../types.js";
-import type { LintOffense, LintContext } from "../types.js";
-import type { ParseResult } from "@herb-tools/core";
-export declare class ERBCommentSyntax extends ParserRule {
+import { ParserRule, BaseAutofixContext, Mutable } from "../types.js";
+import type { UnboundLintOffense, LintOffense, LintContext, FullRuleConfig } from "../types.js";
+import type { ParseResult, ERBContentNode } from "@herb-tools/core";
+interface ERBCommentSyntaxAutofixContext extends BaseAutofixContext {
+    node: Mutable<ERBContentNode>;
+}
+export declare class ERBCommentSyntax extends ParserRule<ERBCommentSyntaxAutofixContext> {
+    static autocorrectable: boolean;
     name: string;
-    check(result: ParseResult, context?: Partial<LintContext>): LintOffense[];
+    get defaultConfig(): FullRuleConfig;
+    check(result: ParseResult, context?: Partial<LintContext>): UnboundLintOffense<ERBCommentSyntaxAutofixContext>[];
+    autofix(offense: LintOffense<ERBCommentSyntaxAutofixContext>, result: ParseResult, _context?: Partial<LintContext>): ParseResult | null;
 }
+export {};

package/dist/types/rules/erb-no-case-node-children.d.ts

@@ -0,0 +1,8 @@
+import { ParserRule } from "../types.js";
+import type { UnboundLintOffense, LintContext, FullRuleConfig } from "../types.js";
+import type { ParseResult } from "@herb-tools/core";
+export declare class ERBNoCaseNodeChildrenRule extends ParserRule {
+    name: string;
+    get defaultConfig(): FullRuleConfig;
+    check(result: ParseResult, context?: Partial<LintContext>): UnboundLintOffense[];
+}

package/dist/types/rules/erb-no-empty-tags.d.ts

@@ -1,7 +1,8 @@
 import { ParserRule } from "../types.js";
-import type { LintOffense, LintContext } from "../types.js";
+import type { UnboundLintOffense, LintContext, FullRuleConfig } from "../types.js";
 import type { ParseResult } from "@herb-tools/core";
 export declare class ERBNoEmptyTagsRule extends ParserRule {
     name: string;
-    check(result: ParseResult, context?: Partial<LintContext>): LintOffense[];
+    get defaultConfig(): FullRuleConfig;
+    check(result: ParseResult, context?: Partial<LintContext>): UnboundLintOffense[];
 }

package/dist/types/rules/erb-no-extra-newline.d.ts

@@ -0,0 +1,14 @@
+import { SourceRule } from "../types.js";
+import type { UnboundLintOffense, LintOffense, LintContext, BaseAutofixContext, FullRuleConfig } from "../types.js";
+interface ERBNoExtraNewLineAutofixContext extends BaseAutofixContext {
+    startOffset: number;
+    endOffset: number;
+}
+export declare class ERBNoExtraNewLineRule extends SourceRule {
+    static autocorrectable: boolean;
+    name: string;
+    get defaultConfig(): FullRuleConfig;
+    check(source: string, context?: Partial<LintContext>): UnboundLintOffense[];
+    autofix(offense: LintOffense<ERBNoExtraNewLineAutofixContext>, source: string, _context?: Partial<LintContext>): string | null;
+}
+export {};

package/dist/types/rules/erb-no-extra-whitespace-inside-tags.d.ts

@@ -0,0 +1,18 @@
+import { ParserRule, BaseAutofixContext, Mutable } from "../types.js";
+import type { ParseResult, Token, ERBNode } from "@herb-tools/core";
+import type { UnboundLintOffense, LintOffense, LintContext, FullRuleConfig } from "../types.js";
+interface ERBNoExtraWhitespaceAutofixContext extends BaseAutofixContext {
+    node: Mutable<ERBNode>;
+    openTag: Token;
+    closeTag: Token;
+    content: string;
+    fixType: "after-open" | "before-close" | "after-comment-equals";
+}
+export declare class ERBNoExtraWhitespaceRule extends ParserRule<ERBNoExtraWhitespaceAutofixContext> {
+    static autocorrectable: boolean;
+    name: string;
+    get defaultConfig(): FullRuleConfig;
+    check(result: ParseResult, context?: Partial<LintContext>): UnboundLintOffense<ERBNoExtraWhitespaceAutofixContext>[];
+    autofix(offense: LintOffense<ERBNoExtraWhitespaceAutofixContext>, result: ParseResult, _context?: Partial<LintContext>): ParseResult | null;
+}
+export {};

package/dist/types/rules/erb-no-output-control-flow.d.ts

@@ -1,7 +1,8 @@
 import type { ParseResult } from "@herb-tools/core";
 import { ParserRule } from "../types.js";
-import type { LintOffense, LintContext } from "../types.js";
+import type { UnboundLintOffense, LintContext, FullRuleConfig } from "../types.js";
 export declare class ERBNoOutputControlFlowRule extends ParserRule {
     name: string;
-    check(result: ParseResult, context?: Partial<LintContext>): LintOffense[];
+    get defaultConfig(): FullRuleConfig;
+    check(result: ParseResult, context?: Partial<LintContext>): UnboundLintOffense[];
 }

package/dist/types/rules/erb-no-silent-tag-in-attribute-name.d.ts

@@ -1,7 +1,8 @@
 import { ParserRule } from "../types.js";
-import type { LintOffense, LintContext } from "../types.js";
+import type { UnboundLintOffense, LintContext, FullRuleConfig } from "../types.js";
 import type { ParseResult } from "@herb-tools/core";
 export declare class ERBNoSilentTagInAttributeNameRule extends ParserRule {
     name: string;
-    check(result: ParseResult, context?: Partial<LintContext>): LintOffense[];
+    get defaultConfig(): FullRuleConfig;
+    check(result: ParseResult, context?: Partial<LintContext>): UnboundLintOffense[];
 }

package/dist/types/rules/erb-prefer-image-tag-helper.d.ts

@@ -1,7 +1,8 @@
 import { ParserRule } from "../types.js";
-import type { LintOffense, LintContext } from "../types.js";
+import type { UnboundLintOffense, LintContext, FullRuleConfig } from "../types.js";
 import type { ParseResult } from "@herb-tools/core";
 export declare class ERBPreferImageTagHelperRule extends ParserRule {
     name: string;
-    check(result: ParseResult, context?: Partial<LintContext>): LintOffense[];
+    get defaultConfig(): FullRuleConfig;
+    check(result: ParseResult, context?: Partial<LintContext>): UnboundLintOffense[];
 }

package/dist/types/rules/erb-require-trailing-newline.d.ts

@@ -0,0 +1,9 @@
+import { SourceRule } from "../types.js";
+import type { UnboundLintOffense, LintOffense, LintContext, FullRuleConfig } from "../types.js";
+export declare class ERBRequireTrailingNewlineRule extends SourceRule {
+    static autocorrectable: boolean;
+    name: string;
+    get defaultConfig(): FullRuleConfig;
+    check(source: string, context?: Partial<LintContext>): UnboundLintOffense[];
+    autofix(_offense: LintOffense, source: string, _context?: Partial<LintContext>): string | null;
+}

package/dist/types/rules/erb-require-whitespace-inside-tags.d.ts

@@ -1,7 +1,18 @@
-import { ParserRule } from "../types.js";
-import type { LintOffense, LintContext } from "../types.js";
-import type { ParseResult } from "@herb-tools/core";
-export declare class ERBRequireWhitespaceRule extends ParserRule {
+import { ParserRule, BaseAutofixContext, Mutable } from "../types.js";
+import type { ParseResult, Token, ERBNode } from "@herb-tools/core";
+import type { UnboundLintOffense, LintOffense, LintContext, FullRuleConfig } from "../types.js";
+interface ERBRequireWhitespaceAutofixContext extends BaseAutofixContext {
+    node: Mutable<ERBNode>;
+    openTag: Token;
+    closeTag: Token;
+    content: string;
+    fixType: "after-open" | "before-close" | "after-comment-equals";
+}
+export declare class ERBRequireWhitespaceRule extends ParserRule<ERBRequireWhitespaceAutofixContext> {
+    static autocorrectable: boolean;
     name: string;
-    check(result: ParseResult, context?: Partial<LintContext>): LintOffense[];
+    get defaultConfig(): FullRuleConfig;
+    check(result: ParseResult, context?: Partial<LintContext>): UnboundLintOffense<ERBRequireWhitespaceAutofixContext>[];
+    autofix(offense: LintOffense<ERBRequireWhitespaceAutofixContext>, result: ParseResult, _context?: Partial<LintContext>): ParseResult | null;
 }
+export {};

package/dist/types/rules/erb-right-trim.d.ts

@@ -1,7 +1,14 @@
-import { ParserRule } from "../types.js";
-import type { LintOffense, LintContext } from "../types.js";
-import type { ParseResult } from "@herb-tools/core";
-export declare class ERBRightTrimRule extends ParserRule {
+import { ParserRule, BaseAutofixContext, Mutable } from "../types.js";
+import type { UnboundLintOffense, LintOffense, LintContext, FullRuleConfig } from "../types.js";
+import type { ERBNode, ParseResult } from "@herb-tools/core";
+interface ERBRightTrimAutofixContext extends BaseAutofixContext {
+    node: Mutable<ERBNode>;
+}
+export declare class ERBRightTrimRule extends ParserRule<ERBRightTrimAutofixContext> {
+    static autocorrectable: boolean;
     name: string;
-    check(result: ParseResult, context?: Partial<LintContext>): LintOffense[];
+    get defaultConfig(): FullRuleConfig;
+    check(result: ParseResult, context?: Partial<LintContext>): UnboundLintOffense<ERBRightTrimAutofixContext>[];
+    autofix(offense: LintOffense<ERBRightTrimAutofixContext>, result: ParseResult, _context?: Partial<LintContext>): ParseResult | null;
 }
+export {};

package/dist/types/rules/herb-disable-comment-base.d.ts

@@ -0,0 +1,37 @@
+import { BaseRuleVisitor } from "./rule-utils.js";
+import { ERBContentNode, Location } from "@herb-tools/core";
+import type { LintContext } from "../types.js";
+import type { HerbDisableComment, HerbDisableRuleName } from "../herb-disable-comment-utils.js";
+/**
+ * Base visitor class for herb:disable comment validation rules.
+ * Handles common patterns like checking ERB comments and parsing herb:disable content.
+ */
+export declare abstract class HerbDisableCommentBaseVisitor extends BaseRuleVisitor {
+    constructor(ruleName: string, context?: Partial<LintContext>);
+    visitERBContentNode(node: ERBContentNode): void;
+    /**
+     * Override this method to implement rule-specific logic.
+     * This is called for every ERB comment node.
+     */
+    protected abstract checkHerbDisableComment(node: ERBContentNode, content: string): void;
+    /**
+     * Helper to create a precise location for a specific rule name within the comment.
+     * Returns null if content location is not available.
+     */
+    protected createRuleNameLocation(node: ERBContentNode, ruleDetail: HerbDisableRuleName): Location | null;
+    /**
+     * Helper to add an offense with a fallback to node location if precise location unavailable.
+     */
+    protected addOffenseWithFallback(message: string, preciseLocation: Location | null, node: ERBContentNode): void;
+}
+/**
+ * Base visitor for rules that need to process parsed herb:disable comments.
+ * Only calls the abstract method if the content successfully parses as a herb:disable comment.
+ */
+export declare abstract class HerbDisableCommentParsedVisitor extends HerbDisableCommentBaseVisitor {
+    protected checkHerbDisableComment(node: ERBContentNode, content: string): void;
+    /**
+     * Override this method to implement rule-specific logic for parsed herb:disable comments.
+     */
+    protected abstract checkParsedHerbDisable(node: ERBContentNode, content: string, herbDisable: HerbDisableComment): void;
+}

package/dist/types/rules/herb-disable-comment-malformed.d.ts

@@ -0,0 +1,8 @@
+import { ParserRule } from "../types.js";
+import type { UnboundLintOffense, LintContext, FullRuleConfig } from "../types.js";
+import type { ParseResult } from "@herb-tools/core";
+export declare class HerbDisableCommentMalformedRule extends ParserRule {
+    name: string;
+    get defaultConfig(): FullRuleConfig;
+    check(result: ParseResult, context?: Partial<LintContext>): UnboundLintOffense[];
+}

package/dist/types/rules/herb-disable-comment-missing-rules.d.ts

@@ -0,0 +1,8 @@
+import { ParserRule } from "../types.js";
+import type { UnboundLintOffense, LintContext, FullRuleConfig } from "../types.js";
+import type { ParseResult } from "@herb-tools/core";
+export declare class HerbDisableCommentMissingRulesRule extends ParserRule {
+    name: string;
+    get defaultConfig(): FullRuleConfig;
+    check(result: ParseResult, context?: Partial<LintContext>): UnboundLintOffense[];
+}

package/dist/types/rules/herb-disable-comment-no-duplicate-rules.d.ts

@@ -0,0 +1,8 @@
+import { ParserRule } from "../types.js";
+import type { UnboundLintOffense, LintContext, FullRuleConfig } from "../types.js";
+import type { ParseResult } from "@herb-tools/core";
+export declare class HerbDisableCommentNoDuplicateRulesRule extends ParserRule {
+    name: string;
+    get defaultConfig(): FullRuleConfig;
+    check(result: ParseResult, context?: Partial<LintContext>): UnboundLintOffense[];
+}

package/dist/types/rules/herb-disable-comment-no-redundant-all.d.ts

@@ -0,0 +1,8 @@
+import { ParserRule } from "../types.js";
+import type { UnboundLintOffense, LintContext, FullRuleConfig } from "../types.js";
+import type { ParseResult } from "@herb-tools/core";
+export declare class HerbDisableCommentNoRedundantAllRule extends ParserRule {
+    name: string;
+    get defaultConfig(): FullRuleConfig;
+    check(result: ParseResult, context?: Partial<LintContext>): UnboundLintOffense[];
+}

package/dist/types/rules/herb-disable-comment-unnecessary.d.ts

@@ -0,0 +1,8 @@
+import { ParserRule } from "../types.js";
+import type { UnboundLintOffense, LintContext, FullRuleConfig } from "../types.js";
+import type { ParseResult } from "@herb-tools/core";
+export declare class HerbDisableCommentUnnecessaryRule extends ParserRule {
+    name: string;
+    get defaultConfig(): FullRuleConfig;
+    check(result: ParseResult, context?: Partial<LintContext>): UnboundLintOffense[];
+}

package/dist/types/rules/herb-disable-comment-valid-rule-name.d.ts

@@ -0,0 +1,8 @@
+import { ParserRule } from "../types.js";
+import type { UnboundLintOffense, LintContext, FullRuleConfig } from "../types.js";
+import type { ParseResult } from "@herb-tools/core";
+export declare class HerbDisableCommentValidRuleNameRule extends ParserRule {
+    name: string;
+    get defaultConfig(): FullRuleConfig;
+    check(result: ParseResult, context?: Partial<LintContext>): UnboundLintOffense[];
+}

package/dist/types/rules/html-anchor-require-href.d.ts

@@ -1,7 +1,8 @@
 import { ParserRule } from "../types.js";
-import type { LintOffense, LintContext } from "../types.js";
+import type { UnboundLintOffense, LintContext, FullRuleConfig } from "../types.js";
 import type { ParseResult } from "@herb-tools/core";
 export declare class HTMLAnchorRequireHrefRule extends ParserRule {
     name: string;
-    check(result: ParseResult, context?: Partial<LintContext>): LintOffense[];
+    get defaultConfig(): FullRuleConfig;
+    check(result: ParseResult, context?: Partial<LintContext>): UnboundLintOffense[];
 }

package/dist/types/rules/html-aria-attribute-must-be-valid.d.ts

@@ -1,7 +1,8 @@
 import { ParserRule } from "../types.js";
-import type { LintOffense, LintContext } from "../types.js";
+import type { UnboundLintOffense, LintContext, FullRuleConfig } from "../types.js";
 import type { ParseResult } from "@herb-tools/core";
 export declare class HTMLAriaAttributeMustBeValid extends ParserRule {
     name: string;
-    check(result: ParseResult, context?: Partial<LintContext>): LintOffense[];
+    get defaultConfig(): FullRuleConfig;
+    check(result: ParseResult, context?: Partial<LintContext>): UnboundLintOffense[];
 }

package/dist/types/rules/html-aria-label-is-well-formatted.d.ts

@@ -1,7 +1,8 @@
 import { ParserRule } from "../types.js";
-import type { LintOffense, LintContext } from "../types.js";
+import type { UnboundLintOffense, LintContext, FullRuleConfig } from "../types.js";
 import type { ParseResult } from "@herb-tools/core";
 export declare class HTMLAriaLabelIsWellFormattedRule extends ParserRule {
     name: string;
-    check(result: ParseResult, context?: Partial<LintContext>): LintOffense[];
+    get defaultConfig(): FullRuleConfig;
+    check(result: ParseResult, context?: Partial<LintContext>): UnboundLintOffense[];
 }

package/dist/types/rules/html-aria-level-must-be-valid.d.ts

@@ -1,7 +1,8 @@
 import { ParserRule } from "../types.js";
-import type { LintOffense, LintContext } from "../types.js";
+import type { UnboundLintOffense, LintContext, FullRuleConfig } from "../types.js";
 import type { ParseResult } from "@herb-tools/core";
 export declare class HTMLAriaLevelMustBeValidRule extends ParserRule {
     name: string;
-    check(result: ParseResult, context?: Partial<LintContext>): LintOffense[];
+    get defaultConfig(): FullRuleConfig;
+    check(result: ParseResult, context?: Partial<LintContext>): UnboundLintOffense[];
 }

package/dist/types/rules/html-aria-role-heading-requires-level.d.ts

@@ -1,7 +1,8 @@
 import { ParserRule } from "../types.js";
-import type { LintOffense, LintContext } from "../types.js";
+import type { UnboundLintOffense, LintContext, FullRuleConfig } from "../types.js";
 import type { ParseResult } from "@herb-tools/core";
 export declare class HTMLAriaRoleHeadingRequiresLevelRule extends ParserRule {
     name: string;
-    check(result: ParseResult, context?: Partial<LintContext>): LintOffense[];
+    get defaultConfig(): FullRuleConfig;
+    check(result: ParseResult, context?: Partial<LintContext>): UnboundLintOffense[];
 }

package/dist/types/rules/html-aria-role-must-be-valid.d.ts

@@ -1,7 +1,8 @@
 import { ParserRule } from "../types.js";
-import type { LintOffense, LintContext } from "../types.js";
+import type { UnboundLintOffense, LintContext, FullRuleConfig } from "../types.js";
 import type { ParseResult } from "@herb-tools/core";
 export declare class HTMLAriaRoleMustBeValidRule extends ParserRule {
     name: string;
-    check(result: ParseResult, context?: Partial<LintContext>): LintOffense[];
+    get defaultConfig(): FullRuleConfig;
+    check(result: ParseResult, context?: Partial<LintContext>): UnboundLintOffense[];
 }

package/dist/types/rules/html-attribute-double-quotes.d.ts

@@ -1,7 +1,15 @@
-import { ParserRule } from "../types.js";
-import type { LintOffense, LintContext } from "../types.js";
-import type { ParseResult } from "@herb-tools/core";
-export declare class HTMLAttributeDoubleQuotesRule extends ParserRule {
+import { ParserRule, BaseAutofixContext, Mutable } from "../types.js";
+import type { UnboundLintOffense, LintOffense, LintContext, FullRuleConfig } from "../types.js";
+import type { ParseResult, HTMLAttributeNode } from "@herb-tools/core";
+interface AttributeDoubleQuotesAutofixContext extends BaseAutofixContext {
+    node: Mutable<HTMLAttributeNode>;
+    valueContent: string;
+}
+export declare class HTMLAttributeDoubleQuotesRule extends ParserRule<AttributeDoubleQuotesAutofixContext> {
+    static autocorrectable: boolean;
     name: string;
-    check(result: ParseResult, context?: Partial<LintContext>): LintOffense[];
+    get defaultConfig(): FullRuleConfig;
+    check(result: ParseResult, context?: Partial<LintContext>): UnboundLintOffense<AttributeDoubleQuotesAutofixContext>[];
+    autofix(offense: LintOffense<AttributeDoubleQuotesAutofixContext>, result: ParseResult, _context?: Partial<LintContext>): ParseResult | null;
 }
+export {};

package/dist/types/rules/html-attribute-equals-spacing.d.ts

@@ -1,7 +1,14 @@
-import { ParserRule } from "../types.js";
-import type { LintOffense, LintContext } from "../types.js";
-import type { ParseResult } from "@herb-tools/core";
-export declare class HTMLAttributeEqualsSpacingRule extends ParserRule {
+import { ParserRule, BaseAutofixContext, Mutable } from "../types.js";
+import type { UnboundLintOffense, LintOffense, LintContext, FullRuleConfig } from "../types.js";
+import type { ParseResult, HTMLAttributeNode } from "@herb-tools/core";
+interface AttributeEqualsSpacingAutofixContext extends BaseAutofixContext {
+    node: Mutable<HTMLAttributeNode>;
+}
+export declare class HTMLAttributeEqualsSpacingRule extends ParserRule<AttributeEqualsSpacingAutofixContext> {
+    static autocorrectable: boolean;
     name: string;
-    check(result: ParseResult, context?: Partial<LintContext>): LintOffense[];
+    get defaultConfig(): FullRuleConfig;
+    check(result: ParseResult, context?: Partial<LintContext>): UnboundLintOffense<AttributeEqualsSpacingAutofixContext>[];
+    autofix(offense: LintOffense<AttributeEqualsSpacingAutofixContext>, result: ParseResult, _context?: Partial<LintContext>): ParseResult | null;
 }
+export {};

package/dist/types/rules/html-attribute-values-require-quotes.d.ts

@@ -1,7 +1,15 @@
-import { ParserRule } from "../types.js";
-import type { LintOffense, LintContext } from "../types.js";
-import type { ParseResult } from "@herb-tools/core";
-export declare class HTMLAttributeValuesRequireQuotesRule extends ParserRule {
+import { ParserRule, BaseAutofixContext, Mutable } from "../types.js";
+import type { UnboundLintOffense, LintOffense, LintContext, FullRuleConfig } from "../types.js";
+import type { HTMLAttributeNode, ParseResult } from "@herb-tools/core";
+interface AttributeValuesRequireQuotesAutofixContext extends BaseAutofixContext {
+    node: Mutable<HTMLAttributeNode>;
+    unquotedValue: string;
+}
+export declare class HTMLAttributeValuesRequireQuotesRule extends ParserRule<AttributeValuesRequireQuotesAutofixContext> {
+    static autocorrectable: boolean;
     name: string;
-    check(result: ParseResult, context?: Partial<LintContext>): LintOffense[];
+    get defaultConfig(): FullRuleConfig;
+    check(result: ParseResult, context?: Partial<LintContext>): UnboundLintOffense<AttributeValuesRequireQuotesAutofixContext>[];
+    autofix(offense: LintOffense<AttributeValuesRequireQuotesAutofixContext>, result: ParseResult, _context?: Partial<LintContext>): ParseResult | null;
 }
+export {};

package/dist/types/rules/html-avoid-both-disabled-and-aria-disabled.d.ts

@@ -1,7 +1,8 @@
 import { ParserRule } from "../types.js";
-import type { LintOffense, LintContext } from "../types.js";
+import type { UnboundLintOffense, LintContext, FullRuleConfig } from "../types.js";
 import type { ParseResult } from "@herb-tools/core";
 export declare class HTMLAvoidBothDisabledAndAriaDisabledRule extends ParserRule {
     name: string;
-    check(result: ParseResult, context?: Partial<LintContext>): LintOffense[];
+    get defaultConfig(): FullRuleConfig;
+    check(result: ParseResult, context?: Partial<LintContext>): UnboundLintOffense[];
 }

package/dist/types/rules/html-body-only-elements.d.ts

@@ -0,0 +1,9 @@
+import { ParserRule } from "../types.js";
+import type { UnboundLintOffense, LintContext, FullRuleConfig } from "../types.js";
+import type { ParseResult } from "@herb-tools/core";
+export declare class HTMLBodyOnlyElementsRule extends ParserRule {
+    static autocorrectable: boolean;
+    name: string;
+    get defaultConfig(): FullRuleConfig;
+    check(result: ParseResult, context?: Partial<LintContext>): UnboundLintOffense[];
+}

package/dist/types/rules/html-boolean-attributes-no-value.d.ts

@@ -1,7 +1,14 @@
-import { ParserRule } from "../types.js";
-import type { LintOffense, LintContext } from "../types.js";
-import type { ParseResult } from "@herb-tools/core";
-export declare class HTMLBooleanAttributesNoValueRule extends ParserRule {
+import { ParserRule, BaseAutofixContext, Mutable } from "../types.js";
+import type { UnboundLintOffense, LintOffense, LintContext, FullRuleConfig } from "../types.js";
+import type { ParseResult, HTMLAttributeNode } from "@herb-tools/core";
+interface BooleanAttributeAutofixContext extends BaseAutofixContext {
+    node: Mutable<HTMLAttributeNode>;
+}
+export declare class HTMLBooleanAttributesNoValueRule extends ParserRule<BooleanAttributeAutofixContext> {
+    static autocorrectable: boolean;
     name: string;
-    check(result: ParseResult, context?: Partial<LintContext>): LintOffense[];
+    get defaultConfig(): FullRuleConfig;
+    check(result: ParseResult, context?: Partial<LintContext>): UnboundLintOffense<BooleanAttributeAutofixContext>[];
+    autofix(offense: LintOffense<BooleanAttributeAutofixContext>, result: ParseResult, _context?: Partial<LintContext>): ParseResult | null;
 }
+export {};

package/dist/types/rules/html-head-only-elements.d.ts

@@ -0,0 +1,9 @@
+import { ParserRule } from "../types";
+import type { ParseResult } from "@herb-tools/core";
+import type { UnboundLintOffense, LintContext, FullRuleConfig } from "../types";
+export declare class HTMLHeadOnlyElementsRule extends ParserRule {
+    static autocorrectable: boolean;
+    name: string;
+    get defaultConfig(): FullRuleConfig;
+    check(result: ParseResult, context?: Partial<LintContext>): UnboundLintOffense[];
+}

package/dist/types/rules/html-iframe-has-title.d.ts

@@ -1,7 +1,8 @@
 import { ParserRule } from "../types.js";
-import type { LintOffense, LintContext } from "../types.js";
+import type { UnboundLintOffense, LintContext, FullRuleConfig } from "../types.js";
 import type { ParseResult } from "@herb-tools/core";
 export declare class HTMLIframeHasTitleRule extends ParserRule {
     name: string;
-    check(result: ParseResult, context?: Partial<LintContext>): LintOffense[];
+    get defaultConfig(): FullRuleConfig;
+    check(result: ParseResult, context?: Partial<LintContext>): UnboundLintOffense[];
 }