@kazupon/eslint-config 0.7.0 → 0.9.0

package/dist/types/gens/promise.d.ts

@@ -0,0 +1,107 @@
+import type { Linter } from 'eslint';
+export interface PromiseRules {
+    /**
+     * Require returning inside each `then()` to create readable and reusable Promise chains.
+     * @see https://github.com/eslint-community/eslint-plugin-promise/blob/main/docs/rules/always-return.md
+     */
+    'promise/always-return'?: Linter.RuleEntry<PromiseAlwaysReturn>;
+    /**
+     * Disallow creating `new` promises outside of utility libs (use [pify][] instead).
+     * @see https://github.com/eslint-community/eslint-plugin-promise/blob/main/docs/rules/avoid-new.md
+     */
+    'promise/avoid-new'?: Linter.RuleEntry<[]>;
+    /**
+     * Enforce the use of `catch()` on un-returned promises.
+     * @see https://github.com/eslint-community/eslint-plugin-promise/blob/main/docs/rules/catch-or-return.md
+     */
+    'promise/catch-or-return'?: Linter.RuleEntry<PromiseCatchOrReturn>;
+    /**
+     * Disallow calling `cb()` inside of a `then()` (use [nodeify][] instead).
+     * @see https://github.com/eslint-community/eslint-plugin-promise/blob/main/docs/rules/no-callback-in-promise.md
+     */
+    'promise/no-callback-in-promise'?: Linter.RuleEntry<PromiseNoCallbackInPromise>;
+    /**
+     * Disallow creating new promises with paths that resolve multiple times.
+     * @see https://github.com/eslint-community/eslint-plugin-promise/blob/main/docs/rules/no-multiple-resolved.md
+     */
+    'promise/no-multiple-resolved'?: Linter.RuleEntry<[]>;
+    /**
+     * Require creating a `Promise` constructor before using it in an ES5 environment.
+     * @see https://github.com/eslint-community/eslint-plugin-promise/blob/main/docs/rules/no-native.md
+     */
+    'promise/no-native'?: Linter.RuleEntry<[]>;
+    /**
+     * Disallow nested `then()` or `catch()` statements.
+     * @see https://github.com/eslint-community/eslint-plugin-promise/blob/main/docs/rules/no-nesting.md
+     */
+    'promise/no-nesting'?: Linter.RuleEntry<[]>;
+    /**
+     * Disallow calling `new` on a Promise static method.
+     * @see https://github.com/eslint-community/eslint-plugin-promise/blob/main/docs/rules/no-new-statics.md
+     */
+    'promise/no-new-statics'?: Linter.RuleEntry<[]>;
+    /**
+     * Disallow using promises inside of callbacks.
+     * @see https://github.com/eslint-community/eslint-plugin-promise/blob/main/docs/rules/no-promise-in-callback.md
+     */
+    'promise/no-promise-in-callback'?: Linter.RuleEntry<[]>;
+    /**
+     * Disallow return statements in `finally()`.
+     * @see https://github.com/eslint-community/eslint-plugin-promise/blob/main/docs/rules/no-return-in-finally.md
+     */
+    'promise/no-return-in-finally'?: Linter.RuleEntry<[]>;
+    /**
+     * Disallow wrapping values in `Promise.resolve` or `Promise.reject` when not needed.
+     * @see https://github.com/eslint-community/eslint-plugin-promise/blob/main/docs/rules/no-return-wrap.md
+     */
+    'promise/no-return-wrap'?: Linter.RuleEntry<PromiseNoReturnWrap>;
+    /**
+     * Enforce consistent param names and ordering when creating new promises.
+     * @see https://github.com/eslint-community/eslint-plugin-promise/blob/main/docs/rules/param-names.md
+     */
+    'promise/param-names'?: Linter.RuleEntry<PromiseParamNames>;
+    /**
+     * Prefer async/await to the callback pattern.
+     * @see https://github.com/eslint-community/eslint-plugin-promise/blob/main/docs/rules/prefer-await-to-callbacks.md
+     */
+    'promise/prefer-await-to-callbacks'?: Linter.RuleEntry<[]>;
+    /**
+     * Prefer `await` to `then()`/`catch()`/`finally()` for reading Promise values.
+     * @see https://github.com/eslint-community/eslint-plugin-promise/blob/main/docs/rules/prefer-await-to-then.md
+     */
+    'promise/prefer-await-to-then'?: Linter.RuleEntry<[]>;
+    /**
+     * Enforces the proper number of arguments are passed to Promise functions.
+     * @see https://github.com/eslint-community/eslint-plugin-promise/blob/main/docs/rules/valid-params.md
+     */
+    'promise/valid-params'?: Linter.RuleEntry<[]>;
+}
+type PromiseAlwaysReturn = [] | [
+    {
+        ignoreLastCallback?: boolean;
+    }
+];
+type PromiseCatchOrReturn = [] | [
+    {
+        allowFinally?: boolean;
+        allowThen?: boolean;
+        terminationMethod?: (string | string[]);
+    }
+];
+type PromiseNoCallbackInPromise = [] | [
+    {
+        exceptions?: string[];
+    }
+];
+type PromiseNoReturnWrap = [] | [
+    {
+        allowReject?: boolean;
+    }
+];
+type PromiseParamNames = [] | [
+    {
+        resolvePattern?: string;
+        rejectPattern?: string;
+    }
+];
+export {};

package/dist/types/gens/regexp.d.cts

@@ -0,0 +1,553 @@
+import type { Linter } from 'eslint';
+export interface RegexpRules {
+    /**
+     * 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<[]>;
+}
+type RegexpHexadecimalEscape = [] | [("always" | "never")];
+type RegexpLetterCase = [] | [
+    {
+        caseInsensitive?: ("lowercase" | "uppercase" | "ignore");
+        unicodeEscape?: ("lowercase" | "uppercase" | "ignore");
+        hexadecimalEscape?: ("lowercase" | "uppercase" | "ignore");
+        controlEscape?: ("lowercase" | "uppercase" | "ignore");
+    }
+];
+type RegexpMatchAny = [] | [
+    {
+        allows?: [("[\\s\\S]" | "[\\S\\s]" | "[^]" | "dotAll"), ...(("[\\s\\S]" | "[\\S\\s]" | "[^]" | "dotAll"))[]];
+    }
+];
+type RegexpNoDupeDisjunctions = [] | [
+    {
+        report?: ("all" | "trivial" | "interesting");
+        reportExponentialBacktracking?: ("none" | "certain" | "potential");
+        reportUnreachable?: ("certain" | "potential");
+    }
+];
+type RegexpNoLazyEnds = [] | [
+    {
+        ignorePartial?: boolean;
+    }
+];
+type RegexpNoLegacyFeatures = [] | [
+    {
+        staticProperties?: ("input" | "$_" | "lastMatch" | "$&" | "lastParen" | "$+" | "leftContext" | "$`" | "rightContext" | "$'" | "$1" | "$2" | "$3" | "$4" | "$5" | "$6" | "$7" | "$8" | "$9")[];
+        prototypeMethods?: ("compile")[];
+    }
+];
+type RegexpNoMisleadingCapturingGroup = [] | [
+    {
+        reportBacktrackingEnds?: boolean;
+    }
+];
+type RegexpNoMisleadingUnicodeCharacter = [] | [
+    {
+        fixable?: boolean;
+    }
+];
+type RegexpNoMissingGFlag = [] | [
+    {
+        strictTypes?: boolean;
+    }
+];
+type RegexpNoObscureRange = [] | [
+    {
+        allowed?: (("all" | "alphanumeric") | [("all" | "alphanumeric")] | [("alphanumeric" | string), ...(("alphanumeric" | string))[]]);
+    }
+];
+type RegexpNoSuperLinearBacktracking = [] | [
+    {
+        report?: ("certain" | "potential");
+    }
+];
+type RegexpNoSuperLinearMove = [] | [
+    {
+        report?: ("certain" | "potential");
+        ignoreSticky?: boolean;
+        ignorePartial?: boolean;
+    }
+];
+type RegexpNoUnusedCapturingGroup = [] | [
+    {
+        fixable?: boolean;
+        allowNamed?: boolean;
+    }
+];
+type RegexpNoUselessCharacterClass = [] | [
+    {
+        ignores?: string[];
+    }
+];
+type RegexpNoUselessFlag = [] | [
+    {
+        ignore?: ("i" | "m" | "s" | "g" | "y")[];
+        strictTypes?: boolean;
+    }
+];
+type RegexpNoUselessNonCapturingGroup = [] | [
+    {
+        allowTop?: (boolean | ("always" | "never" | "partial"));
+    }
+];
+type RegexpOptimalQuantifierConcatenation = [] | [
+    {
+        capturingGroups?: ("ignore" | "report");
+    }
+];
+type RegexpPreferCharacterClass = [] | [
+    {
+        minAlternatives?: number;
+    }
+];
+type RegexpPreferD = [] | [
+    {
+        insideCharacterClass?: ("ignore" | "range" | "d");
+    }
+];
+type RegexpPreferLookaround = [] | [
+    {
+        lookbehind?: boolean;
+        strictTypes?: boolean;
+    }
+];
+type RegexpPreferNamedReplacement = [] | [
+    {
+        strictTypes?: boolean;
+    }
+];
+type RegexpPreferRange = [] | [
+    {
+        target?: (("all" | "alphanumeric") | [("all" | "alphanumeric")] | [("alphanumeric" | string), ...(("alphanumeric" | string))[]]);
+    }
+];
+type RegexpPreferResultArrayGroups = [] | [
+    {
+        strictTypes?: boolean;
+    }
+];
+type RegexpSortCharacterClassElements = [] | [
+    {
+        order?: ("\\s" | "\\w" | "\\d" | "\\p" | "*" | "\\q" | "[]")[];
+    }
+];
+type RegexpUnicodeEscape = [] | [("unicodeCodePointEscape" | "unicodeEscape")];
+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");
+        });
+    }
+];
+export {};