@ttsc/lint 0.18.3 → 0.19.0

package/lib/structures/rules/ITtscLintCoreRules.d.ts

@@ -1,4 +1,5 @@
-import type { TtscLintRuleSetting } from "../TtscLintRuleSetting";
+import type { TtscLintRuleOptionsSetting, TtscLintRuleSetting } from "../TtscLintRuleSetting";
+import type { ITtscLintCoreDefaultCaseRuleOptions, ITtscLintCoreNoDuplicateImportsRuleOptions, ITtscLintCoreNoElseReturnRuleOptions, ITtscLintCoreNoEmptyFunctionRuleOptions, ITtscLintCoreNoEmptyRuleOptions, ITtscLintCoreNoExtendNativeRuleOptions, ITtscLintCoreNoMixedOperatorsRuleOptions, ITtscLintCoreNoParamReassignRuleOptions, ITtscLintCoreNoPromiseExecutorReturnRuleOptions, ITtscLintCoreNoUnusedExpressionsRuleOptions, ITtscLintCorePreferConstRuleOptions, ITtscLintNoFallthroughRuleOptions, TtscLintCoreGroupedAccessorPairsRuleSetting, TtscLintCoreNoInnerDeclarationsRuleSetting, TtscLintCoreNoRestrictedImportsRuleSetting, TtscLintCoreNoRestrictedSyntaxRuleSetting, TtscLintCoreNoReturnAssignRuleSetting } from "./ITtscLintCoreRuleOptions";
 /**
  * Generic ESLint-compatible rules that apply to both JavaScript and TypeScript
  * source.
@@ -35,7 +36,7 @@ export interface ITtscLintCoreRules {
      *
      * @reference https://eslint.org/docs/latest/rules/default-case
      */
-    "default-case"?: TtscLintRuleSetting;
+    "default-case"?: TtscLintRuleOptionsSetting<ITtscLintCoreDefaultCaseRuleOptions>;
     /**
      * Require the `default` clause of a `switch` statement to appear after every
      * explicit `case` label.
@@ -123,7 +124,7 @@ export interface ITtscLintCoreRules {
      *
      * @reference https://eslint.org/docs/latest/rules/grouped-accessor-pairs
      */
-    "grouped-accessor-pairs"?: TtscLintRuleSetting;
+    "grouped-accessor-pairs"?: TtscLintCoreGroupedAccessorPairsRuleSetting;
     /**
      * Require the body of every `for (key in obj)` loop to begin with a guard
      * against inherited keys: `Object.hasOwn(obj, key)` or the older
@@ -271,10 +272,13 @@ export interface ITtscLintCoreRules {
      */
     "no-case-declarations"?: TtscLintRuleSetting;
     /**
-     * Reject reassigning a class binding (`class C {}; C = ...`).
+     * Reject every write to a binding introduced by a class declaration or named
+     * class expression.
      *
-     * The declaration name is effectively final; overwriting it silently leaves
-     * other call sites pointing at the original class.
+     * Binding identity is resolved lexically, so same-spelled parameter, catch,
+     * block, and sibling bindings remain independent. Direct and compound
+     * assignments, updates, destructuring targets, and `for-in`/`for-of` targets
+     * are all covered.
      *
      * @reference https://eslint.org/docs/latest/rules/no-class-assign
      */
@@ -380,8 +384,8 @@ export interface ITtscLintCoreRules {
      */
     "no-dupe-class-members"?: TtscLintRuleSetting;
     /**
-     * Reject `if (a) {} else if (a) {}` — the second branch is unreachable
-     * because the first condition already handled it.
+     * Reject an `else if` branch when duplicate or structurally covered
+     * conditions earlier in the same chain make it unreachable.
      *
      * @reference https://eslint.org/docs/latest/rules/no-dupe-else-if
      */
@@ -401,28 +405,31 @@ export interface ITtscLintCoreRules {
      */
     "no-duplicate-case"?: TtscLintRuleSetting;
     /**
-     * Reject two import declarations that resolve to the same module specifier.
-     * The runtime sees one module load either way; the duplicated declaration is
-     * purely noise at the head of the file and obscures the dependency graph.
+     * Reject an import declaration whose module specifier already appeared above
+     * when the two declarations could be merged into one legal declaration.
+     * Same-module pairs TypeScript cannot consolidate — named next to namespace
+     * bindings, or a type-only default next to type-only named bindings — are not
+     * duplicates. `allowSeparateTypeImports` additionally keeps clause-level
+     * `import type` declarations apart from value imports, and `includeExports`
+     * folds `export … from` declarations into the same analysis.
      *
      * @reference https://eslint.org/docs/latest/rules/no-duplicate-imports
      */
-    "no-duplicate-imports"?: TtscLintRuleSetting;
+    "no-duplicate-imports"?: TtscLintRuleOptionsSetting<ITtscLintCoreNoDuplicateImportsRuleOptions>;
     /**
-     * Reject an `else` block whose preceding `if` branch already terminates
-     * control flow with `return`, `throw`, `break`, or `continue` — flatten the
-     * body into the surrounding scope.
+     * Reject an `else` block whose preceding `if` branch returns on every path;
+     * flatten the body into the surrounding scope.
      *
      * @reference https://eslint.org/docs/latest/rules/no-else-return
      */
-    "no-else-return"?: TtscLintRuleSetting;
+    "no-else-return"?: TtscLintRuleOptionsSetting<ITtscLintCoreNoElseReturnRuleOptions>;
     /**
-     * Reject empty blocks (`if (x) {}`, `while (x) {}`, `try {} catch (e) {}`
-     * etc.) that almost always indicate forgotten code.
+     * Reject empty, uncommented blocks and switches. Set `allowEmptyCatch` to
+     * accept an uncommented empty catch clause; its default is `false`.
      *
      * @reference https://eslint.org/docs/latest/rules/no-empty
      */
-    "no-empty"?: TtscLintRuleSetting;
+    "no-empty"?: TtscLintRuleOptionsSetting<ITtscLintCoreNoEmptyRuleOptions>;
     /**
      * Reject empty regex character classes (`[]`).
      *
@@ -433,14 +440,13 @@ export interface ITtscLintCoreRules {
      */
     "no-empty-character-class"?: TtscLintRuleSetting;
     /**
-     * Reject empty function and method bodies (`function f() {}`, `() => {}`).
-     *
-     * Use `() => undefined` or a leading TODO comment when the empty body is
-     * intentional.
+     * Reject empty, uncommented function bodies. The `allow` option accepts
+     * canonical function, method, accessor, constructor, async, generator,
+     * decorator, and override categories.
      *
      * @reference https://eslint.org/docs/latest/rules/no-empty-function
      */
-    "no-empty-function"?: TtscLintRuleSetting;
+    "no-empty-function"?: TtscLintRuleOptionsSetting<ITtscLintCoreNoEmptyFunctionRuleOptions>;
     /**
      * Reject empty named import or export clauses — `import {} from "x"`, `import
      * name, {} from "x"`, and `export {}` — which bind nothing.
@@ -494,16 +500,17 @@ export interface ITtscLintCoreRules {
      */
     "no-ex-assign"?: TtscLintRuleSetting;
     /**
-     * Reject assignments to a built-in prototype such as `Array.prototype.foo =
-     * bar`. Only `<Builtin>.prototype.<key> = …` is flagged; assigning to
-     * `Object.foo = …` (a static property) is left alone.
+     * Reject extending a built-in prototype through direct assignment or
+     * `Object.defineProperty` / `Object.defineProperties`. Assigning to a static
+     * property such as `Object.foo` is left alone.
      *
      * @reference https://eslint.org/docs/latest/rules/no-extend-native
      */
-    "no-extend-native"?: TtscLintRuleSetting;
+    "no-extend-native"?: TtscLintRuleOptionsSetting<ITtscLintCoreNoExtendNativeRuleOptions>;
     /**
-     * Reject unnecessary `Function.prototype.bind()` calls — for example, binding
-     * without arguments or binding an arrow function (which ignores `this`).
+     * Reject `.bind(thisArg)` on an arrow function or on a regular function whose
+     * own scope never reads `this`. Calls that bind later arguments are preserved
+     * as partial applications.
      *
      * @reference https://eslint.org/docs/latest/rules/no-extra-bind
      */
@@ -516,17 +523,26 @@ export interface ITtscLintCoreRules {
      */
     "no-extra-boolean-cast"?: TtscLintRuleSetting;
     /**
-     * Reject `switch` case fall-through unless preceded by an explicit `// falls
-     * through` comment.
+     * Reject `switch` cases that can reach the next `case` / `default` label
+     * without an intentional-fallthrough comment (`// falls through` by
+     * default).
+     *
+     * Reachability follows statement completion: a case whose every path ends in
+     * `break`, `continue`, `return`, or `throw` (composed through blocks,
+     * `if/else`, loops, labeled statements, and `try/catch/finally`) does not
+     * fall through, while a `return` inside a nested function never terminates
+     * the case. Options: {@link ITtscLintNoFallthroughRuleOptions}.
      *
      * @reference https://eslint.org/docs/latest/rules/no-fallthrough
      */
-    "no-fallthrough"?: TtscLintRuleSetting;
+    "no-fallthrough"?: TtscLintRuleOptionsSetting<ITtscLintNoFallthroughRuleOptions>;
     /**
-     * Reject reassignment of function declarations (`function f() {}; f = 0;`).
+     * Reject writes to bindings introduced by function declarations and named
+     * function expressions. Lexical binding identity keeps same-spelled shadows
+     * independent across parameters, blocks, catches, and sibling scopes.
      *
-     * The hoisted binding looks final to most readers; overwriting it makes the
-     * original implementation unreachable from other references.
+     * Direct and compound assignment, updates, destructuring, and for-in/of
+     * targets are all modifying references to the function binding.
      *
      * @reference https://eslint.org/docs/latest/rules/no-func-assign
      */
@@ -552,12 +568,13 @@ export interface ITtscLintCoreRules {
      */
     "no-import-assign"?: TtscLintRuleSetting;
     /**
-     * Reject `function` and `var` declarations nested in non-function blocks
-     * (loops, `if`, etc.) — they hoist in surprising ways.
+     * Reject function declarations nested in sloppy blocks. The `"both"` mode
+     * also checks `var`; strict ES2015 block-scoped functions are allowed by
+     * default and can be disabled through `blockScopedFunctions`.
      *
      * @reference https://eslint.org/docs/latest/rules/no-inner-declarations
      */
-    "no-inner-declarations"?: TtscLintRuleSetting;
+    "no-inner-declarations"?: TtscLintCoreNoInnerDeclarationsRuleSetting;
     /**
      * Reject `this` references outside any function-like, class method, or
      * class-static-block context.
@@ -609,10 +626,9 @@ export interface ITtscLintCoreRules {
      */
     "no-lonely-if"?: TtscLintRuleSetting;
     /**
-     * Reject function declarations defined inside the body of a loop. Each
-     * iteration of the loop allocates a fresh function whose closure captures the
-     * surrounding `let`/`var` binding — a class of bugs where every captured
-     * function reads the iteration's final value instead of its own.
+     * Reject loop-created closures that capture bindings which can change between
+     * iterations. Constants, per-iteration `let` bindings, and unreferenced
+     * synchronous IIFEs are safe.
      *
      * @reference https://eslint.org/docs/latest/rules/no-loop-func
      */
@@ -645,14 +661,14 @@ export interface ITtscLintCoreRules {
      * The famous case is `a && b || c`: readers expect left-to-right grouping but
      * the parser sees `(a && b) || c` because `&&` binds tighter than `||`.
      *
-     * The conservative baseline only flags the highest-confusion mixes — logical
-     * mixed with a different logical (`&&` next to `||` / `??`), and bitwise
-     * (`&`, `|`, `^`) next to a comparison or logical. Wrapping the inner
-     * sub-expression in parens suppresses the report.
+     * The default groups cover arithmetic, bitwise, comparison, logical, and
+     * relational operators, matching ESLint. A custom `groups` option replaces
+     * that grouping, while `allowSamePrecedence` controls equal-precedence mixes.
+     * Wrapping the inner sub-expression in parens suppresses the report.
      *
      * @reference https://eslint.org/docs/latest/rules/no-mixed-operators
      */
-    "no-mixed-operators"?: TtscLintRuleSetting;
+    "no-mixed-operators"?: TtscLintRuleOptionsSetting<ITtscLintCoreNoMixedOperatorsRuleOptions>;
     /**
      * Reject chained assignment such as `a = b = 0`, which obscures intent and
      * surprises readers who expect comparison.
@@ -745,13 +761,14 @@ export interface ITtscLintCoreRules {
      */
     "no-octal-escape"?: TtscLintRuleSetting;
     /**
-     * Reject reassigning a function parameter inside the body of the function it
-     * belongs to. The parameter name stops pointing at the caller's argument
-     * after the write. Property mutations (`param.foo = …`) are not flagged.
+     * Reject writes to a function parameter's binding, including through nested
+     * closures and destructuring assignment targets. `props: true` also reports
+     * property writes, with the official exact-name and regular-expression ignore
+     * lists.
      *
      * @reference https://eslint.org/docs/latest/rules/no-param-reassign
      */
-    "no-param-reassign"?: TtscLintRuleSetting;
+    "no-param-reassign"?: TtscLintRuleOptionsSetting<ITtscLintCoreNoParamReassignRuleOptions>;
     /**
      * Reject `++` and `--` operators.
      *
@@ -762,12 +779,13 @@ export interface ITtscLintCoreRules {
      */
     "no-plusplus"?: TtscLintRuleSetting;
     /**
-     * Reject `return` inside the Promise executor function — the value is
-     * ignored.
+     * Reject values returned by the global Promise constructor's executor. This
+     * covers concise arrows and explicit returns without crossing nested function
+     * boundaries. Set `allowVoid` to accept an explicit unary `void` return.
      *
      * @reference https://eslint.org/docs/latest/rules/no-promise-executor-return
      */
-    "no-promise-executor-return"?: TtscLintRuleSetting;
+    "no-promise-executor-return"?: TtscLintRuleOptionsSetting<ITtscLintCoreNoPromiseExecutorReturnRuleOptions>;
     /**
      * Reject access to `obj.__proto__`; use `Object.getPrototypeOf` /
      * `Object.setPrototypeOf`.
@@ -802,25 +820,29 @@ export interface ITtscLintCoreRules {
      */
     "no-regex-spaces"?: TtscLintRuleSetting;
     /**
-     * Reject `import` declarations targeting any module specifier in the project
-     * denylist.
+     * Reject static imports and re-exports selected by exact paths or patterns.
+     * Missing or empty restrictions are a no-op.
      *
      * @reference https://eslint.org/docs/latest/rules/no-restricted-imports
      */
-    "no-restricted-imports"?: TtscLintRuleSetting;
+    "no-restricted-imports"?: TtscLintCoreNoRestrictedImportsRuleSetting;
     /**
-     * Reject AST node kinds listed in the project denylist.
+     * Reject syntax matching the configured AST selectors. With no selector
+     * options the rule is silent; it does not impose a built-in denylist.
+     *
+     * Native TypeScript-Go kind names and the documented esquery-compatible
+     * selector forms are supported, including TypeScript-only syntax.
      *
      * @reference https://eslint.org/docs/latest/rules/no-restricted-syntax
      */
-    "no-restricted-syntax"?: TtscLintRuleSetting;
+    "no-restricted-syntax"?: TtscLintCoreNoRestrictedSyntaxRuleSetting;
     /**
      * Reject assignment expressions used as the operand of `return` (`return x =
      * 1`) — almost always a typo for `===`.
      *
      * @reference https://eslint.org/docs/latest/rules/no-return-assign
      */
-    "no-return-assign"?: TtscLintRuleSetting;
+    "no-return-assign"?: TtscLintCoreNoReturnAssignRuleSetting;
     /**
      * Reject `javascript:` URLs in string literals — they execute their body as
      * code on browser navigation, and security scanners treat them as an `eval`
@@ -959,12 +981,21 @@ export interface ITtscLintCoreRules {
      */
     "no-unsafe-optional-chaining"?: TtscLintRuleSetting;
     /**
-     * Reject expression statements with no observable effect, like a bare `x;` or
-     * `'use strict' && f();`.
+     * Reject expression statements with no observable effect, like a bare `x;`,
+     * `a === b;`, or a tagged template literal statement.
+     *
+     * Directive prologues — the leading run of string-literal statements at the
+     * top of a script, module, namespace body, or function body — are accepted
+     * whatever their text (`"use strict"`, `"use client"`, …); the same strings
+     * elsewhere are rejected. Productive expressions (calls, `new`, assignments,
+     * updates, `delete`, `void`, `await`, `yield`) are accepted, and JSX is
+     * accepted unless
+     * {@link ITtscLintCoreNoUnusedExpressionsRuleOptions.enforceForJSX} is
+     * enabled.
      *
      * @reference https://eslint.org/docs/latest/rules/no-unused-expressions
      */
-    "no-unused-expressions"?: TtscLintRuleSetting;
+    "no-unused-expressions"?: TtscLintRuleOptionsSetting<ITtscLintCoreNoUnusedExpressionsRuleOptions>;
     /**
      * Reject labels that no `break` or `continue` statement references.
      *
@@ -1083,12 +1114,15 @@ export interface ITtscLintCoreRules {
      */
     "prefer-arrow-callback"?: TtscLintRuleSetting;
     /**
-     * Require `const` for variables that are never reassigned after declaration.
-     * Autofixable for single-declaration `let`s.
+     * Require `const` for lexical bindings that are never reassigned after their
+     * initial value is established. Declaration-only and destructured bindings
+     * follow ESLint's `ignoreReadBeforeAssign` and `destructuring` options.
+     * Autofixable when one initialized declaration can safely change its shared
+     * `let` keyword.
      *
      * @reference https://eslint.org/docs/latest/rules/prefer-const
      */
-    "prefer-const"?: TtscLintRuleSetting;
+    "prefer-const"?: TtscLintRuleOptionsSetting<ITtscLintCorePreferConstRuleOptions>;
     /**
      * Reject single-property and single-index variable declarations (`const a =
      * obj.a`, `const x = arr[0]`) that destructuring would replace verbatim.

package/lib/structures/rules/ITtscLintRegexpRules.d.ts

@@ -91,10 +91,15 @@ export interface ITtscLintRegexpRules {
     "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`.
+     * with no case-variable character, `m` on a pattern with no `^`/`$`
+     * assertion.
      *
      * Cleans up flag combos that suggest behavior the pattern can never trigger.
+     * A character is case-variable wherever it sits, so `/[a-z]/i` keeps its flag
+     * (the flag is what extends the class to `A-Z`), and a `^` or `$` inside a
+     * character class is a plain character that does not save `m`. Patterns the
+     * rule cannot settle from the source — a Unicode property escape, a
+     * backreference, a `v`-mode set-notation class — count as using the flag.
      *
      * @reference https://ota-meshi.github.io/eslint-plugin-regexp/rules/no-useless-flag.html
      */

package/lib/structures/rules/ITtscLintRuleOptionsMap.d.ts

@@ -1,33 +1,54 @@
+import type { TtscLintRuleOptionsSetting } from "../TtscLintRuleSetting";
 import type { ITtscLintBoundariesDependenciesRuleOptions, ITtscLintBoundariesElementTypesRuleOptions, ITtscLintBoundariesEntryPointRuleOptions, ITtscLintBoundariesExternalRuleOptions, ITtscLintBoundariesNoPrivateRuleOptions, ITtscLintBoundariesNoUnknownRuleOptions } from "./ITtscLintBoundariesRuleOptions";
+import type { ITtscLintCoreDefaultCaseRuleOptions, ITtscLintCoreNoDuplicateImportsRuleOptions, ITtscLintCoreNoElseReturnRuleOptions, ITtscLintCoreNoEmptyFunctionRuleOptions, ITtscLintCoreNoEmptyRuleOptions, ITtscLintCoreNoExtendNativeRuleOptions, ITtscLintCoreNoMixedOperatorsRuleOptions, ITtscLintCoreNoParamReassignRuleOptions, ITtscLintCoreNoPromiseExecutorReturnRuleOptions, ITtscLintCoreNoUnusedExpressionsRuleOptions, ITtscLintCorePreferConstRuleOptions, ITtscLintNoFallthroughRuleOptions } from "./ITtscLintCoreRuleOptions";
 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";
+import type { ITtscLintTypeScriptBanTsCommentRuleOptions, ITtscLintTypeScriptNoFloatingPromisesRuleOptions, ITtscLintTypeScriptNoMisusedPromisesRuleOptions, ITtscLintTypeScriptNoRestrictedTypesRuleOptions, ITtscLintTypeScriptSwitchExhaustivenessCheckRuleOptions } from "./ITtscLintTypeScriptRuleOptions";
+import type { ITtscLintUnicornBetterRegexRuleOptions, ITtscLintUnicornConsistentFunctionScopingRuleOptions, ITtscLintUnicornFilenameCaseRuleOptions, ITtscLintUnicornImportStyleRuleOptions, ITtscLintUnicornIsolatedFunctionsRuleOptions, ITtscLintUnicornNoTypeofUndefinedRuleOptions, ITtscLintUnicornNoUnnecessaryPolyfillsRuleOptions, ITtscLintUnicornPreferNumberPropertiesRuleOptions, ITtscLintUnicornPreventAbbreviationsRuleOptions, ITtscLintUnicornStringContentRuleOptions, ITtscLintUnicornTemplateIndentRuleOptions, ITtscLintUnicornTextEncodingIdentifierCaseRuleOptions } from "./ITtscLintUnicornRuleOptions";
 /**
- * Index from typed rule name to its options object.
+ * Index from typed rule name to its single options-object slot.
  *
- * Built-in rule families with configurable options are listed here. Contributor
- * plugins extend the map by augmenting it from their own package:
+ * Built-in rule families with one object option are listed here. Rules with
+ * canonical positional lists expose dedicated setting types instead.
+ * 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 };
+ *     "demo/no-marker-comment": { markers?: readonly 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.
+ * {@link TtscLintRuleOptionsOverlay} maps every entry to its strongly typed
+ * severity tuple. {@link ITtscLintRules} intersects that overlay with the
+ * built-in families and the open contributor fallback, so importing a plugin's
+ * augmentation tightens its registered rule while unknown contributor names
+ * retain the backward-compatible `unknown` options slot.
  *
  * `format/*` is **not** listed: formatter behavior is configured through the
  * top-level `format` block ({@link ITtscLintFormat}), not through the `rules`
  * surface.
  */
 export interface ITtscLintRuleOptionsMap {
+    "default-case": ITtscLintCoreDefaultCaseRuleOptions;
+    "unicorn/template-indent": ITtscLintUnicornTemplateIndentRuleOptions;
+    "typescript/no-floating-promises": ITtscLintTypeScriptNoFloatingPromisesRuleOptions;
+    "no-duplicate-imports": ITtscLintCoreNoDuplicateImportsRuleOptions;
+    "no-else-return": ITtscLintCoreNoElseReturnRuleOptions;
+    "no-empty": ITtscLintCoreNoEmptyRuleOptions;
+    "no-empty-function": ITtscLintCoreNoEmptyFunctionRuleOptions;
+    "no-extend-native": ITtscLintCoreNoExtendNativeRuleOptions;
+    "no-mixed-operators": ITtscLintCoreNoMixedOperatorsRuleOptions;
+    "no-param-reassign": ITtscLintCoreNoParamReassignRuleOptions;
+    "no-promise-executor-return": ITtscLintCoreNoPromiseExecutorReturnRuleOptions;
+    "no-unused-expressions": ITtscLintCoreNoUnusedExpressionsRuleOptions;
+    "no-fallthrough": ITtscLintNoFallthroughRuleOptions;
+    "prefer-const": ITtscLintCorePreferConstRuleOptions;
     "testing-library/consistent-data-testid": ITtscLintTestingLibraryConsistentDataTestIdRuleOptions;
     "functional/functional-parameters": ITtscLintFunctionalParametersRuleOptions;
     "functional/immutable-data": ITtscLintFunctionalImmutableDataRuleOptions;
@@ -62,4 +83,29 @@ export interface ITtscLintRuleOptionsMap {
     "react-perf/jsx-no-jsx-as-prop": ITtscLintReactPerfRuleOptions;
     "storybook/no-uninstalled-addons": ITtscLintStorybookNoUninstalledAddonsRuleOptions;
     "react/only-export-components": ITtscLintReactOnlyExportComponentsRuleOptions;
+    "typescript/ban-ts-comment": ITtscLintTypeScriptBanTsCommentRuleOptions;
+    "typescript/no-misused-promises": ITtscLintTypeScriptNoMisusedPromisesRuleOptions;
+    "typescript/no-restricted-types": ITtscLintTypeScriptNoRestrictedTypesRuleOptions;
+    "typescript/switch-exhaustiveness-check": ITtscLintTypeScriptSwitchExhaustivenessCheckRuleOptions;
+    "unicorn/consistent-function-scoping": ITtscLintUnicornConsistentFunctionScopingRuleOptions;
+    "unicorn/better-regex": ITtscLintUnicornBetterRegexRuleOptions;
+    "unicorn/prevent-abbreviations": ITtscLintUnicornPreventAbbreviationsRuleOptions;
+    "unicorn/import-style": ITtscLintUnicornImportStyleRuleOptions;
+    "unicorn/filename-case": ITtscLintUnicornFilenameCaseRuleOptions;
+    "unicorn/string-content": ITtscLintUnicornStringContentRuleOptions;
+    "unicorn/isolated-functions": ITtscLintUnicornIsolatedFunctionsRuleOptions;
+    "unicorn/no-typeof-undefined": ITtscLintUnicornNoTypeofUndefinedRuleOptions;
+    "unicorn/no-unnecessary-polyfills": ITtscLintUnicornNoUnnecessaryPolyfillsRuleOptions;
+    "unicorn/prefer-number-properties": ITtscLintUnicornPreferNumberPropertiesRuleOptions;
+    "unicorn/text-encoding-identifier-case": ITtscLintUnicornTextEncodingIdentifierCaseRuleOptions;
 }
+/**
+ * Strongly typed rule settings derived from the augmentable options map.
+ *
+ * This mapped overlay is consumed by {@link ITtscLintRules}; keeping the
+ * derivation here makes module augmentation immediately affect the public
+ * configuration type without a second per-plugin rule-name declaration.
+ */
+export type TtscLintRuleOptionsOverlay = {
+    [TRuleName in keyof ITtscLintRuleOptionsMap]?: TtscLintRuleOptionsSetting<ITtscLintRuleOptionsMap[TRuleName]>;
+};

package/lib/structures/rules/ITtscLintRules.d.ts

@@ -12,6 +12,7 @@ import type { ITtscLintPromiseRules } from "./ITtscLintPromiseRules";
 import type { ITtscLintReactPerfRules } from "./ITtscLintReactPerfRules";
 import type { ITtscLintReactRules } from "./ITtscLintReactRules";
 import type { ITtscLintRegexpRules } from "./ITtscLintRegexpRules";
+import type { TtscLintRuleOptionsOverlay } from "./ITtscLintRuleOptionsMap";
 import type { ITtscLintSecurityRules } from "./ITtscLintSecurityRules";
 import type { ITtscLintSolidRules } from "./ITtscLintSolidRules";
 import type { ITtscLintStorybookRules } from "./ITtscLintStorybookRules";
@@ -50,6 +51,9 @@ import type { ITtscLintVitestRules } from "./ITtscLintVitestRules";
  *   public rules surface.
  * - Any other `"<namespace>/<rule>"` key is accepted via
  *   {@link ITtscLintContributorRules} so plugin-shipped rules compose cleanly
- *   without ambient module augmentation.
+ *   without ambient module augmentation. A plugin can augment
+ *   `ITtscLintRuleOptionsMap`; {@link TtscLintRuleOptionsOverlay} then tightens
+ *   that rule's options while the open fallback remains for unregistered
+ *   contributor names.
  */
-export type ITtscLintRules = ITtscLintCoreRules & ITtscLintTypeScriptRules & ITtscLintBoundariesRules & ITtscLintCypressRules & ITtscLintFunctionalRules & ITtscLintJestRules & ITtscLintJsdocRules & ITtscLintJsxA11yRules & ITtscLintNextjsRules & ITtscLintPlaywrightRules & ITtscLintPromiseRules & ITtscLintReactRules & ITtscLintReactPerfRules & ITtscLintRegexpRules & ITtscLintSecurityRules & ITtscLintSolidRules & ITtscLintStorybookRules & ITtscLintTanstackQueryRules & ITtscLintTestingLibraryRules & ITtscLintUnicornRules & ITtscLintVitestRules & ITtscLintContributorRules;
+export type ITtscLintRules = ITtscLintCoreRules & ITtscLintTypeScriptRules & ITtscLintBoundariesRules & ITtscLintCypressRules & ITtscLintFunctionalRules & ITtscLintJestRules & ITtscLintJsdocRules & ITtscLintJsxA11yRules & ITtscLintNextjsRules & ITtscLintPlaywrightRules & ITtscLintPromiseRules & ITtscLintReactRules & ITtscLintReactPerfRules & ITtscLintRegexpRules & ITtscLintSecurityRules & ITtscLintSolidRules & ITtscLintStorybookRules & ITtscLintTanstackQueryRules & ITtscLintTestingLibraryRules & ITtscLintUnicornRules & ITtscLintVitestRules & ITtscLintContributorRules & TtscLintRuleOptionsOverlay;

package/lib/structures/rules/ITtscLintSolidRules.d.ts

@@ -57,14 +57,6 @@ export interface ITtscLintSolidRules {
      * @reference https://github.com/solidjs-community/eslint-plugin-solid/blob/main/packages/eslint-plugin-solid/docs/jsx-no-undef.md
      */
     "solid/jsx-no-undef"?: TtscLintRuleSetting;
-    /**
-     * Scope-marker compatibility rule (mirrors ESLint's `react/jsx-uses-vars`).
-     *
-     * The native engine emits no diagnostics for this id.
-     *
-     * @reference https://github.com/solidjs-community/eslint-plugin-solid/blob/main/packages/eslint-plugin-solid/docs/jsx-uses-vars.md
-     */
-    "solid/jsx-uses-vars"?: TtscLintRuleSetting;
     /**
      * Reject array values passed as Solid event handlers — Solid does not unwrap
      * the array form React supports.