@herb-tools/linter 0.4.3 → 0.6.0

package/dist/types/rules/rule-utils.d.ts

@@ -1,5 +1,5 @@
 import { Visitor, Location } from "@herb-tools/core";
-import type { HTMLAttributeNode, HTMLOpenTagNode, HTMLSelfCloseTagNode, LexResult, Token } from "@herb-tools/core";
+import type { HTMLAttributeNode, HTMLAttributeValueNode, HTMLOpenTagNode, LexResult, Token, Node } from "@herb-tools/core";
 import type { LintOffense, LintSeverity, LintContext } from "../types.js";
 /**
  * Base visitor class that provides common functionality for rule visitors
@@ -19,17 +19,52 @@ export declare abstract class BaseRuleVisitor extends Visitor {
     protected addOffense(message: string, location: Location, severity?: LintSeverity): void;
 }
 /**
- * Gets attributes from either an HTMLOpenTagNode or HTMLSelfCloseTagNode
+ * Gets attributes from an HTMLOpenTagNode
  */
-export declare function getAttributes(node: HTMLOpenTagNode | HTMLSelfCloseTagNode): any[];
+export declare function getAttributes(node: HTMLOpenTagNode): HTMLAttributeNode[];
 /**
  * Gets the tag name from an HTML tag node (lowercased)
  */
-export declare function getTagName(node: HTMLOpenTagNode | HTMLSelfCloseTagNode): string | null;
+export declare function getTagName(node: HTMLOpenTagNode): string | null;
 /**
  * Gets the attribute name from an HTMLAttributeNode (lowercased)
+ * Returns null if the attribute name contains dynamic content (ERB)
  */
 export declare function getAttributeName(attributeNode: HTMLAttributeNode): string | null;
+/**
+ * Checks if an attribute has a dynamic (ERB-containing) name
+ */
+export declare function hasDynamicAttributeName(attributeNode: HTMLAttributeNode): boolean;
+/**
+ * Gets the combined string representation of an attribute name (for debugging)
+ * This includes both static content and ERB syntax
+ */
+export declare function getCombinedAttributeNameString(attributeNode: HTMLAttributeNode): string;
+/**
+ * Checks if an attribute value contains only static content (no ERB)
+ */
+export declare function hasStaticAttributeValue(attributeNode: HTMLAttributeNode): boolean;
+/**
+ * Checks if an attribute value contains dynamic content (ERB)
+ */
+export declare function hasDynamicAttributeValue(attributeNode: HTMLAttributeNode): boolean;
+/**
+ * Gets the static string value of an attribute (returns null if it contains ERB)
+ */
+export declare function getStaticAttributeValue(attributeNode: HTMLAttributeNode): string | null;
+/**
+ * Gets the value nodes array for dynamic inspection
+ */
+export declare function getAttributeValueNodes(attributeNode: HTMLAttributeNode): Node[];
+/**
+ * Checks if an attribute value contains any static content (for validation purposes)
+ */
+export declare function hasStaticAttributeValueContent(attributeNode: HTMLAttributeNode): boolean;
+/**
+ * Gets the static content of an attribute value (all literal parts combined)
+ * Returns the concatenated literal content, or null if no literal nodes exist
+ */
+export declare function getStaticAttributeValueContent(attributeNode: HTMLAttributeNode): string | null;
 /**
  * Gets the attribute value content from an HTMLAttributeValueNode
  */
@@ -41,20 +76,25 @@ export declare function hasAttributeValue(attributeNode: HTMLAttributeNode): boo
 /**
  * Gets the quote type used for an attribute value
  */
-export declare function getAttributeValueQuoteType(attributeNode: HTMLAttributeNode): "single" | "double" | "none" | null;
+export declare function getAttributeValueQuoteType(nodeOrAttribute: HTMLAttributeNode | HTMLAttributeValueNode): "single" | "double" | "none" | null;
 /**
  * Finds an attribute by name in a list of attributes
  */
-export declare function findAttributeByName(attributes: any[], attributeName: string): HTMLAttributeNode | null;
+export declare function findAttributeByName(attributes: Node[], attributeName: string): HTMLAttributeNode | null;
 /**
  * Checks if a tag has a specific attribute
  */
-export declare function hasAttribute(node: HTMLOpenTagNode | HTMLSelfCloseTagNode, attributeName: string): boolean;
+export declare function hasAttribute(node: HTMLOpenTagNode, attributeName: string): boolean;
+/**
+ * Checks if a tag has a specific attribute
+ */
+export declare function getAttribute(node: HTMLOpenTagNode, attributeName: string): HTMLAttributeNode | null;
 /**
  * Common HTML element categorization
  */
 export declare const HTML_INLINE_ELEMENTS: Set<string>;
 export declare const HTML_BLOCK_ELEMENTS: Set<string>;
+export declare const HTML_VOID_ELEMENTS: Set<string>;
 export declare const HTML_BOOLEAN_ATTRIBUTES: Set<string>;
 export declare const HEADING_TAGS: Set<string>;
 /**
@@ -67,6 +107,37 @@ export declare const SVG_CAMEL_CASE_ELEMENTS: Set<string>;
  */
 export declare const SVG_LOWERCASE_TO_CAMELCASE: Map<string, string>;
 export declare const VALID_ARIA_ROLES: Set<string>;
+/**
+ * Parameter types for AttributeVisitorMixin methods
+ */
+export interface StaticAttributeStaticValueParams {
+    attributeName: string;
+    attributeValue: string;
+    attributeNode: HTMLAttributeNode;
+    parentNode: HTMLOpenTagNode;
+}
+export interface StaticAttributeDynamicValueParams {
+    attributeName: string;
+    valueNodes: Node[];
+    attributeNode: HTMLAttributeNode;
+    parentNode: HTMLOpenTagNode;
+    combinedValue?: string | null;
+}
+export interface DynamicAttributeStaticValueParams {
+    nameNodes: Node[];
+    attributeValue: string;
+    attributeNode: HTMLAttributeNode;
+    parentNode: HTMLOpenTagNode;
+    combinedName?: string;
+}
+export interface DynamicAttributeDynamicValueParams {
+    nameNodes: Node[];
+    valueNodes: Node[];
+    attributeNode: HTMLAttributeNode;
+    parentNode: HTMLOpenTagNode;
+    combinedName?: string;
+    combinedValue?: string | null;
+}
 export declare const ARIA_ATTRIBUTES: Set<string>;
 /**
  * Helper function to create a location at the end of the source with a 1-character range
@@ -80,21 +151,44 @@ export declare function isInlineElement(tagName: string): boolean;
  * Checks if an element is block-level
  */
 export declare function isBlockElement(tagName: string): boolean;
+/**
+ * Checks if an element is a void element
+ */
+export declare function isVoidElement(tagName: string): boolean;
 /**
  * Checks if an attribute is a boolean attribute
  */
 export declare function isBooleanAttribute(attributeName: string): boolean;
 /**
- * Abstract base class for rules that need to check individual attributes on HTML tags
- * Eliminates duplication of visitHTMLOpenTagNode/visitHTMLSelfCloseTagNode patterns
- * and attribute iteration logic. Provides simplified interface with extracted attribute info.
+ * Attribute visitor that provides granular processing based on both
+ * attribute name type (static/dynamic) and value type (static/dynamic)
+ *
+ * This gives you 4 distinct methods to override:
+ * - checkStaticAttributeStaticValue()   - name="class" value="foo"
+ * - checkStaticAttributeDynamicValue()  - name="class" value="<%= css_class %>"
+ * - checkDynamicAttributeStaticValue()  - name="data-<%= key %>" value="foo"
+ * - checkDynamicAttributeDynamicValue() - name="data-<%= key %>" value="<%= value %>"
  */
 export declare abstract class AttributeVisitorMixin extends BaseRuleVisitor {
     constructor(ruleName: string, context?: Partial<LintContext>);
     visitHTMLOpenTagNode(node: HTMLOpenTagNode): void;
-    visitHTMLSelfCloseTagNode(node: HTMLSelfCloseTagNode): void;
     private checkAttributesOnNode;
-    protected abstract checkAttribute(attributeName: string, attributeValue: string | null, attributeNode: HTMLAttributeNode, parentNode: HTMLOpenTagNode | HTMLSelfCloseTagNode): void;
+    /**
+     * Static attribute name with static value: class="container"
+     */
+    protected checkStaticAttributeStaticValue(params: StaticAttributeStaticValueParams): void;
+    /**
+     * Static attribute name with dynamic value: class="<%= css_class %>"
+     */
+    protected checkStaticAttributeDynamicValue(params: StaticAttributeDynamicValueParams): void;
+    /**
+     * Dynamic attribute name with static value: data-<%= key %>="foo"
+     */
+    protected checkDynamicAttributeStaticValue(params: DynamicAttributeStaticValueParams): void;
+    /**
+     * Dynamic attribute name with dynamic value: data-<%= key %>="<%= value %>"
+     */
+    protected checkDynamicAttributeDynamicValue(params: DynamicAttributeDynamicValueParams): void;
 }
 /**
  * Checks if an attribute value is quoted
@@ -103,7 +197,7 @@ export declare function isAttributeValueQuoted(attributeNode: HTMLAttributeNode)
 /**
  * Iterates over all attributes of a tag node, calling the callback for each attribute
  */
-export declare function forEachAttribute(node: HTMLOpenTagNode | HTMLSelfCloseTagNode, callback: (attributeNode: HTMLAttributeNode) => void): void;
+export declare function forEachAttribute(node: HTMLOpenTagNode, callback: (attributeNode: HTMLAttributeNode) => void): void;
 /**
  * Base lexer visitor class that provides common functionality for lexer-based rule visitors
  */

package/dist/types/rules/svg-tag-name-capitalization.d.ts

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

package/dist/types/src/cli/argument-parser.d.ts

@@ -1,7 +1,8 @@
 import type { ThemeInput } from "@herb-tools/highlighter";
+export type FormatOption = "simple" | "detailed" | "json" | "github";
 export interface ParsedArguments {
     pattern: string;
-    formatOption: 'simple' | 'detailed';
+    formatOption: FormatOption;
     showTiming: boolean;
     theme: ThemeInput;
     wrapLines: boolean;

package/dist/types/src/cli/file-processor.d.ts

@@ -1,21 +1,22 @@
 import type { Diagnostic } from "@herb-tools/core";
+import type { FormatOption } from "./argument-parser.js";
 export interface ProcessedFile {
     filename: string;
-    diagnostic: Diagnostic;
+    offense: Diagnostic;
     content: string;
 }
 export interface ProcessingResult {
     totalErrors: number;
     totalWarnings: number;
-    filesWithIssues: number;
+    filesWithOffenses: number;
     ruleCount: number;
-    allDiagnostics: ProcessedFile[];
-    ruleViolations: Map<string, {
+    allOffenses: ProcessedFile[];
+    ruleOffenses: Map<string, {
         count: number;
         files: Set<string>;
     }>;
 }
 export declare class FileProcessor {
     private linter;
-    processFiles(files: string[]): Promise<ProcessingResult>;
+    processFiles(files: string[], formatOption?: FormatOption): Promise<ProcessingResult>;
 }

package/dist/types/src/cli/formatters/base-formatter.d.ts

@@ -1,6 +1,6 @@
 import type { Diagnostic } from "@herb-tools/core";
 import type { ProcessedFile } from "../file-processor.js";
 export declare abstract class BaseFormatter {
-    abstract format(allDiagnostics: ProcessedFile[], isSingleFile?: boolean): Promise<void>;
-    abstract formatFile(filename: string, diagnostics: Diagnostic[]): void;
+    abstract format(allOffenses: ProcessedFile[], isSingleFile?: boolean): Promise<void>;
+    abstract formatFile(filename: string, offenses: Diagnostic[]): void;
 }

package/dist/types/src/cli/formatters/detailed-formatter.d.ts

@@ -8,6 +8,6 @@ export declare class DetailedFormatter extends BaseFormatter {
     private wrapLines;
     private truncateLines;
     constructor(theme?: ThemeInput, wrapLines?: boolean, truncateLines?: boolean);
-    format(allDiagnostics: ProcessedFile[], isSingleFile?: boolean): Promise<void>;
-    formatFile(_filename: string, _diagnostics: Diagnostic[]): void;
+    format(allOffenses: ProcessedFile[], isSingleFile?: boolean): Promise<void>;
+    formatFile(_filename: string, _offenses: Diagnostic[]): void;
 }

package/dist/types/src/cli/formatters/github-actions-formatter.d.ts

@@ -0,0 +1,12 @@
+import { BaseFormatter } from "./base-formatter.js";
+import type { Diagnostic } from "@herb-tools/core";
+import type { ProcessedFile } from "../file-processor.js";
+export declare class GitHubActionsFormatter extends BaseFormatter {
+    private static readonly MESSAGE_ESCAPE_MAP;
+    private static readonly PARAM_ESCAPE_MAP;
+    format(allDiagnostics: ProcessedFile[]): Promise<void>;
+    formatFile(filename: string, diagnostics: Diagnostic[]): void;
+    private formatDiagnostic;
+    private escapeMessage;
+    private escapeParam;
+}

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

@@ -1,3 +1,5 @@
 export { BaseFormatter } from "./base-formatter.js";
 export { SimpleFormatter } from "./simple-formatter.js";
 export { DetailedFormatter } from "./detailed-formatter.js";
+export { JSONFormatter, type JSONOutput } from "./json-formatter.js";
+export { GitHubActionsFormatter } from "./github-actions-formatter.js";

package/dist/types/src/cli/formatters/json-formatter.d.ts

@@ -0,0 +1,42 @@
+import { BaseFormatter } from "./base-formatter.js";
+import type { Diagnostic, SerializedDiagnostic } from "@herb-tools/core";
+import type { ProcessedFile } from "../file-processor.js";
+interface JSONOffense extends SerializedDiagnostic {
+    filename: string;
+}
+interface JSONSummary {
+    filesChecked: number;
+    filesWithOffenses: number;
+    totalErrors: number;
+    totalWarnings: number;
+    totalOffenses: number;
+    ruleCount: number;
+}
+interface JSONTiming {
+    startTime: string;
+    duration: number;
+}
+export interface JSONOutput {
+    offenses: JSONOffense[];
+    summary: JSONSummary | null;
+    timing: JSONTiming | null;
+    completed: boolean;
+    clean: boolean | null;
+    message: string | null;
+}
+interface JSONFormatOptions {
+    files: string[];
+    totalErrors: number;
+    totalWarnings: number;
+    filesWithOffenses: number;
+    ruleCount: number;
+    startTime: number;
+    startDate: Date;
+    showTiming: boolean;
+}
+export declare class JSONFormatter extends BaseFormatter {
+    format(allOffenses: ProcessedFile[]): Promise<void>;
+    formatWithSummary(allOffenses: ProcessedFile[], options: JSONFormatOptions): Promise<void>;
+    formatFile(_filename: string, _offenses: Diagnostic[]): void;
+}
+export {};

package/dist/types/src/cli/formatters/simple-formatter.d.ts

@@ -2,6 +2,6 @@ import { BaseFormatter } from "./base-formatter.js";
 import type { Diagnostic } from "@herb-tools/core";
 import type { ProcessedFile } from "../file-processor.js";
 export declare class SimpleFormatter extends BaseFormatter {
-    format(allDiagnostics: ProcessedFile[]): Promise<void>;
-    formatFile(filename: string, diagnostics: Diagnostic[]): void;
+    format(allOffenses: ProcessedFile[]): Promise<void>;
+    formatFile(filename: string, offenses: Diagnostic[]): void;
 }

package/dist/types/src/cli/output-manager.d.ts

@@ -0,0 +1,31 @@
+import type { ThemeInput } from "@herb-tools/highlighter";
+import type { FormatOption } from "./argument-parser.js";
+import type { ProcessingResult } from "./file-processor.js";
+interface OutputOptions {
+    formatOption: FormatOption;
+    theme: ThemeInput;
+    wrapLines: boolean;
+    truncateLines: boolean;
+    showTiming: boolean;
+    startTime: number;
+    startDate: Date;
+}
+interface LintResults extends ProcessingResult {
+    files: string[];
+}
+export declare class OutputManager {
+    private summaryReporter;
+    /**
+     * Output successful lint results
+     */
+    outputResults(results: LintResults, options: OutputOptions): Promise<void>;
+    /**
+     * Output informational message (like "no files found")
+     */
+    outputInfo(message: string, options: OutputOptions): void;
+    /**
+     * Output error message
+     */
+    outputError(message: string, options: OutputOptions): void;
+}
+export {};

package/dist/types/src/cli/summary-reporter.d.ts

@@ -2,12 +2,12 @@ export interface SummaryData {
     files: string[];
     totalErrors: number;
     totalWarnings: number;
-    filesWithViolations: number;
+    filesWithOffenses: number;
     ruleCount: number;
     startTime: number;
     startDate: Date;
     showTiming: boolean;
-    ruleViolations: Map<string, {
+    ruleOffenses: Map<string, {
         count: number;
         files: Set<string>;
     }>;
@@ -15,7 +15,7 @@ export interface SummaryData {
 export declare class SummaryReporter {
     private pluralize;
     displaySummary(data: SummaryData): void;
-    displayMostViolatedRules(ruleViolations: Map<string, {
+    displayMostViolatedRules(ruleOffenses: Map<string, {
         count: number;
         files: Set<string>;
     }>, limit?: number): void;

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

@@ -1,6 +1,8 @@
 export declare class CLI {
     private argumentParser;
     private fileProcessor;
-    private summaryReporter;
+    private outputManager;
+    private exitWithError;
+    private exitWithInfo;
     run(): Promise<void>;
 }

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

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

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

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

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

@@ -0,0 +1,7 @@
+import { ParserRule } from "../types.js";
+import type { LintOffense, LintContext } 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[];
+}

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

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

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

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

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

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

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

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

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

@@ -0,0 +1,7 @@
+import { ParserRule } from "../types.js";
+import type { LintOffense, LintContext } 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[];
+}

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

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

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

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

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

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

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

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

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

@@ -0,0 +1,7 @@
+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 {
+    name: string;
+    check(result: ParseResult, context?: Partial<LintContext>): LintOffense[];
+}

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

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

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

@@ -0,0 +1,7 @@
+import { ParserRule } from "../types.js";
+import type { LintOffense, LintContext } 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[];
+}

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

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

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

@@ -0,0 +1,7 @@
+import { ParserRule } from "../types.js";
+import type { LintOffense, LintContext } 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[];
+}

package/dist/types/src/rules/html-img-require-alt.d.ts

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

package/dist/types/src/rules/html-navigation-has-label.d.ts

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

package/dist/types/src/rules/html-no-aria-hidden-on-focusable.d.ts

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

package/dist/types/src/rules/html-no-block-inside-inline.d.ts

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

package/dist/types/src/rules/html-no-duplicate-attributes.d.ts

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

package/dist/types/src/rules/html-no-duplicate-ids.d.ts

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