@jimmy.codes/eslint-config 3.15.0 → 3.16.0

package/dist/index.d.mts

@@ -1,3 +1,4 @@
+import * as eslint_plugin_regexp from 'eslint-plugin-regexp';
 import * as eslint_plugin_react_refresh from 'eslint-plugin-react-refresh';
 import * as eslint_plugin_react from 'eslint-plugin-react';
 import * as eslint_plugin_n from 'eslint-plugin-n';
@@ -4001,6 +4002,416 @@ interface RuleOptions {
    * @see https://github.com/jsx-eslint/eslint-plugin-react/tree/master/docs/rules/void-dom-elements-no-children.md
    */
   'react/void-dom-elements-no-children'?: Linter.RuleEntry<[]>
+  /**
+   * disallow confusing quantifiers
+   * @see https://ota-meshi.github.io/eslint-plugin-regexp/rules/confusing-quantifier.html
+   */
+  'regexp/confusing-quantifier'?: Linter.RuleEntry<[]>
+  /**
+   * enforce consistent escaping of control characters
+   * @see https://ota-meshi.github.io/eslint-plugin-regexp/rules/control-character-escape.html
+   */
+  'regexp/control-character-escape'?: Linter.RuleEntry<[]>
+  /**
+   * enforce single grapheme in string literal
+   * @see https://ota-meshi.github.io/eslint-plugin-regexp/rules/grapheme-string-literal.html
+   */
+  'regexp/grapheme-string-literal'?: Linter.RuleEntry<[]>
+  /**
+   * enforce consistent usage of hexadecimal escape
+   * @see https://ota-meshi.github.io/eslint-plugin-regexp/rules/hexadecimal-escape.html
+   */
+  'regexp/hexadecimal-escape'?: Linter.RuleEntry<RegexpHexadecimalEscape>
+  /**
+   * enforce into your favorite case
+   * @see https://ota-meshi.github.io/eslint-plugin-regexp/rules/letter-case.html
+   */
+  'regexp/letter-case'?: Linter.RuleEntry<RegexpLetterCase>
+  /**
+   * enforce match any character style
+   * @see https://ota-meshi.github.io/eslint-plugin-regexp/rules/match-any.html
+   */
+  'regexp/match-any'?: Linter.RuleEntry<RegexpMatchAny>
+  /**
+   * enforce use of escapes on negation
+   * @see https://ota-meshi.github.io/eslint-plugin-regexp/rules/negation.html
+   */
+  'regexp/negation'?: Linter.RuleEntry<[]>
+  /**
+   * disallow elements that contradict assertions
+   * @see https://ota-meshi.github.io/eslint-plugin-regexp/rules/no-contradiction-with-assertion.html
+   */
+  'regexp/no-contradiction-with-assertion'?: Linter.RuleEntry<[]>
+  /**
+   * disallow control characters
+   * @see https://ota-meshi.github.io/eslint-plugin-regexp/rules/no-control-character.html
+   */
+  'regexp/no-control-character'?: Linter.RuleEntry<[]>
+  /**
+   * disallow duplicate characters in the RegExp character class
+   * @see https://ota-meshi.github.io/eslint-plugin-regexp/rules/no-dupe-characters-character-class.html
+   */
+  'regexp/no-dupe-characters-character-class'?: Linter.RuleEntry<[]>
+  /**
+   * disallow duplicate disjunctions
+   * @see https://ota-meshi.github.io/eslint-plugin-regexp/rules/no-dupe-disjunctions.html
+   */
+  'regexp/no-dupe-disjunctions'?: Linter.RuleEntry<RegexpNoDupeDisjunctions>
+  /**
+   * disallow alternatives without elements
+   * @see https://ota-meshi.github.io/eslint-plugin-regexp/rules/no-empty-alternative.html
+   */
+  'regexp/no-empty-alternative'?: Linter.RuleEntry<[]>
+  /**
+   * disallow capturing group that captures empty.
+   * @see https://ota-meshi.github.io/eslint-plugin-regexp/rules/no-empty-capturing-group.html
+   */
+  'regexp/no-empty-capturing-group'?: Linter.RuleEntry<[]>
+  /**
+   * disallow character classes that match no characters
+   * @see https://ota-meshi.github.io/eslint-plugin-regexp/rules/no-empty-character-class.html
+   */
+  'regexp/no-empty-character-class'?: Linter.RuleEntry<[]>
+  /**
+   * disallow empty group
+   * @see https://ota-meshi.github.io/eslint-plugin-regexp/rules/no-empty-group.html
+   */
+  'regexp/no-empty-group'?: Linter.RuleEntry<[]>
+  /**
+   * disallow empty lookahead assertion or empty lookbehind assertion
+   * @see https://ota-meshi.github.io/eslint-plugin-regexp/rules/no-empty-lookarounds-assertion.html
+   */
+  'regexp/no-empty-lookarounds-assertion'?: Linter.RuleEntry<[]>
+  /**
+   * disallow empty string literals in character classes
+   * @see https://ota-meshi.github.io/eslint-plugin-regexp/rules/no-empty-string-literal.html
+   */
+  'regexp/no-empty-string-literal'?: Linter.RuleEntry<[]>
+  /**
+   * disallow escape backspace (`[\b]`)
+   * @see https://ota-meshi.github.io/eslint-plugin-regexp/rules/no-escape-backspace.html
+   */
+  'regexp/no-escape-backspace'?: Linter.RuleEntry<[]>
+  /**
+   * disallow unnecessary nested lookaround assertions
+   * @see https://ota-meshi.github.io/eslint-plugin-regexp/rules/no-extra-lookaround-assertions.html
+   */
+  'regexp/no-extra-lookaround-assertions'?: Linter.RuleEntry<[]>
+  /**
+   * disallow invalid regular expression strings in `RegExp` constructors
+   * @see https://ota-meshi.github.io/eslint-plugin-regexp/rules/no-invalid-regexp.html
+   */
+  'regexp/no-invalid-regexp'?: Linter.RuleEntry<[]>
+  /**
+   * disallow invisible raw character
+   * @see https://ota-meshi.github.io/eslint-plugin-regexp/rules/no-invisible-character.html
+   */
+  'regexp/no-invisible-character'?: Linter.RuleEntry<[]>
+  /**
+   * disallow lazy quantifiers at the end of an expression
+   * @see https://ota-meshi.github.io/eslint-plugin-regexp/rules/no-lazy-ends.html
+   */
+  'regexp/no-lazy-ends'?: Linter.RuleEntry<RegexpNoLazyEnds>
+  /**
+   * disallow legacy RegExp features
+   * @see https://ota-meshi.github.io/eslint-plugin-regexp/rules/no-legacy-features.html
+   */
+  'regexp/no-legacy-features'?: Linter.RuleEntry<RegexpNoLegacyFeatures>
+  /**
+   * disallow capturing groups that do not behave as one would expect
+   * @see https://ota-meshi.github.io/eslint-plugin-regexp/rules/no-misleading-capturing-group.html
+   */
+  'regexp/no-misleading-capturing-group'?: Linter.RuleEntry<RegexpNoMisleadingCapturingGroup>
+  /**
+   * disallow multi-code-point characters in character classes and quantifiers
+   * @see https://ota-meshi.github.io/eslint-plugin-regexp/rules/no-misleading-unicode-character.html
+   */
+  'regexp/no-misleading-unicode-character'?: Linter.RuleEntry<RegexpNoMisleadingUnicodeCharacter>
+  /**
+   * disallow missing `g` flag in patterns used in `String#matchAll` and `String#replaceAll`
+   * @see https://ota-meshi.github.io/eslint-plugin-regexp/rules/no-missing-g-flag.html
+   */
+  'regexp/no-missing-g-flag'?: Linter.RuleEntry<RegexpNoMissingGFlag>
+  /**
+   * disallow non-standard flags
+   * @see https://ota-meshi.github.io/eslint-plugin-regexp/rules/no-non-standard-flag.html
+   */
+  'regexp/no-non-standard-flag'?: Linter.RuleEntry<[]>
+  /**
+   * disallow obscure character ranges
+   * @see https://ota-meshi.github.io/eslint-plugin-regexp/rules/no-obscure-range.html
+   */
+  'regexp/no-obscure-range'?: Linter.RuleEntry<RegexpNoObscureRange>
+  /**
+   * disallow octal escape sequence
+   * @see https://ota-meshi.github.io/eslint-plugin-regexp/rules/no-octal.html
+   */
+  'regexp/no-octal'?: Linter.RuleEntry<[]>
+  /**
+   * disallow optional assertions
+   * @see https://ota-meshi.github.io/eslint-plugin-regexp/rules/no-optional-assertion.html
+   */
+  'regexp/no-optional-assertion'?: Linter.RuleEntry<[]>
+  /**
+   * disallow backreferences that reference a group that might not be matched
+   * @see https://ota-meshi.github.io/eslint-plugin-regexp/rules/no-potentially-useless-backreference.html
+   */
+  'regexp/no-potentially-useless-backreference'?: Linter.RuleEntry<[]>
+  /**
+   * disallow standalone backslashes (`\`)
+   * @see https://ota-meshi.github.io/eslint-plugin-regexp/rules/no-standalone-backslash.html
+   */
+  'regexp/no-standalone-backslash'?: Linter.RuleEntry<[]>
+  /**
+   * disallow exponential and polynomial backtracking
+   * @see https://ota-meshi.github.io/eslint-plugin-regexp/rules/no-super-linear-backtracking.html
+   */
+  'regexp/no-super-linear-backtracking'?: Linter.RuleEntry<RegexpNoSuperLinearBacktracking>
+  /**
+   * disallow quantifiers that cause quadratic moves
+   * @see https://ota-meshi.github.io/eslint-plugin-regexp/rules/no-super-linear-move.html
+   */
+  'regexp/no-super-linear-move'?: Linter.RuleEntry<RegexpNoSuperLinearMove>
+  /**
+   * disallow trivially nested assertions
+   * @see https://ota-meshi.github.io/eslint-plugin-regexp/rules/no-trivially-nested-assertion.html
+   */
+  'regexp/no-trivially-nested-assertion'?: Linter.RuleEntry<[]>
+  /**
+   * disallow nested quantifiers that can be rewritten as one quantifier
+   * @see https://ota-meshi.github.io/eslint-plugin-regexp/rules/no-trivially-nested-quantifier.html
+   */
+  'regexp/no-trivially-nested-quantifier'?: Linter.RuleEntry<[]>
+  /**
+   * disallow unused capturing group
+   * @see https://ota-meshi.github.io/eslint-plugin-regexp/rules/no-unused-capturing-group.html
+   */
+  'regexp/no-unused-capturing-group'?: Linter.RuleEntry<RegexpNoUnusedCapturingGroup>
+  /**
+   * disallow assertions that are known to always accept (or reject)
+   * @see https://ota-meshi.github.io/eslint-plugin-regexp/rules/no-useless-assertions.html
+   */
+  'regexp/no-useless-assertions'?: Linter.RuleEntry<[]>
+  /**
+   * disallow useless backreferences in regular expressions
+   * @see https://ota-meshi.github.io/eslint-plugin-regexp/rules/no-useless-backreference.html
+   */
+  'regexp/no-useless-backreference'?: Linter.RuleEntry<[]>
+  /**
+   * disallow character class with one character
+   * @see https://ota-meshi.github.io/eslint-plugin-regexp/rules/no-useless-character-class.html
+   */
+  'regexp/no-useless-character-class'?: Linter.RuleEntry<RegexpNoUselessCharacterClass>
+  /**
+   * disallow useless `$` replacements in replacement string
+   * @see https://ota-meshi.github.io/eslint-plugin-regexp/rules/no-useless-dollar-replacements.html
+   */
+  'regexp/no-useless-dollar-replacements'?: Linter.RuleEntry<[]>
+  /**
+   * disallow unnecessary escape characters in RegExp
+   * @see https://ota-meshi.github.io/eslint-plugin-regexp/rules/no-useless-escape.html
+   */
+  'regexp/no-useless-escape'?: Linter.RuleEntry<[]>
+  /**
+   * disallow unnecessary regex flags
+   * @see https://ota-meshi.github.io/eslint-plugin-regexp/rules/no-useless-flag.html
+   */
+  'regexp/no-useless-flag'?: Linter.RuleEntry<RegexpNoUselessFlag>
+  /**
+   * disallow unnecessarily non-greedy quantifiers
+   * @see https://ota-meshi.github.io/eslint-plugin-regexp/rules/no-useless-lazy.html
+   */
+  'regexp/no-useless-lazy'?: Linter.RuleEntry<[]>
+  /**
+   * disallow unnecessary non-capturing group
+   * @see https://ota-meshi.github.io/eslint-plugin-regexp/rules/no-useless-non-capturing-group.html
+   */
+  'regexp/no-useless-non-capturing-group'?: Linter.RuleEntry<RegexpNoUselessNonCapturingGroup>
+  /**
+   * disallow quantifiers that can be removed
+   * @see https://ota-meshi.github.io/eslint-plugin-regexp/rules/no-useless-quantifier.html
+   */
+  'regexp/no-useless-quantifier'?: Linter.RuleEntry<[]>
+  /**
+   * disallow unnecessary character ranges
+   * @see https://ota-meshi.github.io/eslint-plugin-regexp/rules/no-useless-range.html
+   */
+  'regexp/no-useless-range'?: Linter.RuleEntry<[]>
+  /**
+   * disallow unnecessary elements in expression character classes
+   * @see https://ota-meshi.github.io/eslint-plugin-regexp/rules/no-useless-set-operand.html
+   */
+  'regexp/no-useless-set-operand'?: Linter.RuleEntry<[]>
+  /**
+   * disallow string disjunction of single characters in `\q{...}`
+   * @see https://ota-meshi.github.io/eslint-plugin-regexp/rules/no-useless-string-literal.html
+   */
+  'regexp/no-useless-string-literal'?: Linter.RuleEntry<[]>
+  /**
+   * disallow unnecessary `{n,m}` quantifier
+   * @see https://ota-meshi.github.io/eslint-plugin-regexp/rules/no-useless-two-nums-quantifier.html
+   */
+  'regexp/no-useless-two-nums-quantifier'?: Linter.RuleEntry<[]>
+  /**
+   * disallow quantifiers with a maximum of zero
+   * @see https://ota-meshi.github.io/eslint-plugin-regexp/rules/no-zero-quantifier.html
+   */
+  'regexp/no-zero-quantifier'?: Linter.RuleEntry<[]>
+  /**
+   * disallow the alternatives of lookarounds that end with a non-constant quantifier
+   * @see https://ota-meshi.github.io/eslint-plugin-regexp/rules/optimal-lookaround-quantifier.html
+   */
+  'regexp/optimal-lookaround-quantifier'?: Linter.RuleEntry<[]>
+  /**
+   * require optimal quantifiers for concatenated quantifiers
+   * @see https://ota-meshi.github.io/eslint-plugin-regexp/rules/optimal-quantifier-concatenation.html
+   */
+  'regexp/optimal-quantifier-concatenation'?: Linter.RuleEntry<RegexpOptimalQuantifierConcatenation>
+  /**
+   * enforce using character class
+   * @see https://ota-meshi.github.io/eslint-plugin-regexp/rules/prefer-character-class.html
+   */
+  'regexp/prefer-character-class'?: Linter.RuleEntry<RegexpPreferCharacterClass>
+  /**
+   * enforce using `\d`
+   * @see https://ota-meshi.github.io/eslint-plugin-regexp/rules/prefer-d.html
+   */
+  'regexp/prefer-d'?: Linter.RuleEntry<RegexpPreferD>
+  /**
+   * enforces escape of replacement `$` character (`$$`).
+   * @see https://ota-meshi.github.io/eslint-plugin-regexp/rules/prefer-escape-replacement-dollar-char.html
+   */
+  'regexp/prefer-escape-replacement-dollar-char'?: Linter.RuleEntry<[]>
+  /**
+   * prefer lookarounds over capturing group that do not replace
+   * @see https://ota-meshi.github.io/eslint-plugin-regexp/rules/prefer-lookaround.html
+   */
+  'regexp/prefer-lookaround'?: Linter.RuleEntry<RegexpPreferLookaround>
+  /**
+   * enforce using named backreferences
+   * @see https://ota-meshi.github.io/eslint-plugin-regexp/rules/prefer-named-backreference.html
+   */
+  'regexp/prefer-named-backreference'?: Linter.RuleEntry<[]>
+  /**
+   * enforce using named capture groups
+   * @see https://ota-meshi.github.io/eslint-plugin-regexp/rules/prefer-named-capture-group.html
+   */
+  'regexp/prefer-named-capture-group'?: Linter.RuleEntry<[]>
+  /**
+   * enforce using named replacement
+   * @see https://ota-meshi.github.io/eslint-plugin-regexp/rules/prefer-named-replacement.html
+   */
+  'regexp/prefer-named-replacement'?: Linter.RuleEntry<RegexpPreferNamedReplacement>
+  /**
+   * enforce using `+` quantifier
+   * @see https://ota-meshi.github.io/eslint-plugin-regexp/rules/prefer-plus-quantifier.html
+   */
+  'regexp/prefer-plus-quantifier'?: Linter.RuleEntry<[]>
+  /**
+   * prefer predefined assertion over equivalent lookarounds
+   * @see https://ota-meshi.github.io/eslint-plugin-regexp/rules/prefer-predefined-assertion.html
+   */
+  'regexp/prefer-predefined-assertion'?: Linter.RuleEntry<[]>
+  /**
+   * enforce using quantifier
+   * @see https://ota-meshi.github.io/eslint-plugin-regexp/rules/prefer-quantifier.html
+   */
+  'regexp/prefer-quantifier'?: Linter.RuleEntry<[]>
+  /**
+   * enforce using `?` quantifier
+   * @see https://ota-meshi.github.io/eslint-plugin-regexp/rules/prefer-question-quantifier.html
+   */
+  'regexp/prefer-question-quantifier'?: Linter.RuleEntry<[]>
+  /**
+   * enforce using character class range
+   * @see https://ota-meshi.github.io/eslint-plugin-regexp/rules/prefer-range.html
+   */
+  'regexp/prefer-range'?: Linter.RuleEntry<RegexpPreferRange>
+  /**
+   * enforce that `RegExp#exec` is used instead of `String#match` if no global flag is provided
+   * @see https://ota-meshi.github.io/eslint-plugin-regexp/rules/prefer-regexp-exec.html
+   */
+  'regexp/prefer-regexp-exec'?: Linter.RuleEntry<[]>
+  /**
+   * enforce that `RegExp#test` is used instead of `String#match` and `RegExp#exec`
+   * @see https://ota-meshi.github.io/eslint-plugin-regexp/rules/prefer-regexp-test.html
+   */
+  'regexp/prefer-regexp-test'?: Linter.RuleEntry<[]>
+  /**
+   * enforce using result array `groups`
+   * @see https://ota-meshi.github.io/eslint-plugin-regexp/rules/prefer-result-array-groups.html
+   */
+  'regexp/prefer-result-array-groups'?: Linter.RuleEntry<RegexpPreferResultArrayGroups>
+  /**
+   * prefer character class set operations instead of lookarounds
+   * @see https://ota-meshi.github.io/eslint-plugin-regexp/rules/prefer-set-operation.html
+   */
+  'regexp/prefer-set-operation'?: Linter.RuleEntry<[]>
+  /**
+   * enforce using `*` quantifier
+   * @see https://ota-meshi.github.io/eslint-plugin-regexp/rules/prefer-star-quantifier.html
+   */
+  'regexp/prefer-star-quantifier'?: Linter.RuleEntry<[]>
+  /**
+   * enforce use of unicode codepoint escapes
+   * @see https://ota-meshi.github.io/eslint-plugin-regexp/rules/prefer-unicode-codepoint-escapes.html
+   */
+  'regexp/prefer-unicode-codepoint-escapes'?: Linter.RuleEntry<[]>
+  /**
+   * enforce using `\w`
+   * @see https://ota-meshi.github.io/eslint-plugin-regexp/rules/prefer-w.html
+   */
+  'regexp/prefer-w'?: Linter.RuleEntry<[]>
+  /**
+   * enforce the use of the `u` flag
+   * @see https://ota-meshi.github.io/eslint-plugin-regexp/rules/require-unicode-regexp.html
+   */
+  'regexp/require-unicode-regexp'?: Linter.RuleEntry<[]>
+  /**
+   * enforce the use of the `v` flag
+   * @see https://ota-meshi.github.io/eslint-plugin-regexp/rules/require-unicode-sets-regexp.html
+   */
+  'regexp/require-unicode-sets-regexp'?: Linter.RuleEntry<[]>
+  /**
+   * require simplify set operations
+   * @see https://ota-meshi.github.io/eslint-plugin-regexp/rules/simplify-set-operations.html
+   */
+  'regexp/simplify-set-operations'?: Linter.RuleEntry<[]>
+  /**
+   * sort alternatives if order doesn't matter
+   * @see https://ota-meshi.github.io/eslint-plugin-regexp/rules/sort-alternatives.html
+   */
+  'regexp/sort-alternatives'?: Linter.RuleEntry<[]>
+  /**
+   * enforces elements order in character class
+   * @see https://ota-meshi.github.io/eslint-plugin-regexp/rules/sort-character-class-elements.html
+   */
+  'regexp/sort-character-class-elements'?: Linter.RuleEntry<RegexpSortCharacterClassElements>
+  /**
+   * require regex flags to be sorted
+   * @see https://ota-meshi.github.io/eslint-plugin-regexp/rules/sort-flags.html
+   */
+  'regexp/sort-flags'?: Linter.RuleEntry<[]>
+  /**
+   * disallow not strictly valid regular expressions
+   * @see https://ota-meshi.github.io/eslint-plugin-regexp/rules/strict.html
+   */
+  'regexp/strict'?: Linter.RuleEntry<[]>
+  /**
+   * enforce consistent usage of unicode escape or unicode codepoint escape
+   * @see https://ota-meshi.github.io/eslint-plugin-regexp/rules/unicode-escape.html
+   */
+  'regexp/unicode-escape'?: Linter.RuleEntry<RegexpUnicodeEscape>
+  /**
+   * enforce consistent naming of unicode properties
+   * @see https://ota-meshi.github.io/eslint-plugin-regexp/rules/unicode-property.html
+   */
+  'regexp/unicode-property'?: Linter.RuleEntry<RegexpUnicodeProperty>
+  /**
+   * use the `i` flag if it simplifies the pattern
+   * @see https://ota-meshi.github.io/eslint-plugin-regexp/rules/use-ignore-case.html
+   */
+  'regexp/use-ignore-case'?: Linter.RuleEntry<[]>
   /**
    * Disallow assignments that can lead to race conditions due to usage of `await` or `yield`
    * @see https://eslint.org/docs/latest/rules/require-atomic-updates
@@ -9479,6 +9890,124 @@ type ReactStylePropObject = []|[{
   allow?: string[]
   [k: string]: unknown | undefined
 }]
+// ----- regexp/hexadecimal-escape -----
+type RegexpHexadecimalEscape = []|[("always" | "never")]
+// ----- regexp/letter-case -----
+type RegexpLetterCase = []|[{
+  caseInsensitive?: ("lowercase" | "uppercase" | "ignore")
+  unicodeEscape?: ("lowercase" | "uppercase" | "ignore")
+  hexadecimalEscape?: ("lowercase" | "uppercase" | "ignore")
+  controlEscape?: ("lowercase" | "uppercase" | "ignore")
+}]
+// ----- regexp/match-any -----
+type RegexpMatchAny = []|[{
+  
+  allows?: [("[\\s\\S]" | "[\\S\\s]" | "[^]" | "dotAll"), ...(("[\\s\\S]" | "[\\S\\s]" | "[^]" | "dotAll"))[]]
+}]
+// ----- regexp/no-dupe-disjunctions -----
+type RegexpNoDupeDisjunctions = []|[{
+  report?: ("all" | "trivial" | "interesting")
+  reportExponentialBacktracking?: ("none" | "certain" | "potential")
+  reportUnreachable?: ("certain" | "potential")
+}]
+// ----- regexp/no-lazy-ends -----
+type RegexpNoLazyEnds = []|[{
+  ignorePartial?: boolean
+}]
+// ----- regexp/no-legacy-features -----
+type RegexpNoLegacyFeatures = []|[{
+  staticProperties?: ("input" | "$_" | "lastMatch" | "$&" | "lastParen" | "$+" | "leftContext" | "$`" | "rightContext" | "$'" | "$1" | "$2" | "$3" | "$4" | "$5" | "$6" | "$7" | "$8" | "$9")[]
+  prototypeMethods?: ("compile")[]
+}]
+// ----- regexp/no-misleading-capturing-group -----
+type RegexpNoMisleadingCapturingGroup = []|[{
+  reportBacktrackingEnds?: boolean
+}]
+// ----- regexp/no-misleading-unicode-character -----
+type RegexpNoMisleadingUnicodeCharacter = []|[{
+  fixable?: boolean
+}]
+// ----- regexp/no-missing-g-flag -----
+type RegexpNoMissingGFlag = []|[{
+  strictTypes?: boolean
+}]
+// ----- regexp/no-obscure-range -----
+type RegexpNoObscureRange = []|[{
+  allowed?: (("all" | "alphanumeric") | [("all" | "alphanumeric")] | [("alphanumeric" | string), ...(("alphanumeric" | string))[]])
+}]
+// ----- regexp/no-super-linear-backtracking -----
+type RegexpNoSuperLinearBacktracking = []|[{
+  report?: ("certain" | "potential")
+}]
+// ----- regexp/no-super-linear-move -----
+type RegexpNoSuperLinearMove = []|[{
+  report?: ("certain" | "potential")
+  ignoreSticky?: boolean
+  ignorePartial?: boolean
+}]
+// ----- regexp/no-unused-capturing-group -----
+type RegexpNoUnusedCapturingGroup = []|[{
+  fixable?: boolean
+  allowNamed?: boolean
+}]
+// ----- regexp/no-useless-character-class -----
+type RegexpNoUselessCharacterClass = []|[{
+  ignores?: string[]
+}]
+// ----- regexp/no-useless-flag -----
+type RegexpNoUselessFlag = []|[{
+  ignore?: ("i" | "m" | "s" | "g" | "y")[]
+  strictTypes?: boolean
+}]
+// ----- regexp/no-useless-non-capturing-group -----
+type RegexpNoUselessNonCapturingGroup = []|[{
+  allowTop?: (boolean | ("always" | "never" | "partial"))
+}]
+// ----- regexp/optimal-quantifier-concatenation -----
+type RegexpOptimalQuantifierConcatenation = []|[{
+  capturingGroups?: ("ignore" | "report")
+}]
+// ----- regexp/prefer-character-class -----
+type RegexpPreferCharacterClass = []|[{
+  minAlternatives?: number
+}]
+// ----- regexp/prefer-d -----
+type RegexpPreferD = []|[{
+  insideCharacterClass?: ("ignore" | "range" | "d")
+}]
+// ----- regexp/prefer-lookaround -----
+type RegexpPreferLookaround = []|[{
+  lookbehind?: boolean
+  strictTypes?: boolean
+}]
+// ----- regexp/prefer-named-replacement -----
+type RegexpPreferNamedReplacement = []|[{
+  strictTypes?: boolean
+}]
+// ----- regexp/prefer-range -----
+type RegexpPreferRange = []|[{
+  target?: (("all" | "alphanumeric") | [("all" | "alphanumeric")] | [("alphanumeric" | string), ...(("alphanumeric" | string))[]])
+}]
+// ----- regexp/prefer-result-array-groups -----
+type RegexpPreferResultArrayGroups = []|[{
+  strictTypes?: boolean
+}]
+// ----- regexp/sort-character-class-elements -----
+type RegexpSortCharacterClassElements = []|[{
+  order?: ("\\s" | "\\w" | "\\d" | "\\p" | "*" | "\\q" | "[]")[]
+}]
+// ----- regexp/unicode-escape -----
+type RegexpUnicodeEscape = []|[("unicodeCodePointEscape" | "unicodeEscape")]
+// ----- regexp/unicode-property -----
+type RegexpUnicodeProperty = []|[{
+  generalCategory?: ("always" | "never" | "ignore")
+  key?: ("short" | "long" | "ignore")
+  property?: (("short" | "long" | "ignore") | {
+    binary?: ("short" | "long" | "ignore")
+    generalCategory?: ("short" | "long" | "ignore")
+    script?: ("short" | "long" | "ignore")
+  })
+}]
 // ----- require-atomic-updates -----
 type RequireAtomicUpdates = []|[{
   allowProperties?: boolean
@@ -12248,6 +12777,19 @@ declare const jimmyDotCodes: ({ astro, autoDetect, configs, ignores, react, test
             version: string;
         };
     };
+} | {
+    name: string;
+    plugins: {
+        regexp: typeof eslint_plugin_regexp;
+    };
+    rules: {
+        "regexp/confusing-quantifier": "error";
+        "regexp/no-empty-alternative": "error";
+        "regexp/no-lazy-ends": "error";
+        "regexp/no-potentially-useless-backreference": "error";
+        "regexp/no-useless-flag": "error";
+        "regexp/optimal-lookaround-quantifier": "error";
+    };
 } | {
     files: string[];
     name: string;