@herb-tools/linter 0.4.1 → 0.4.3

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

@@ -1,13 +1,14 @@
-import { Visitor } from "@herb-tools/core";
-import type { HTMLAttributeNode, HTMLOpenTagNode, HTMLSelfCloseTagNode, Location } from "@herb-tools/core";
-import type { LintOffense, LintSeverity } from "../types.js";
+import { Visitor, Location } from "@herb-tools/core";
+import type { HTMLAttributeNode, HTMLOpenTagNode, HTMLSelfCloseTagNode, LexResult, Token } from "@herb-tools/core";
+import type { LintOffense, LintSeverity, LintContext } from "../types.js";
 /**
  * Base visitor class that provides common functionality for rule visitors
  */
 export declare abstract class BaseRuleVisitor extends Visitor {
     readonly offenses: LintOffense[];
     protected ruleName: string;
-    constructor(ruleName: string);
+    protected context: LintContext;
+    constructor(ruleName: string, context?: Partial<LintContext>);
     /**
      * Helper method to create a lint offense
      */
@@ -56,8 +57,21 @@ export declare const HTML_INLINE_ELEMENTS: Set<string>;
 export declare const HTML_BLOCK_ELEMENTS: Set<string>;
 export declare const HTML_BOOLEAN_ATTRIBUTES: Set<string>;
 export declare const HEADING_TAGS: Set<string>;
+/**
+ * SVG elements that use camelCase naming
+ */
+export declare const SVG_CAMEL_CASE_ELEMENTS: Set<string>;
+/**
+ * Mapping from lowercase SVG element names to their correct camelCase versions
+ * Generated dynamically from SVG_CAMEL_CASE_ELEMENTS
+ */
+export declare const SVG_LOWERCASE_TO_CAMELCASE: Map<string, string>;
 export declare const VALID_ARIA_ROLES: Set<string>;
 export declare const ARIA_ATTRIBUTES: Set<string>;
+/**
+ * Helper function to create a location at the end of the source with a 1-character range
+ */
+export declare function createEndOfFileLocation(source: string): Location;
 /**
  * Checks if an element is inline
  */
@@ -76,6 +90,7 @@ export declare function isBooleanAttribute(attributeName: string): boolean;
  * and attribute iteration logic. Provides simplified interface with extracted attribute info.
  */
 export declare abstract class AttributeVisitorMixin extends BaseRuleVisitor {
+    constructor(ruleName: string, context?: Partial<LintContext>);
     visitHTMLOpenTagNode(node: HTMLOpenTagNode): void;
     visitHTMLSelfCloseTagNode(node: HTMLSelfCloseTagNode): void;
     private checkAttributesOnNode;
@@ -89,3 +104,66 @@ 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;
+/**
+ * Base lexer visitor class that provides common functionality for lexer-based rule visitors
+ */
+export declare abstract class BaseLexerRuleVisitor {
+    readonly offenses: LintOffense[];
+    protected ruleName: string;
+    protected context: LintContext;
+    constructor(ruleName: string, context?: Partial<LintContext>);
+    /**
+     * Helper method to create a lint offense for lexer rules
+     */
+    protected createOffense(message: string, location: Location, severity?: LintSeverity): LintOffense;
+    /**
+     * Helper method to add an offense to the offenses array
+     */
+    protected addOffense(message: string, location: Location, severity?: LintSeverity): void;
+    /**
+     * Main entry point for lexer rule visitors
+     * @param lexResult - The lexer result containing tokens and source
+     */
+    visit(lexResult: LexResult): void;
+    /**
+     * Visit all tokens
+     * Override this method to implement token-level checks
+     */
+    protected visitTokens(tokens: Token[]): void;
+    /**
+     * Visit individual tokens
+     * Override this method to implement per-token checks
+     */
+    protected visitToken(_token: Token): void;
+}
+/**
+ * Base source visitor class that provides common functionality for source-based rule visitors
+ */
+export declare abstract class BaseSourceRuleVisitor {
+    readonly offenses: LintOffense[];
+    protected ruleName: string;
+    protected context: LintContext;
+    constructor(ruleName: string, context?: Partial<LintContext>);
+    /**
+     * Helper method to create a lint offense for source rules
+     */
+    protected createOffense(message: string, location: Location, severity?: LintSeverity): LintOffense;
+    /**
+     * Helper method to add an offense to the offenses array
+     */
+    protected addOffense(message: string, location: Location, severity?: LintSeverity): void;
+    /**
+     * Main entry point for source rule visitors
+     * @param source - The raw source code
+     */
+    visit(source: string): void;
+    /**
+     * Visit the source code directly
+     * Override this method to implement source-level checks
+     */
+    protected abstract visitSource(source: string): void;
+    /**
+     * Helper method to create a location for a specific position in the source
+     */
+    protected createLocationAt(source: string, position: number): Location;
+}

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

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

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

@@ -1,18 +1,33 @@
-import type { RuleClass, LintResult } from "./types.js";
-import type { DocumentNode } from "@herb-tools/core";
+import type { RuleClass, LintResult, LintContext } from "./types.js";
+import type { HerbBackend } from "@herb-tools/core";
 export declare class Linter {
     private rules;
+    private herb;
     private offenses;
     /**
      * Creates a new Linter instance.
-     * @param rules - Array of rule classes (not instances) to use. If not provided, uses default 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.
      */
-    constructor(rules?: RuleClass[]);
+    constructor(herb: HerbBackend, rules?: RuleClass[]);
     /**
      * Returns the default set of rule classes used by the linter.
      * @returns Array of rule classes
      */
     private getDefaultRules;
     getRuleCount(): number;
-    lint(document: DocumentNode): LintResult;
+    /**
+     * Type guard to check if a rule is a LexerRule
+     */
+    private isLexerRule;
+    /**
+     * Type guard to check if a rule is a SourceRule
+     */
+    private isSourceRule;
+    /**
+     * 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;
 }

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

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

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

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

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

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

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

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

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

@@ -0,0 +1,6 @@
+import { SourceRule } from "../types.js";
+import type { LintOffense, LintContext } from "../types.js";
+export declare class ERBRequiresTrailingNewlineRule extends SourceRule {
+    name: string;
+    check(source: string, context?: Partial<LintContext>): LintOffense[];
+}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

package/dist/types/src/rules/html-no-empty-headings.d.ts

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

package/dist/types/src/rules/html-no-nested-links.d.ts

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

package/dist/types/src/rules/html-tag-name-lowercase.d.ts

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

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

@@ -1,6 +1,9 @@
 export * from "./erb-no-empty-tags.js";
 export * from "./erb-no-output-control-flow.js";
+export * from "./erb-prefer-image-tag-helper.js";
+export * from "./erb-requires-trailing-newline.js";
 export * from "./html-anchor-require-href.js";
+export * from "./html-aria-level-must-be-valid.js";
 export * from "./html-aria-role-heading-requires-level.js";
 export * from "./html-aria-role-must-be-valid.js";
 export * from "./html-attribute-double-quotes.js";
@@ -13,3 +16,4 @@ export * from "./html-no-duplicate-ids.js";
 export * from "./html-no-empty-headings.js";
 export * from "./html-no-nested-links.js";
 export * from "./html-tag-name-lowercase.js";
+export * from "./svg-tag-name-capitalization.js";

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

@@ -1,13 +1,14 @@
-import { Visitor } from "@herb-tools/core";
-import type { HTMLAttributeNode, HTMLOpenTagNode, HTMLSelfCloseTagNode, Location } from "@herb-tools/core";
-import type { LintOffense, LintSeverity } from "../types.js";
+import { Visitor, Location } from "@herb-tools/core";
+import type { HTMLAttributeNode, HTMLOpenTagNode, HTMLSelfCloseTagNode, LexResult, Token } from "@herb-tools/core";
+import type { LintOffense, LintSeverity, LintContext } from "../types.js";
 /**
  * Base visitor class that provides common functionality for rule visitors
  */
 export declare abstract class BaseRuleVisitor extends Visitor {
     readonly offenses: LintOffense[];
     protected ruleName: string;
-    constructor(ruleName: string);
+    protected context: LintContext;
+    constructor(ruleName: string, context?: Partial<LintContext>);
     /**
      * Helper method to create a lint offense
      */
@@ -56,8 +57,21 @@ export declare const HTML_INLINE_ELEMENTS: Set<string>;
 export declare const HTML_BLOCK_ELEMENTS: Set<string>;
 export declare const HTML_BOOLEAN_ATTRIBUTES: Set<string>;
 export declare const HEADING_TAGS: Set<string>;
+/**
+ * SVG elements that use camelCase naming
+ */
+export declare const SVG_CAMEL_CASE_ELEMENTS: Set<string>;
+/**
+ * Mapping from lowercase SVG element names to their correct camelCase versions
+ * Generated dynamically from SVG_CAMEL_CASE_ELEMENTS
+ */
+export declare const SVG_LOWERCASE_TO_CAMELCASE: Map<string, string>;
 export declare const VALID_ARIA_ROLES: Set<string>;
 export declare const ARIA_ATTRIBUTES: Set<string>;
+/**
+ * Helper function to create a location at the end of the source with a 1-character range
+ */
+export declare function createEndOfFileLocation(source: string): Location;
 /**
  * Checks if an element is inline
  */
@@ -76,6 +90,7 @@ export declare function isBooleanAttribute(attributeName: string): boolean;
  * and attribute iteration logic. Provides simplified interface with extracted attribute info.
  */
 export declare abstract class AttributeVisitorMixin extends BaseRuleVisitor {
+    constructor(ruleName: string, context?: Partial<LintContext>);
     visitHTMLOpenTagNode(node: HTMLOpenTagNode): void;
     visitHTMLSelfCloseTagNode(node: HTMLSelfCloseTagNode): void;
     private checkAttributesOnNode;
@@ -89,3 +104,66 @@ 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;
+/**
+ * Base lexer visitor class that provides common functionality for lexer-based rule visitors
+ */
+export declare abstract class BaseLexerRuleVisitor {
+    readonly offenses: LintOffense[];
+    protected ruleName: string;
+    protected context: LintContext;
+    constructor(ruleName: string, context?: Partial<LintContext>);
+    /**
+     * Helper method to create a lint offense for lexer rules
+     */
+    protected createOffense(message: string, location: Location, severity?: LintSeverity): LintOffense;
+    /**
+     * Helper method to add an offense to the offenses array
+     */
+    protected addOffense(message: string, location: Location, severity?: LintSeverity): void;
+    /**
+     * Main entry point for lexer rule visitors
+     * @param lexResult - The lexer result containing tokens and source
+     */
+    visit(lexResult: LexResult): void;
+    /**
+     * Visit all tokens
+     * Override this method to implement token-level checks
+     */
+    protected visitTokens(tokens: Token[]): void;
+    /**
+     * Visit individual tokens
+     * Override this method to implement per-token checks
+     */
+    protected visitToken(_token: Token): void;
+}
+/**
+ * Base source visitor class that provides common functionality for source-based rule visitors
+ */
+export declare abstract class BaseSourceRuleVisitor {
+    readonly offenses: LintOffense[];
+    protected ruleName: string;
+    protected context: LintContext;
+    constructor(ruleName: string, context?: Partial<LintContext>);
+    /**
+     * Helper method to create a lint offense for source rules
+     */
+    protected createOffense(message: string, location: Location, severity?: LintSeverity): LintOffense;
+    /**
+     * Helper method to add an offense to the offenses array
+     */
+    protected addOffense(message: string, location: Location, severity?: LintSeverity): void;
+    /**
+     * Main entry point for source rule visitors
+     * @param source - The raw source code
+     */
+    visit(source: string): void;
+    /**
+     * Visit the source code directly
+     * Override this method to implement source-level checks
+     */
+    protected abstract visitSource(source: string): void;
+    /**
+     * Helper method to create a location for a specific position in the source
+     */
+    protected createLocationAt(source: string, position: number): Location;
+}

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

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

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

@@ -1,4 +1,4 @@
-import { Node, Diagnostic } from "@herb-tools/core";
+import { Node, Diagnostic, LexResult } from "@herb-tools/core";
 import type { defaultRules } from "./default-rules.js";
 export type LintSeverity = "error" | "warning";
 /**
@@ -15,12 +15,55 @@ export interface LintResult {
     errors: number;
     warnings: number;
 }
-export interface Rule {
-    name: string;
-    check(node: Node): LintOffense[];
+export declare abstract class ParserRule {
+    static type: "parser";
+    abstract name: string;
+    abstract check(node: Node, context?: Partial<LintContext>): LintOffense[];
+}
+export declare abstract class LexerRule {
+    static type: "lexer";
+    abstract name: string;
+    abstract check(lexResult: LexResult, context?: Partial<LintContext>): LintOffense[];
+}
+export interface LexerRuleConstructor {
+    type: "lexer";
+    new (): LexerRule;
 }
 /**
- * Type representing a rule class constructor.
+ * Complete lint context with all properties defined.
+ * Use Partial<LintContext> when passing context to rules.
+ */
+export interface LintContext {
+    fileName: string | undefined;
+}
+/**
+ * Default context object with all keys defined but set to undefined
+ */
+export declare const DEFAULT_LINT_CONTEXT: LintContext;
+export declare abstract class SourceRule {
+    static type: "source";
+    abstract name: string;
+    abstract check(source: string, context?: Partial<LintContext>): LintOffense[];
+}
+export interface SourceRuleConstructor {
+    type: "source";
+    new (): SourceRule;
+}
+/**
+ * Type representing a parser/AST rule class constructor.
  * The Linter accepts rule classes rather than instances for better performance and memory usage.
+ * Parser rules are the default and don't require static properties.
+ */
+export type ParserRuleClass = (new () => ParserRule) & {
+    type?: "parser";
+};
+export type LexerRuleClass = LexerRuleConstructor;
+export type SourceRuleClass = SourceRuleConstructor;
+/**
+ * Union type for any rule instance (Parser/AST, Lexer, or Source)
+ */
+export type Rule = ParserRule | LexerRule | SourceRule;
+/**
+ * Union type for any rule class (Parser/AST, Lexer, or Source)
  */
-export type RuleClass = new () => Rule;
+export type RuleClass = ParserRuleClass | LexerRuleClass | SourceRuleClass;