diff --git a/docs/rules/prefer-immutable-types.md b/docs/rules/prefer-immutable-types.md
index 202946f70..09b6f4d0b 100644
--- a/docs/rules/prefer-immutable-types.md
+++ b/docs/rules/prefer-immutable-types.md
@@ -244,6 +244,24 @@ type Options = {
     ReadonlyDeep?: Array<Array<{ pattern: string; replace: string }>>;
     Immutable?: Array<Array<{ pattern: string; replace: string }>>;
   };
+
+  overrides?: Array<{
+    match:
+      | {
+          from: "file";
+          path?: string;
+        }
+      | {
+          from: "lib";
+        }
+      | {
+          from: "package";
+          package?: string;
+        }
+      | TypeDeclarationSpecifier[];
+    options: Omit<Options, "overrides">;
+    disable: boolean;
+  }>;
 };
 ```
 
@@ -475,3 +493,22 @@ 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.
+
+#### `overrides[n].options`
+
+The options to use when a specifiers matches.
+
+#### `overrides[n].disable`
+
+If true, when a specifier matches, this rule will not be applied to the matching node.
diff --git a/src/options/index.ts b/src/options/index.ts
index a2ca8f7c3..e5b888321 100644
--- a/src/options/index.ts
+++ b/src/options/index.ts
@@ -1 +1,2 @@
 export * from "./ignore";
+export * from "./overrides";
diff --git a/src/options/overrides.ts b/src/options/overrides.ts
new file mode 100644
index 000000000..735ca2256
--- /dev/null
+++ b/src/options/overrides.ts
@@ -0,0 +1,68 @@
+import { type TSESTree } from "@typescript-eslint/utils";
+import { type RuleContext } from "@typescript-eslint/utils/ts-eslint";
+import typeMatchesSpecifier, {
+  type TypeDeclarationSpecifier,
+} from "ts-declaration-location";
+
+import { getTypeOfNode } from "../utils/rule";
+
+/**
+ * Options that can be overridden.
+ */
+export type OverridableOptions<CoreOptions> = CoreOptions & {
+  overrides?: Array<
+    {
+      specifiers: TypeDeclarationSpecifier | TypeDeclarationSpecifier[];
+    } & (
+      | {
+          options: CoreOptions;
+          disable?: false;
+        }
+      | {
+          disable: true;
+        }
+    )
+  >;
+};
+
+/**
+ * Get the core options to use, taking into account overrides.
+ *
+ * @throws when there is a configuration error.
+ */
+export function getCoreOptions<
+  CoreOptions extends object,
+  Options extends readonly [Readonly<OverridableOptions<CoreOptions>>],
+>(
+  node: TSESTree.Node,
+  context: Readonly<RuleContext<string, Options>>,
+  options: Readonly<Options>,
+): CoreOptions | null {
+  const [optionsObject] = options;
+
+  const program = context.sourceCode.parserServices?.program ?? undefined;
+  if (program === undefined) {
+    return optionsObject;
+  }
+
+  const type = getTypeOfNode(node, context);
+  const found = optionsObject.overrides?.find((override) =>
+    (Array.isArray(override.specifiers)
+      ? override.specifiers
+      : [override.specifiers]
+    ).some((specifier) => typeMatchesSpecifier(program, specifier, type)),
+  );
+
+  if (found !== undefined) {
+    if (found.disable === true) {
+      return null;
+    }
+    if (found.options === undefined) {
+      // eslint-disable-next-line functional/no-throw-statements
+      throw new Error("Configuration error: No options found for override.");
+    }
+    return found.options;
+  }
+
+  return optionsObject;
+}
diff --git a/src/rules/functional-parameters.ts b/src/rules/functional-parameters.ts
index 4a3f505ce..6b4fba80b 100644
--- a/src/rules/functional-parameters.ts
+++ b/src/rules/functional-parameters.ts
@@ -5,23 +5,21 @@ import {
 } from "@typescript-eslint/utils/json-schema";
 import { type RuleContext } from "@typescript-eslint/utils/ts-eslint";
 import { deepmerge } from "deepmerge-ts";
-import typeMatchesSpecifier, {
-  type TypeDeclarationSpecifier,
-} from "ts-declaration-location";
 
 import {
+  getCoreOptions,
   ignoreIdentifierPatternOptionSchema,
   ignorePrefixSelectorOptionSchema,
   shouldIgnorePattern,
   type IgnoreIdentifierPatternOption,
   type IgnorePrefixSelectorOption,
+  type OverridableOptions,
 } from "#eslint-plugin-functional/options";
 import { typeSpecifiersSchema } from "#eslint-plugin-functional/utils/common-schemas";
 import { ruleNameScope } from "#eslint-plugin-functional/utils/misc";
 import { type ESFunction } from "#eslint-plugin-functional/utils/node-types";
 import {
   createRuleUsingFunction,
-  getTypeOfNode,
   type NamedCreateRuleCustomMeta,
   type RuleResult,
 } from "#eslint-plugin-functional/utils/rule";
@@ -69,23 +67,7 @@ type CoreOptions = IgnoreIdentifierPatternOption &
 /**
  * The options this rule can take.
  */
-type Options = [
-  CoreOptions & {
-    overrides?: Array<
-      {
-        specifiers: TypeDeclarationSpecifier | TypeDeclarationSpecifier[];
-      } & (
-        | {
-            options: CoreOptions;
-            disable?: false;
-          }
-        | {
-            disable: true;
-          }
-      )
-    >;
-  },
-];
+type Options = [OverridableOptions<CoreOptions>];
 
 const coreOptionsPropertiesSchema: JSONSchema4ObjectSchema["properties"] = {
   allowRestParameter: {
@@ -206,39 +188,6 @@ const meta: NamedCreateRuleCustomMeta<keyof typeof errorMessages, Options> = {
   schema,
 };
 
-/**
- * Get the core options to use, taking into account overrides.
- */
-function getCoreOptions(
-  node: TSESTree.Node,
-  context: Readonly<RuleContext<keyof typeof errorMessages, Options>>,
-  options: Readonly<Options>,
-): CoreOptions | null {
-  const [optionsObject] = options;
-
-  const program = context.sourceCode.parserServices?.program ?? undefined;
-  if (program === undefined) {
-    return optionsObject;
-  }
-
-  const type = getTypeOfNode(node, context);
-  const found = optionsObject.overrides?.find((override) =>
-    (Array.isArray(override.specifiers)
-      ? override.specifiers
-      : [override.specifiers]
-    ).some((specifier) => typeMatchesSpecifier(program, specifier, type)),
-  );
-
-  if (found !== undefined) {
-    if (found.disable === true) {
-      return null;
-    }
-    return found.options;
-  }
-
-  return optionsObject;
-}
-
 /**
  * Get the rest parameter violations.
  */
@@ -313,7 +262,11 @@ function checkFunction(
   context: Readonly<RuleContext<keyof typeof errorMessages, Options>>,
   options: Readonly<Options>,
 ): RuleResult<keyof typeof errorMessages, Options> {
-  const optionsToUse = getCoreOptions(node, context, options);
+  const optionsToUse = getCoreOptions<CoreOptions, Options>(
+    node,
+    context,
+    options,
+  );
 
   if (optionsToUse === null) {
     return {
@@ -359,7 +312,7 @@ function checkIdentifier(
   const optionsToUse =
     functionNode === null
       ? options[0]
-      : getCoreOptions(functionNode, context, options);
+      : getCoreOptions<CoreOptions, Options>(functionNode, context, options);
 
   if (optionsToUse === null) {
     return {
diff --git a/src/rules/prefer-immutable-types.ts b/src/rules/prefer-immutable-types.ts
index ab31d5b62..181a17254 100644
--- a/src/rules/prefer-immutable-types.ts
+++ b/src/rules/prefer-immutable-types.ts
@@ -11,12 +11,15 @@ import { deepmerge } from "deepmerge-ts";
 import { Immutability } from "is-immutable-type";
 
 import {
+  getCoreOptions,
   ignoreClassesOptionSchema,
   shouldIgnoreClasses,
   shouldIgnoreInFunction,
   shouldIgnorePattern,
   type IgnoreClassesOption,
+  type OverridableOptions,
 } from "#eslint-plugin-functional/options";
+import { typeSpecifiersSchema } from "#eslint-plugin-functional/utils/common-schemas";
 import { ruleNameScope } from "#eslint-plugin-functional/utils/misc";
 import { type ESFunctionType } from "#eslint-plugin-functional/utils/node-types";
 import {
@@ -55,7 +58,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 +68,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 +111,7 @@ 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 Options = [OverridableOptions<CoreOptions>];
 
 /**
  * The enum options for the level of enforcement.
@@ -211,51 +215,75 @@ const suggestionsSchema: JSONSchema4 = {
   },
 };
 
+const coreOptionsPropertiesSchema: JSONSchema4ObjectSchema["properties"] = {
+  parameters: optionSchema,
+  returnTypes: optionSchema,
+  variables: {
+    oneOf: [
+      {
+        type: "object",
+        properties: deepmerge(optionExpandedSchema, {
+          ignoreInFunctions: {
+            type: "boolean",
+          },
+        }),
+        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[] = [
   {
     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,
+    properties: deepmerge(optionExpandedSchema, coreOptionsPropertiesSchema, {
+      overrides: {
+        type: "array",
+        items: {
+          type: "object",
+          properties: {
+            specifiers: typeSpecifiersSchema,
+            options: {
+              type: "object",
+              properties: deepmerge(
+                optionExpandedSchema,
+                coreOptionsPropertiesSchema,
+              ),
+              additionalProperties: false,
+            },
+            disable: {
+              type: "boolean",
+            },
           },
-        ],
-      },
-      fixer: {
-        type: "object",
-        properties: {
-          ReadonlyShallow: fixerSchema,
-          ReadonlyDeep: fixerSchema,
-          Immutable: fixerSchema,
-        },
-        additionalProperties: false,
-      },
-      suggestions: {
-        type: "object",
-        properties: {
-          ReadonlyShallow: suggestionsSchema,
-          ReadonlyDeep: suggestionsSchema,
-          Immutable: suggestionsSchema,
+          additionalProperties: false,
         },
-        additionalProperties: false,
       },
-    }),
+    } satisfies JSONSchema4ObjectSchema["properties"]),
     additionalProperties: false,
   },
 ];
@@ -398,7 +426,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]
@@ -454,14 +482,13 @@ function parseSuggestionsConfigs(
 function getParameterTypeViolations(
   node: ESFunctionType,
   context: Readonly<RuleContext<keyof typeof errorMessages, Options>>,
-  options: Readonly<Options>,
+  options: Readonly<CoreOptions>,
 ): Descriptor[] {
-  const [optionsObject] = options;
   const {
     parameters: rawOption,
     fixer: rawFixerConfig,
     suggestions: rawSuggestionsConfigs,
-  } = optionsObject;
+  } = options;
   const {
     enforcement: rawEnforcement,
     ignoreInferredTypes,
@@ -469,10 +496,10 @@ function getParameterTypeViolations(
     ignoreNamePattern,
     ignoreTypePattern,
   } = {
-    ignoreInferredTypes: optionsObject.ignoreInferredTypes,
-    ignoreClasses: optionsObject.ignoreClasses,
-    ignoreNamePattern: optionsObject.ignoreNamePattern,
-    ignoreTypePattern: optionsObject.ignoreTypePattern,
+    ignoreInferredTypes: options.ignoreInferredTypes,
+    ignoreClasses: options.ignoreClasses,
+    ignoreNamePattern: options.ignoreNamePattern,
+    ignoreTypePattern: options.ignoreTypePattern,
     ...(typeof rawOption === "object"
       ? rawOption
       : {
@@ -480,9 +507,7 @@ function getParameterTypeViolations(
         }),
   };
 
-  const enforcement = parseEnforcement(
-    rawEnforcement ?? optionsObject.enforcement,
-  );
+  const enforcement = parseEnforcement(rawEnforcement ?? options.enforcement);
   if (
     enforcement === false ||
     shouldIgnoreClasses(node, context, ignoreClasses)
@@ -592,14 +617,13 @@ function getParameterTypeViolations(
 function getReturnTypeViolations(
   node: ESFunctionType,
   context: Readonly<RuleContext<keyof typeof errorMessages, Options>>,
-  options: Readonly<Options>,
+  options: Readonly<CoreOptions>,
 ): Descriptor[] {
-  const [optionsObject] = options;
   const {
     returnTypes: rawOption,
     fixer: rawFixerConfig,
     suggestions: rawSuggestionsConfigs,
-  } = optionsObject;
+  } = options;
   const {
     enforcement: rawEnforcement,
     ignoreInferredTypes,
@@ -607,16 +631,14 @@ function getReturnTypeViolations(
     ignoreNamePattern,
     ignoreTypePattern,
   } = {
-    ignoreInferredTypes: optionsObject.ignoreInferredTypes,
-    ignoreClasses: optionsObject.ignoreClasses,
-    ignoreNamePattern: optionsObject.ignoreNamePattern,
-    ignoreTypePattern: optionsObject.ignoreTypePattern,
+    ignoreInferredTypes: options.ignoreInferredTypes,
+    ignoreClasses: options.ignoreClasses,
+    ignoreNamePattern: options.ignoreNamePattern,
+    ignoreTypePattern: options.ignoreTypePattern,
     ...(typeof rawOption === "object" ? rawOption : { enforcement: rawOption }),
   };
 
-  const enforcement = parseEnforcement(
-    rawEnforcement ?? optionsObject.enforcement,
-  );
+  const enforcement = parseEnforcement(rawEnforcement ?? options.enforcement);
 
   if (
     enforcement === false ||
@@ -743,10 +765,19 @@ function checkFunction(
   context: Readonly<RuleContext<keyof typeof errorMessages, Options>>,
   options: Readonly<Options>,
 ): RuleResult<keyof typeof errorMessages, Options> {
-  const descriptors = [
-    ...getParameterTypeViolations(node, context, options),
-    ...getReturnTypeViolations(node, context, options),
-  ];
+  const optionsToUse = getCoreOptions<CoreOptions, Options>(
+    node,
+    context,
+    options,
+  );
+
+  const descriptors =
+    optionsToUse === null
+      ? []
+      : [
+          ...getParameterTypeViolations(node, context, optionsToUse),
+          ...getReturnTypeViolations(node, context, optionsToUse),
+        ];
 
   return {
     context,
@@ -762,13 +793,24 @@ function checkVariable(
   context: Readonly<RuleContext<keyof typeof errorMessages, Options>>,
   options: Readonly<Options>,
 ): RuleResult<keyof typeof errorMessages, Options> {
-  const [optionsObject] = options;
+  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 +819,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 (
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;