@herb-tools/linter 0.7.5 → 0.8.0

package/dist/types/src/cli.d.ts

@@ -1,6 +1,8 @@
-import { ArgumentParser, type FormatOption } from "./cli/argument-parser.js";
+import { Config } from "@herb-tools/config";
+import { ArgumentParser } from "./cli/argument-parser.js";
 import { FileProcessor } from "./cli/file-processor.js";
 import { OutputManager } from "./cli/output-manager.js";
+import type { FormatOption } from "./cli/argument-parser.js";
 export * from "./cli/index.js";
 export declare class CLI {
     protected argumentParser: ArgumentParser;
@@ -8,15 +10,18 @@ export declare class CLI {
     protected outputManager: OutputManager;
     protected projectPath: string;
     getProjectPath(): string;
-    protected findProjectRoot(startPath: string): string;
     protected exitWithError(message: string, formatOption: FormatOption, exitCode?: number): void;
     protected exitWithInfo(message: string, formatOption: FormatOption, exitCode?: number, timingData?: {
         startTime: number;
         startDate: Date;
         showTiming: boolean;
     }): void;
-    protected determineProjectPath(pattern: string | undefined): void;
-    protected adjustPattern(pattern: string | undefined): string;
+    protected determineProjectPath(patterns: string[]): void;
+    protected adjustPattern(pattern: string | undefined, configGlobPattern: string): string;
+    protected resolvePatternToFiles(pattern: string, config: Config, force: boolean): Promise<{
+        files: string[];
+        explicitFile: string | undefined;
+    }>;
     protected beforeProcess(): Promise<void>;
     protected afterProcess(_results: any, _outputOptions: any): Promise<void>;
     run(): Promise<void>;

package/dist/types/src/custom-rule-loader.d.ts

@@ -0,0 +1,62 @@
+import type { RuleClass } from "./types.js";
+export interface CustomRuleLoaderOptions {
+    /**
+     * Base directory to search for custom rules
+     * Defaults to current working directory
+     */
+    baseDir?: string;
+    /**
+     * Glob patterns to search for custom rule files
+     * Defaults to looking in common locations
+     */
+    patterns?: string[];
+    /**
+     * Whether to suppress errors when loading custom rules
+     * Defaults to false
+     */
+    silent?: boolean;
+}
+/**
+ * Loads custom linter rules from the user's project
+ */
+export declare class CustomRuleLoader {
+    private baseDir;
+    private patterns;
+    private silent;
+    constructor(options?: CustomRuleLoaderOptions);
+    /**
+     * Discovers custom rule files in the project
+     */
+    discoverRuleFiles(): Promise<string[]>;
+    /**
+     * Loads a single rule file
+     */
+    loadRuleFile(filePath: string): Promise<RuleClass[]>;
+    /**
+     * Type guard to check if an export is a valid rule class
+     */
+    private isValidRuleClass;
+    /**
+     * Loads all custom rules from the project
+     */
+    loadRules(): Promise<RuleClass[]>;
+    /**
+     * Loads all custom rules and returns detailed information about each rule
+     */
+    loadRulesWithInfo(): Promise<{
+        rules: RuleClass[];
+        ruleInfo: Array<{
+            name: string;
+            path: string;
+        }>;
+        duplicateWarnings: string[];
+    }>;
+    /**
+     * Static helper to check if custom rules exist in a project
+     */
+    static hasCustomRules(baseDir?: string): Promise<boolean>;
+    /**
+     * Static helper to load custom rules and merge with default rules
+     */
+    static loadAndMergeRules(defaultRules: RuleClass[], options?: CustomRuleLoaderOptions): Promise<RuleClass[]>;
+}

package/dist/types/src/herb-disable-comment-utils.d.ts

@@ -0,0 +1,69 @@
+/**
+ * Utilities for parsing herb:disable comments
+ */
+/**
+ * Information about a single rule name in a herb:disable comment
+ */
+export interface HerbDisableRuleName {
+    /** The rule name */
+    name: string;
+    /** The starting offset of this rule name within the content/line */
+    offset: number;
+    /** The length of the rule name */
+    length: number;
+}
+/**
+ * Result of parsing a herb:disable comment
+ */
+export interface HerbDisableComment {
+    /** The full matched string */
+    match: string;
+    /** Array of rule names specified in the comment */
+    ruleNames: string[];
+    /** Array of rule name information with positions */
+    ruleNameDetails: HerbDisableRuleName[];
+    /** The original rules string (e.g., "rule1, rule2") */
+    rulesString: string;
+}
+/**
+ * Parse a herb:disable comment from ERB comment content.
+ * Use this when you have the content inside <%# ... %> (e.g., from ERBContentNode.content.value)
+ *
+ * @param content - The content string (without <%# %> delimiters)
+ * @returns Parsed comment data or null if not a valid herb:disable comment
+ *
+ * @example
+ * ```ts
+ * const result = parseHerbDisableContent("herb:disable rule1, rule2")
+ * // { match: "herb:disable rule1, rule2", ruleNames: ["rule1", "rule2"], rulesString: "rule1, rule2" }
+ * ```
+ */
+export declare function parseHerbDisableContent(content: string): HerbDisableComment | null;
+/**
+ * Parse a herb:disable comment from a full source line.
+ * Use this when you have a complete line that may contain <%# herb:disable ... %>
+ *
+ * @param line - The source line that may contain a herb:disable comment
+ * @returns Parsed comment data or null if not a valid herb:disable comment
+ *
+ * @example
+ * ```ts
+ * const result = parseHerbDisableLine("<div>test</div> <%# herb:disable rule1, rule2 %>")
+ * // { match: "<%# herb:disable rule1, rule2 %>", ruleNames: ["rule1", "rule2"], rulesString: "rule1, rule2" }
+ * ```
+ */
+export declare function parseHerbDisableLine(line: string): HerbDisableComment | null;
+/**
+ * Check if an ERB comment content contains a herb:disable directive.
+ *
+ * @param content - The content string (without <%# %> delimiters)
+ * @returns true if the content contains a herb:disable directive
+ */
+export declare function isHerbDisableContent(content: string): boolean;
+/**
+ * Check if a source line contains a herb:disable comment.
+ *
+ * @param line - The source line
+ * @returns true if the line contains a herb:disable comment
+ */
+export declare function isHerbDisableLine(line: string): boolean;

package/dist/types/src/index.d.ts

@@ -1,3 +1,4 @@
 export * from "./linter.js";
 export * from "./rules/index.js";
 export * from "./types.js";
+export { rules } from "./rules.js";

package/dist/types/src/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/src/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/src/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/src/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/src/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/src/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/src/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/src/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/src/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/src/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/src/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/src/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/src/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/src/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/src/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/src/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/src/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/src/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/src/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/src/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/src/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/src/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/src/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/src/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[];
 }