@ttsc/lint 0.13.1 → 0.14.0-dev.20260528.1

package/src/structures/rules/ITtscLintCypressRuleOptions.ts

@@ -0,0 +1,18 @@
+/**
+ * Options shapes for rules in {@link ITtscLintCypressRules} that accept
+ * configuration. Only `cypress/unsafe-to-chain-command` is configurable in
+ * the current native subset.
+ *
+ * @reference https://github.com/cypress-io/eslint-plugin-cypress
+ */
+
+/** `cypress/unsafe-to-chain-command` rule options. */
+export interface ITtscLintCypressUnsafeToChainCommandRuleOptions {
+  /**
+   * Additional Cypress command names that should be treated as unsafe
+   * action commands when another command is chained after them.
+   *
+   * @default []
+   */
+  methods?: readonly string[];
+}

package/src/structures/rules/ITtscLintCypressRules.ts

@@ -0,0 +1,145 @@
+import type { ITtscLintCypressUnsafeToChainCommandRuleOptions } from "./ITtscLintCypressRuleOptions";
+import type {
+  TtscLintRuleOptionsSetting,
+  TtscLintRuleSetting,
+} from "../TtscLintRuleSetting";
+
+/**
+ * Cypress end-to-end test rules.
+ *
+ * Apply to TypeScript/TSX sources that use the Cypress runner
+ * (`cy.*` commands and Mocha-style `describe`/`it` blocks). Mirror
+ * the rule set from `eslint-plugin-cypress` and detect
+ * Cypress-specific anti-patterns such as async test bodies, missing
+ * assertions before screenshots, or deprecated XPath selectors.
+ *
+ * @reference https://github.com/cypress-io/eslint-plugin-cypress
+ */
+export interface ITtscLintCypressRules {
+  /**
+   * Require at least one Cypress assertion (e.g. `cy.should(...)`)
+   * before each `cy.screenshot()` call, so the captured screenshot
+   * reflects a stable application state.
+   *
+   * @reference https://github.com/cypress-io/eslint-plugin-cypress/blob/master/docs/rules/assertion-before-screenshot.md
+   */
+  "cypress/assertion-before-screenshot"?: TtscLintRuleSetting;
+
+  /**
+   * Prefer `cy.should()` over `.and()` when starting a Cypress
+   * assertion chain — `.and()` only makes sense after a preceding
+   * `.should()`.
+   *
+   * @reference https://github.com/cypress-io/eslint-plugin-cypress/blob/master/docs/rules/no-and.md
+   */
+  "cypress/no-and"?: TtscLintRuleSetting;
+
+  /**
+   * Reject assigning the return value of a Cypress command.
+   *
+   * Cypress commands are asynchronous wrappers; assignment yields a
+   * chainer proxy rather than the underlying subject.
+   *
+   * @reference https://github.com/cypress-io/eslint-plugin-cypress/blob/master/docs/rules/no-assigning-return-values.md
+   */
+  "cypress/no-assigning-return-values"?: TtscLintRuleSetting;
+
+  /**
+   * Reject `async` Cypress `before` / `beforeEach` hooks.
+   *
+   * Cypress already serializes commands; an `async` hook breaks the
+   * runner's ordering.
+   *
+   * @reference https://github.com/cypress-io/eslint-plugin-cypress/blob/master/docs/rules/no-async-before.md
+   */
+  "cypress/no-async-before"?: TtscLintRuleSetting;
+
+  /**
+   * Reject `async` Cypress `it`/`specify` test callbacks.
+   *
+   * Cypress builds a synchronous command queue when the test body
+   * runs and replays it later; an `async` body resolves before the
+   * queue executes, so the test reports success before any command
+   * has run.
+   *
+   * @reference https://github.com/cypress-io/eslint-plugin-cypress/blob/master/docs/rules/no-async-tests.md
+   */
+  "cypress/no-async-tests"?: TtscLintRuleSetting;
+
+  /**
+   * Reject chained `.get(...).get(...)` calls.
+   *
+   * Subsequent `.get()` calls do not narrow the previous subject;
+   * use a single selector or `.find()`.
+   *
+   * @reference https://github.com/cypress-io/eslint-plugin-cypress/blob/master/docs/rules/no-chained-get.md
+   */
+  "cypress/no-chained-get"?: TtscLintRuleSetting;
+
+  /**
+   * Reject `cy.debug()` and chained `.debug()` commands.
+   *
+   * The helpers drop into the browser debugger and pause the runner
+   * indefinitely — fine for local exploration but hangs CI when one
+   * slips into a committed test.
+   *
+   * @reference https://github.com/cypress-io/eslint-plugin-cypress/blob/master/docs/rules/no-debug.md
+   */
+  "cypress/no-debug"?: TtscLintRuleSetting;
+
+  /**
+   * Reject `{ force: true }` on Cypress action commands such as
+   * `.click({ force: true })`. The option masks real UX issues.
+   *
+   * @reference https://github.com/cypress-io/eslint-plugin-cypress/blob/master/docs/rules/no-force.md
+   */
+  "cypress/no-force"?: TtscLintRuleSetting;
+
+  /**
+   * Reject `cy.pause()` and chained `.pause()` commands.
+   *
+   * They halt the Cypress runner until manually resumed, which is a
+   * local-debugging affordance that hangs CI when committed.
+   *
+   * @reference https://github.com/cypress-io/eslint-plugin-cypress/blob/master/docs/rules/no-pause.md
+   */
+  "cypress/no-pause"?: TtscLintRuleSetting;
+
+  /**
+   * Reject numeric `cy.wait(ms)` sleeps — they create flaky tests.
+   * Wait on a Cypress retry-aware assertion (`should`, `findBy*`,
+   * intercepted requests) instead.
+   *
+   * @reference https://github.com/cypress-io/eslint-plugin-cypress/blob/master/docs/rules/no-unnecessary-waiting.md
+   */
+  "cypress/no-unnecessary-waiting"?: TtscLintRuleSetting;
+
+  /**
+   * Reject `cy.xpath(...)` selectors.
+   *
+   * The plugin shipping `cy.xpath` is deprecated, and XPath
+   * expressions tend to encode brittle DOM structure rather than the
+   * semantic attributes Cypress otherwise targets.
+   *
+   * @reference https://github.com/cypress-io/eslint-plugin-cypress/blob/master/docs/rules/no-xpath.md
+   */
+  "cypress/no-xpath"?: TtscLintRuleSetting;
+
+  /**
+   * Require `cy.get()` selectors to target a `data-*` attribute
+   * when the selector is a string literal — separates testing
+   * concerns from styling.
+   *
+   * @reference https://github.com/cypress-io/eslint-plugin-cypress/blob/master/docs/rules/require-data-selectors.md
+   */
+  "cypress/require-data-selectors"?: TtscLintRuleSetting;
+
+  /**
+   * Reject chaining further Cypress commands after action commands
+   * (e.g. `.click().then(...)`). Configurable per-command via the
+   * options object.
+   *
+   * @reference https://github.com/cypress-io/eslint-plugin-cypress/blob/master/docs/rules/unsafe-to-chain-command.md
+   */
+  "cypress/unsafe-to-chain-command"?: TtscLintRuleOptionsSetting<ITtscLintCypressUnsafeToChainCommandRuleOptions>;
+}

package/src/structures/rules/ITtscLintFunctionalRuleOptions.ts

@@ -0,0 +1,213 @@
+/**
+ * Options shapes for every configurable rule in
+ * {@link ITtscLintFunctionalRules}.
+ *
+ * Most `functional/*` rules share an ignore-pattern block — exposed below
+ * as {@link ITtscLintFunctionalPatternOptions} — and then extend it with
+ * rule-specific knobs.
+ *
+ * @reference https://github.com/eslint-functional/eslint-plugin-functional
+ */
+
+/** Shared pattern option accepted by several `functional/*` rules. */
+export interface ITtscLintFunctionalPatternOptions {
+  /** Identifier regex string(s) the rule should skip. */
+  ignoreIdentifierPattern?: string | readonly string[];
+
+  /** Source-code regex string(s) the rule should skip. */
+  ignoreCodePattern?: string | readonly string[];
+}
+
+/** `functional/functional-parameters` rule options. */
+export interface ITtscLintFunctionalParametersRuleOptions
+  extends ITtscLintFunctionalPatternOptions {
+  /** Allow rest parameters such as `(...args: readonly string[])`. */
+  allowRestParameter?: boolean;
+
+  /** Allow the legacy `arguments` object. */
+  allowArgumentsKeyword?: boolean;
+
+  /**
+   * Require functions to declare parameters. `true` maps to the
+   * conservative at-least-one policy.
+   */
+  enforceParameterCount?: boolean | "atLeastOne" | "exactlyOne";
+}
+
+/** `functional/immutable-data` rule options. */
+export interface ITtscLintFunctionalImmutableDataRuleOptions
+  extends ITtscLintFunctionalPatternOptions {
+  /**
+   * Skip mutating `Map` and `Set` methods while still checking arrays
+   * and property assignment.
+   */
+  ignoreMapsAndSets?: boolean;
+}
+
+/** `functional/no-let` rule options. */
+export interface ITtscLintFunctionalNoLetRuleOptions
+  extends ITtscLintFunctionalPatternOptions {
+  /** Permit `let` in a `for` statement initializer. */
+  allowInForLoopInit?: boolean;
+
+  /**
+   * Permit `let` inside functions while still rejecting module-level
+   * `let`.
+   */
+  allowInFunctions?: boolean;
+}
+
+/** `functional/no-conditional-statements` rule options. */
+export interface ITtscLintFunctionalNoConditionalStatementsRuleOptions {
+  /**
+   * Reserved for upstream-compatible configs; the current native rule
+   * rejects all `if` / `switch` statements regardless of value.
+   */
+  allowReturningBranches?: boolean | "ifExhaustive";
+}
+
+/** `functional/no-try-statements` rule options. */
+export interface ITtscLintFunctionalNoTryStatementsRuleOptions {
+  /** Allow `try/catch` while still checking `finally` when present. */
+  allowCatch?: boolean;
+
+  /** Allow `try/finally` while still checking `catch` when present. */
+  allowFinally?: boolean;
+}
+
+/** `functional/no-throw-statements` rule options. */
+export interface ITtscLintFunctionalNoThrowStatementsRuleOptions {
+  /**
+   * Reserved for upstream-compatible configs; the current native rule
+   * rejects every `throw` statement regardless of value.
+   */
+  allowToRejectPromises?: boolean;
+}
+
+/** `functional/no-mixed-types` rule options. */
+export interface ITtscLintFunctionalNoMixedTypesRuleOptions {
+  /** Check interface member kinds. */
+  checkInterfaces?: boolean;
+
+  /** Check type-literal member kinds. */
+  checkTypeLiterals?: boolean;
+}
+
+/** `functional/no-return-void` rule options. */
+export interface ITtscLintFunctionalNoReturnVoidRuleOptions {
+  /** Permit a function that returns `null` to satisfy the rule. */
+  allowNull?: boolean;
+
+  /** Permit a function that returns `undefined` to satisfy the rule. */
+  allowUndefined?: boolean;
+
+  /**
+   * Skip functions whose return type is inferred to be `void` rather
+   * than declared explicitly.
+   */
+  ignoreInferredTypes?: boolean;
+}
+
+/** `functional/prefer-immutable-types` rule options. */
+export interface ITtscLintFunctionalPreferImmutableTypesRuleOptions
+  extends ITtscLintFunctionalPatternOptions {
+  /**
+   * Minimum accepted immutability. The native subset treats any
+   * configured value as readonly-required.
+   */
+  enforcement?:
+    | "ReadonlyShallow"
+    | "ReadonlyDeep"
+    | "Immutable"
+    | "None"
+    | false;
+}
+
+/** `functional/prefer-readonly-type` rule options. */
+export interface ITtscLintFunctionalPreferReadonlyTypeRuleOptions
+  extends ITtscLintFunctionalPatternOptions {
+  /** Permit mutation of locals while still policing exported types. */
+  allowLocalMutation?: boolean;
+
+  /** Permit a mutable return type even when parameters must be readonly. */
+  allowMutableReturnType?: boolean;
+
+  /** Also check property positions that have no explicit type annotation. */
+  checkImplicit?: boolean;
+
+  /** Skip array / tuple / `Map` / `Set` types. */
+  ignoreCollections?: boolean;
+
+  /**
+   * Skip class fields. `"fieldsOnly"` keeps the rule active for
+   * non-field class members.
+   */
+  ignoreClass?: boolean | "fieldsOnly";
+
+  /** Skip interface members entirely. */
+  ignoreInterface?: boolean;
+}
+
+/** `functional/prefer-tacit` rule options. */
+export interface ITtscLintFunctionalPreferTacitRuleOptions {
+  /** Check member expressions such as `x => service.map(x)`. */
+  checkMemberExpressions?: boolean;
+}
+
+/** `functional/readonly-type` rule options. */
+export interface ITtscLintFunctionalReadonlyTypeRuleOptions {
+  /**
+   * Preferred readonly spelling.
+   *
+   * @default "keyword"
+   */
+  prefer?: "keyword" | "generic";
+}
+
+/** `functional/type-declaration-immutability` declaration policy. */
+export interface ITtscLintFunctionalTypeDeclarationImmutabilityRule {
+  /** Type / interface name or regex string(s) this policy applies to. */
+  identifiers: string | readonly string[];
+
+  /**
+   * Reserved for upstream-compatible configs; the current native subset
+   * treats every value as readonly-required.
+   */
+  immutability?:
+    | "ReadonlyShallow"
+    | "ReadonlyDeep"
+    | "Immutable"
+    | "Mutable";
+
+  /** Comparator applied to the immutability level above. */
+  comparator?:
+    | "Less"
+    | "AtMost"
+    | "Exactly"
+    | "AtLeast"
+    | "More"
+    | -2
+    | -1
+    | 0
+    | 1
+    | 2;
+}
+
+/** `functional/type-declaration-immutability` rule options. */
+export interface ITtscLintFunctionalTypeDeclarationImmutabilityRuleOptions
+  extends ITtscLintFunctionalPatternOptions {
+  /** Declaration-name policies. Empty means all type declarations. */
+  rules?: readonly ITtscLintFunctionalTypeDeclarationImmutabilityRule[];
+
+  /** Skip interface declarations and only check type aliases. */
+  ignoreInterfaces?: boolean;
+}
+
+/**
+ * Empty object options accepted by simple `functional/*` policy rules.
+ *
+ * Present as a named type so plugin authors can write `extends
+ * ITtscLintFunctionalEmptyRuleOptions` while still surviving a future
+ * field addition.
+ */
+export interface ITtscLintFunctionalEmptyRuleOptions {}

package/src/structures/rules/ITtscLintFunctionalRules.ts

@@ -0,0 +1,202 @@
+import type {
+  ITtscLintFunctionalEmptyRuleOptions,
+  ITtscLintFunctionalImmutableDataRuleOptions,
+  ITtscLintFunctionalNoConditionalStatementsRuleOptions,
+  ITtscLintFunctionalNoLetRuleOptions,
+  ITtscLintFunctionalNoMixedTypesRuleOptions,
+  ITtscLintFunctionalNoReturnVoidRuleOptions,
+  ITtscLintFunctionalNoThrowStatementsRuleOptions,
+  ITtscLintFunctionalNoTryStatementsRuleOptions,
+  ITtscLintFunctionalParametersRuleOptions,
+  ITtscLintFunctionalPreferImmutableTypesRuleOptions,
+  ITtscLintFunctionalPreferReadonlyTypeRuleOptions,
+  ITtscLintFunctionalPreferTacitRuleOptions,
+  ITtscLintFunctionalReadonlyTypeRuleOptions,
+  ITtscLintFunctionalTypeDeclarationImmutabilityRuleOptions,
+} from "./ITtscLintFunctionalRuleOptions";
+import type { TtscLintRuleOptionsSetting } from "../TtscLintRuleSetting";
+
+/**
+ * Functional-programming policy rules from `eslint-plugin-functional`.
+ * Pushes code toward immutability, side-effect-free expressions, and
+ * expression-style control flow.
+ *
+ * Most rules are useful in pieces — projects rarely enable the whole
+ * family at `"error"`. Enabling the whole set together expresses a
+ * strict functional-core / imperative-shell discipline.
+ *
+ * @reference https://github.com/eslint-functional/eslint-plugin-functional
+ */
+export interface ITtscLintFunctionalRules {
+  /**
+   * Enforce functional parameter style: reject `arguments`, reject
+   * rest parameters, and optionally enforce a per-function
+   * parameter-count policy.
+   *
+   * @reference https://github.com/eslint-functional/eslint-plugin-functional/blob/main/docs/rules/functional-parameters.md
+   */
+  "functional/functional-parameters"?: TtscLintRuleOptionsSetting<ITtscLintFunctionalParametersRuleOptions>;
+
+  /**
+   * Reject property assignment (`obj.x = ...`), element assignment
+   * (`arr[0] = ...`), and `Map`/`Set` mutation methods. Configurable
+   * to allow mutation inside constructors or initialization
+   * expressions.
+   *
+   * @reference https://github.com/eslint-functional/eslint-plugin-functional/blob/main/docs/rules/immutable-data.md
+   */
+  "functional/immutable-data"?: TtscLintRuleOptionsSetting<ITtscLintFunctionalImmutableDataRuleOptions>;
+
+  /**
+   * Reject `abstract` classes and `extends` clauses on class
+   * declarations; prefer composition and structural typing.
+   *
+   * @reference https://github.com/eslint-functional/eslint-plugin-functional/blob/main/docs/rules/no-class-inheritance.md
+   */
+  "functional/no-class-inheritance"?: TtscLintRuleOptionsSetting<ITtscLintFunctionalEmptyRuleOptions>;
+
+  /**
+   * Reject `class` declarations and class expressions altogether.
+   *
+   * @reference https://github.com/eslint-functional/eslint-plugin-functional/blob/main/docs/rules/no-classes.md
+   */
+  "functional/no-classes"?: TtscLintRuleOptionsSetting<ITtscLintFunctionalEmptyRuleOptions>;
+
+  /**
+   * Reject `if` and `switch` *statements*. The conditional-expression
+   * forms (ternary, `&&`, `||`) remain allowed.
+   *
+   * @reference https://github.com/eslint-functional/eslint-plugin-functional/blob/main/docs/rules/no-conditional-statements.md
+   */
+  "functional/no-conditional-statements"?: TtscLintRuleOptionsSetting<ITtscLintFunctionalNoConditionalStatementsRuleOptions>;
+
+  /**
+   * Reject expression statements that exist purely for their side
+   * effects (`mutate(x);`); pure code is built up from expressions
+   * with assigned or returned results.
+   *
+   * @reference https://github.com/eslint-functional/eslint-plugin-functional/blob/main/docs/rules/no-expression-statements.md
+   */
+  "functional/no-expression-statements"?: TtscLintRuleOptionsSetting<ITtscLintFunctionalEmptyRuleOptions>;
+
+  /**
+   * Reject `let` declarations so every binding is `const`. The shared
+   * ignore-pattern options can carve out specific identifier shapes
+   * (test locals, loop counters) when a full ban is too aggressive.
+   *
+   * @reference https://github.com/eslint-functional/eslint-plugin-functional/blob/main/docs/rules/no-let.md
+   */
+  "functional/no-let"?: TtscLintRuleOptionsSetting<ITtscLintFunctionalNoLetRuleOptions>;
+
+  /**
+   * Reject `for`, `while`, and `do/while` loop statements; use
+   * recursive helpers or array methods (`map`, `reduce`) instead.
+   *
+   * @reference https://github.com/eslint-functional/eslint-plugin-functional/blob/main/docs/rules/no-loop-statements.md
+   */
+  "functional/no-loop-statements"?: TtscLintRuleOptionsSetting<ITtscLintFunctionalEmptyRuleOptions>;
+
+  /**
+   * Reject interfaces and type literals that mix property, method,
+   * call, and index member kinds; mixed shapes make composition
+   * harder.
+   *
+   * @reference https://github.com/eslint-functional/eslint-plugin-functional/blob/main/docs/rules/no-mixed-types.md
+   */
+  "functional/no-mixed-types"?: TtscLintRuleOptionsSetting<ITtscLintFunctionalNoMixedTypesRuleOptions>;
+
+  /**
+   * Reject any call to `Promise.reject(...)`; resolve with an
+   * `Option` / `Result` shape so failures stay in the value channel.
+   *
+   * @reference https://github.com/eslint-functional/eslint-plugin-functional/blob/main/docs/rules/no-promise-reject.md
+   */
+  "functional/no-promise-reject"?: TtscLintRuleOptionsSetting<ITtscLintFunctionalEmptyRuleOptions>;
+
+  /**
+   * Reject void returns and functions whose declared return type is
+   * `void`; functions should always return a value.
+   *
+   * @reference https://github.com/eslint-functional/eslint-plugin-functional/blob/main/docs/rules/no-return-void.md
+   */
+  "functional/no-return-void"?: TtscLintRuleOptionsSetting<ITtscLintFunctionalNoReturnVoidRuleOptions>;
+
+  /**
+   * Reject any `this` expression. Combined with
+   * `functional/no-classes` this leaves no place where `this` is
+   * legal; on its own it still forbids `this` in standalone functions,
+   * modules, and arrow pipelines.
+   *
+   * @reference https://github.com/eslint-functional/eslint-plugin-functional/blob/main/docs/rules/no-this-expressions.md
+   */
+  "functional/no-this-expressions"?: TtscLintRuleOptionsSetting<ITtscLintFunctionalEmptyRuleOptions>;
+
+  /**
+   * Reject `throw` statements; functional code surfaces failures
+   * through return values (`Either`, `Result`) instead.
+   *
+   * @reference https://github.com/eslint-functional/eslint-plugin-functional/blob/main/docs/rules/no-throw-statements.md
+   */
+  "functional/no-throw-statements"?: TtscLintRuleOptionsSetting<ITtscLintFunctionalNoThrowStatementsRuleOptions>;
+
+  /**
+   * Reject `try/catch` and `try/finally` statements as a corollary
+   * of `functional/no-throw-statements`.
+   *
+   * @reference https://github.com/eslint-functional/eslint-plugin-functional/blob/main/docs/rules/no-try-statements.md
+   */
+  "functional/no-try-statements"?: TtscLintRuleOptionsSetting<ITtscLintFunctionalNoTryStatementsRuleOptions>;
+
+  /**
+   * Require declared variable, parameter, and property types to be
+   * `readonly` or otherwise structurally immutable.
+   *
+   * @reference https://github.com/eslint-functional/eslint-plugin-functional/blob/main/docs/rules/prefer-immutable-types.md
+   */
+  "functional/prefer-immutable-types"?: TtscLintRuleOptionsSetting<ITtscLintFunctionalPreferImmutableTypesRuleOptions>;
+
+  /**
+   * Prefer function-property signatures (`fn: () => T`) over method
+   * shorthand (`fn(): T`) in interfaces and type literals.
+   *
+   * Only the property form accepts `readonly`, so method shorthand
+   * silently makes the slot mutable; overloads still need the method
+   * form.
+   *
+   * @reference https://github.com/eslint-functional/eslint-plugin-functional/blob/main/docs/rules/prefer-property-signatures.md
+   */
+  "functional/prefer-property-signatures"?: TtscLintRuleOptionsSetting<ITtscLintFunctionalEmptyRuleOptions>;
+
+  /**
+   * Prefer `readonly` array, tuple, collection, and property types
+   * over their mutable counterparts.
+   *
+   * @reference https://github.com/eslint-functional/eslint-plugin-functional/blob/main/docs/rules/prefer-readonly-type.md
+   */
+  "functional/prefer-readonly-type"?: TtscLintRuleOptionsSetting<ITtscLintFunctionalPreferReadonlyTypeRuleOptions>;
+
+  /**
+   * Reject trivial wrappers such as `x => f(x)` in favor of the tacit
+   * form `f`; reduces noise in functional pipelines.
+   *
+   * @reference https://github.com/eslint-functional/eslint-plugin-functional/blob/main/docs/rules/prefer-tacit.md
+   */
+  "functional/prefer-tacit"?: TtscLintRuleOptionsSetting<ITtscLintFunctionalPreferTacitRuleOptions>;
+
+  /**
+   * Enforce one consistent spelling for readonly types — `readonly
+   * T[]` vs `ReadonlyArray<T>` — across the project.
+   *
+   * @reference https://github.com/eslint-functional/eslint-plugin-functional/blob/main/docs/rules/readonly-type.md
+   */
+  "functional/readonly-type"?: TtscLintRuleOptionsSetting<ITtscLintFunctionalReadonlyTypeRuleOptions>;
+
+  /**
+   * Enforce readonly/immutable type declarations by *declaration
+   * name* policy — for projects that want only types matching
+   * certain naming conventions to be locked down.
+   *
+   * @reference https://github.com/eslint-functional/eslint-plugin-functional/blob/main/docs/rules/type-declaration-immutability.md
+   */
+  "functional/type-declaration-immutability"?: TtscLintRuleOptionsSetting<ITtscLintFunctionalTypeDeclarationImmutabilityRuleOptions>;
+}