@ttsc/lint 0.13.1 → 0.14.0-dev.20260528.1

package/src/structures/rules/ITtscLintReactRules.ts

@@ -0,0 +1,321 @@
+import type { ITtscLintReactOnlyExportComponentsRuleOptions } from "./ITtscLintReactRuleOptions";
+import type {
+  TtscLintRuleOptionsSetting,
+  TtscLintRuleSetting,
+} from "../TtscLintRuleSetting";
+
+/**
+ * React TSX rules.
+ *
+ * Bundles rules from `eslint-plugin-react`, `eslint-plugin-react-hooks`,
+ * and `eslint-plugin-react-refresh` under one namespace, matching
+ * Oxlint's `react/*` plugin layout. Performance-only rules live in a
+ * separate {@link ITtscLintReactPerfRules} family because they are
+ * opt-in toggles rather than correctness checks.
+ *
+ * @reference https://github.com/jsx-eslint/eslint-plugin-react
+ */
+export interface ITtscLintReactRules {
+  /**
+   * Require explicit, valid `type` values on JSX `<button>` elements
+   * (`"button"`, `"submit"`, `"reset"`) — the HTML default of
+   * `"submit"` causes accidental form submissions.
+   *
+   * @reference https://github.com/jsx-eslint/eslint-plugin-react/blob/master/docs/rules/button-has-type.md
+   */
+  "react/button-has-type"?: TtscLintRuleSetting;
+
+  /**
+   * Require components wrapped in `React.memo(...)` or
+   * `React.forwardRef(...)` to be named — either by passing a named
+   * function, assigning the call to a named binding, or setting an
+   * explicit `displayName`.
+   *
+   * Anonymous wrappers leave the resulting component nameless in
+   * React DevTools and runtime stack frames.
+   *
+   * @reference https://github.com/jsx-eslint/eslint-plugin-react/blob/master/docs/rules/display-name.md
+   */
+  "react/display-name"?: TtscLintRuleSetting;
+
+  /**
+   * Detect high-confidence missing identifiers in React Hook
+   * dependency arrays (`useEffect`, `useLayoutEffect`,
+   * `useInsertionEffect`, `useMemo`, `useCallback`).
+   *
+   * @reference https://react.dev/reference/react/useEffect#specifying-reactive-dependencies
+   */
+  "react/exhaustive-deps"?: TtscLintRuleSetting;
+
+  /**
+   * Reject declaring a component or custom Hook inside another
+   * component or Hook body.
+   *
+   * Each render rebuilds the inner function, giving it a new
+   * identity that discards its state and breaks memoization.
+   *
+   * @reference https://react.dev/reference/rules/components-and-hooks-must-be-pure
+   */
+  "react/component-hook-factories"?: TtscLintRuleSetting;
+
+  /**
+   * Require JSX `<iframe>` elements to declare a `sandbox` attribute,
+   * which restricts what embedded content can do (scripts, forms,
+   * navigation).
+   *
+   * @reference https://github.com/jsx-eslint/eslint-plugin-react/blob/master/docs/rules/iframe-missing-sandbox.md
+   */
+  "react/iframe-missing-sandbox"?: TtscLintRuleSetting;
+
+  /**
+   * Reject mutating props, state, or Hook return values inside a
+   * component or Hook.
+   *
+   * React treats these as read-only; mutating a memoized value can
+   * desync renders from the dependencies React tracked it under.
+   *
+   * @reference https://react.dev/reference/rules/components-and-hooks-must-be-pure
+   */
+  "react/immutability"?: TtscLintRuleSetting;
+
+  /**
+   * Require `key` props on JSX elements produced from arrays or
+   * `.map(...)` calls — React uses the key to track list identity
+   * across renders.
+   *
+   * @reference https://github.com/jsx-eslint/eslint-plugin-react/blob/master/docs/rules/jsx-key.md
+   */
+  "react/jsx-key"?: TtscLintRuleSetting;
+
+  /**
+   * Reject duplicate JSX prop names on the same element — later
+   * occurrences silently overwrite earlier ones.
+   *
+   * @reference https://github.com/jsx-eslint/eslint-plugin-react/blob/master/docs/rules/jsx-no-duplicate-props.md
+   */
+  "react/jsx-no-duplicate-props"?: TtscLintRuleSetting;
+
+  /**
+   * Reject `javascript:` URLs in JSX URL-like props such as `href`
+   * and `src`.
+   *
+   * Such URLs evaluate the URL body as script — the same
+   * code-execution surface as `eval`, and a common XSS vector when
+   * the value is user-controlled.
+   *
+   * @reference https://github.com/jsx-eslint/eslint-plugin-react/blob/master/docs/rules/jsx-no-script-url.md
+   */
+  "react/jsx-no-script-url"?: TtscLintRuleSetting;
+
+  /**
+   * Reject `<a target="_blank">` (or any JSX element with
+   * `target="_blank"`) that does not also carry `rel="noreferrer"`
+   * (or `rel="noopener noreferrer"`).
+   *
+   * Without those tokens the opened page can navigate the originating
+   * window through `window.opener`, a phishing and tab-nabbing vector.
+   *
+   * @reference https://github.com/jsx-eslint/eslint-plugin-react/blob/master/docs/rules/jsx-no-target-blank.md
+   */
+  "react/jsx-no-target-blank"?: TtscLintRuleSetting;
+
+  /**
+   * Reject JSX elements whose tag is an uppercase identifier with no
+   * value-level declaration anywhere in the source file.
+   *
+   * Lowercase tags are intrinsic HTML; qualified `<Foo.Bar>` forms are
+   * skipped because resolving the outer name requires module-level
+   * information that belongs to the type checker.
+   *
+   * @reference https://github.com/jsx-eslint/eslint-plugin-react/blob/master/docs/rules/jsx-no-undef.md
+   */
+  "react/jsx-no-undef"?: TtscLintRuleSetting;
+
+  /**
+   * Reject JSX fragments that wrap exactly one element child or have
+   * no meaningful content — the child (or nothing) can be returned
+   * directly.
+   *
+   * Covers both the short `<>...</>` form and explicit
+   * `<Fragment>` / `<React.Fragment>` elements.
+   *
+   * @reference https://github.com/jsx-eslint/eslint-plugin-react/blob/master/docs/rules/jsx-no-useless-fragment.md
+   */
+  "react/jsx-no-useless-fragment"?: TtscLintRuleSetting;
+
+  /**
+   * Reject `key={index}` patterns inside JSX lists — array index
+   * keys reorder incorrectly on insertion.
+   *
+   * @reference https://github.com/jsx-eslint/eslint-plugin-react/blob/master/docs/rules/no-array-index-key.md
+   */
+  "react/no-array-index-key"?: TtscLintRuleSetting;
+
+  /**
+   * Reject passing children through an explicit `children` JSX prop.
+   *
+   * The nested-tag form is shorter, mirrors HTML, and avoids the
+   * double-children footgun where a `children` prop and nested JSX
+   * both target the same slot.
+   *
+   * @reference https://github.com/jsx-eslint/eslint-plugin-react/blob/master/docs/rules/no-children-prop.md
+   */
+  "react/no-children-prop"?: TtscLintRuleSetting;
+
+  /**
+   * Reject `dangerouslySetInnerHTML` altogether.
+   *
+   * The prop bypasses React's escaping and injects raw HTML into the
+   * DOM — a common XSS vector when the input is not sanitized
+   * upstream.
+   *
+   * @reference https://github.com/jsx-eslint/eslint-plugin-react/blob/master/docs/rules/no-danger.md
+   */
+  "react/no-danger"?: TtscLintRuleSetting;
+
+  /**
+   * Reject combining `dangerouslySetInnerHTML` with JSX children
+   * — React throws at runtime in this case.
+   *
+   * @reference https://github.com/jsx-eslint/eslint-plugin-react/blob/master/docs/rules/no-danger-with-children.md
+   */
+  "react/no-danger-with-children"?: TtscLintRuleSetting;
+
+  /**
+   * Reject direct writes to `this.state` outside constructor
+   * initialization. Use `this.setState(...)` instead.
+   *
+   * @reference https://github.com/jsx-eslint/eslint-plugin-react/blob/master/docs/rules/no-direct-mutation-state.md
+   */
+  "react/no-direct-mutation-state"?: TtscLintRuleSetting;
+
+  /**
+   * Reject `findDOMNode(...)` calls.
+   *
+   * The API is deprecated, blocks future React internals work, and
+   * breaks component abstraction by reaching across composition
+   * boundaries; attach a `ref` to the target element instead.
+   *
+   * @reference https://github.com/jsx-eslint/eslint-plugin-react/blob/master/docs/rules/no-find-dom-node.md
+   */
+  "react/no-find-dom-node"?: TtscLintRuleSetting;
+
+  /**
+   * Reject `this.isMounted()` calls on class components.
+   *
+   * The API is deprecated, and anti-patterns around it usually hide
+   * a memory leak in async callbacks; cancel the work in
+   * `componentWillUnmount` instead.
+   *
+   * @reference https://github.com/jsx-eslint/eslint-plugin-react/blob/master/docs/rules/no-is-mounted.md
+   */
+  "react/no-is-mounted"?: TtscLintRuleSetting;
+
+  /**
+   * Reject string-form JSX refs (`ref="myInput"`).
+   *
+   * The API is legacy, slated for removal, and has well-known issues
+   * with static typing, owner tracking, and stale references; use
+   * `useRef` or a callback ref instead.
+   *
+   * @reference https://github.com/jsx-eslint/eslint-plugin-react/blob/master/docs/rules/no-string-refs.md
+   */
+  "react/no-string-refs"?: TtscLintRuleSetting;
+
+  /**
+   * Reject unescaped `>`, `"`, `'`, and `}` characters in JSX
+   * text content — they render literally and almost always come
+   * from forgotten HTML escaping.
+   *
+   * @reference https://github.com/jsx-eslint/eslint-plugin-react/blob/master/docs/rules/no-unescaped-entities.md
+   */
+  "react/no-unescaped-entities"?: TtscLintRuleSetting;
+
+  /**
+   * Keep React Fast Refresh component modules from exporting
+   * non-component values. Mixing a component export with a
+   * constant or hook in the same file invalidates HMR.
+   *
+   * @reference https://github.com/ArnaudBarre/eslint-plugin-react-refresh/blob/main/README.md
+   */
+  "react/only-export-components"?: TtscLintRuleOptionsSetting<ITtscLintReactOnlyExportComponentsRuleOptions>;
+
+  /**
+   * Reject reading or writing `ref.current` during render.
+   *
+   * Refs persist mutably across renders without re-rendering, so
+   * touching them in render breaks the pure-render contract and
+   * produces inconsistent output between render passes.
+   *
+   * @reference https://react.dev/reference/rules/components-and-hooks-must-be-pure
+   */
+  "react/refs"?: TtscLintRuleSetting;
+
+  /**
+   * Enforce the Rules of Hooks: only call Hooks at the top level
+   * of a component or custom Hook, never inside conditionals,
+   * loops, or nested functions.
+   *
+   * @reference https://react.dev/reference/rules/rules-of-hooks
+   */
+  "react/rules-of-hooks"?: TtscLintRuleSetting;
+
+  /**
+   * Reject unconditional `setState` calls in `useEffect` bodies.
+   *
+   * The state update schedules another render and re-runs the
+   * effect, which usually loops forever; the value almost always
+   * belongs in `useMemo` or derived state instead.
+   *
+   * @reference https://react.dev/learn/you-might-not-need-an-effect
+   */
+  "react/set-state-in-effect"?: TtscLintRuleSetting;
+
+  /**
+   * Reject calling `setState` during render.
+   *
+   * Render must stay pure; queuing an update from the render body
+   * schedules another render that queues another update, producing
+   * an infinite render loop unless guarded by an explicit equality
+   * check.
+   *
+   * @reference https://react.dev/reference/rules/components-and-hooks-must-be-pure
+   */
+  "react/set-state-in-render"?: TtscLintRuleSetting;
+
+  /**
+   * Reject string-form `style` values such as `style="color: red"` or
+   * `style={\`...\`}`.
+   *
+   * React expects a `{ camelCaseProp: value }` object, not the
+   * HTML-style CSS string, and the latter is silently coerced and
+   * never applied.
+   *
+   * @reference https://github.com/jsx-eslint/eslint-plugin-react/blob/master/docs/rules/style-prop-object.md
+   */
+  "react/style-prop-object"?: TtscLintRuleSetting;
+
+  /**
+   * Reject `useMemo` calculation callbacks that do not return a
+   * value.
+   *
+   * A block-bodied callback without `return` memoizes `undefined`,
+   * silently discarding the intended computation — a common mistake
+   * when wrapping an object literal in `{ ... }` instead of
+   * `({ ... })`.
+   *
+   * @reference https://react.dev/reference/react/useMemo
+   */
+  "react/use-memo"?: TtscLintRuleSetting;
+
+  /**
+   * Reject `children` or `dangerouslySetInnerHTML` on void DOM
+   * elements (`<img>`, `<br>`, `<input>`, etc.).
+   *
+   * Void elements have no content model, so React throws at render
+   * time when you try to give them any.
+   *
+   * @reference https://github.com/jsx-eslint/eslint-plugin-react/blob/master/docs/rules/void-dom-elements-no-children.md
+   */
+  "react/void-dom-elements-no-children"?: TtscLintRuleSetting;
+}

package/src/structures/rules/ITtscLintRegexpRules.ts

@@ -0,0 +1,212 @@
+import type { TtscLintRuleSetting } from "../TtscLintRuleSetting";
+
+/**
+ * Regular-expression rules from `eslint-plugin-regexp`.
+ *
+ * These rules check the structure of regex literals — emptiness,
+ * uselessness, flag ordering, shorthand classes, Unicode support.
+ *
+ * Some rules duplicate (and supersede) the regex-related rules in
+ * {@link ITtscLintCoreRules}; both ids exist so projects can keep
+ * the legacy ESLint names alongside the regexp-plugin variants.
+ *
+ * @reference https://github.com/ota-meshi/eslint-plugin-regexp
+ */
+export interface ITtscLintRegexpRules {
+  /**
+   * Reject ASCII control characters in regex literals. Alias of
+   * the bare core check.
+   *
+   * @reference https://ota-meshi.github.io/eslint-plugin-regexp/rules/no-control-character.html
+   */
+  "regexp/no-control-character"?: TtscLintRuleSetting;
+
+  /**
+   * Reject duplicate literal characters inside simple regex
+   * character classes (`/[aa]/`).
+   *
+   * @reference https://ota-meshi.github.io/eslint-plugin-regexp/rules/no-dupe-characters-character-class.html
+   */
+  "regexp/no-dupe-characters-character-class"?: TtscLintRuleSetting;
+
+  /**
+   * Reject empty alternatives in a disjunction (`/a||b/`), which
+   * silently match the empty string.
+   *
+   * @reference https://ota-meshi.github.io/eslint-plugin-regexp/rules/no-empty-alternative.html
+   */
+  "regexp/no-empty-alternative"?: TtscLintRuleSetting;
+
+  /**
+   * Reject empty capturing groups such as `/()/`.
+   *
+   * The group shifts the numbering of every later backreference and
+   * capture slot while only ever capturing the empty string — almost
+   * always a leftover from an unfinished edit.
+   *
+   * @reference https://ota-meshi.github.io/eslint-plugin-regexp/rules/no-empty-capturing-group.html
+   */
+  "regexp/no-empty-capturing-group"?: TtscLintRuleSetting;
+
+  /**
+   * Reject empty regex character classes (`[]`). Alias of the
+   * bare core check.
+   *
+   * @reference https://ota-meshi.github.io/eslint-plugin-regexp/rules/no-empty-character-class.html
+   */
+  "regexp/no-empty-character-class"?: TtscLintRuleSetting;
+
+  /**
+   * Reject empty non-capturing groups such as `/(?:)/`.
+   *
+   * The group contributes nothing to the match and is virtually always
+   * a leftover from a deleted inner pattern.
+   *
+   * @reference https://ota-meshi.github.io/eslint-plugin-regexp/rules/no-empty-group.html
+   */
+  "regexp/no-empty-group"?: TtscLintRuleSetting;
+
+  /**
+   * Reject empty lookaround assertions such as `/(?=)/` or `/(?!)/`.
+   *
+   * An empty positive lookaround always matches; an empty negative
+   * lookaround never matches. The assertion either collapses to a
+   * no-op or breaks the surrounding pattern.
+   *
+   * @reference https://ota-meshi.github.io/eslint-plugin-regexp/rules/no-empty-lookarounds-assertion.html
+   */
+  "regexp/no-empty-lookarounds-assertion"?: TtscLintRuleSetting;
+
+  /**
+   * Reject misleading Unicode characters in regex classes. Alias
+   * of the bare misleading-character check.
+   *
+   * @reference https://ota-meshi.github.io/eslint-plugin-regexp/rules/no-misleading-unicode-character.html
+   */
+  "regexp/no-misleading-unicode-character"?: TtscLintRuleSetting;
+
+  /**
+   * Reject single-character character classes such as `/[x]/`
+   * — `/x/` is equivalent.
+   *
+   * @reference https://ota-meshi.github.io/eslint-plugin-regexp/rules/no-useless-character-class.html
+   */
+  "regexp/no-useless-character-class"?: TtscLintRuleSetting;
+
+  /**
+   * Reject unnecessary escapes inside regex literals. Alias of
+   * core `no-useless-escape` for regex contexts.
+   *
+   * @reference https://ota-meshi.github.io/eslint-plugin-regexp/rules/no-useless-escape.html
+   */
+  "regexp/no-useless-escape"?: TtscLintRuleSetting;
+
+  /**
+   * Reject regex flags that the literal does not exercise — `i` on
+   * a pattern without case-variable characters, `m` without `^`/`$`,
+   * `s` without `.`, and similar dead flags on `g`/`y`.
+   *
+   * Cleans up flag combos that suggest behavior the pattern can never
+   * trigger.
+   *
+   * @reference https://ota-meshi.github.io/eslint-plugin-regexp/rules/no-useless-flag.html
+   */
+  "regexp/no-useless-flag"?: TtscLintRuleSetting;
+
+  /**
+   * Reject quantifiers that do not change the match — constant-one
+   * counts (`/a{1}/`), `?` on patterns already matching the empty
+   * string (`/(?:a+|b*)?/`), and quantifiers on non-consuming
+   * atoms (`/(?:\b)+/`).
+   *
+   * @reference https://ota-meshi.github.io/eslint-plugin-regexp/rules/no-useless-quantifier.html
+   */
+  "regexp/no-useless-quantifier"?: TtscLintRuleSetting;
+
+  /**
+   * Reject equal min/max quantifiers (`/a{2,2}/`) in favor of
+   * `/a{2}/`.
+   *
+   * @reference https://ota-meshi.github.io/eslint-plugin-regexp/rules/no-useless-two-nums-quantifier.html
+   */
+  "regexp/no-useless-two-nums-quantifier"?: TtscLintRuleSetting;
+
+  /**
+   * Reject zero-repeat quantifiers (`/a{0}/`, `/a{0,0}/`) — the atom
+   * never matches, so the quantifier is either dead code or a typo
+   * for `{1,…}`.
+   *
+   * The fix is normally to delete the atom or correct the upper
+   * bound.
+   *
+   * @reference https://ota-meshi.github.io/eslint-plugin-regexp/rules/no-zero-quantifier.html
+   */
+  "regexp/no-zero-quantifier"?: TtscLintRuleSetting;
+
+  /**
+   * Prefer `\d` over `[0-9]` in regex literals.
+   *
+   * @reference https://ota-meshi.github.io/eslint-plugin-regexp/rules/prefer-d.html
+   */
+  "regexp/prefer-d"?: TtscLintRuleSetting;
+
+  /**
+   * Prefer `+` over `{1,}` in regex literals.
+   *
+   * @reference https://ota-meshi.github.io/eslint-plugin-regexp/rules/prefer-plus-quantifier.html
+   */
+  "regexp/prefer-plus-quantifier"?: TtscLintRuleSetting;
+
+  /**
+   * Prefer `?` over `{0,1}` in regex literals.
+   *
+   * @reference https://ota-meshi.github.io/eslint-plugin-regexp/rules/prefer-question-quantifier.html
+   */
+  "regexp/prefer-question-quantifier"?: TtscLintRuleSetting;
+
+  /**
+   * Prefer `*` over `{0,}` in regex literals.
+   *
+   * @reference https://ota-meshi.github.io/eslint-plugin-regexp/rules/prefer-star-quantifier.html
+   */
+  "regexp/prefer-star-quantifier"?: TtscLintRuleSetting;
+
+  /**
+   * Prefer `\w` over `[A-Za-z0-9_]` in regex literals.
+   *
+   * @reference https://ota-meshi.github.io/eslint-plugin-regexp/rules/prefer-w.html
+   */
+  "regexp/prefer-w"?: TtscLintRuleSetting;
+
+  /**
+   * Require regex literals to use the `u` or `v` flag, so
+   * Unicode-property escapes and surrogate-pair handling stay
+   * predictable.
+   *
+   * @reference https://ota-meshi.github.io/eslint-plugin-regexp/rules/require-unicode-regexp.html
+   */
+  "regexp/require-unicode-regexp"?: TtscLintRuleSetting;
+
+  /**
+   * Require regex literals to use the `v` flag specifically — the
+   * stricter Unicode-sets mode that enables set notation, string
+   * properties, and stricter escape rules on top of `u`.
+   *
+   * Choose this over `require-unicode-regexp` only on engines that
+   * ship ES2024-era regex.
+   *
+   * @reference https://ota-meshi.github.io/eslint-plugin-regexp/rules/require-unicode-sets-regexp.html
+   */
+  "regexp/require-unicode-sets-regexp"?: TtscLintRuleSetting;
+
+  /**
+   * Require regex flags to appear in canonical alphabetical order
+   * (`dgimsuvy`).
+   *
+   * Stable ordering keeps diffs small and lets readers compare flag
+   * sets at a glance.
+   *
+   * @reference https://ota-meshi.github.io/eslint-plugin-regexp/rules/sort-flags.html
+   */
+  "regexp/sort-flags"?: TtscLintRuleSetting;
+}

package/src/structures/rules/ITtscLintRuleOptionsMap.ts

@@ -0,0 +1,89 @@
+import type {
+  ITtscLintBoundariesDependenciesRuleOptions,
+  ITtscLintBoundariesElementTypesRuleOptions,
+  ITtscLintBoundariesEntryPointRuleOptions,
+  ITtscLintBoundariesExternalRuleOptions,
+  ITtscLintBoundariesNoPrivateRuleOptions,
+  ITtscLintBoundariesNoUnknownRuleOptions,
+} from "./ITtscLintBoundariesRuleOptions";
+import type { ITtscLintCypressUnsafeToChainCommandRuleOptions } from "./ITtscLintCypressRuleOptions";
+import type {
+  ITtscLintFunctionalEmptyRuleOptions,
+  ITtscLintFunctionalImmutableDataRuleOptions,
+  ITtscLintFunctionalNoConditionalStatementsRuleOptions,
+  ITtscLintFunctionalNoLetRuleOptions,
+  ITtscLintFunctionalNoMixedTypesRuleOptions,
+  ITtscLintFunctionalNoReturnVoidRuleOptions,
+  ITtscLintFunctionalNoThrowStatementsRuleOptions,
+  ITtscLintFunctionalNoTryStatementsRuleOptions,
+  ITtscLintFunctionalParametersRuleOptions,
+  ITtscLintFunctionalPreferImmutableTypesRuleOptions,
+  ITtscLintFunctionalPreferReadonlyTypeRuleOptions,
+  ITtscLintFunctionalPreferTacitRuleOptions,
+  ITtscLintFunctionalReadonlyTypeRuleOptions,
+  ITtscLintFunctionalTypeDeclarationImmutabilityRuleOptions,
+} from "./ITtscLintFunctionalRuleOptions";
+import type { ITtscLintReactPerfRuleOptions } from "./ITtscLintReactPerfRuleOptions";
+import type { ITtscLintReactOnlyExportComponentsRuleOptions } from "./ITtscLintReactRuleOptions";
+import type { ITtscLintStorybookNoUninstalledAddonsRuleOptions } from "./ITtscLintStorybookRuleOptions";
+import type { ITtscLintTestingLibraryConsistentDataTestIdRuleOptions } from "./ITtscLintTestingLibraryRuleOptions";
+
+/**
+ * Index from typed rule name to its options object.
+ *
+ * Built-in rule families with configurable options are listed here.
+ * Contributor plugins extend the map by augmenting it from their own
+ * package:
+ *
+ * ```ts
+ * declare module "@ttsc/lint" {
+ *   interface ITtscLintRuleOptionsMap {
+ *     "demo/no-marker-comment": { marker: string };
+ *   }
+ * }
+ * ```
+ *
+ * After augmentation, `{@link TtscLintRuleOptionsSetting}` tuples and the
+ * `defineConfig`-style helpers in plugin packages can type-check the
+ * options object against the contributor's declared shape.
+ *
+ * `format/*` is **not** listed: formatter behavior is configured through
+ * the top-level `format` block ({@link ITtscLintFormat}), not through the
+ * `rules` surface.
+ */
+export interface ITtscLintRuleOptionsMap {
+  "testing-library/consistent-data-testid": ITtscLintTestingLibraryConsistentDataTestIdRuleOptions;
+  "functional/functional-parameters": ITtscLintFunctionalParametersRuleOptions;
+  "functional/immutable-data": ITtscLintFunctionalImmutableDataRuleOptions;
+  "functional/no-class-inheritance": ITtscLintFunctionalEmptyRuleOptions;
+  "functional/no-classes": ITtscLintFunctionalEmptyRuleOptions;
+  "functional/no-conditional-statements": ITtscLintFunctionalNoConditionalStatementsRuleOptions;
+  "functional/no-expression-statements": ITtscLintFunctionalEmptyRuleOptions;
+  "functional/no-let": ITtscLintFunctionalNoLetRuleOptions;
+  "functional/no-loop-statements": ITtscLintFunctionalEmptyRuleOptions;
+  "functional/no-mixed-types": ITtscLintFunctionalNoMixedTypesRuleOptions;
+  "functional/no-promise-reject": ITtscLintFunctionalEmptyRuleOptions;
+  "functional/no-return-void": ITtscLintFunctionalNoReturnVoidRuleOptions;
+  "functional/no-this-expressions": ITtscLintFunctionalEmptyRuleOptions;
+  "functional/no-throw-statements": ITtscLintFunctionalNoThrowStatementsRuleOptions;
+  "functional/no-try-statements": ITtscLintFunctionalNoTryStatementsRuleOptions;
+  "functional/prefer-immutable-types": ITtscLintFunctionalPreferImmutableTypesRuleOptions;
+  "functional/prefer-property-signatures": ITtscLintFunctionalEmptyRuleOptions;
+  "functional/prefer-readonly-type": ITtscLintFunctionalPreferReadonlyTypeRuleOptions;
+  "functional/prefer-tacit": ITtscLintFunctionalPreferTacitRuleOptions;
+  "functional/readonly-type": ITtscLintFunctionalReadonlyTypeRuleOptions;
+  "functional/type-declaration-immutability": ITtscLintFunctionalTypeDeclarationImmutabilityRuleOptions;
+  "cypress/unsafe-to-chain-command": ITtscLintCypressUnsafeToChainCommandRuleOptions;
+  "boundaries/dependencies": ITtscLintBoundariesDependenciesRuleOptions;
+  "boundaries/element-types": ITtscLintBoundariesElementTypesRuleOptions;
+  "boundaries/entry-point": ITtscLintBoundariesEntryPointRuleOptions;
+  "boundaries/external": ITtscLintBoundariesExternalRuleOptions;
+  "boundaries/no-private": ITtscLintBoundariesNoPrivateRuleOptions;
+  "boundaries/no-unknown": ITtscLintBoundariesNoUnknownRuleOptions;
+  "react-perf/jsx-no-new-array-as-prop": ITtscLintReactPerfRuleOptions;
+  "react-perf/jsx-no-new-function-as-prop": ITtscLintReactPerfRuleOptions;
+  "react-perf/jsx-no-new-object-as-prop": ITtscLintReactPerfRuleOptions;
+  "react-perf/jsx-no-jsx-as-prop": ITtscLintReactPerfRuleOptions;
+  "storybook/no-uninstalled-addons": ITtscLintStorybookNoUninstalledAddonsRuleOptions;
+  "react/only-export-components": ITtscLintReactOnlyExportComponentsRuleOptions;
+}