Language & Framework Support

/**
 * Core JavaScript configuration with globals and base rules
 * @param options - JavaScript configuration options
 * @returns ESLint config for JavaScript files
 */
function javascript(
  options?: OptionsIsInEditor & OptionsOverrides
): Promise<TypedFlatConfigItem[]>;

interface OptionsIsInEditor {
  /** Whether running in editor environment */
  isInEditor?: boolean;
}

import { javascript } from "@antfu/eslint-config";

// Basic JavaScript config
const jsConfig = await javascript();

// With editor-specific rules disabled
const jsConfigEditor = await javascript({
  isInEditor: true,
  overrides: {
    'no-console': 'off',
  },
});

/**
 * TypeScript configuration with parser and type-aware rules
 * @param options - TypeScript configuration options
 * @returns ESLint config for TypeScript files  
 */
function typescript(
  options?: OptionsFiles & OptionsComponentExts & OptionsOverrides & OptionsTypeScriptWithTypes & OptionsTypeScriptParserOptions & OptionsProjectType
): Promise<TypedFlatConfigItem[]>;

interface OptionsTypeScriptWithTypes {
  /** Path to tsconfig.json for type-aware rules */
  tsconfigPath?: string;
  /** Override type aware rules */
  overridesTypeAware?: TypedFlatConfigItem['rules'];
}

interface OptionsTypeScriptParserOptions {
  /** Additional parser options for TypeScript */
  parserOptions?: Partial<ParserOptions>;
  /** Files that should be type aware */
  filesTypeAware?: string[];
  /** Files that should not be type aware */
  ignoresTypeAware?: string[];
}

type OptionsTypescript = (OptionsTypeScriptWithTypes & OptionsOverrides) | (OptionsTypeScriptParserOptions & OptionsOverrides);

import { typescript } from "@antfu/eslint-config";

// Basic TypeScript config
const tsConfig = await typescript();

// With type-aware linting
const tsConfigStrict = await typescript({
  tsconfigPath: './tsconfig.json',
  type: 'lib',
  overridesTypeAware: {
    '@typescript-eslint/no-unsafe-assignment': 'error',
  },
});

/**
 * Vue.js configuration for SFC files and templates
 * @param options - Vue configuration options
 * @returns ESLint config for Vue files
 */
function vue(
  options?: OptionsVue & OptionsHasTypeScript & OptionsOverrides & OptionsStylistic & OptionsFiles
): Promise<TypedFlatConfigItem[]>;

interface OptionsVue extends OptionsOverrides {
  /** Create virtual files for Vue SFC blocks */
  sfcBlocks?: boolean | VueBlocksOptions;
  /** Vue version for different rule sets */
  vueVersion?: 2 | 3;
  /** Enable Vue accessibility plugin */
  a11y?: boolean;
}

import { vue } from "@antfu/eslint-config";

// Basic Vue config
const vueConfig = await vue();

// With Vue 2 and accessibility
const vueConfigA11y = await vue({
  vueVersion: 2, 
  a11y: true,
  typescript: true,
  stylistic: {
    indent: 2,
  },
});

/**
 * React configuration for JSX and hooks
 * @param options - React configuration options
 * @returns ESLint config for React files
 */
function react(
  options?: OptionsTypeScriptParserOptions & OptionsTypeScriptWithTypes & OptionsOverrides & OptionsFiles
): Promise<TypedFlatConfigItem[]>;

import { react } from "@antfu/eslint-config";

// Basic React config
const reactConfig = await react();

// With TypeScript and custom rules
const reactConfigTS = await react({
  tsconfigPath: './tsconfig.json',
  overrides: {
    'react/prop-types': 'off',
  },
});

/**
 * Next.js configuration for Next.js applications
 * @param options - Next.js configuration options
 * @returns ESLint config for Next.js projects
 */
function nextjs(
  options?: OptionsOverrides & OptionsFiles
): Promise<TypedFlatConfigItem[]>;

/**
 * Svelte configuration for Svelte components
 * @param options - Svelte configuration options
 * @returns ESLint config for Svelte files
 */
function svelte(
  options?: OptionsOverrides & OptionsStylistic & OptionsHasTypeScript & OptionsFiles
): Promise<TypedFlatConfigItem[]>;

interface OptionsHasTypeScript {
  /** Whether TypeScript is enabled */
  typescript?: boolean;
}

/**
 * Solid.js configuration for Solid components
 * @param options - Solid configuration options
 * @returns ESLint config for Solid files
 */
function solid(
  options?: OptionsOverrides & OptionsFiles & OptionsTypeScriptWithTypes & OptionsHasTypeScript
): Promise<TypedFlatConfigItem[]>;

/**
 * Astro configuration for Astro components
 * @param options - Astro configuration options
 * @returns ESLint config for Astro files
 */
function astro(
  options?: OptionsOverrides & OptionsStylistic & OptionsFiles
): Promise<TypedFlatConfigItem[]>;

/**
 * JSX configuration for JSX syntax
 * @param options - JSX configuration options
 * @returns ESLint config for JSX files
 */
function jsx(
  options?: OptionsJSX
): Promise<TypedFlatConfigItem[]>;

interface OptionsJSX {
  /** Enable JSX accessibility rules */
  a11y?: boolean | OptionsJSXA11y;
}

interface OptionsJSXA11y extends OptionsOverrides {
  // JSX accessibility specific options
}

/**
 * Test configuration for testing frameworks
 * @param options - Test configuration options
 * @returns ESLint config for test files
 */
function test(
  options?: OptionsIsInEditor & OptionsOverrides & OptionsFiles
): Promise<TypedFlatConfigItem[]>;

/**
 * Import configuration for import/export rules
 * @param options - Import configuration options
 * @returns ESLint config for import rules
 */
function imports(
  options?: OptionsOverrides & OptionsStylistic
): Promise<TypedFlatConfigItem[]>;

/**
 * JSDoc configuration for documentation comments
 * @param options - JSDoc configuration options
 * @returns ESLint config for JSDoc rules
 */
function jsdoc(
  options?: OptionsStylistic
): Promise<TypedFlatConfigItem[]>;

/**
 * Node.js configuration for Node.js environments
 * @returns ESLint config for Node.js globals and rules
 */
function node(): Promise<TypedFlatConfigItem[]>;

/**
 * Comments configuration for ESLint comment directives
 * @returns ESLint config for comment rules
 */
function comments(): Promise<TypedFlatConfigItem[]>;

/**
 * Command configuration for inline ESLint commands
 * @returns ESLint config for command processing
 */
function command(): Promise<TypedFlatConfigItem[]>;

/**
 * Disables configuration for rule disable patterns
 * @returns ESLint config for disable management
 */
function disables(): Promise<TypedFlatConfigItem[]>;

/**
 * Unicorn configuration for modern JavaScript practices
 * @param options - Unicorn configuration options
 * @returns ESLint config for Unicorn rules
 */
function unicorn(options?: OptionsUnicorn): Promise<TypedFlatConfigItem[]>;

interface OptionsUnicorn {
  rules?: Partial<UnicornRules>;
}

/**
 * Perfectionist configuration for sorting and organization
 * @returns ESLint config for sorting rules
 */
function perfectionist(): Promise<TypedFlatConfigItem[]>;

/**
 * RegExp configuration for regular expression rules
 * @param options - RegExp configuration options
 * @returns ESLint config for RegExp rules
 */
function regexp(options?: OptionsRegExp & OptionsOverrides): Promise<TypedFlatConfigItem[]>;

interface OptionsRegExp {
  level?: 'error' | 'warn';
}

/**
 * UnoCSS configuration for atomic CSS
 * @param options - UnoCSS configuration options
 * @returns ESLint config for UnoCSS rules
 */
function unocss(options?: OptionsUnoCSS & OptionsOverrides & OptionsFiles): Promise<TypedFlatConfigItem[]>;

interface OptionsUnoCSS {
  attributify?: boolean;
  strict?: boolean;
}

/**
 * PNPM configuration for PNPM package manager
 * @returns ESLint config for PNPM rules
 */
function pnpm(): Promise<TypedFlatConfigItem[]>;

/**
 * Package.json sorting configuration
 * @returns ESLint config for package.json sorting
 */
function sortPackageJson(): Promise<TypedFlatConfigItem[]>;

/**
 * TSConfig sorting configuration
 * @returns ESLint config for tsconfig.json sorting
 */
function sortTsconfig(): TypedFlatConfigItem[];

/**
 * Ignores configuration for file patterns
 * @param userIgnores - Additional ignore patterns
 * @returns ESLint config for ignore patterns
 */
function ignores(userIgnores?: string[]): Promise<TypedFlatConfigItem[]>;