@herb-tools/linter 0.7.4 → 0.8.0

package/dist/types/src/rules/html-no-space-in-tag.d.ts

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

package/dist/types/src/rules/html-no-title-attribute.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 HTMLNoTitleAttributeRule 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-no-underscores-in-attribute-names.d.ts

@@ -1,7 +1,8 @@
 import { ParserRule } from "../types.js";
-import type { LintContext, LintOffense } from "../types.js";
+import type { UnboundLintOffense, LintContext, FullRuleConfig } from "../types.js";
 import type { ParseResult } from "@herb-tools/core";
 export declare class HTMLNoUnderscoresInAttributeNamesRule 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-tag-name-lowercase.d.ts

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

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

@@ -1,9 +1,22 @@
 export * from "./rule-utils.js";
+export * from "./herb-disable-comment-base.js";
+export * from "./erb-comment-syntax.js";
+export * from "./erb-no-case-node-children.js";
 export * from "./erb-no-empty-tags.js";
+export * from "./erb-no-extra-newline.js";
+export * from "./erb-no-extra-whitespace-inside-tags.js";
 export * from "./erb-no-output-control-flow.js";
 export * from "./erb-no-silent-tag-in-attribute-name.js";
 export * from "./erb-prefer-image-tag-helper.js";
-export * from "./erb-requires-trailing-newline.js";
+export * from "./erb-require-trailing-newline.js";
+export * from "./erb-require-whitespace-inside-tags.js";
+export * from "./erb-right-trim.js";
+export * from "./herb-disable-comment-valid-rule-name.js";
+export * from "./herb-disable-comment-no-redundant-all.js";
+export * from "./herb-disable-comment-no-duplicate-rules.js";
+export * from "./herb-disable-comment-missing-rules.js";
+export * from "./herb-disable-comment-malformed.js";
+export * from "./herb-disable-comment-unnecessary.js";
 export * from "./html-anchor-require-href.js";
 export * from "./html-aria-label-is-well-formatted.js";
 export * from "./html-aria-level-must-be-valid.js";
@@ -13,20 +26,25 @@ export * from "./html-attribute-double-quotes.js";
 export * from "./html-attribute-equals-spacing.js";
 export * from "./html-attribute-values-require-quotes.js";
 export * from "./html-avoid-both-disabled-and-aria-disabled.js";
+export * from "./html-body-only-elements.js";
 export * from "./html-boolean-attributes-no-value.js";
+export * from "./html-head-only-elements.js";
 export * from "./html-iframe-has-title.js";
 export * from "./html-img-require-alt.js";
+export * from "./html-input-require-autocomplete.js";
 export * from "./html-navigation-has-label.js";
 export * from "./html-no-aria-hidden-on-focusable.js";
 export * from "./html-no-block-inside-inline.js";
 export * from "./html-no-duplicate-attributes.js";
 export * from "./html-no-duplicate-ids.js";
+export * from "./html-no-duplicate-meta-names.js";
 export * from "./html-no-empty-attributes.js";
 export * from "./html-no-empty-headings.js";
 export * from "./html-no-nested-links.js";
 export * from "./html-no-positive-tab-index.js";
 export * from "./html-no-self-closing.js";
+export * from "./html-no-space-in-tag.js";
 export * from "./html-no-title-attribute.js";
+export * from "./html-no-underscores-in-attribute-names.js";
 export * from "./html-tag-name-lowercase.js";
 export * from "./svg-tag-name-capitalization.js";
-export * from "./html-no-underscores-in-attribute-names.js";

package/dist/types/src/rules/parser-no-errors.d.ts

@@ -1,8 +1,9 @@
 import { ParserRule } from "../types.js";
-import type { LintOffense } from "../types.js";
+import type { LintOffense, FullRuleConfig } from "../types.js";
 import type { ParseResult } from "@herb-tools/core";
 export declare class ParserNoErrorsRule extends ParserRule {
     name: string;
+    get defaultConfig(): FullRuleConfig;
     check(result: ParseResult): LintOffense[];
     private herbErrorToLintOffense;
 }

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

@@ -1,7 +1,7 @@
 import { Visitor, Location } from "@herb-tools/core";
-import type { HTMLAttributeNode, HTMLAttributeValueNode, HTMLOpenTagNode, LexResult, Token, Node } from "@herb-tools/core";
+import type { HTMLAttributeNode, HTMLAttributeValueNode, HTMLElementNode, HTMLOpenTagNode, LexResult, Token, Node } from "@herb-tools/core";
 import type * as Nodes from "@herb-tools/core";
-import type { LintOffense, LintSeverity, LintContext } from "../types.js";
+import type { UnboundLintOffense, LintContext, BaseAutofixContext } from "../types.js";
 export declare enum ControlFlowType {
     CONDITIONAL = 0,
     LOOP = 1
@@ -9,35 +9,37 @@ export declare enum ControlFlowType {
 /**
  * Base visitor class that provides common functionality for rule visitors
  */
-export declare abstract class BaseRuleVisitor extends Visitor {
-    readonly offenses: LintOffense[];
+export declare abstract class BaseRuleVisitor<TAutofixContext extends BaseAutofixContext = BaseAutofixContext> extends Visitor {
+    readonly offenses: UnboundLintOffense<TAutofixContext>[];
     protected ruleName: string;
     protected context: LintContext;
     constructor(ruleName: string, context?: Partial<LintContext>);
     /**
-     * Helper method to create a lint offense
+     * Helper method to create an unbound lint offense (without severity).
+     * The Linter will bind severity based on the rule's config.
      */
-    protected createOffense(message: string, location: Location, severity?: LintSeverity): LintOffense;
+    protected createOffense(message: string, location: Location, autofixContext?: TAutofixContext): UnboundLintOffense<TAutofixContext>;
     /**
      * Helper method to add an offense to the offenses array
      */
-    protected addOffense(message: string, location: Location, severity?: LintSeverity): void;
+    protected addOffense(message: string, location: Location, autofixContext?: TAutofixContext): void;
 }
 /**
  * Mixin that adds control flow tracking capabilities to rule visitors
  * This allows rules to track state across different control flow structures
  * like if/else branches, loops, etc.
  *
+ * @template TAutofixContext - Type for autofix context (node + custom data)
  * @template TControlFlowState - Type for state passed between onEnterControlFlow and onExitControlFlow
  * @template TBranchState - Type for state passed between onEnterBranch and onExitBranch
  */
-export declare abstract class ControlFlowTrackingVisitor<TControlFlowState = any, TBranchState = any> extends BaseRuleVisitor {
+export declare abstract class ControlFlowTrackingVisitor<TAutofixContext extends BaseAutofixContext = BaseAutofixContext, TControlFlowState = any, TBranchState = any> extends BaseRuleVisitor<TAutofixContext> {
     protected isInControlFlow: boolean;
     protected currentControlFlowType: ControlFlowType | null;
     /**
      * Handle visiting a control flow node with proper scope management
      */
-    protected handleControlFlowNode(node: Node, controlFlowType: ControlFlowType, visitChildren: () => void): void;
+    protected handleControlFlowNode(_node: Node, controlFlowType: ControlFlowType, visitChildren: () => void): void;
     /**
      * Handle visiting a branch node (like else, when) with proper scope management
      */
@@ -64,7 +66,7 @@ export declare function getAttributes(node: HTMLOpenTagNode): HTMLAttributeNode[
 /**
  * Gets the tag name from an HTML tag node (lowercased)
  */
-export declare function getTagName(node: HTMLOpenTagNode): string | null;
+export declare function getTagName(node: HTMLElementNode | HTMLOpenTagNode | null | undefined): string | null;
 /**
  * Gets the attribute name from an HTMLAttributeNode (lowercased)
  * Returns null if the attribute name contains dynamic content (ERB)
@@ -210,7 +212,7 @@ export declare function isBooleanAttribute(attributeName: string): boolean;
  * - checkDynamicAttributeStaticValue()  - name="data-<%= key %>" value="foo"
  * - checkDynamicAttributeDynamicValue() - name="data-<%= key %>" value="<%= value %>"
  */
-export declare abstract class AttributeVisitorMixin extends BaseRuleVisitor {
+export declare abstract class AttributeVisitorMixin<TAutofixContext extends BaseAutofixContext = BaseAutofixContext> extends BaseRuleVisitor<TAutofixContext> {
     constructor(ruleName: string, context?: Partial<LintContext>);
     visitHTMLOpenTagNode(node: HTMLOpenTagNode): void;
     private checkAttributesOnNode;
@@ -242,19 +244,20 @@ export declare function forEachAttribute(node: HTMLOpenTagNode, callback: (attri
 /**
  * Base lexer visitor class that provides common functionality for lexer-based rule visitors
  */
-export declare abstract class BaseLexerRuleVisitor {
-    readonly offenses: LintOffense[];
+export declare abstract class BaseLexerRuleVisitor<TAutofixContext extends BaseAutofixContext = BaseAutofixContext> {
+    readonly offenses: UnboundLintOffense<TAutofixContext>[];
     protected ruleName: string;
     protected context: LintContext;
     constructor(ruleName: string, context?: Partial<LintContext>);
     /**
-     * Helper method to create a lint offense for lexer rules
+     * Helper method to create an unbound lint offense (without severity).
+     * The Linter will bind severity based on the rule's config.
      */
-    protected createOffense(message: string, location: Location, severity?: LintSeverity): LintOffense;
+    protected createOffense(message: string, location: Location, autofixContext?: TAutofixContext): UnboundLintOffense<TAutofixContext>;
     /**
      * Helper method to add an offense to the offenses array
      */
-    protected addOffense(message: string, location: Location, severity?: LintSeverity): void;
+    protected addOffense(message: string, location: Location, autofixContext?: TAutofixContext): void;
     /**
      * Main entry point for lexer rule visitors
      * @param lexResult - The lexer result containing tokens and source
@@ -274,19 +277,20 @@ export declare abstract class BaseLexerRuleVisitor {
 /**
  * Base source visitor class that provides common functionality for source-based rule visitors
  */
-export declare abstract class BaseSourceRuleVisitor {
-    readonly offenses: LintOffense[];
+export declare abstract class BaseSourceRuleVisitor<TAutofixContext extends BaseAutofixContext = BaseAutofixContext> {
+    readonly offenses: UnboundLintOffense<TAutofixContext>[];
     protected ruleName: string;
     protected context: LintContext;
     constructor(ruleName: string, context?: Partial<LintContext>);
     /**
-     * Helper method to create a lint offense for source rules
+     * Helper method to create an unbound lint offense (without severity).
+     * The Linter will bind severity based on the rule's config.
      */
-    protected createOffense(message: string, location: Location, severity?: LintSeverity): LintOffense;
+    protected createOffense(message: string, location: Location, autofixContext?: TAutofixContext): UnboundLintOffense<TAutofixContext>;
     /**
      * Helper method to add an offense to the offenses array
      */
-    protected addOffense(message: string, location: Location, severity?: LintSeverity): void;
+    protected addOffense(message: string, location: Location, autofixContext?: TAutofixContext): void;
     /**
      * Main entry point for source rule visitors
      * @param source - The raw source code
@@ -297,8 +301,51 @@ export declare abstract class BaseSourceRuleVisitor {
      * 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;
 }
+/**
+ * Autofix utilities for applying string replacements
+ */
+/**
+ * Checks if two locations are equal
+ * @param a - First location
+ * @param b - Second location
+ * @returns true if locations are equal
+ */
+export declare function locationsEqual(a: Location, b: Location): boolean;
+/**
+ * Finds a node in the AST that has a specific location
+ * Uses direct recursive traversal for reliability
+ * @param root - The root node to search from
+ * @param location - The location to match
+ * @param predicate - Optional predicate function to filter nodes (e.g., isERBNode)
+ * @returns The matching node or null if not found
+ */
+export declare function findNodeByLocation(root: Node, location: Location, predicate?: (node: Node) => boolean): any;
+/**
+ * AST Navigation Utilities
+ * These utilities help navigate the AST tree for complex autofix operations
+ */
+/**
+ * Finds the parent node of a given child node in the AST
+ * @param root - The root node to search from (typically the document node)
+ * @param target - The child node to find the parent of
+ * @returns The parent node, or null if not found
+ *
+ * @example
+ * const parent = findParent(result.value, offense.autofixContext.node)
+ * if (parent?.type === "AST_HTML_ELEMENT_NODE") {
+ *   // Modify parent...
+ * }
+ */
+export declare function findParent(root: Node, target: Node): Node | null;
+export declare const DOCUMENT_ONLY_TAG_NAMES: Set<string>;
+export declare const HTML_ONLY_TAG_NAMES: Set<string>;
+export declare const HEAD_ONLY_TAG_NAMES: Set<string>;
+export declare const HEAD_AND_BODY_TAG_NAMES: Set<string>;
+export declare function isDocumentOnlyTag(tagName: string): boolean;
+export declare function isHtmlOnlyTag(tagName: string): boolean;
+export declare function isHeadOnlyTag(tagName: string): boolean;
+export declare function isHeadAndBodyTag(tagName: string): boolean;
+export declare function isBodyOnlyTag(tagName: string): boolean;
+export declare function isBodyTag(tagName: string): boolean;
+export declare function isHeadTag(tagName: string): boolean;

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

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

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

@@ -0,0 +1,2 @@
+import type { RuleClass } from "./types.js";
+export declare const rules: RuleClass[];

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

@@ -1,24 +1,76 @@
 import { Diagnostic, LexResult, ParseResult } from "@herb-tools/core";
-import type { defaultRules } from "./default-rules.js";
+import type { rules } from "./rules.js";
+import type { Node } from "@herb-tools/core";
+import type { RuleConfig } from "@herb-tools/config";
+import type { Mutable } from "@herb-tools/rewriter";
+export type { Mutable } from "@herb-tools/rewriter";
 export type LintSeverity = "error" | "warning" | "info" | "hint";
+export type FullRuleConfig = Required<Pick<RuleConfig, 'enabled' | 'severity'>> & Omit<RuleConfig, 'enabled' | 'severity'>;
 /**
  * Automatically inferred union type of all available linter rule names.
  * This type extracts the 'name' property from each rule class instance.
  */
-export type LinterRule = InstanceType<typeof defaultRules[number]>['name'];
-export interface LintOffense extends Diagnostic {
+export type LinterRule = InstanceType<typeof rules[number]>['name'];
+/**
+ * Base context for autofix operations. Contains the offending node.
+ * Rules can extend this interface to include rule-specific autofix data.
+ * Note: The node is typed as Mutable to allow direct mutation in autofix methods.
+ */
+export interface BaseAutofixContext {
+    /** The AST node, token, or data structure that caused the offense (mutable) */
+    node: Mutable<Node>;
+}
+/**
+ * A lint offense without severity bound. Rules produce these, and the Linter
+ * binds severity based on the rule's defaultConfig and user config overrides.
+ */
+export interface UnboundLintOffense<TAutofixContext extends BaseAutofixContext = BaseAutofixContext> extends Omit<Diagnostic, 'severity'> {
     rule: LinterRule;
+    /** Context data for autofix, including the offending node and rule-specific data */
+    autofixContext?: TAutofixContext;
+}
+/**
+ * A lint offense with severity bound. The Linter produces these by binding
+ * severity to UnboundLintOffenses based on rule configuration.
+ */
+export interface LintOffense<TAutofixContext extends BaseAutofixContext = BaseAutofixContext> extends UnboundLintOffense<TAutofixContext> {
     severity: LintSeverity;
 }
-export interface LintResult {
-    offenses: LintOffense[];
+export interface LintResult<TAutofixContext extends BaseAutofixContext = BaseAutofixContext> {
+    offenses: LintOffense<TAutofixContext>[];
     errors: number;
     warnings: number;
+    info: number;
+    hints: number;
+    ignored: number;
+    wouldBeIgnored?: number;
+}
+/**
+ * Result of applying autofixes to source code
+ */
+export interface AutofixResult<TAutofixContext extends BaseAutofixContext = BaseAutofixContext> {
+    /** The corrected source code with all fixes applied */
+    source: string;
+    /** Offenses that were successfully fixed */
+    fixed: LintOffense<TAutofixContext>[];
+    /** Offenses that could not be automatically fixed */
+    unfixed: LintOffense<TAutofixContext>[];
 }
-export declare abstract class ParserRule {
+/**
+ * Default configuration for rules when defaultConfig is not specified.
+ * Custom rules can omit defaultConfig and will use these defaults.
+ */
+export declare const DEFAULT_RULE_CONFIG: FullRuleConfig;
+/**
+ * Base class for parser rules.
+ */
+export declare abstract class ParserRule<TAutofixContext extends BaseAutofixContext = BaseAutofixContext> {
     static type: "parser";
+    /** Indicates whether this rule supports autofix. Defaults to false. */
+    static autocorrectable: boolean;
     abstract name: string;
-    abstract check(result: ParseResult, context?: Partial<LintContext>): LintOffense[];
+    get defaultConfig(): FullRuleConfig;
+    abstract check(result: ParseResult, context?: Partial<LintContext>): UnboundLintOffense<TAutofixContext>[];
     /**
      * Optional method to determine if this rule should run.
      * If not implemented, rule is always enabled.
@@ -27,11 +79,26 @@ export declare abstract class ParserRule {
      * @returns true if rule should run, false to skip
      */
     isEnabled?(result: ParseResult, context?: Partial<LintContext>): boolean;
+    /**
+     * Optional method to automatically fix an offense by mutating the AST.
+     * If not implemented, the rule does not support autofix.
+     * @param offense - The offense to fix (includes autofixContext with node and rule-specific data)
+     * @param result - The parse result containing the AST (mutate it directly and return it)
+     * @param context - Optional context for linting
+     * @returns The mutated ParseResult if fixed, or null if the offense could not be fixed
+     */
+    autofix?(offense: LintOffense<TAutofixContext>, result: ParseResult, context?: Partial<LintContext>): ParseResult | null;
 }
-export declare abstract class LexerRule {
+/**
+ * Base class for lexer rules.
+ */
+export declare abstract class LexerRule<TAutofixContext extends BaseAutofixContext = BaseAutofixContext> {
     static type: "lexer";
+    /** Indicates whether this rule supports autofix. Defaults to false. */
+    static autocorrectable: boolean;
     abstract name: string;
-    abstract check(lexResult: LexResult, context?: Partial<LintContext>): LintOffense[];
+    get defaultConfig(): FullRuleConfig;
+    abstract check(lexResult: LexResult, context?: Partial<LintContext>): UnboundLintOffense<TAutofixContext>[];
     /**
      * Optional method to determine if this rule should run.
      * If not implemented, rule is always enabled.
@@ -40,6 +107,15 @@ export declare abstract class LexerRule {
      * @returns true if rule should run, false to skip
      */
     isEnabled?(lexResult: LexResult, context?: Partial<LintContext>): boolean;
+    /**
+     * Optional method to automatically fix an offense by mutating tokens.
+     * If not implemented, the rule does not support autofix.
+     * @param offense - The offense to fix (includes autofixContext with node and rule-specific data)
+     * @param lexResult - The lex result containing tokens (mutate them directly and return)
+     * @param context - Optional context for linting
+     * @returns The mutated LexResult if fixed, or null if the offense could not be fixed
+     */
+    autofix?(offense: LintOffense<TAutofixContext>, lexResult: LexResult, context?: Partial<LintContext>): LexResult | null;
 }
 export interface LexerRuleConstructor {
     type: "lexer";
@@ -51,15 +127,21 @@ export interface LexerRuleConstructor {
  */
 export interface LintContext {
     fileName: string | undefined;
+    validRuleNames: string[] | undefined;
+    ignoredOffensesByLine: Map<number, Set<string>> | undefined;
+    ignoreDisableComments: boolean | undefined;
 }
 /**
  * Default context object with all keys defined but set to undefined
  */
 export declare const DEFAULT_LINT_CONTEXT: LintContext;
-export declare abstract class SourceRule {
+export declare abstract class SourceRule<TAutofixContext extends BaseAutofixContext = BaseAutofixContext> {
     static type: "source";
+    /** Indicates whether this rule supports autofix. Defaults to false. */
+    static autocorrectable: boolean;
     abstract name: string;
-    abstract check(source: string, context?: Partial<LintContext>): LintOffense[];
+    get defaultConfig(): FullRuleConfig;
+    abstract check(source: string, context?: Partial<LintContext>): UnboundLintOffense<TAutofixContext>[];
     /**
      * Optional method to determine if this rule should run.
      * If not implemented, rule is always enabled.
@@ -68,6 +150,15 @@ export declare abstract class SourceRule {
      * @returns true if rule should run, false to skip
      */
     isEnabled?(source: string, context?: Partial<LintContext>): boolean;
+    /**
+     * Optional method to automatically fix an offense.
+     * If not implemented, the rule does not support autofix.
+     * @param offense - The offense to fix (includes autofixContext with node and rule-specific data)
+     * @param source - The original source code
+     * @param context - Optional context for linting
+     * @returns The corrected source if the offense can be fixed, null otherwise
+     */
+    autofix?(offense: LintOffense<TAutofixContext>, source: string, context?: Partial<LintContext>): string | null;
 }
 export interface SourceRuleConstructor {
     type: "source";