import { Linter } from '../index';

export interface StylisticIssues extends Linter.RulesRecord {
    /**
     * Rule to enforce linebreaks after opening and before closing array brackets.
     *
     * @since 4.0.0-alpha.1
     * @see https://eslint.org/docs/rules/array-bracket-newline
     */
    'array-bracket-newline': Linter.RuleEntry<[
        'always' | 'never' | 'consistent' | Partial<{
            /**
             * @default true
             */
            multiline: boolean;
            /**
             * @default null
             */
            minItems: number | null;
        }>
    ]>;

    /**
     * Rule to enforce consistent spacing inside array brackets.
     *
     * @since 0.24.0
     * @see https://eslint.org/docs/rules/array-bracket-spacing
     */
    'array-bracket-spacing': Linter.RuleEntry<[
        'never',
        Partial<{
            /**
             * @default false
             */
            singleValue: boolean;
            /**
             * @default false
             */
            objectsInArrays: boolean;
            /**
             * @default false
             */
            arraysInArrays: boolean;
        }>
    ]> | Linter.RuleEntry<[
        'always',
        Partial<{
            /**
             * @default true
             */
            singleValue: boolean;
            /**
             * @default true
             */
            objectsInArrays: boolean;
            /**
             * @default true
             */
            arraysInArrays: boolean;
        }>
    ]>;

    /**
     * Rule to enforce line breaks after each array element.
     *
     * @since 4.0.0-rc.0
     * @see https://eslint.org/docs/rules/array-element-newline
     */
    'array-element-newline': Linter.RuleEntry<[
        'always' | 'never' | 'consistent' | Partial<{
            /**
             * @default true
             */
            multiline: boolean;
            /**
             * @default null
             */
            minItems: number | null;
        }>
    ]>;

    /**
     * Rule to disallow or enforce spaces inside of blocks after opening block and before closing block.
     *
     * @since 1.2.0
     * @see https://eslint.org/docs/rules/block-spacing
     */
    'block-spacing': Linter.RuleEntry<[
        'always' | 'never'
    ]>;

    /**
     * Rule to enforce consistent brace style for blocks.
     *
     * @since 0.0.7
     * @see https://eslint.org/docs/rules/brace-style
     */
    'brace-style': Linter.RuleEntry<[
        '1tbs' | 'stroustrup' | 'allman',
        Partial<{
            /**
             * @default false
             */
            allowSingleLine: boolean;
        }>
    ]>;

    /**
     * Rule to enforce camelcase naming convention.
     *
     * @since 0.0.2
     * @see https://eslint.org/docs/rules/camelcase
     */
    'camelcase': Linter.RuleEntry<[
        Partial<{
            /**
             * @default 'always'
             */
            properties: 'always' | 'never';
            /**
             * @default false
             */
            ignoreDestructuring: boolean;
            /**
             * @remarks
             * Also accept for regular expression patterns
             */
            allow: string[];
        }>
    ]>;

    /**
     * Rule to enforce or disallow capitalization of the first letter of a comment.
     *
     * @since 3.11.0
     * @see https://eslint.org/docs/rules/capitalized-comments
     */
    'capitalized-comments': Linter.RuleEntry<[
        'always' | 'never',
        Partial<{
            ignorePattern: string[];
            /**
             * @default false
             */
            ignoreInlineComments: boolean;
            /**
             * @default false
             */
            ignoreConsecutiveComments: boolean;
        }>
    ]>;

    /**
     * Rule to require or disallow trailing commas.
     *
     * @since 0.16.0
     * @see https://eslint.org/docs/rules/comma-dangle
     */
    'comma-dangle': Linter.RuleEntry<[
        'never' | 'always' | 'always-multiline' | 'only-multiline' | Partial<{
            /**
             * @default 'never'
             */
            arrays: 'never' | 'always' | 'always-multiline' | 'only-multiline';
            /**
             * @default 'never'
             */
            objects: 'never' | 'always' | 'always-multiline' | 'only-multiline';
            /**
             * @default 'never'
             */
            imports: 'never' | 'always' | 'always-multiline' | 'only-multiline';
            /**
             * @default 'never'
             */
            exports: 'never' | 'always' | 'always-multiline' | 'only-multiline';
            /**
             * @default 'never'
             */
            functions: 'never' | 'always' | 'always-multiline' | 'only-multiline';
        }>
    ]>;

    /**
     * Rule to enforce consistent spacing before and after commas.
     *
     * @since 0.9.0
     * @see https://eslint.org/docs/rules/comma-spacing
     */
    'comma-spacing': Linter.RuleEntry<[
        Partial<{
            /**
             * @default false
             */
            before: boolean;
            /**
             * @default true
             */
            after: boolean;
        }>
    ]>;

    /**
     * Rule to enforce consistent comma style.
     *
     * @since 0.9.0
     * @see https://eslint.org/docs/rules/comma-style
     */
    'comma-style': Linter.RuleEntry<[
        'last' | 'first',
        Partial<{
            exceptions: Record<string, boolean>;
        }>
    ]>;

    /**
     * Rule to enforce consistent spacing inside computed property brackets.
     *
     * @since 0.23.0
     * @see https://eslint.org/docs/rules/computed-property-spacing
     */
    'computed-property-spacing': Linter.RuleEntry<[
        'never' | 'always'
    ]>;

    /**
     * Rule to enforce consistent naming when capturing the current execution context.
     *
     * @since 0.0.9
     * @see https://eslint.org/docs/rules/consistent-this
     */
    'consistent-this': Linter.RuleEntry<[
        ...string[]
    ]>;

    /**
     * Rule to require or disallow newline at the end of files.
     *
     * @since 0.7.1
     * @see https://eslint.org/docs/rules/eol-last
     */
    'eol-last': Linter.RuleEntry<[
        'always' | 'never' // | 'unix' | 'windows'
    ]>;

    /**
     * Rule to require or disallow spacing between function identifiers and their invocations.
     *
     * @since 3.3.0
     * @see https://eslint.org/docs/rules/func-call-spacing
     */
    'func-call-spacing': Linter.RuleEntry<[
        'never' | 'always'
    ]>;

    /**
     * Rule to require function names to match the name of the variable or property to which they are assigned.
     *
     * @since 3.8.0
     * @see https://eslint.org/docs/rules/func-name-matching
     */
    'func-name-matching': Linter.RuleEntry<[
        'always' | 'never',
        Partial<{
            /**
             * @default false
             */
            considerPropertyDescriptor: boolean;
            /**
             * @default false
             */
            includeCommonJSModuleExports: boolean;
        }>
    ]> | Linter.RuleEntry<[
        Partial<{
            /**
             * @default false
             */
            considerPropertyDescriptor: boolean;
            /**
             * @default false
             */
            includeCommonJSModuleExports: boolean;
        }>
    ]>;

    /**
     * Rule to require or disallow named `function` expressions.
     *
     * @since 0.4.0
     * @see https://eslint.org/docs/rules/func-names
     */
    'func-names': Linter.RuleEntry<[
        'always' | 'as-needed' | 'never',
        Partial<{
            generators: 'always' | 'as-needed' | 'never';
        }>
    ]>;

    /**
     * Rule to enforce the consistent use of either `function` declarations or expressions.
     *
     * @since 0.2.0
     * @see https://eslint.org/docs/rules/func-style
     */
    'func-style': Linter.RuleEntry<[
        'expression' | 'declaration',
        Partial<{
            /**
             * @default false
             */
            allowArrowFunctions: boolean;
        }>
    ]>;

    /**
     * Rule to enforce consistent line breaks inside function parentheses.
     *
     * @since 4.6.0
     * @see https://eslint.org/docs/rules/function-paren-newline
     */
    'function-paren-newline': Linter.RuleEntry<[
        'always' | 'never' | 'multiline' | 'multiline-arguments' | 'consistent' | Partial<{
            minItems: number;
        }>
    ]>;

    /**
     * Rule to disallow specified identifiers.
     *
     * @since 2.0.0-beta.2
     * @see https://eslint.org/docs/rules/id-blacklist
     */
    'id-blacklist': Linter.RuleEntry<[
        ...string[]
    ]>;

    /**
     * Rule to enforce minimum and maximum identifier lengths.
     *
     * @since 1.0.0
     * @see https://eslint.org/docs/rules/id-length
     */
    'id-length': Linter.RuleEntry<[
        Partial<{
            /**
             * @default 2
             */
            min: number;
            /**
             * @default Infinity
             */
            max: number;
            /**
             * @default 'always'
             */
            properties: 'always' | 'never';
            exceptions: string[];
        }>
    ]>;

    /**
     * Rule to require identifiers to match a specified regular expression.
     *
     * @since 1.0.0
     * @see https://eslint.org/docs/rules/id-match
     */
    'id-match': Linter.RuleEntry<[
        string,
        Partial<{
            /**
             * @default false
             */
            properties: boolean;
            /**
             * @default false
             */
            onlyDeclarations: boolean;
            /**
             * @default false
             */
            ignoreDestructuring: boolean;
        }>
    ]>;

    /**
     * Rule to enforce the location of arrow function bodies.
     *
     * @since 4.12.0
     * @see https://eslint.org/docs/rules/implicit-arrow-linebreak
     */
    'implicit-arrow-linebreak': Linter.RuleEntry<[
        'beside' | 'below'
    ]>;

    /**
     * Rule to enforce consistent indentation.
     *
     * @since 0.14.0
     * @see https://eslint.org/docs/rules/indent
     */
    'indent': Linter.RuleEntry<[
        number | 'tab',
        Partial<{
            /**
             * @default 0
             */
            SwitchCase: number;
            /**
             * @default 1
             */
            VariableDeclarator: Partial<{
                /**
                 * @default 1
                 */
                var: number | 'first';
                /**
                 * @default 1
                 */
                let: number | 'first';
                /**
                 * @default 1
                 */
                const: number | 'first';
            }> | number | 'first';
            /**
             * @default 1
             */
            outerIIFEBody: number;
            /**
             * @default 1
             */
            MemberExpression: number | 'off';
            /**
             * @default { parameters: 1, body: 1 }
             */
            FunctionDeclaration: Partial<{
                /**
                 * @default 1
                 */
                parameters: number | 'first' | 'off';
                /**
                 * @default 1
                 */
                body: number;
            }>;
            /**
             * @default { parameters: 1, body: 1 }
             */
            FunctionExpression: Partial<{
                /**
                 * @default 1
                 */
                parameters: number | 'first' | 'off';
                /**
                 * @default 1
                 */
                body: number;
            }>;
            /**
             * @default { arguments: 1 }
             */
            CallExpression: Partial<{
                /**
                 * @default 1
                 */
                arguments: number | 'first' | 'off';
            }>;
            /**
             * @default 1
             */
            ArrayExpression: number | 'first' | 'off';
            /**
             * @default 1
             */
            ObjectExpression: number | 'first' | 'off';
            /**
             * @default 1
             */
            ImportDeclaration: number | 'first' | 'off';
            /**
             * @default false
             */
            flatTernaryExpressions: boolean;
            ignoredNodes: string[];
            /**
             * @default false
             */
            ignoreComments: boolean;
        }>
    ]>;

    /**
     * Rule to enforce the consistent use of either double or single quotes in JSX attributes.
     *
     * @since 1.4.0
     * @see https://eslint.org/docs/rules/jsx-quotes
     */
    'jsx-quotes': Linter.RuleEntry<[
        'prefer-double' | 'prefer-single'
    ]>;

    /**
     * Rule to enforce consistent spacing between keys and values in object literal properties.
     *
     * @since 0.9.0
     * @see https://eslint.org/docs/rules/key-spacing
     */
    'key-spacing': Linter.RuleEntry<[
        Partial<{
            /**
             * @default false
             */
            beforeColon: boolean;
            /**
             * @default true
             */
            afterColon: boolean;
            /**
             * @default 'strict'
             */
            mode: 'strict' | 'minimum';
            align: Partial<{
                /**
                 * @default false
                 */
                beforeColon: boolean;
                /**
                 * @default true
                 */
                afterColon: boolean;
                /**
                 * @default 'colon'
                 */
                on: 'value' | 'colon';
                /**
                 * @default 'strict'
                 */
                mode: 'strict' | 'minimum';
            }> | 'value' | 'colon';
        } | {
            singleLine?: Partial<{
                /**
                 * @default false
                 */
                beforeColon: boolean;
                /**
                 * @default true
                 */
                afterColon: boolean;
                /**
                 * @default 'strict'
                 */
                mode: 'strict' | 'minimum';
            }>;
            multiLine?: Partial<{
                /**
                 * @default false
                 */
                beforeColon: boolean;
                /**
                 * @default true
                 */
                afterColon: boolean;
                /**
                 * @default 'strict'
                 */
                mode: 'strict' | 'minimum';
                align: Partial<{
                    /**
                     * @default false
                     */
                    beforeColon: boolean;
                    /**
                     * @default true
                     */
                    afterColon: boolean;
                    /**
                     * @default 'colon'
                     */
                    on: 'value' | 'colon';
                    /**
                     * @default 'strict'
                     */
                    mode: 'strict' | 'minimum';
                }> | 'value' | 'colon';
            }>;
        }> | {
            align: Partial<{
                /**
                 * @default false
                 */
                beforeColon: boolean;
                /**
                 * @default true
                 */
                afterColon: boolean;
                /**
                 * @default 'colon'
                 */
                on: 'value' | 'colon';
                /**
                 * @default 'strict'
                 */
                mode: 'strict' | 'minimum';
            }>;
            singleLine?: Partial<{
                /**
                 * @default false
                 */
                beforeColon: boolean;
                /**
                 * @default true
                 */
                afterColon: boolean;
                /**
                 * @default 'strict'
                 */
                mode: 'strict' | 'minimum';
            }>;
            multiLine?: Partial<{
                /**
                 * @default false
                 */
                beforeColon: boolean;
                /**
                 * @default true
                 */
                afterColon: boolean;
                /**
                 * @default 'strict'
                 */
                mode: 'strict' | 'minimum';
            }>;
        }
    ]>;

    /**
     * Rule to enforce consistent spacing before and after keywords.
     *
     * @since 2.0.0-beta.1
     * @see https://eslint.org/docs/rules/keyword-spacing
     */
    'keyword-spacing': Linter.RuleEntry<[
        Partial<{
            /**
             * @default true
             */
            before: boolean;
            /**
             * @default true
             */
            after: boolean;
            overrides: Record<string, Partial<{
                before: boolean;
                after: boolean;
            }>>;
        }>
    ]>;

    /**
     * Rule to enforce position of line comments.
     *
     * @since 3.5.0
     * @see https://eslint.org/docs/rules/line-comment-position
     */
    'line-comment-position': Linter.RuleEntry<[
        Partial<{
            /**
             * @default 'above'
             */
            position: 'above' | 'beside';
            ignorePattern: string;
            /**
             * @default true
             */
            applyDefaultIgnorePatterns: boolean;
        }>
    ]>;

    /**
     * Rule to enforce consistent linebreak style.
     *
     * @since 0.21.0
     * @see https://eslint.org/docs/rules/linebreak-style
     */
    'linebreak-style': Linter.RuleEntry<[
        'unix' | 'windows'
    ]>;

    /**
     * Rule to require empty lines around comments.
     *
     * @since 0.22.0
     * @see https://eslint.org/docs/rules/lines-around-comment
     */
    'lines-around-comment': Linter.RuleEntry<[
        Partial<{
            /**
             * @default true
             */
            beforeBlockComment: boolean;
            /**
             * @default false
             */
            afterBlockComment: boolean;
            /**
             * @default false
             */
            beforeLineComment: boolean;
            /**
             * @default false
             */
            afterLineComment: boolean;
            /**
             * @default false
             */
            allowBlockStart: boolean;
            /**
             * @default false
             */
            allowBlockEnd: boolean;
            /**
             * @default false
             */
            allowObjectStart: boolean;
            /**
             * @default false
             */
            allowObjectEnd: boolean;
            /**
             * @default false
             */
            allowArrayStart: boolean;
            /**
             * @default false
             */
            allowArrayEnd: boolean;
            /**
             * @default false
             */
            allowClassStart: boolean;
            /**
             * @default false
             */
            allowClassEnd: boolean;
            ignorePattern: string;
            /**
             * @default true
             */
            applyDefaultIgnorePatterns: boolean;
        }>
    ]>;

    /**
     * Rule to require or disallow an empty line between class members.
     *
     * @since 4.9.0
     * @see https://eslint.org/docs/rules/lines-between-class-members
     */
    'lines-between-class-members': Linter.RuleEntry<[
        'always' | 'never',
        Partial<{
            /**
             * @default false
             */
            exceptAfterSingleLine: boolean;
        }>
    ]>;

    /**
     * Rule to enforce a maximum depth that blocks can be nested.
     *
     * @since 0.0.9
     * @see https://eslint.org/docs/rules/max-depth
     */
    'max-depth': Linter.RuleEntry<[
        Partial<{
            /**
             * @default 4
             */
            max: number;
        }>
    ]>;

    /**
     * Rule to enforce a maximum line length.
     *
     * @since 0.0.9
     * @see https://eslint.org/docs/rules/max-len
     */
    'max-len': Linter.RuleEntry<[
        Partial<{
            /**
             * @default 80
             */
            code: number;
            /**
             * @default 4
             */
            tabWidth: number;
            comments: number;
            ignorePattern: string;
            /**
             * @default false
             */
            ignoreComments: boolean;
            /**
             * @default false
             */
            ignoreTrailingComments: boolean;
            /**
             * @default false
             */
            ignoreUrls: boolean;
            /**
             * @default false
             */
            ignoreStrings: boolean;
            /**
             * @default false
             */
            ignoreTemplateLiterals: boolean;
            /**
             * @default false
             */
            ignoreRegExpLiterals: boolean;
        }>
    ]>;

    /**
     * Rule to enforce a maximum number of lines per file.
     *
     * @since 2.12.0
     * @see https://eslint.org/docs/rules/max-lines
     */
    'max-lines': Linter.RuleEntry<[
        Partial<{
            /**
             * @default 300
             */
            max: number;
            /**
             * @default false
             */
            skipBlankLines: boolean;
            /**
             * @default false
             */
            skipComments: boolean;
        }> | number
    ]>;

    /**
     * Rule to enforce a maximum number of line of code in a function.
     *
     * @since 5.0.0
     * @see https://eslint.org/docs/rules/max-lines-per-function
     */
    'max-lines-per-function': Linter.RuleEntry<[
        Partial<{
            /**
             * @default 50
             */
            max: number;
            /**
             * @default false
             */
            skipBlankLines: boolean;
            /**
             * @default false
             */
            skipComments: boolean;
            /**
             * @default false
             */
            IIFEs: boolean;
        }>
    ]>;

    /**
     * Rule to enforce a maximum depth that callbacks can be nested.
     *
     * @since 0.2.0
     * @see https://eslint.org/docs/rules/max-nested-callbacks
     */
    'max-nested-callbacks': Linter.RuleEntry<[
        Partial<{
            /**
             * @default 10
             */
            max: number;
        }> | number
    ]>;

    /**
     * Rule to enforce a maximum number of parameters in function definitions.
     *
     * @since 0.0.9
     * @see https://eslint.org/docs/rules/max-params
     */
    'max-params': Linter.RuleEntry<[
        Partial<{
            /**
             * @default 3
             */
            max: number;
        }> | number
    ]>;

    /**
     * Rule to enforce a maximum number of statements allowed in function blocks.
     *
     * @since 0.0.9
     * @see https://eslint.org/docs/rules/max-statements
     */
    'max-statements': Linter.RuleEntry<[
        Partial<{
            /**
             * @default 10
             */
            max: number;
            /**
             * @default false
             */
            ignoreTopLevelFunctions: boolean;
        }> | number
    ]>;

    /**
     * Rule to enforce a maximum number of statements allowed per line.
     *
     * @since 2.5.0
     * @see https://eslint.org/docs/rules/max-statements-per-line
     */
    'max-statements-per-line': Linter.RuleEntry<[
        Partial<{
            /**
             * @default 1
             */
            max: number;
        }> | number
    ]>;

    /**
     * Rule to enforce a particular style for multiline comments.
     *
     * @since 4.10.0
     * @see https://eslint.org/docs/rules/multiline-comment-style
     */
    'multiline-comment-style': Linter.RuleEntry<[
        'starred-block' | 'bare-block' | 'separate-lines'
    ]>;

    /**
     * Rule to enforce newlines between operands of ternary expressions.
     *
     * @since 3.1.0
     * @see https://eslint.org/docs/rules/multiline-ternary
     */
    'multiline-ternary': Linter.RuleEntry<[
        'always' | 'always-multiline' | 'never'
    ]>;

    /**
     * Rule to require constructor names to begin with a capital letter.
     *
     * @since 0.0.3-0
     * @see https://eslint.org/docs/rules/new-cap
     */
    'new-cap': Linter.RuleEntry<[
        Partial<{
            /**
             * @default true
             */
            newIsCap: boolean;
            /**
             * @default true
             */
            capIsNew: boolean;
            newIsCapExceptions: string[];
            newIsCapExceptionPattern: string;
            capIsNewExceptions: string[];
            capIsNewExceptionPattern: string;
            /**
             * @default true
             */
            properties: boolean;
        }>
    ]>;

    /**
     * Rule to enforce or disallow parentheses when invoking a constructor with no arguments.
     *
     * @since 0.0.6
     * @see https://eslint.org/docs/rules/new-parens
     */
    'new-parens': Linter.RuleEntry<[
        'always' | 'never'
    ]>;

    /**
     * Rule to require a newline after each call in a method chain.
     *
     * @since 2.0.0-rc.0
     * @see https://eslint.org/docs/rules/newline-per-chained-call
     */
    'newline-per-chained-call': Linter.RuleEntry<[
        {
            /**
             * @default 2
             */
            ignoreChainWithDepth: number;
        }
    ]>;

    /**
     * Rule to disallow `Array` constructors.
     *
     * @since 0.4.0
     * @see https://eslint.org/docs/rules/no-array-constructor
     */
    'no-array-constructor': Linter.RuleEntry<[]>;

    /**
     * Rule to disallow bitwise operators.
     *
     * @since 0.0.2
     * @see https://eslint.org/docs/rules/no-bitwise
     */
    'no-bitwise': Linter.RuleEntry<[
        Partial<{
            allow: string[];
            /**
             * @default false
             */
            int32Hint: boolean;
        }>
    ]>;

    /**
     * Rule to disallow `continue` statements.
     *
     * @since 0.19.0
     * @see https://eslint.org/docs/rules/no-continue
     */
    'no-continue': Linter.RuleEntry<[]>;

    /**
     * Rule to disallow inline comments after code.
     *
     * @since 0.10.0
     * @see https://eslint.org/docs/rules/no-inline-comments
     */
    'no-inline-comments': Linter.RuleEntry<[]>;

    /**
     * Rule to disallow `if` statements as the only statement in `else` blocks.
     *
     * @since 0.6.0
     * @see https://eslint.org/docs/rules/no-lonely-if
     */
    'no-lonely-if': Linter.RuleEntry<[]>;

    /**
     * Rule to disallow mixed binary operators.
     *
     * @since 2.12.0
     * @see https://eslint.org/docs/rules/no-mixed-operators
     */
    'no-mixed-operators': Linter.RuleEntry<[
        Partial<{
            /**
             * @default
             * [
             *     ["+", "-", "*", "/", "%", "**"],
             *     ["&", "|", "^", "~", "<<", ">>", ">>>"],
             *     ["==", "!=", "===", "!==", ">", ">=", "<", "<="],
             *     ["&&", "||"],
             *     ["in", "instanceof"]
             * ]
             */
            groups: string[][];
            /**
             * @default true
             */
            allowSamePrecedence: boolean;
        }>
    ]>;

    /**
     * Rule to disallow mixed spaces and tabs for indentation.
     *
     * @remarks
     * Recommended by ESLint, the rule was enabled in `eslint:recommended`.
     *
     * @since 0.7.1
     * @see https://eslint.org/docs/rules/no-mixed-spaces-and-tabs
     */
    'no-mixed-spaces-and-tabs': Linter.RuleEntry<[
        'smart-tabs'
    ]>;

    /**
     * Rule to disallow use of chained assignment expressions.
     *
     * @since 3.14.0
     * @see https://eslint.org/docs/rules/no-multi-assign
     */
    'no-multi-assign': Linter.RuleEntry<[]>;

    /**
     * Rule to disallow multiple empty lines.
     *
     * @since 0.9.0
     * @see https://eslint.org/docs/rules/no-multiple-empty-lines
     */
    'no-multiple-empty-lines': Linter.RuleEntry<[
        Partial<{
            /**
             * @default 2
             */
            max: number;
            maxEOF: number;
            maxBOF: number;
        }> | number
    ]>;

    /**
     * Rule to disallow negated conditions.
     *
     * @since 1.6.0
     * @see https://eslint.org/docs/rules/no-negated-condition
     */
    'no-negated-condition': Linter.RuleEntry<[]>;

    /**
     * Rule to disallow nested ternary expressions.
     *
     * @since 0.2.0
     * @see https://eslint.org/docs/rules/no-nested-ternary
     */
    'no-nested-ternary': Linter.RuleEntry<[]>;

    /**
     * Rule to disallow `Object` constructors.
     *
     * @since 0.0.9
     * @see https://eslint.org/docs/rules/no-new-object
     */
    'no-new-object': Linter.RuleEntry<[]>;

    /**
     * Rule to disallow the unary operators `++` and `--`.
     *
     * @since 0.0.9
     * @see https://eslint.org/docs/rules/no-plusplus
     */
    'no-plusplus': Linter.RuleEntry<[
        Partial<{
            /**
             * @default false
             */
            allowForLoopAfterthoughts: boolean;
        }>
    ]>;

    /**
     * Rule to disallow specified syntax.
     *
     * @since 1.4.0
     * @see https://eslint.org/docs/rules/no-restricted-syntax
     */
    'no-restricted-syntax': Linter.RuleEntry<[
        ...Array<string | {
            selector: string;
            message?: string;
        }>
    ]>;

    /**
     * Rule to disallow all tabs.
     *
     * @since 3.2.0
     * @see https://eslint.org/docs/rules/no-tabs
     */
    'no-tabs': Linter.RuleEntry<[
        Partial<{
            /**
             * @default false
             */
            allowIndentationTabs: boolean;
        }>
    ]>;

    /**
     * Rule to disallow ternary operators.
     *
     * @since 0.0.9
     * @see https://eslint.org/docs/rules/no-ternary
     */
    'no-ternary': Linter.RuleEntry<[]>;

    /**
     * Rule to disallow trailing whitespace at the end of lines.
     *
     * @since 0.7.1
     * @see https://eslint.org/docs/rules/no-trailing-spaces
     */
    'no-trailing-spaces': Linter.RuleEntry<[
        Partial<{
            /**
             * @default false
             */
            skipBlankLines: boolean;
            /**
             * @default false
             */
            ignoreComments: boolean;
        }>
    ]>;

    /**
     * Rule to disallow dangling underscores in identifiers.
     *
     * @since 0.0.9
     * @see https://eslint.org/docs/rules/no-underscore-dangle
     */
    'no-underscore-dangle': Linter.RuleEntry<[
        Partial<{
            allow: string[];
            /**
             * @default false
             */
            allowAfterThis: boolean;
            /**
             * @default false
             */
            allowAfterSuper: boolean;
            /**
             * @default false
             */
            enforceInMethodNames: boolean;
        }>
    ]>;

    /**
     * Rule to disallow ternary operators when simpler alternatives exist.
     *
     * @since 0.21.0
     * @see https://eslint.org/docs/rules/no-unneeded-ternary
     */
    'no-unneeded-ternary': Linter.RuleEntry<[
        Partial<{
            /**
             * @default true
             */
            defaultAssignment: boolean;
        }>
    ]>;

    /**
     * Rule to disallow whitespace before properties.
     *
     * @since 2.0.0-beta.1
     * @see https://eslint.org/docs/rules/no-whitespace-before-property
     */
    'no-whitespace-before-property': Linter.RuleEntry<[]>;

    /**
     * Rule to enforce the location of single-line statements.
     *
     * @since 3.17.0
     * @see https://eslint.org/docs/rules/nonblock-statement-body-position
     */
    'nonblock-statement-body-position': Linter.RuleEntry<[
        'beside' | 'below' | 'any',
        Partial<{
            overrides: Record<string, 'beside' | 'below' | 'any'>;
        }>
    ]>;

    /**
     * Rule to enforce consistent line breaks inside braces.
     *
     * @since 2.12.0
     * @see https://eslint.org/docs/rules/object-curly-newline
     */
    'object-curly-newline': Linter.RuleEntry<[
        | 'always' | 'never'
        | Partial<{
                /**
                 * @default false
                 */
                multiline: boolean;
                minProperties: number;
                /**
                 * @default true
                 */
                consistent: boolean;
            }>
        | Partial<Record<'ObjectExpression' | 'ObjectPattern' | 'ImportDeclaration' | 'ExportDeclaration',
            | 'always' | 'never'
            | Partial<{
                /**
                 * @default false
                 */
                multiline: boolean;
                minProperties: number;
                /**
                 * @default true
                 */
                consistent: boolean;
            }>>>
    ]>;

    /**
     * Rule to enforce consistent spacing inside braces.
     *
     * @since 0.22.0
     * @see https://eslint.org/docs/rules/object-curly-spacing
     */
    'object-curly-spacing': Linter.RuleEntry<[
        'never',
        {
            /**
             * @default false
             */
            arraysInObjects: boolean;
            /**
             * @default false
             */
            objectsInObjects: boolean;
        }
    ]> | Linter.RuleEntry<[
        'always',
        {
            /**
             * @default true
             */
            arraysInObjects: boolean;
            /**
             * @default true
             */
            objectsInObjects: boolean;
        }
    ]>;

    /**
     * Rule to enforce placing object properties on separate lines.
     *
     * @since 2.10.0
     * @see https://eslint.org/docs/rules/object-property-newline
     */
    'object-property-newline': Linter.RuleEntry<[
        Partial<{
            /**
             * @default false
             */
            allowAllPropertiesOnSameLine: boolean;
        }>
    ]>;

    /**
     * Rule to enforce variables to be declared either together or separately in functions.
     *
     * @since 0.0.9
     * @see https://eslint.org/docs/rules/one-var
     */
    'one-var': Linter.RuleEntry<[
        | 'always' | 'never' | 'consecutive'
        | Partial<{
                /**
                 * @default false
                 */
                separateRequires: boolean;
            } & Record<'var' | 'let' | 'const', 'always' | 'never' | 'consecutive'>>
        | Partial<Record<'initialized' | 'uninitialized', 'always' | 'never' | 'consecutive'>>
    ]>;

    /**
     * Rule to require or disallow newlines around variable declarations.
     *
     * @since 2.0.0-beta.3
     * @see https://eslint.org/docs/rules/one-var-declaration-per-line
     */
    'one-var-declaration-per-line': Linter.RuleEntry<[
        'initializations' | 'always'
    ]>;

    /**
     * Rule to require or disallow assignment operator shorthand where possible.
     *
     * @since 0.10.0
     * @see https://eslint.org/docs/rules/operator-assignment
     */
    'operator-assignment': Linter.RuleEntry<[
        'always' | 'never'
    ]>;

    /**
     * Rule to enforce consistent linebreak style for operators.
     *
     * @since 0.19.0
     * @see https://eslint.org/docs/rules/operator-linebreak
     */
    'operator-linebreak': Linter.RuleEntry<[
        'after' | 'before' | 'none',
        Partial<{
            overrides: Record<string, 'after' | 'before' | 'none'>;
        }>
    ]>;

    /**
     * Rule to require or disallow padding within blocks.
     *
     * @since 0.9.0
     * @see https://eslint.org/docs/rules/padded-blocks
     */
    'padded-blocks': Linter.RuleEntry<[
        | 'always' | 'never'
        | Partial<Record<'blocks' | 'classes' | 'switches', 'always' | 'never'>>,
        {
            /**
             * @default false
             */
            allowSingleLineBlocks: boolean;
        }
    ]>;

    /**
     * Rule to require or disallow padding lines between statements.
     *
     * @since 4.0.0-beta.0
     * @see https://eslint.org/docs/rules/padding-line-between-statements
     */
    'padding-line-between-statements': Linter.RuleEntry<[
        ...Array<{
            blankLine: 'any' | 'never' | 'always';
        } & Record<'prev' | 'next', string | string[]>>
    ]>;

    /**
     * Rule to disallow using Object.assign with an object literal as the first argument and prefer the use of object spread instead.
     *
     * @since 5.0.0-alpha.3
     * @see https://eslint.org/docs/rules/prefer-object-spread
     */
    'prefer-object-spread': Linter.RuleEntry<[]>;

    /**
     * Rule to require quotes around object literal property names.
     *
     * @since 0.0.6
     * @see https://eslint.org/docs/rules/quote-props
     */
    'quote-props': Linter.RuleEntry<[
        'always' | 'consistent'
    ]> | Linter.RuleEntry<[
        'as-needed',
        Partial<{
            /**
             * @default false
             */
            keywords: boolean;
            /**
             * @default true
             */
            unnecessary: boolean;
            /**
             * @default false
             */
            numbers: boolean;
        }>
    ]> | Linter.RuleEntry<[
        'consistent-as-needed',
        Partial<{
            /**
             * @default false
             */
            keywords: boolean;
        }>
    ]>;

    /**
     * Rule to enforce the consistent use of either backticks, double, or single quotes.
     *
     * @since 0.0.7
     * @see https://eslint.org/docs/rules/quotes
     */
    'quotes': Linter.RuleEntry<[
        'double' | 'single' | 'backtick',
        Partial<{
            /**
             * @default false
             */
            avoidEscape: boolean;
            /**
             * @default false
             */
            allowTemplateLiterals: boolean;
        }>
    ]>;

    /**
     * Rule to require or disallow semicolons instead of ASI.
     *
     * @since 0.0.6
     * @see https://eslint.org/docs/rules/semi
     */
    'semi': Linter.RuleEntry<[
        'always',
        Partial<{
            /**
             * @default false
             */
            omitLastInOneLineBlock: boolean;
        }>
    ]> | Linter.RuleEntry<[
        'never',
        Partial<{
            /**
             * @default 'any'
             */
            beforeStatementContinuationChars: 'any' | 'always' | 'never';
        }>
    ]>;

    /**
     * Rule to enforce consistent spacing before and after semicolons.
     *
     * @since 0.16.0
     * @see https://eslint.org/docs/rules/semi-spacing
     */
    'semi-spacing': Linter.RuleEntry<[
        Partial<{
            /**
             * @default false
             */
            before: boolean;
            /**
             * @default true
             */
            after: boolean;
        }>
    ]>;

    /**
     * Rule to enforce location of semicolons.
     *
     * @since 4.0.0-beta.0
     * @see https://eslint.org/docs/rules/semi-style
     */
    'semi-style': Linter.RuleEntry<[
        'last' | 'first'
    ]>;

    /**
     * Rule to require object keys to be sorted.
     *
     * @since 3.3.0
     * @see https://eslint.org/docs/rules/sort-keys
     */
    'sort-keys': Linter.RuleEntry<[
        'asc' | 'desc',
        Partial<{
            /**
             * @default true
             */
            caseSensitive: boolean;
            /**
             * @default 2
             */
            minKeys: number;
            /**
             * @default false
             */
            natural: boolean;
        }>
    ]>;

    /**
     * Rule to require variables within the same declaration block to be sorted.
     *
     * @since 0.2.0
     * @see https://eslint.org/docs/rules/sort-vars
     */
    'sort-vars': Linter.RuleEntry<[
        Partial<{
            /**
             * @default false
             */
            ignoreCase: boolean;
        }>
    ]>;

    /**
     * Rule to enforce consistent spacing before blocks.
     *
     * @since 0.9.0
     * @see https://eslint.org/docs/rules/space-before-blocks
     */
    'space-before-blocks': Linter.RuleEntry<[
        | 'always' | 'never'
        | Partial<Record<'functions' | 'keywords' | 'classes', 'always' | 'never' | 'off'>>
    ]>;

    /**
     * Rule to enforce consistent spacing before `function` definition opening parenthesis.
     *
     * @since 0.18.0
     * @see https://eslint.org/docs/rules/space-before-function-paren
     */
    'space-before-function-paren': Linter.RuleEntry<[
        | 'always' | 'never'
        | Partial<Record<'anonymous' | 'named' | 'asyncArrow', 'always' | 'never' | 'ignore'>>
    ]>;

    /**
     * Rule to enforce consistent spacing inside parentheses.
     *
     * @since 0.8.0
     * @see https://eslint.org/docs/rules/space-in-parens
     */
    'space-in-parens': Linter.RuleEntry<[
        'never' | 'always',
        Partial<{
            exceptions: string[];
        }>
    ]>;

    /**
     * Rule to require spacing around infix operators.
     *
     * @since 0.2.0
     * @see https://eslint.org/docs/rules/space-infix-ops
     */
    'space-infix-ops': Linter.RuleEntry<[
        Partial<{
            /**
             * @default false
             */
            int32Hint: boolean;
        }>
    ]>;

    /**
     * Rule to enforce consistent spacing before or after unary operators.
     *
     * @since 0.10.0
     * @see https://eslint.org/docs/rules/space-unary-ops
     */
    'space-unary-ops': Linter.RuleEntry<[
        Partial<{
            /**
             * @default true
             */
            words: boolean;
            /**
             * @default false
             */
            nonwords: boolean;
            overrides: Record<string, boolean>;
        }>
    ]>;

    /**
     * Rule to enforce consistent spacing after the `//` or `/*` in a comment.
     *
     * @since 0.23.0
     * @see https://eslint.org/docs/rules/spaced-comment
     */
    'spaced-comment': Linter.RuleEntry<[
        'always' | 'never',
        {
            exceptions: string[];
            markers: string[];
            line: {
                exceptions: string[];
                markers: string[];
            };
            block: {
                exceptions: string[];
                markers: string[];
                /**
                 * @default false
                 */
                balanced: boolean;
            };
        }
    ]>;

    /**
     * Rule to enforce spacing around colons of switch statements.
     *
     * @since 4.0.0-beta.0
     * @see https://eslint.org/docs/rules/switch-colon-spacing
     */
    'switch-colon-spacing': Linter.RuleEntry<[
        Partial<{
            /**
             * @default false
             */
            before: boolean;
            /**
             * @default true
             */
            after: boolean;
        }>
    ]>;

    /**
     * Rule to require or disallow spacing between template tags and their literals.
     *
     * @since 3.15.0
     * @see https://eslint.org/docs/rules/template-tag-spacing
     */
    'template-tag-spacing': Linter.RuleEntry<[
        'never' | 'always'
    ]>;

    /**
     * Rule to require or disallow Unicode byte order mark (BOM).
     *
     * @since 2.11.0
     * @see https://eslint.org/docs/rules/unicode-bom
     */
    'unicode-bom': Linter.RuleEntry<[
        'never' | 'always'
    ]>;

    /**
     * Rule to require parenthesis around regex literals.
     *
     * @since 0.1.0
     * @see https://eslint.org/docs/rules/wrap-regex
     */
    'wrap-regex': Linter.RuleEntry<[]>;
}
