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<[]>;
}
