import { Linter } from 'eslint';
import * as prettier from 'prettier';

type Dependencies = Record<string, string>;
type PackageJson = {
    version: string;
    dependencies?: Dependencies;
    devDependencies?: Dependencies;
};
type Jsconfig = {
    compilerOptions?: {
        baseUrl?: string;
        paths?: Record<string, string[]>;
    };
};

declare const servicePresetNames: {
    readonly base: "base";
    readonly extend: "extend";
};
declare const publicPresetNames: {
    readonly imports: "imports";
    readonly node: "node";
    readonly prettier: "prettier";
    readonly typescript: "typescript";
    readonly react: "react";
    readonly astro: "astro";
    readonly vue: "vue";
    readonly solidJs: "solid.js";
    readonly effector: "effector";
    readonly nextJs: "next.js";
    readonly remix: "remix";
    readonly svelte: "svelte";
};
type ServicePresetName = (typeof servicePresetNames)[keyof typeof servicePresetNames];
type PublicPresetName = (typeof publicPresetNames)[keyof typeof publicPresetNames];
type PresetName = ServicePresetName | PublicPresetName;

type Meta = {
    root: string;
    allowDebug: boolean;
    readPackageJson(): PackageJson | null;
    readJsconfig(): Jsconfig | null;
    presets: Set<PresetName>;
    imports: {
        extensions: string[];
    };
    typescript: {
        root: string;
        tsconfig: string;
        enforceUsingType: boolean;
    };
};
type Input<T = void> = {
    options?: T;
    meta: Meta;
};
type Preset<T = void> = {
    name: PresetName;
    options?: T;
    updateMeta(input: Input<T>): void;
    compile(input: Input<T>): Linter.Config;
};

type Options$6 = {
    typescriptPackage: unknown;
    noTypeCheck: boolean;
};

type Options$5 = {
    future?: boolean;
};

type Options$4 = {
    version?: string | 'detect';
};

type Options$3 = {
    version?: string | 'detect';
    oldJSXTransform?: boolean;
};

type Options$2 = {
    root?: string;
    tsconfig?: string;
    enforceUsingType?: boolean;
};

type Options$1 = {
    sort?: {
        newline?: boolean;
        groups?: string[][];
    };
    alias?: {
        root?: string;
        paths?: Record<string, string>;
        jsconfig?: string;
    };
};

declare const presets: {
    imports: (options?: Options$1 | undefined) => Preset<Options$1>;
    node: (options?: void | undefined) => Preset<void>;
    prettier: (options?: prettier.Config | undefined) => Preset<prettier.Config>;
    typescript: (options?: Options$2 | undefined) => Preset<Options$2>;
    react: (options?: Options$3 | undefined) => Preset<Options$3>;
    vue: (options?: Options$4 | undefined) => Preset<Options$4>;
    astro: (options?: void | undefined) => Preset<void>;
    solidJs: (options?: void | undefined) => Preset<void>;
    effector: (options?: Options$5 | undefined) => Preset<Options$5>;
    nextJs: (options?: void | undefined) => Preset<void>;
    remix: (options?: void | undefined) => Preset<void>;
    svelte: (options?: Options$6 | undefined) => Preset<Options$6>;
};

type Mode = 'default' | 'only-errors' | 'only-warns' | 'disable-warns' | 'decrease-level';

declare const ESLintKitOptionsSymbol: unique symbol;
type ExtendedLinterConfig<T extends Linter.RulesRecord = Linter.RulesRecord> = {
    [ESLintKitOptionsSymbol]: FinalOptions;
} & Linter.Config<T>;
type Options = {
    extends?: string | ExtendedLinterConfig;
    root?: string;
    mode?: Mode;
    allowDebug?: boolean;
    presets?: Preset<unknown>[];
    extend?: Linter.Config;
};
type FinalOptions = {
    extends?: Options['extends'];
    root: Required<Options>['root'];
    mode: Required<Options>['mode'];
    allowDebug?: boolean;
    presets: Required<Options>['presets'];
    extend: Required<Options>['extend'];
};
declare function configure(options: Options): ExtendedLinterConfig<Linter.RulesRecord>;

export { configure, presets };