diff --git a/docs/rules/prefer-immutable-types.md b/docs/rules/prefer-immutable-types.md
index 18be71d56..4344a9c2d 100644
--- a/docs/rules/prefer-immutable-types.md
+++ b/docs/rules/prefer-immutable-types.md
@@ -244,6 +244,37 @@ type Options = {
     ReadonlyDeep?: Array<Array<{ pattern: string; replace: string }>>;
     Immutable?: Array<Array<{ pattern: string; replace: string }>>;
   };
+
+  overrides?: Array<{
+    match: Array<
+      | {
+          from: "file";
+          path?: string;
+          name?: string | string[];
+          pattern?: RegExp | RegExp[];
+          ignoreName?: string | string[];
+          ignorePattern?: RegExp | RegExp[];
+        }
+      | {
+          from: "lib";
+          name?: string | string[];
+          pattern?: RegExp | RegExp[];
+          ignoreName?: string | string[];
+          ignorePattern?: RegExp | RegExp[];
+        }
+      | {
+          from: "package";
+          package?: string;
+          name?: string | string[];
+          pattern?: RegExp | RegExp[];
+          ignoreName?: string | string[];
+          ignorePattern?: RegExp | RegExp[];
+        }
+    >;
+    options: Omit<Options, "overrides">;
+    inherit?: boolean;
+    disable: boolean;
+  }>;
 };
 ```
 
@@ -475,3 +506,29 @@ It allows for the ability to ignore violations based on the identifier (name) of
 
 This option takes a `RegExp` string or an array of `RegExp` strings.
 It allows for the ability to ignore violations based on the type (as written, with whitespace removed) of the node in question.
+
+### `overrides`
+
+Allows for applying overrides to the options based on where the type is defined.
+This can be used to override the settings for types coming from 3rd party libraries.
+
+Note: Only the first matching override will be used.
+
+#### `overrides[n].specifiers`
+
+A specifier, or an array of specifiers to match the function type against.
+
+In the case of reference types, both the type and its generics will be recursively checked.
+If any of them match, the specifier will be considered a match.
+
+#### `overrides[n].options`
+
+The options to use when a specifiers matches.
+
+#### `overrides[n].inherit`
+
+Inherit the root options? Default is `true`.
+
+#### `overrides[n].disable`
+
+If true, when a specifier matches, this rule will not be applied to the matching node.
diff --git a/src/options/overrides.ts b/src/options/overrides.ts
index 7e8d4f475..7a5616d06 100644
--- a/src/options/overrides.ts
+++ b/src/options/overrides.ts
@@ -1,7 +1,12 @@
+import assert from "node:assert/strict";
+
 import { type TSESTree } from "@typescript-eslint/utils";
 import { type RuleContext } from "@typescript-eslint/utils/ts-eslint";
 import { deepmerge } from "deepmerge-ts";
-import typeMatchesSpecifier from "ts-declaration-location";
+import typeMatchesSpecifier, {
+  type TypeDeclarationSpecifier,
+} from "ts-declaration-location";
+import { type Program, type Type, type TypeNode } from "typescript";
 
 import { getTypeDataOfNode } from "#eslint-plugin-functional/utils/rule";
 import {
@@ -108,13 +113,30 @@ export function getCoreOptions<
   }
 
   const [type, typeNode] = getTypeDataOfNode(node, context);
+  return getCoreOptionsForType(type, typeNode, context, options);
+}
+
+export function getCoreOptionsForType<
+  CoreOptions extends object,
+  Options extends Readonly<OverridableOptions<CoreOptions>>,
+>(
+  type: Type,
+  typeNode: TypeNode | null,
+  context: Readonly<RuleContext<string, unknown[]>>,
+  options: Readonly<Options>,
+): CoreOptions | null {
+  const program = context.sourceCode.parserServices?.program ?? undefined;
+  if (program === undefined) {
+    return options;
+  }
+
   const found = options.overrides?.find((override) =>
     (Array.isArray(override.specifiers)
       ? override.specifiers
       : [override.specifiers]
     ).some(
       (specifier) =>
-        typeMatchesSpecifier(program, specifier, type) &&
+        typeMatchesSpecifierDeep(program, specifier, type) &&
         (specifier.include === undefined ||
           specifier.include.length === 0 ||
           typeMatchesPattern(
@@ -139,3 +161,25 @@ export function getCoreOptions<
 
   return options;
 }
+
+function typeMatchesSpecifierDeep(
+  program: Program,
+  specifier: TypeDeclarationSpecifier,
+  type: Type,
+) {
+  const stack = [type];
+  // eslint-disable-next-line functional/no-loop-statements -- best to do this iteratively.
+  while (stack.length > 0) {
+    const t = stack.pop() ?? assert.fail();
+
+    if (typeMatchesSpecifier(program, specifier, t)) {
+      return true;
+    }
+
+    if (t.aliasTypeArguments !== undefined) {
+      stack.push(...t.aliasTypeArguments);
+    }
+  }
+
+  return false;
+}
diff --git a/src/rules/prefer-immutable-types.ts b/src/rules/prefer-immutable-types.ts
index c5199e5a2..cec620fcf 100644
--- a/src/rules/prefer-immutable-types.ts
+++ b/src/rules/prefer-immutable-types.ts
@@ -9,13 +9,19 @@ import {
 } from "@typescript-eslint/utils/ts-eslint";
 import { deepmerge } from "deepmerge-ts";
 import { Immutability } from "is-immutable-type";
+import { type Type, type TypeNode } from "typescript";
 
 import {
   type IgnoreClassesOption,
+  type OverridableOptions,
+  type RawOverridableOptions,
+  getCoreOptions,
+  getCoreOptionsForType,
   ignoreClassesOptionSchema,
   shouldIgnoreClasses,
   shouldIgnoreInFunction,
   shouldIgnorePattern,
+  upgradeRawOverridableOptions,
 } from "#eslint-plugin-functional/options";
 import { ruleNameScope } from "#eslint-plugin-functional/utils/misc";
 import { type ESFunctionType } from "#eslint-plugin-functional/utils/node-types";
@@ -24,6 +30,7 @@ import {
   type RuleResult,
   createRule,
   getReturnTypesOfFunction,
+  getTypeDataOfNode,
   getTypeImmutabilityOfNode,
   getTypeImmutabilityOfType,
   isImplementationOfOverload,
@@ -42,6 +49,8 @@ import {
   isTSTypePredicate,
 } from "#eslint-plugin-functional/utils/type-guards";
 
+import { overridableOptionsSchema } from "../utils/schemas";
+
 /**
  * The name of this rule.
  */
@@ -55,7 +64,8 @@ export const fullName = `${ruleNameScope}/${name}`;
 type RawEnforcement =
   | Exclude<Immutability | keyof typeof Immutability, "Unknown" | "Mutable">
   | "None"
-  | false;
+  | false
+  | undefined;
 
 type Option = IgnoreClassesOption & {
   enforcement: RawEnforcement;
@@ -64,6 +74,20 @@ type Option = IgnoreClassesOption & {
   ignoreTypePattern?: string[] | string;
 };
 
+type CoreOptions = Option & {
+  parameters?: Partial<Option> | RawEnforcement;
+  returnTypes?: Partial<Option> | RawEnforcement;
+  variables?:
+    | Partial<
+        Option & {
+          ignoreInFunctions?: boolean;
+        }
+      >
+    | RawEnforcement;
+  fixer?: FixerConfigRawMap;
+  suggestions?: SuggestionConfigRawMap;
+};
+
 type FixerConfigRaw = {
   pattern: string;
   replace: string;
@@ -93,21 +117,8 @@ type SuggestionsConfig = FixerConfig[];
 /**
  * The options this rule can take.
  */
-type Options = [
-  Option & {
-    parameters?: Partial<Option> | RawEnforcement;
-    returnTypes?: Partial<Option> | RawEnforcement;
-    variables?:
-      | Partial<
-          Option & {
-            ignoreInFunctions?: boolean;
-          }
-        >
-      | RawEnforcement;
-    fixer?: FixerConfigRawMap;
-    suggestions?: SuggestionConfigRawMap;
-  },
-];
+type RawOptions = [RawOverridableOptions<CoreOptions>];
+type Options = OverridableOptions<CoreOptions>;
 
 /**
  * The enum options for the level of enforcement.
@@ -211,59 +222,59 @@ const suggestionsSchema: JSONSchema4 = {
   },
 };
 
-/**
- * The schema for the rule options.
- */
-const schema: JSONSchema4[] = [
-  {
-    type: "object",
-    properties: deepmerge(optionExpandedSchema, {
-      parameters: optionSchema,
-      returnTypes: optionSchema,
-      variables: {
-        oneOf: [
-          {
-            type: "object",
-            properties: deepmerge(optionExpandedSchema, {
-              ignoreInFunctions: {
-                type: "boolean",
-              },
-            }),
-            additionalProperties: false,
-          },
-          {
-            type: ["string", "number", "boolean"],
-            enum: enforcementEnumOptions,
-          },
-        ],
-      },
-      fixer: {
+const coreOptionsPropertiesSchema: NonNullable<
+  JSONSchema4ObjectSchema["properties"]
+> = deepmerge(optionExpandedSchema, {
+  parameters: optionSchema,
+  returnTypes: optionSchema,
+  variables: {
+    oneOf: [
+      {
         type: "object",
-        properties: {
-          ReadonlyShallow: fixerSchema,
-          ReadonlyDeep: fixerSchema,
-          Immutable: fixerSchema,
-        },
+        properties: deepmerge(optionExpandedSchema, {
+          ignoreInFunctions: {
+            type: "boolean",
+          },
+        }),
         additionalProperties: false,
       },
-      suggestions: {
-        type: "object",
-        properties: {
-          ReadonlyShallow: suggestionsSchema,
-          ReadonlyDeep: suggestionsSchema,
-          Immutable: suggestionsSchema,
-        },
-        additionalProperties: false,
+      {
+        type: ["string", "number", "boolean"],
+        enum: enforcementEnumOptions,
       },
-    }),
+    ],
+  },
+  fixer: {
+    type: "object",
+    properties: {
+      ReadonlyShallow: fixerSchema,
+      ReadonlyDeep: fixerSchema,
+      Immutable: fixerSchema,
+    },
     additionalProperties: false,
   },
+  suggestions: {
+    type: "object",
+    properties: {
+      ReadonlyShallow: suggestionsSchema,
+      ReadonlyDeep: suggestionsSchema,
+      Immutable: suggestionsSchema,
+    },
+    additionalProperties: false,
+  },
+});
+
+/**
+ * The schema for the rule options.
+ */
+const schema: JSONSchema4[] = [
+  overridableOptionsSchema(coreOptionsPropertiesSchema),
 ];
 
 /**
  * The default options for the rule.
  */
-const defaultOptions: Options = [
+const defaultOptions: RawOptions = [
   {
     enforcement: Immutability.Immutable,
     ignoreInferredTypes: false,
@@ -308,25 +319,26 @@ const errorMessages = {
 /**
  * The meta data for this rule.
  */
-const meta: NamedCreateRuleCustomMeta<keyof typeof errorMessages, Options> = {
-  type: "suggestion",
-  docs: {
-    category: "No Mutations",
-    description:
-      "Require function parameters to be typed as certain immutability",
-    recommended: "recommended",
-    recommendedSeverity: "error",
-    requiresTypeChecking: true,
-  },
-  fixable: "code",
-  hasSuggestions: true,
-  messages: errorMessages,
-  schema,
-};
+const meta: NamedCreateRuleCustomMeta<keyof typeof errorMessages, RawOptions> =
+  {
+    type: "suggestion",
+    docs: {
+      category: "No Mutations",
+      description:
+        "Require function parameters to be typed as certain immutability",
+      recommended: "recommended",
+      recommendedSeverity: "error",
+      requiresTypeChecking: true,
+    },
+    fixable: "code",
+    hasSuggestions: true,
+    messages: errorMessages,
+    schema,
+  };
 
 type Descriptor = RuleResult<
   keyof typeof errorMessages,
-  Options
+  RawOptions
 >["descriptors"][number];
 
 type AllFixers = {
@@ -339,7 +351,7 @@ type AllFixers = {
  */
 function getAllFixers(
   node: TSESTree.Node,
-  context: Readonly<RuleContext<keyof typeof errorMessages, Options>>,
+  context: Readonly<RuleContext<keyof typeof errorMessages, RawOptions>>,
   fixerConfigs: FixerConfig[] | false,
   suggestionsConfigs: SuggestionsConfig[] | false,
 ): AllFixers {
@@ -398,7 +410,7 @@ function getConfiguredSuggestionFixers(
  * Get the level of enforcement from the raw value given.
  */
 function parseEnforcement(rawEnforcement: RawEnforcement) {
-  return rawEnforcement === "None"
+  return rawEnforcement === "None" || rawEnforcement === undefined
     ? false
     : typeof rawEnforcement === "string"
       ? Immutability[rawEnforcement]
@@ -409,7 +421,7 @@ function parseEnforcement(rawEnforcement: RawEnforcement) {
  * Get the fixer config for the the given enforcement level from the raw config given.
  */
 function parseFixerConfigs(
-  allRawConfigs: Options[0]["fixer"],
+  allRawConfigs: RawOptions[0]["fixer"],
   enforcement: Immutability,
 ): FixerConfig[] | false {
   const key = Immutability[enforcement] as keyof NonNullable<
@@ -430,7 +442,7 @@ function parseFixerConfigs(
  * Get the suggestions config for the the given enforcement level from the raw config given.
  */
 function parseSuggestionsConfigs(
-  rawSuggestions: Options[0]["suggestions"],
+  rawSuggestions: RawOptions[0]["suggestions"],
   enforcement: Immutability,
 ): SuggestionsConfig[] | false {
   const key = Immutability[enforcement] as keyof NonNullable<
@@ -453,56 +465,67 @@ function parseSuggestionsConfigs(
  */
 function getParameterTypeViolations(
   node: ESFunctionType,
-  context: Readonly<RuleContext<keyof typeof errorMessages, Options>>,
+  context: Readonly<RuleContext<keyof typeof errorMessages, RawOptions>>,
   options: Readonly<Options>,
 ): Descriptor[] {
-  const [optionsObject] = options;
-  const {
-    parameters: rawOption,
-    fixer: rawFixerConfig,
-    suggestions: rawSuggestionsConfigs,
-  } = optionsObject;
-  const {
-    enforcement: rawEnforcement,
-    ignoreInferredTypes,
-    ignoreClasses,
-    ignoreNamePattern,
-    ignoreTypePattern,
-  } = {
-    ignoreInferredTypes: optionsObject.ignoreInferredTypes,
-    ignoreClasses: optionsObject.ignoreClasses,
-    ignoreNamePattern: optionsObject.ignoreNamePattern,
-    ignoreTypePattern: optionsObject.ignoreTypePattern,
-    ...(typeof rawOption === "object"
-      ? rawOption
-      : {
-          enforcement: rawOption,
-        }),
-  };
+  return node.params
+    .map((param): Descriptor | undefined => {
+      const parameterProperty = isTSParameterProperty(param);
+      const actualParam = parameterProperty ? param.parameter : param;
 
-  const enforcement = parseEnforcement(
-    rawEnforcement ?? optionsObject.enforcement,
-  );
-  if (
-    enforcement === false ||
-    shouldIgnoreClasses(node, context, ignoreClasses)
-  ) {
-    return [];
-  }
+      const optionsToUse = getCoreOptions<CoreOptions, Options>(
+        param,
+        context,
+        options,
+      );
 
-  const fixerConfigs = parseFixerConfigs(rawFixerConfig, enforcement);
-  const suggestionsConfigs = parseSuggestionsConfigs(
-    rawSuggestionsConfigs,
-    enforcement,
-  );
+      if (optionsToUse === null) {
+        return undefined;
+      }
+
+      const {
+        parameters: rawOption,
+        fixer: rawFixerConfig,
+        suggestions: rawSuggestionsConfigs,
+      } = optionsToUse;
+      const {
+        enforcement: rawEnforcement,
+        ignoreInferredTypes,
+        ignoreClasses,
+        ignoreNamePattern,
+        ignoreTypePattern,
+      } = {
+        ignoreInferredTypes: optionsToUse.ignoreInferredTypes,
+        ignoreClasses: optionsToUse.ignoreClasses,
+        ignoreNamePattern: optionsToUse.ignoreNamePattern,
+        ignoreTypePattern: optionsToUse.ignoreTypePattern,
+        ...(typeof rawOption === "object"
+          ? rawOption
+          : {
+              enforcement: rawOption,
+            }),
+      };
+
+      const enforcement = parseEnforcement(
+        rawEnforcement ?? optionsToUse.enforcement,
+      );
+      if (
+        enforcement === false ||
+        shouldIgnoreClasses(node, context, ignoreClasses)
+      ) {
+        return undefined;
+      }
+
+      const fixerConfigs = parseFixerConfigs(rawFixerConfig, enforcement);
+      const suggestionsConfigs = parseSuggestionsConfigs(
+        rawSuggestionsConfigs,
+        enforcement,
+      );
 
-  return node.params
-    .map((param): Descriptor | undefined => {
       if (shouldIgnorePattern(param, context, ignoreNamePattern)) {
         return undefined;
       }
 
-      const parameterProperty = isTSParameterProperty(param);
       if (parameterProperty && !param.readonly) {
         const messageId = "propertyModifier";
         const fix: NonNullable<Descriptor["fix"]> | null = (fixer) =>
@@ -521,8 +544,6 @@ function getParameterTypeViolations(
         };
       }
 
-      const actualParam = parameterProperty ? param.parameter : param;
-
       if (
         // inferred types
         (ignoreInferredTypes && actualParam.typeAnnotation === undefined) ||
@@ -591,93 +612,125 @@ function getParameterTypeViolations(
  */
 function getReturnTypeViolations(
   node: ESFunctionType,
-  context: Readonly<RuleContext<keyof typeof errorMessages, Options>>,
+  context: Readonly<RuleContext<keyof typeof errorMessages, RawOptions>>,
   options: Readonly<Options>,
 ): Descriptor[] {
-  const [optionsObject] = options;
-  const {
-    returnTypes: rawOption,
-    fixer: rawFixerConfig,
-    suggestions: rawSuggestionsConfigs,
-  } = optionsObject;
-  const {
-    enforcement: rawEnforcement,
-    ignoreInferredTypes,
-    ignoreClasses,
-    ignoreNamePattern,
-    ignoreTypePattern,
-  } = {
-    ignoreInferredTypes: optionsObject.ignoreInferredTypes,
-    ignoreClasses: optionsObject.ignoreClasses,
-    ignoreNamePattern: optionsObject.ignoreNamePattern,
-    ignoreTypePattern: optionsObject.ignoreTypePattern,
-    ...(typeof rawOption === "object" ? rawOption : { enforcement: rawOption }),
-  };
+  function getOptions(type: Type, typeNode: TypeNode | null) {
+    const optionsToUse = getCoreOptionsForType<CoreOptions, Options>(
+      type,
+      typeNode,
+      context,
+      options,
+    );
 
-  const enforcement = parseEnforcement(
-    rawEnforcement ?? optionsObject.enforcement,
-  );
+    if (optionsToUse === null) {
+      return null;
+    }
 
-  if (
-    enforcement === false ||
-    (ignoreInferredTypes && node.returnType?.typeAnnotation === undefined) ||
-    shouldIgnoreClasses(node, context, ignoreClasses) ||
-    shouldIgnorePattern(node, context, ignoreNamePattern)
-  ) {
-    return [];
-  }
+    const {
+      returnTypes: rawOption,
+      fixer: rawFixerConfig,
+      suggestions: rawSuggestionsConfigs,
+    } = optionsToUse;
+    const {
+      enforcement: rawEnforcement,
+      ignoreClasses,
+      ignoreNamePattern,
+      ignoreTypePattern,
+      ignoreInferredTypes,
+    } = {
+      ignoreClasses: optionsToUse.ignoreClasses,
+      ignoreNamePattern: optionsToUse.ignoreNamePattern,
+      ignoreTypePattern: optionsToUse.ignoreTypePattern,
+      ignoreInferredTypes: optionsToUse.ignoreInferredTypes,
+      ...(typeof rawOption === "object"
+        ? rawOption
+        : { enforcement: rawOption }),
+    };
 
-  const fixerConfigs = parseFixerConfigs(rawFixerConfig, enforcement);
-  const suggestionsConfigs = parseSuggestionsConfigs(
-    rawSuggestionsConfigs,
-    enforcement,
-  );
+    const enforcement = parseEnforcement(
+      rawEnforcement ?? optionsToUse.enforcement,
+    );
 
-  if (
-    node.returnType?.typeAnnotation !== undefined &&
-    !isTSTypePredicate(node.returnType.typeAnnotation)
-  ) {
-    if (shouldIgnorePattern(node.returnType, context, ignoreTypePattern)) {
-      return [];
+    if (
+      enforcement === false ||
+      shouldIgnoreClasses(node, context, ignoreClasses) ||
+      shouldIgnorePattern(node, context, ignoreNamePattern)
+    ) {
+      return null;
     }
 
-    const immutability = getTypeImmutabilityOfNode(
-      node.returnType.typeAnnotation,
-      context,
+    const fixerConfigs = parseFixerConfigs(rawFixerConfig, enforcement);
+    const suggestionsConfigs = parseSuggestionsConfigs(
+      rawSuggestionsConfigs,
       enforcement,
     );
 
-    if (immutability >= enforcement) {
+    return {
+      ignoreTypePattern,
+      ignoreInferredTypes,
+      enforcement,
+      fixerConfigs,
+      suggestionsConfigs,
+    };
+  }
+
+  if (node.returnType?.typeAnnotation !== undefined) {
+    const [type, typeNode] = getTypeDataOfNode(node, context);
+    const optionsToUse = getOptions(type, typeNode);
+    if (optionsToUse === null) {
       return [];
     }
 
-    const { fix, suggestionFixers } = getAllFixers(
-      node.returnType.typeAnnotation,
-      context,
-      fixerConfigs,
-      suggestionsConfigs,
-    );
+    const { ignoreTypePattern, enforcement, fixerConfigs, suggestionsConfigs } =
+      optionsToUse;
 
-    const messageId = "returnType";
-    const data = {
-      actual: Immutability[immutability],
-      expected: Immutability[enforcement],
-    };
+    if (
+      node.returnType?.typeAnnotation !== undefined &&
+      !isTSTypePredicate(node.returnType.typeAnnotation)
+    ) {
+      if (shouldIgnorePattern(node.returnType, context, ignoreTypePattern)) {
+        return [];
+      }
 
-    return [
-      {
-        node: node.returnType,
-        messageId,
-        data,
-        fix,
-        suggest:
-          suggestionFixers?.map((fix) => ({
-            messageId,
-            data,
-            fix,
-          })) ?? null,
-      },
-    ];
+      const immutability = getTypeImmutabilityOfNode(
+        node.returnType.typeAnnotation,
+        context,
+        enforcement,
+      );
+
+      if (immutability >= enforcement) {
+        return [];
+      }
+
+      const { fix, suggestionFixers } = getAllFixers(
+        node.returnType.typeAnnotation,
+        context,
+        fixerConfigs,
+        suggestionsConfigs,
+      );
+
+      const messageId = "returnType";
+      const data = {
+        actual: Immutability[immutability],
+        expected: Immutability[enforcement],
+      };
+
+      return [
+        {
+          node: node.returnType,
+          messageId,
+          data,
+          fix,
+          suggest:
+            suggestionFixers?.map((fix) => ({
+              messageId,
+              data,
+              fix,
+            })) ?? null,
+        },
+      ];
+    }
   }
 
   if (!isFunctionLike(node)) {
@@ -693,8 +746,25 @@ function getReturnTypeViolations(
     return [];
   }
 
+  const returnType = returnTypes[0]!;
+
+  const optionsToUse = getOptions(
+    returnType,
+    (returnType as Type & { node: TypeNode }).node ?? null,
+  );
+  if (optionsToUse === null) {
+    return [];
+  }
+
+  const { ignoreInferredTypes, enforcement, fixerConfigs, suggestionsConfigs } =
+    optionsToUse;
+
+  if (ignoreInferredTypes) {
+    return [];
+  }
+
   const immutability = getTypeImmutabilityOfType(
-    returnTypes[0]!,
+    returnType,
     context,
     enforcement,
   );
@@ -740,9 +810,11 @@ function getReturnTypeViolations(
  */
 function checkFunction(
   node: ESFunctionType,
-  context: Readonly<RuleContext<keyof typeof errorMessages, Options>>,
-  options: Readonly<Options>,
-): RuleResult<keyof typeof errorMessages, Options> {
+  context: Readonly<RuleContext<keyof typeof errorMessages, RawOptions>>,
+  rawOptions: Readonly<RawOptions>,
+): RuleResult<keyof typeof errorMessages, RawOptions> {
+  const options = upgradeRawOverridableOptions(rawOptions[0]);
+
   const descriptors = [
     ...getParameterTypeViolations(node, context, options),
     ...getReturnTypeViolations(node, context, options),
@@ -759,16 +831,28 @@ function checkFunction(
  */
 function checkVariable(
   node: TSESTree.VariableDeclarator | TSESTree.PropertyDefinition,
-  context: Readonly<RuleContext<keyof typeof errorMessages, Options>>,
-  options: Readonly<Options>,
-): RuleResult<keyof typeof errorMessages, Options> {
-  const [optionsObject] = options;
+  context: Readonly<RuleContext<keyof typeof errorMessages, RawOptions>>,
+  rawOptions: Readonly<RawOptions>,
+): RuleResult<keyof typeof errorMessages, RawOptions> {
+  const options = upgradeRawOverridableOptions(rawOptions[0]);
+  const optionsToUse = getCoreOptions<CoreOptions, Options>(
+    node,
+    context,
+    options,
+  );
+
+  if (optionsToUse === null) {
+    return {
+      context,
+      descriptors: [],
+    };
+  }
 
   const {
     variables: rawOption,
     fixer: rawFixerConfig,
     suggestions: rawSuggestionsConfigs,
-  } = optionsObject;
+  } = optionsToUse;
   const {
     enforcement: rawEnforcement,
     ignoreInferredTypes,
@@ -777,16 +861,16 @@ function checkVariable(
     ignoreTypePattern,
     ignoreInFunctions,
   } = {
-    ignoreInferredTypes: optionsObject.ignoreInferredTypes,
-    ignoreClasses: optionsObject.ignoreClasses,
-    ignoreNamePattern: optionsObject.ignoreNamePattern,
-    ignoreTypePattern: optionsObject.ignoreTypePattern,
+    ignoreInferredTypes: optionsToUse.ignoreInferredTypes,
+    ignoreClasses: optionsToUse.ignoreClasses,
+    ignoreNamePattern: optionsToUse.ignoreNamePattern,
+    ignoreTypePattern: optionsToUse.ignoreTypePattern,
     ignoreInFunctions: false,
     ...(typeof rawOption === "object" ? rawOption : { enforcement: rawOption }),
   };
 
   const enforcement = parseEnforcement(
-    rawEnforcement ?? optionsObject.enforcement,
+    rawEnforcement ?? optionsToUse.enforcement,
   );
 
   if (
@@ -923,7 +1007,7 @@ function checkVariable(
 }
 
 // Create the rule.
-export const rule = createRule<keyof typeof errorMessages, Options>(
+export const rule = createRule<keyof typeof errorMessages, RawOptions>(
   name,
   meta,
   defaultOptions,
diff --git a/tests/rules/prefer-immutable-types/ts/parameters/invalid.ts b/tests/rules/prefer-immutable-types/ts/parameters/invalid.ts
index cc2a297e3..59048afed 100644
--- a/tests/rules/prefer-immutable-types/ts/parameters/invalid.ts
+++ b/tests/rules/prefer-immutable-types/ts/parameters/invalid.ts
@@ -612,6 +612,37 @@ const tests: Array<
       },
     ],
   },
+  {
+    code: dedent`
+      type Foo<T> = readonly T[];
+      function foo(arg: Foo<{ bar: string; }>) { }
+    `,
+    errors: [
+      {
+        messageId: "parameter",
+        type: AST_NODE_TYPES.Identifier,
+        line: 2,
+        column: 14,
+      },
+    ],
+    optionsSet: [
+      [
+        {
+          parameters: "ReadonlyShallow",
+          overrides: [
+            {
+              specifiers: {
+                from: "file",
+              },
+              options: {
+                parameters: "ReadonlyDeep",
+              },
+            },
+          ],
+        },
+      ],
+    ],
+  },
 ];
 
 export default tests;
diff --git a/tests/rules/prefer-immutable-types/ts/parameters/valid.ts b/tests/rules/prefer-immutable-types/ts/parameters/valid.ts
index 17c1edf52..bbf8d4e99 100644
--- a/tests/rules/prefer-immutable-types/ts/parameters/valid.ts
+++ b/tests/rules/prefer-immutable-types/ts/parameters/valid.ts
@@ -264,6 +264,42 @@ const tests: Array<ValidTestCaseSet<OptionsOf<typeof rule>>> = [
     `,
     optionsSet: [[{ ignoreTypePattern: "^Readonly<.+>$" }]],
   },
+  {
+    code: dedent`
+      type Foo<T> = readonly T[];
+      function foo(arg: Foo<{ bar: string; }>) { }
+    `,
+    optionsSet: [
+      [
+        {
+          parameters: "ReadonlyDeep",
+          overrides: [
+            {
+              specifiers: {
+                from: "file",
+              },
+              disable: true,
+            },
+          ],
+        },
+      ],
+      [
+        {
+          parameters: "ReadonlyDeep",
+          overrides: [
+            {
+              specifiers: {
+                from: "file",
+              },
+              options: {
+                parameters: "ReadonlyShallow",
+              },
+            },
+          ],
+        },
+      ],
+    ],
+  },
 ];
 
 export default tests;