import * as _typescript_eslint_utils_ts_eslint from '@typescript-eslint/utils/ts-eslint';
import { RuleModule } from '@typescript-eslint/utils/ts-eslint';
import { Linter } from 'eslint';
import { ESLintUtils } from '@typescript-eslint/utils';
export { ResolverFactory } from 'oxc-resolver';

/**
 * Rule creation helper using @typescript-eslint/utils
 */

declare const baseCreateRule: <Options extends readonly unknown[], MessageIds extends string>({ meta, name, ...rule }: Readonly<ESLintUtils.RuleWithMetaAndName<Options, MessageIds, unknown>>) => ESLintUtils.RuleModule<MessageIds, Options, unknown, ESLintUtils.RuleListener> & {
    name: string;
};
declare const createRule: typeof baseCreateRule;
/**
 * Schema for prompting user to configure a rule option in the CLI
 */
interface OptionFieldSchema {
    /** Field name in the options object */
    key: string;
    /** Display label for the prompt */
    label: string;
    /** Prompt type */
    type: "text" | "number" | "boolean" | "select" | "multiselect";
    /** Default value */
    defaultValue: unknown;
    /** Placeholder text (for text/number inputs) */
    placeholder?: string;
    /** Options for select/multiselect */
    options?: Array<{
        value: string | number;
        label: string;
    }>;
    /** Description/hint for the field */
    description?: string;
}
/**
 * Schema describing how to prompt for rule options during installation
 */
interface RuleOptionSchema {
    /** Fields that can be configured for this rule */
    fields: OptionFieldSchema[];
}
/**
 * External requirement that a rule needs to function
 */
interface RuleRequirement {
    /** Requirement type for programmatic checks. Plugins define their own types. */
    type: string;
    /** Human-readable description */
    description: string;
    /** Optional: how to satisfy the requirement */
    setupHint?: string;
}
/**
 * Rule migration definition for updating rule options between versions
 */
interface RuleMigration {
    /** Source version (semver) */
    from: string;
    /** Target version (semver) */
    to: string;
    /** Human-readable description of what changed */
    description: string;
    /** Function to migrate options from old format to new format */
    migrate: (oldOptions: unknown[]) => unknown[];
    /** Whether this migration contains breaking changes */
    breaking?: boolean;
}
/**
 * Colocated rule metadata - exported alongside each rule
 *
 * This structure keeps all rule metadata in the same file as the rule implementation,
 * making it easy to maintain and extend as new rules are added.
 */
interface RuleMeta {
    /** Rule identifier (e.g., "consistent-dark-mode") - must match filename */
    id: string;
    /** Semantic version of the rule (e.g., "1.0.0") */
    version: string;
    /** Display name for CLI (e.g., "No Arbitrary Tailwind") */
    name: string;
    /** Short description for CLI selection prompts (one line) */
    description: string;
    /** Default severity level */
    defaultSeverity: "error" | "warn" | "off";
    /** Category for grouping in CLI */
    category: string;
    /** Icon for display in CLI/UI (emoji or icon name) */
    icon?: string;
    /** Short hint about the rule type/requirements */
    hint?: string;
    /** Whether rule is enabled by default during install */
    defaultEnabled?: boolean;
    /** External requirements the rule needs */
    requirements?: RuleRequirement[];
    /**
     * NPM packages that must be installed for this rule to work.
     * These will be added to the target project's dependencies during installation.
     *
     * Example: ["xxhash-wasm"] for rules using the xxhash library
     */
    npmDependencies?: string[];
    /** Instructions to show after installation */
    postInstallInstructions?: string;
    /** Framework compatibility */
    frameworks?: ("next" | "vite" | "cra" | "remix")[];
    /** Whether this rule requires a styleguide file */
    requiresStyleguide?: boolean;
    /** Default options for the rule (passed as second element in ESLint config) */
    defaultOptions?: unknown[];
    /** Schema for prompting user to configure options during install */
    optionSchema?: RuleOptionSchema;
    /**
     * Detailed documentation in markdown format.
     * Should include:
     * - What the rule does
     * - Why it's useful
     * - Examples of incorrect and correct code
     * - Configuration options explained
     */
    docs: string;
    /**
     * Internal utility dependencies that this rule requires.
     * When the rule is copied to a target project, these utilities
     * will be transformed to import from "uilint-eslint" instead
     * of relative paths.
     *
     * Example: ["coverage-aggregator", "dependency-graph"]
     */
    internalDependencies?: string[];
    /**
     * Whether this rule is directory-based (has lib/ folder with utilities).
     * Directory-based rules are installed as folders with index.ts and lib/ subdirectory.
     * Single-file rules are installed as single .ts files.
     *
     * When true, ESLint config imports will use:
     *   ./.uilint/rules/rule-id/index.js
     * When false (default):
     *   ./.uilint/rules/rule-id.js
     */
    isDirectoryBased?: boolean;
    /**
     * Migrations for updating rule options between versions.
     * Migrations are applied in order to transform options from older versions.
     */
    migrations?: RuleMigration[];
    /**
     * Which UI plugin should handle this rule.
     * Plugins define their own identifiers.
     */
    plugin?: string;
    /**
     * ESLint import specifier for external plugin rules.
     *
     * When set, `uilint init` will generate an import from this specifier
     * instead of looking for the rule in `.uilint/rules/`. The import should
     * be a default export of the ESLint rule implementation.
     *
     * Example: `"uilint-vision/eslint-rules/semantic-vision"`
     *
     * The generated ESLint config will include:
     * ```js
     * import SemanticVisionRule from "uilint-vision/eslint-rules/semantic-vision";
     * ```
     */
    eslintImport?: string;
    /**
     * Custom inspector panel ID to use for this rule's issues.
     * If not specified, uses the plugin's default issue inspector.
     * Plugins define their own panel IDs.
     */
    customInspector?: string;
    /**
     * Custom heatmap color for this rule's issues.
     * CSS color value (hex, rgb, hsl, or named color).
     * If not specified, uses severity-based coloring.
     */
    heatmapColor?: string;
    /**
     * ESLint messageIds that represent internal/sentinel errors.
     *
     * Issues reported with these messageIds are not user-facing lint issues
     * but internal error signals (e.g., "analysis backend failed" or
     * "styleguide not found"). The serve command will log these to the
     * dashboard and filter them from client results automatically.
     *
     * This allows rules with fallible backends (LLM calls, external services)
     * to signal errors through ESLint's reporting mechanism without those
     * errors being shown to end users as lint issues.
     *
     * Example: `["analysisError", "styleguideNotFound"]`
     */
    sentinelMessageIds?: string[];
}
/**
 * Helper to define rule metadata with type safety
 */
declare function defineRuleMeta(meta: RuleMeta): RuleMeta;

/**
 * Styleguide loader for the LLM semantic rule
 *
 * Only the semantic rule reads the styleguide - static rules use ESLint options.
 */
/**
 * Find the styleguide file path
 */
declare function findStyleguidePath(startDir: string, explicitPath?: string): string | null;
/**
 * Load styleguide content from file
 */
declare function loadStyleguide(startDir: string, explicitPath?: string): string | null;
/**
 * Get styleguide path and content
 */
declare function getStyleguide(startDir: string, explicitPath?: string): {
    path: string | null;
    content: string | null;
};

/**
 * File-hash based caching for LLM semantic rule
 *
 * Uses xxhash for fast hashing of file contents.
 */
/**
 * Hash content using xxhash (async) or djb2 (sync fallback)
 */
declare function hashContent(content: string): Promise<string>;
/**
 * Synchronous hash for when async is not possible
 */
declare function hashContentSync(content: string): string;
interface CacheEntry {
    fileHash: string;
    styleguideHash: string;
    issues: CachedIssue[];
    timestamp: number;
}
interface CachedIssue {
    line: number;
    column?: number;
    message: string;
    ruleId: string;
    severity: 1 | 2;
}
interface CacheStore {
    version: number;
    entries: Record<string, CacheEntry>;
}
/**
 * Load the cache store
 */
declare function loadCache(projectRoot: string): CacheStore;
/**
 * Save the cache store
 */
declare function saveCache(projectRoot: string, cache: CacheStore): void;
/**
 * Get cached entry for a file
 */
declare function getCacheEntry(projectRoot: string, filePath: string, fileHash: string, styleguideHash: string): CacheEntry | null;
/**
 * Set cached entry for a file
 */
declare function setCacheEntry(projectRoot: string, filePath: string, entry: CacheEntry): void;
/**
 * Clear cache for a specific file
 */
declare function clearCacheEntry(projectRoot: string, filePath: string): void;
/**
 * Clear entire cache
 */
declare function clearCache$1(projectRoot: string): void;

/**
 * Clear entire cache
 */
declare function clearAllSuggestions(projectRoot: string): void;

/**
 * Lightweight process-local profiling for UILint ESLint rules.
 *
 * The profiler is intentionally quiet during linting: visitor callbacks only
 * update in-memory aggregates, and summaries are flushed once at process exit.
 */
interface RuleProfilerOptions {
    enabled: boolean;
    profileDir: string;
    outlierLimit: number;
    minOutlierMs: number;
}
interface RuleProfileListenerSummary {
    selector: string;
    totalMs: number;
    calls: number;
}
interface RuleProfileSummary {
    ruleId: string;
    files: number;
    reports: number;
    setupMs: number;
    listenerMs: number;
    totalMs: number;
    listenerCalls: number;
    avgFileMs: number;
    p95FileMs: number;
    p99FileMs: number;
    maxFileMs: number;
    listeners: RuleProfileListenerSummary[];
}
interface RuleProfileOutlier {
    ruleId: string;
    filePath: string;
    totalMs: number;
    setupMs: number;
    listenerMs: number;
    listenerCalls: number;
    reports: number;
}
interface RuleProfileSession {
    version: number;
    generatedAt: string;
    durationMs: number;
    cwd: string;
    nodeVersion: string;
    fileCount: number;
    enabledRuleCount: number;
    rules: RuleProfileSummary[];
    outliers: RuleProfileOutlier[];
}
declare function getRuleProfilerOptions(): RuleProfilerOptions;
declare function buildRuleProfileSession(): RuleProfileSession;
declare function flushRuleProfiler(): RuleProfileSession | null;
declare function resetRuleProfilerForTests(now?: () => bigint): void;
declare function setRuleProfilerNowForTests(now: () => bigint): void;

/**
 * Component Parser
 *
 * Parses a single component's body to extract styling information
 * and identify nested component usage.
 */

/**
 * Known UI library import patterns
 */
type LibraryName = "shadcn" | "mui" | "chakra" | "antd";

/**
 * Import Graph Service
 *
 * Provides demand-driven cross-file analysis to detect UI library usage
 * across component trees. Uses in-memory caching for performance.
 */

/**
 * Information about a component's UI library usage
 */
interface ComponentLibraryInfo {
    /** Direct library (from import source, e.g., "@mui/material" -> "mui") */
    library: LibraryName | null;
    /** Libraries used internally by this component (for local components) */
    internalLibraries: Set<LibraryName>;
    /** Evidence of which internal components caused the library detection */
    libraryEvidence: Array<{
        componentName: string;
        library: LibraryName;
    }>;
    /** Whether this is a local component (resolved from project files) */
    isLocalComponent: boolean;
}
/**
 * Analyze a component's library usage, including transitive dependencies
 *
 * @param contextFilePath - The file where the component is used (for resolving relative imports)
 * @param componentName - The name of the component (e.g., "Button", "MyCard")
 * @param importSource - The import source (e.g., "@mui/material", "./components/cards")
 * @returns Library information including direct and transitive library usage
 */
declare function getComponentLibrary(contextFilePath: string, componentName: string, importSource: string): ComponentLibraryInfo;
/**
 * Clear all caches (useful for testing or between ESLint runs)
 */
declare function clearCache(): void;

/**
 * Category Registry
 *
 * Centralized metadata for rule categories.
 * Used by CLI installers and UI components to display category information
 * without hardcoding assumptions.
 */
/**
 * Metadata for a rule category
 */
interface CategoryMeta {
    /** Category identifier */
    id: string;
    /** Display name */
    name: string;
    /** Short description */
    description: string;
    /** Icon for display (emoji) */
    icon: string;
    /** Whether rules in this category are enabled by default during install */
    defaultEnabled: boolean;
}
/**
 * Registry of all rule categories
 */
declare const categoryRegistry: CategoryMeta[];
/**
 * Get metadata for a specific category
 */
declare function getCategoryMeta(id: string): CategoryMeta | undefined;
/**
 * Get all registered categories (excluding "static" which is built-in).
 * Returns plugin-provided categories like "styleguide", "duplicates", etc.
 */
declare function getPluginCategories(): CategoryMeta[];
/**
 * Register a new category from a plugin package.
 * Idempotent: silently skips if a category with the same id already exists.
 */
declare function registerCategory(meta: CategoryMeta): void;

/**
 * Rule Registry
 *
 * Central registry of all UILint ESLint rules with metadata for CLI tooling.
 * Metadata is now colocated with each rule file - this module re-exports
 * the collected metadata for use by installers and other tools.
 *
 * Plugin packages (e.g. uilint-vision, uilint-semantic) contribute their
 * rules dynamically via `registerRuleMeta()` and `registerESLintRule()`.
 */

/**
 * Registry of all available UILint ESLint rules
 *
 * When adding a new rule:
 * 1. Create the rule file in src/rules/
 * 2. Export a `meta` object using `defineRuleMeta()`
 * 3. Import and add the meta to this array
 * 4. Run `pnpm generate:index` to regenerate exports
 */
declare const ruleRegistry: RuleMeta[];
/**
 * Get rule metadata by ID
 */
declare function getRuleMetadata(id: string): RuleMeta | undefined;
/**
 * Get all rules in a category
 */
declare function getRulesByCategory(category: string): RuleMeta[];
/**
 * Get documentation for a rule (useful for CLI help commands)
 */
declare function getRuleDocs(id: string): string | undefined;
/**
 * Get all rule IDs
 */
declare function getAllRuleIds(): string[];

/**
 * Register additional rule metadata from an external plugin package.
 *
 * @param meta - Rule metadata to register
 * @throws Error if a rule with the same id is already registered
 */
declare function registerRuleMeta(meta: RuleMeta): void;
/**
 * Register multiple rule metadata entries from an external plugin package.
 */
declare function registerRuleMetas(metas: RuleMeta[]): void;
/**
 * Register an ESLint rule implementation from a plugin package.
 * This makes the rule available to ESLint when constructing the plugin object.
 */
declare function registerESLintRule(id: string, rule: RuleModule<string, readonly unknown[]>): void;
/**
 * Get all registered external rule implementations.
 * Used by the serve command to merge plugin rules into the ESLint plugin.
 */
declare function getExternalRules(): Map<string, RuleModule<string, readonly unknown[]>>;
/**
 * Remove all externally registered rules (useful for testing).
 * Preserves the built-in static rules.
 */
declare function clearExternalRules(): void;

/**
 * All available rules
 */
declare const rules: {
    "consistent-dark-mode": _typescript_eslint_utils_ts_eslint.RuleModule<"inconsistentDarkMode" | "missingDarkMode", [({
        warnOnMissingDarkMode?: boolean;
    } | undefined)?], unknown, _typescript_eslint_utils_ts_eslint.RuleListener> & {
        name: string;
    };
    "no-direct-store-import": _typescript_eslint_utils_ts_eslint.RuleModule<"noDirectImport", [{
        storePattern?: string;
    }], unknown, _typescript_eslint_utils_ts_eslint.RuleListener> & {
        name: string;
    };
    "prefer-zustand-state-management": _typescript_eslint_utils_ts_eslint.RuleModule<"excessiveStateHooks", [({
        maxStateHooks?: number;
        countUseState?: boolean;
        countUseReducer?: boolean;
        countUseContext?: boolean;
    } | undefined)?], unknown, _typescript_eslint_utils_ts_eslint.RuleListener> & {
        name: string;
    };
    "no-mixed-component-libraries": _typescript_eslint_utils_ts_eslint.RuleModule<"nonPreferredLibrary" | "transitiveNonPreferred", [{
        preferred: LibraryName;
        libraries?: LibraryName[];
    }], unknown, _typescript_eslint_utils_ts_eslint.RuleListener> & {
        name: string;
    };
    "no-raw-ui-elements": _typescript_eslint_utils_ts_eslint.RuleModule<"rawElement", [({
        preferred?: "shadcn" | "mui" | "chakra" | "antd" | "auto" | "custom";
        elements?: string[];
        components?: Partial<Record<"button" | "input" | "input:checkbox" | "input:radio" | "input:range" | "textarea" | "select" | "dialog", string>>;
        ignoreFiles?: string[];
    } | undefined)?], unknown, _typescript_eslint_utils_ts_eslint.RuleListener> & {
        name: string;
    };
    "enforce-absolute-imports": _typescript_eslint_utils_ts_eslint.RuleModule<"preferAbsoluteImport", [{
        maxRelativeDepth?: number;
        aliasPrefix?: string;
        ignorePaths?: string[];
    }], unknown, _typescript_eslint_utils_ts_eslint.RuleListener> & {
        name: string;
    };
    "no-any-in-props": _typescript_eslint_utils_ts_eslint.RuleModule<"anyInProps" | "anyInPropsProperty", [{
        checkFCGenerics?: boolean;
        allowInGenericDefaults?: boolean;
    }], unknown, _typescript_eslint_utils_ts_eslint.RuleListener> & {
        name: string;
    };
    "no-unsafe-type-casts": _typescript_eslint_utils_ts_eslint.RuleModule<"noAsAny" | "noAsUnknown" | "noDoubleCast" | "noLegacyAsAny" | "noLegacyAsUnknown", [{
        reportAsAny?: boolean;
        reportAsUnknown?: boolean;
        reportDoubleCast?: boolean;
        allowInTestFiles?: boolean;
        allowInCatchBlocks?: boolean;
        allowedTypes?: string[];
    }], unknown, _typescript_eslint_utils_ts_eslint.RuleListener> & {
        name: string;
    };
    "zustand-use-selectors": _typescript_eslint_utils_ts_eslint.RuleModule<"missingSelector" | "useSelectorFunction", [{
        storePattern?: string;
        allowShallow?: boolean;
        requireNamedSelectors?: boolean;
    }], unknown, _typescript_eslint_utils_ts_eslint.RuleListener> & {
        name: string;
    };
    "prefer-store-selectors": _typescript_eslint_utils_ts_eslint.RuleModule<"useMemoWithStoreData" | "chainedDerivedState", [{
        storeHookPattern?: string;
    }], unknown, _typescript_eslint_utils_ts_eslint.RuleListener> & {
        name: string;
    };
    "no-prop-drilling-depth": _typescript_eslint_utils_ts_eslint.RuleModule<"propDrilling", [{
        maxDepth?: number;
        ignoredProps?: string[];
        ignoreComponents?: string[];
    }], unknown, _typescript_eslint_utils_ts_eslint.RuleListener> & {
        name: string;
    };
    "no-secrets-in-code": _typescript_eslint_utils_ts_eslint.RuleModule<"secretDetected" | "suspiciousVariable", [{
        additionalPatterns?: Array<{
            name: string;
            pattern: string;
        }>;
        checkVariableNames?: boolean;
        minSecretLength?: number;
        allowInTestFiles?: boolean;
    }], unknown, _typescript_eslint_utils_ts_eslint.RuleListener> & {
        name: string;
    };
    "require-input-validation": _typescript_eslint_utils_ts_eslint.RuleModule<"missingValidation" | "unvalidatedBodyAccess", [{
        httpMethods?: string[];
        routePatterns?: string[];
        allowManualValidation?: boolean;
    }], unknown, _typescript_eslint_utils_ts_eslint.RuleListener> & {
        name: string;
    };
    "prefer-tailwind": _typescript_eslint_utils_ts_eslint.RuleModule<"preferTailwind" | "preferSemanticColors" | "preferSemanticColorsWithSuggestion" | "preferSemanticClassGroups" | "semanticOpacityModifier" | "componentVariantLeakage", [({
        styleRatioThreshold?: number;
        minElementsForAnalysis?: number;
        allowedStyleProperties?: string[];
        ignoreComponents?: string[];
        preferSemanticColors?: boolean;
        allowedHardCodedColors?: string[];
        useLlmSuggestions?: boolean;
        preferSemanticClassGroups?: boolean;
        visualUtilityThreshold?: number;
        visualUtilityMinGroups?: number;
        disallowSemanticOpacityModifiers?: boolean;
        allowedOpacityModifierClasses?: string[];
        allowedVisualUtilityClasses?: string[];
        preferComponentVariants?: boolean;
        componentVariantComponents?: string[];
        componentVariantProps?: string[];
        componentVariantClassThreshold?: number;
        allowedComponentVariantClasses?: string[];
    } | undefined)?], unknown, _typescript_eslint_utils_ts_eslint.RuleListener> & {
        name: string;
    };
};
/**
 * Plugin metadata
 */
declare const meta: {
    name: string;
    version: string;
};
/**
 * The ESLint plugin object
 */
declare const plugin: {
    meta: {
        name: string;
        version: string;
    };
    rules: {
        "consistent-dark-mode": _typescript_eslint_utils_ts_eslint.RuleModule<"inconsistentDarkMode" | "missingDarkMode", [({
            warnOnMissingDarkMode?: boolean;
        } | undefined)?], unknown, _typescript_eslint_utils_ts_eslint.RuleListener> & {
            name: string;
        };
        "no-direct-store-import": _typescript_eslint_utils_ts_eslint.RuleModule<"noDirectImport", [{
            storePattern?: string;
        }], unknown, _typescript_eslint_utils_ts_eslint.RuleListener> & {
            name: string;
        };
        "prefer-zustand-state-management": _typescript_eslint_utils_ts_eslint.RuleModule<"excessiveStateHooks", [({
            maxStateHooks?: number;
            countUseState?: boolean;
            countUseReducer?: boolean;
            countUseContext?: boolean;
        } | undefined)?], unknown, _typescript_eslint_utils_ts_eslint.RuleListener> & {
            name: string;
        };
        "no-mixed-component-libraries": _typescript_eslint_utils_ts_eslint.RuleModule<"nonPreferredLibrary" | "transitiveNonPreferred", [{
            preferred: LibraryName;
            libraries?: LibraryName[];
        }], unknown, _typescript_eslint_utils_ts_eslint.RuleListener> & {
            name: string;
        };
        "no-raw-ui-elements": _typescript_eslint_utils_ts_eslint.RuleModule<"rawElement", [({
            preferred?: "shadcn" | "mui" | "chakra" | "antd" | "auto" | "custom";
            elements?: string[];
            components?: Partial<Record<"button" | "input" | "input:checkbox" | "input:radio" | "input:range" | "textarea" | "select" | "dialog", string>>;
            ignoreFiles?: string[];
        } | undefined)?], unknown, _typescript_eslint_utils_ts_eslint.RuleListener> & {
            name: string;
        };
        "enforce-absolute-imports": _typescript_eslint_utils_ts_eslint.RuleModule<"preferAbsoluteImport", [{
            maxRelativeDepth?: number;
            aliasPrefix?: string;
            ignorePaths?: string[];
        }], unknown, _typescript_eslint_utils_ts_eslint.RuleListener> & {
            name: string;
        };
        "no-any-in-props": _typescript_eslint_utils_ts_eslint.RuleModule<"anyInProps" | "anyInPropsProperty", [{
            checkFCGenerics?: boolean;
            allowInGenericDefaults?: boolean;
        }], unknown, _typescript_eslint_utils_ts_eslint.RuleListener> & {
            name: string;
        };
        "no-unsafe-type-casts": _typescript_eslint_utils_ts_eslint.RuleModule<"noAsAny" | "noAsUnknown" | "noDoubleCast" | "noLegacyAsAny" | "noLegacyAsUnknown", [{
            reportAsAny?: boolean;
            reportAsUnknown?: boolean;
            reportDoubleCast?: boolean;
            allowInTestFiles?: boolean;
            allowInCatchBlocks?: boolean;
            allowedTypes?: string[];
        }], unknown, _typescript_eslint_utils_ts_eslint.RuleListener> & {
            name: string;
        };
        "zustand-use-selectors": _typescript_eslint_utils_ts_eslint.RuleModule<"missingSelector" | "useSelectorFunction", [{
            storePattern?: string;
            allowShallow?: boolean;
            requireNamedSelectors?: boolean;
        }], unknown, _typescript_eslint_utils_ts_eslint.RuleListener> & {
            name: string;
        };
        "prefer-store-selectors": _typescript_eslint_utils_ts_eslint.RuleModule<"useMemoWithStoreData" | "chainedDerivedState", [{
            storeHookPattern?: string;
        }], unknown, _typescript_eslint_utils_ts_eslint.RuleListener> & {
            name: string;
        };
        "no-prop-drilling-depth": _typescript_eslint_utils_ts_eslint.RuleModule<"propDrilling", [{
            maxDepth?: number;
            ignoredProps?: string[];
            ignoreComponents?: string[];
        }], unknown, _typescript_eslint_utils_ts_eslint.RuleListener> & {
            name: string;
        };
        "no-secrets-in-code": _typescript_eslint_utils_ts_eslint.RuleModule<"secretDetected" | "suspiciousVariable", [{
            additionalPatterns?: Array<{
                name: string;
                pattern: string;
            }>;
            checkVariableNames?: boolean;
            minSecretLength?: number;
            allowInTestFiles?: boolean;
        }], unknown, _typescript_eslint_utils_ts_eslint.RuleListener> & {
            name: string;
        };
        "require-input-validation": _typescript_eslint_utils_ts_eslint.RuleModule<"missingValidation" | "unvalidatedBodyAccess", [{
            httpMethods?: string[];
            routePatterns?: string[];
            allowManualValidation?: boolean;
        }], unknown, _typescript_eslint_utils_ts_eslint.RuleListener> & {
            name: string;
        };
        "prefer-tailwind": _typescript_eslint_utils_ts_eslint.RuleModule<"preferTailwind" | "preferSemanticColors" | "preferSemanticColorsWithSuggestion" | "preferSemanticClassGroups" | "semanticOpacityModifier" | "componentVariantLeakage", [({
            styleRatioThreshold?: number;
            minElementsForAnalysis?: number;
            allowedStyleProperties?: string[];
            ignoreComponents?: string[];
            preferSemanticColors?: boolean;
            allowedHardCodedColors?: string[];
            useLlmSuggestions?: boolean;
            preferSemanticClassGroups?: boolean;
            visualUtilityThreshold?: number;
            visualUtilityMinGroups?: number;
            disallowSemanticOpacityModifiers?: boolean;
            allowedOpacityModifierClasses?: string[];
            allowedVisualUtilityClasses?: string[];
            preferComponentVariants?: boolean;
            componentVariantComponents?: string[];
            componentVariantProps?: string[];
            componentVariantClassThreshold?: number;
            allowedComponentVariantClasses?: string[];
        } | undefined)?], unknown, _typescript_eslint_utils_ts_eslint.RuleListener> & {
            name: string;
        };
    };
};
/**
 * Pre-configured configs
 */
declare const configs: Record<string, Linter.Config>;
/**
 * UILint ESLint export interface
 */
interface UILintESLint {
    meta: typeof meta;
    plugin: typeof plugin;
    rules: typeof rules;
    configs: Record<string, Linter.Config>;
}
/**
 * Default export for ESLint flat config
 */
declare const uilintEslint: UILintESLint;

export { type CacheEntry, type CacheStore, type CachedIssue, type CategoryMeta, type LibraryName, type OptionFieldSchema, type RuleMeta, type RuleMeta as RuleMetadata, type RuleMigration, type RuleOptionSchema, type RuleProfileOutlier, type RuleProfileSession, type RuleProfileSummary, type RuleRequirement, type UILintESLint, buildRuleProfileSession, categoryRegistry, clearAllSuggestions, clearCache$1 as clearCache, clearCacheEntry, clearExternalRules, clearCache as clearImportGraphCache, configs, createRule, uilintEslint as default, defineRuleMeta, findStyleguidePath, flushRuleProfiler, getAllRuleIds, getCacheEntry, getCategoryMeta, getComponentLibrary, getExternalRules, getPluginCategories, getRuleDocs, getRuleMetadata, getRuleProfilerOptions, getRulesByCategory, getStyleguide, hashContent, hashContentSync, loadCache, loadStyleguide, meta, plugin, registerCategory, registerESLintRule, registerRuleMeta, registerRuleMetas, resetRuleProfilerForTests, ruleRegistry, rules, saveCache, setCacheEntry, setRuleProfilerNowForTests };