@herb-tools/linter 0.8.9 → 0.9.0

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

@@ -1,54 +0,0 @@
-export * from "./rule-utils.js";
-export * from "./file-utils.js";
-export * from "./string-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-require-trailing-newline.js";
-export * from "./erb-require-whitespace-inside-tags.js";
-export * from "./erb-right-trim.js";
-export * from "./erb-strict-locals-comment-syntax.js";
-export * from "./erb-strict-locals-required.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";
-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";
-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";

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

@@ -1,9 +0,0 @@
-import { ParserRule } 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,351 +0,0 @@
-import { Visitor, Location } 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 { UnboundLintOffense, LintContext, BaseAutofixContext } from "../types.js";
-export declare enum ControlFlowType {
-    CONDITIONAL = 0,
-    LOOP = 1
-}
-/**
- * Base visitor class that provides common functionality for rule visitors
- */
-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 an unbound lint offense (without severity).
-     * The Linter will bind severity based on the rule's config.
-     */
-    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, 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<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;
-    /**
-     * Handle visiting a branch node (like else, when) with proper scope management
-     */
-    protected startNewBranch(visitChildren: () => void): void;
-    visitERBIfNode(node: Nodes.ERBIfNode): void;
-    visitERBUnlessNode(node: Nodes.ERBUnlessNode): void;
-    visitERBCaseNode(node: Nodes.ERBCaseNode): void;
-    visitERBCaseMatchNode(node: Nodes.ERBCaseMatchNode): void;
-    visitERBWhileNode(node: Nodes.ERBWhileNode): void;
-    visitERBForNode(node: Nodes.ERBForNode): void;
-    visitERBUntilNode(node: Nodes.ERBUntilNode): void;
-    visitERBBlockNode(node: Nodes.ERBBlockNode): void;
-    visitERBElseNode(node: Nodes.ERBElseNode): void;
-    visitERBWhenNode(node: Nodes.ERBWhenNode): void;
-    protected abstract onEnterControlFlow(controlFlowType: ControlFlowType, wasAlreadyInControlFlow: boolean): TControlFlowState;
-    protected abstract onExitControlFlow(controlFlowType: ControlFlowType, wasAlreadyInControlFlow: boolean, stateToRestore: TControlFlowState): void;
-    protected abstract onEnterBranch(): TBranchState;
-    protected abstract onExitBranch(stateToRestore: TBranchState): void;
-}
-/**
- * Gets attributes from an HTMLOpenTagNode
- */
-export declare function getAttributes(node: HTMLOpenTagNode): HTMLAttributeNode[];
-/**
- * Gets the tag name from an HTML tag node (lowercased)
- */
-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)
- */
-export declare function getAttributeName(attributeNode: HTMLAttributeNode, lowercase?: boolean): 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
- */
-export declare function getAttributeValue(attributeNode: HTMLAttributeNode): string | null;
-/**
- * Checks if an attribute has a value
- */
-export declare function hasAttributeValue(attributeNode: HTMLAttributeNode): boolean;
-/**
- * Gets the quote type used for an attribute value
- */
-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: Node[], attributeName: string): HTMLAttributeNode | null;
-/**
- * Checks if a tag has a specific attribute
- */
-export declare function hasAttribute(node: HTMLOpenTagNode | null | undefined, 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>;
-/**
- * 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>;
-/**
- * Parameter types for AttributeVisitorMixin methods
- */
-export interface StaticAttributeStaticValueParams {
-    attributeName: string;
-    attributeValue: string;
-    attributeNode: HTMLAttributeNode;
-    originalAttributeName: string;
-    parentNode: HTMLOpenTagNode;
-}
-export interface StaticAttributeDynamicValueParams {
-    attributeName: string;
-    valueNodes: Node[];
-    attributeNode: HTMLAttributeNode;
-    originalAttributeName: string;
-    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
- */
-export declare function createEndOfFileLocation(source: string): Location;
-/**
- * Checks if an element is inline
- */
-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;
-/**
- * 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<TAutofixContext extends BaseAutofixContext = BaseAutofixContext> extends BaseRuleVisitor<TAutofixContext> {
-    constructor(ruleName: string, context?: Partial<LintContext>);
-    visitHTMLOpenTagNode(node: HTMLOpenTagNode): void;
-    private checkAttributesOnNode;
-    /**
-     * 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
- */
-export declare function isAttributeValueQuoted(attributeNode: HTMLAttributeNode): boolean;
-/**
- * Iterates over all attributes of a tag node, calling the callback for each attribute
- */
-export declare function forEachAttribute(node: HTMLOpenTagNode, callback: (attributeNode: HTMLAttributeNode) => void): void;
-/**
- * Base lexer visitor class that provides common functionality for lexer-based rule visitors
- */
-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 an unbound lint offense (without severity).
-     * The Linter will bind severity based on the rule's config.
-     */
-    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, autofixContext?: TAutofixContext): 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<TAutofixContext extends BaseAutofixContext = BaseAutofixContext> {
-    readonly offenses: UnboundLintOffense<TAutofixContext>[];
-    protected ruleName: string;
-    protected context: LintContext;
-    constructor(ruleName: string, context?: Partial<LintContext>);
-    /**
-     * 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, autofixContext?: TAutofixContext): UnboundLintOffense<TAutofixContext>;
-    /**
-     * Helper method to add an offense to the offenses array
-     */
-    protected addOffense(message: string, location: Location, autofixContext?: TAutofixContext): 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;
-}
-/**
- * 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/string-utils.d.ts

@@ -1,15 +0,0 @@
-/**
- * Checks if parentheses in a string are balanced
- * Returns false if there are more closing parens than opening at any point
- */
-export declare function hasBalancedParentheses(content: string): boolean;
-/**
- * Splits a string by commas at the top level only
- * Respects nested parentheses, brackets, braces, and strings
- *
- * @example
- * splitByTopLevelComma("a, b, c") // ["a", " b", " c"]
- * splitByTopLevelComma("a, (b, c), d") // ["a", " (b, c)", " d"]
- * splitByTopLevelComma('a, "b, c", d') // ["a", ' "b, c"', " d"]
- */
-export declare function splitByTopLevelComma(str: string): string[];

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

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

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

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

@@ -1,190 +0,0 @@
-import { Diagnostic, LexResult, ParseResult } from "@herb-tools/core";
-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 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<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>[];
-}
-/**
- * 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;
-    /** Indicates whether this rule supports unsafe autofix (requires --fix-unsafely). Defaults to false. */
-    static unsafeAutocorrectable: boolean;
-    abstract name: string;
-    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.
-     * @param result - The parse result to analyze
-     * @param context - Optional context for linting
-     * @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;
-}
-/**
- * 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;
-    /** Indicates whether this rule supports unsafe autofix (requires --fix-unsafely). Defaults to false. */
-    static unsafeAutocorrectable: boolean;
-    abstract name: string;
-    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.
-     * @param lexResult - The lex result to analyze
-     * @param context - Optional context for linting
-     * @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";
-    new (): LexerRule;
-}
-/**
- * Complete lint context with all properties defined.
- * Use Partial<LintContext> when passing context to rules.
- */
-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<TAutofixContext extends BaseAutofixContext = BaseAutofixContext> {
-    static type: "source";
-    /** Indicates whether this rule supports autofix. Defaults to false. */
-    static autocorrectable: boolean;
-    /** Indicates whether this rule supports unsafe autofix (requires --fix-unsafely). Defaults to false. */
-    static unsafeAutocorrectable: boolean;
-    abstract name: string;
-    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.
-     * @param source - The source code to analyze
-     * @param context - Optional context for linting
-     * @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";
-    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 = ParserRuleClass | LexerRuleClass | SourceRuleClass;