diff --git a/docs/API.md b/docs/API.md
index 8e01a2c0..5a1678fb 100644
--- a/docs/API.md
+++ b/docs/API.md
@@ -27,7 +27,7 @@ All these options are optional.
 
 #### `mergeRecords`
 
-Type: `false | (values: Record<any, unknown>[], utils: DeepMergeMergeFunctionUtils, meta: MetaData) => unknown`
+Type: `false | (values: Record<any, unknown>[], utils: DeepMergeFunctionUtils, meta: MetaData) => unknown`
 
 If `false`, records won't be merged. If set to a function, that function will be used to merge records.
 
@@ -35,25 +35,25 @@ Note: Records are "vanilla" objects (e.g. `{ foo: "hello", bar: "world" }`).
 
 #### `mergeArrays`
 
-Type: `false | (values: unknown[][], utils: DeepMergeMergeFunctionUtils, meta: MetaData) => unknown`
+Type: `false | (values: unknown[][], utils: DeepMergeFunctionUtils, meta: MetaData) => unknown`
 
 If `false`, arrays won't be merged. If set to a function, that function will be used to merge arrays.
 
 #### `mergeMaps`
 
-Type: `false | (values: Map<unknown, unknown>[], utils: DeepMergeMergeFunctionUtils, meta: MetaData) => unknown`
+Type: `false | (values: Map<unknown, unknown>[], utils: DeepMergeFunctionUtils, meta: MetaData) => unknown`
 
 If `false`, maps won't be merged. If set to a function, that function will be used to merge maps.
 
 #### `mergeSets`
 
-Type: `false | (values: Set<unknown>[], utils: DeepMergeMergeFunctionUtils, meta: MetaData) => unknown`
+Type: `false | (values: Set<unknown>[], utils: DeepMergeFunctionUtils, meta: MetaData) => unknown`
 
 If `false`, sets won't be merged. If set to a function, that function will be used to merge sets.
 
 #### `mergeOthers`
 
-Type: `(values: unknown[], utils: DeepMergeMergeFunctionUtils, meta: MetaData) => unknown`
+Type: `(values: unknown[], utils: DeepMergeFunctionUtils, meta: MetaData) => unknown`
 
 If set to a function, that function will be used to merge everything else.
 
@@ -72,7 +72,7 @@ Type: `MetaData`
 
 The given meta data value will be passed to root level merges.
 
-### DeepMergeMergeFunctionUtils
+### DeepMergeFunctionUtils
 
 This is a set of utility functions that are made available to your custom merge functions.
 
@@ -115,7 +115,7 @@ All these options are optional.
 
 #### `mergeRecords`
 
-Type: `false | (target: DeepMergeValueReference<Record<PropertyKey, unknown>>, values: Record<any, unknown>[], utils: DeepMergeMergeFunctionUtils, meta: MetaData) => void | symbol` <!-- markdownlint-disable-line MD013 -->
+Type: `false | (target: DeepMergeValueReference<Record<PropertyKey, unknown>>, values: Record<any, unknown>[], utils: DeepMergeFunctionUtils, meta: MetaData) => void | symbol` <!-- markdownlint-disable-line MD013 -->
 
 If `false`, records won't be merged. If set to a function, that function will be used to merge records by mutating
 `target.value`.
@@ -124,28 +124,28 @@ Note: Records are "vanilla" objects (e.g. `{ foo: "hello", bar: "world" }`).
 
 #### `mergeArrays`
 
-Type: `false | (target: DeepMergeValueReference<unknown[]>, values: unknown[][], utils: DeepMergeMergeIntoFunctionUtils, meta: MetaData) => void | symbol` <!-- markdownlint-disable-line MD013 -->
+Type: `false | (target: DeepMergeValueReference<unknown[]>, values: unknown[][], utils: DeepMergeIntoFunctionUtils, meta: MetaData) => void | symbol` <!-- markdownlint-disable-line MD013 -->
 
 If `false`, arrays won't be merged. If set to a function, that function will be used to merge arrays by mutating
 `target.value`.
 
 #### `mergeMaps`
 
-Type: `false | (target: DeepMergeValueReference<Map<unknown, unknown>>, values: Map<unknown, unknown>[], utils: DeepMergeMergeIntoFunctionUtils, meta: MetaData) => void | symbol` <!-- markdownlint-disable-line MD013 -->
+Type: `false | (target: DeepMergeValueReference<Map<unknown, unknown>>, values: Map<unknown, unknown>[], utils: DeepMergeIntoFunctionUtils, meta: MetaData) => void | symbol` <!-- markdownlint-disable-line MD013 -->
 
 If `false`, maps won't be merged. If set to a function, that function will be used to merge maps by mutating
 `target.value`.
 
 #### `mergeSets`
 
-Type: `false | (target: DeepMergeValueReference<Set<unknown>>, values: Set<unknown>[], utils: DeepMergeMergeIntoFunctionUtils, meta: MetaData) => void | symbol` <!-- markdownlint-disable-line MD013 -->
+Type: `false | (target: DeepMergeValueReference<Set<unknown>>, values: Set<unknown>[], utils: DeepMergeIntoFunctionUtils, meta: MetaData) => void | symbol` <!-- markdownlint-disable-line MD013 -->
 
 If `false`, sets won't be merged. If set to a function, that function will be used to merge sets by mutating
 `target.value`.
 
 #### `mergeOthers`
 
-Type: `(target: DeepMergeValueReference<unknown>, values: unknown[], utils: DeepMergeMergeIntoFunctionUtils, meta: MetaData) => void | symbol` <!-- markdownlint-disable-line MD013 -->
+Type: `(target: DeepMergeValueReference<unknown>, values: unknown[], utils: DeepMergeIntoFunctionUtils, meta: MetaData) => void | symbol` <!-- markdownlint-disable-line MD013 -->
 
 If set to a function, that function will be used to merge everything else by mutating `target.value`.
 
@@ -164,7 +164,7 @@ Type: `MetaData`
 
 The given meta data value will be passed to root level merges.
 
-### DeepMergeMergeIntoFunctionUtils
+### DeepMergeIntoFunctionUtils
 
 This is a set of utility functions that are made available to your custom merge functions.
 
diff --git a/docs/deepmergeCustom.md b/docs/deepmergeCustom.md
index d85c69ab..c25bd000 100644
--- a/docs/deepmergeCustom.md
+++ b/docs/deepmergeCustom.md
@@ -159,7 +159,7 @@ const y = { foo: [5, 6] };
 customDeepmerge(x, y); // => { foo: [5, 6], bar: [3, 4] }
 ```
 
-When resolving a HKT, we use a lookup inside an interface called `DeepMergeMergeFunctionURItoKind`.
+When resolving a HKT, we use a lookup inside an interface called `DeepMergeFunctionURItoKind`.
 This interface needs to contain all the mappings of the URIs to their actual type.
 
 When defining your own HKT for use with deepmerge, you need to extend this interface with your mapping.
@@ -168,9 +168,9 @@ declaring a module block for this library and defining the same interface.
 
 ```ts
 declare module "deepmerge-ts" {
-  interface DeepMergeMergeFunctionURItoKind<
+  interface DeepMergeFunctionURItoKind<
     Ts extends ReadonlyArray<unknown>,
-    MF extends DeepMergeMergeFunctionsURIs,
+    MF extends DeepMergeFunctionsURIs,
     M,
   > {
     readonly MyCustomMergeURI: MyValue;
@@ -184,9 +184,9 @@ Here's an example of creating a custom deepmerge function that amalgamates dates
 
 ```ts
 import {
+  type DeepMergeFunctionURItoKind,
+  type DeepMergeFunctionsURIs,
   type DeepMergeLeaf,
-  type DeepMergeMergeFunctionURItoKind,
-  type DeepMergeMergeFunctionsURIs,
   deepmergeCustom,
 } from "deepmerge-ts";
 
@@ -213,9 +213,9 @@ const z = { foo: new Date("2022-03-03") };
 customDeepmerge(x, y, z); // => { foo: [Date, Date, Date] }
 
 declare module "deepmerge-ts" {
-  interface DeepMergeMergeFunctionURItoKind<
+  interface DeepMergeFunctionURItoKind<
     Ts extends ReadonlyArray<unknown>,
-    MF extends DeepMergeMergeFunctionsURIs,
+    MF extends DeepMergeFunctionsURIs,
     M,
   > {
     readonly MyDeepMergeDatesURI: EveryIsDate<Ts> extends true
@@ -247,8 +247,8 @@ Be sure to also set the `DeepMergeFilterValuesURI` to `DeepMergeNoFilteringURI`
 
 ```ts
 import {
-  type DeepMergeMergeFunctionURItoKind,
-  type DeepMergeMergeFunctionsURIs,
+  type DeepMergeFunctionURItoKind,
+  type DeepMergeFunctionsURIs,
   type DeepMergeNoFilteringURI,
   deepmergeCustom,
 } from "deepmerge-ts";
@@ -275,8 +275,8 @@ Here's an example that creates a custom deepmerge function that filters out all
 
 ```ts
 import {
-  type DeepMergeMergeFunctionURItoKind,
-  type DeepMergeMergeFunctionsURIs,
+  type DeepMergeFunctionURItoKind,
+  type DeepMergeFunctionsURIs,
   type FilterOut,
   deepmergeCustom,
 } from "deepmerge-ts";
@@ -299,9 +299,9 @@ const z = { key1: { subkey2: `two` } };
 customizedDeepmerge(x, y, z); // => { key1: { subkey1: `one`, subkey2: `two` } }
 
 declare module "deepmerge-ts" {
-  interface DeepMergeMergeFunctionURItoKind<
+  interface DeepMergeFunctionURItoKind<
     Ts extends Readonly<ReadonlyArray<unknown>>,
-    MF extends DeepMergeMergeFunctionsURIs,
+    MF extends DeepMergeFunctionsURIs,
     M,
   > {
     readonly FilterNullValues: FilterOut<Ts, null>;
@@ -318,9 +318,9 @@ under.
 
 ```ts
 import {
+  type DeepMergeFunctionURItoKind,
+  type DeepMergeFunctionsURIs,
   type DeepMergeLeaf,
-  type DeepMergeMergeFunctionURItoKind,
-  type DeepMergeMergeFunctionsURIs,
   deepmergeCustom,
 } from "deepmerge-ts";
 
@@ -370,9 +370,9 @@ Here's an example that uses custom metadata that accumulates the full key path.
 
 ```ts
 import {
+  type DeepMergeFunctionURItoKind,
+  type DeepMergeFunctionsURIs,
   type DeepMergeLeaf,
-  type DeepMergeMergeFunctionURItoKind,
-  type DeepMergeMergeFunctionsURIs,
   deepmergeCustom,
 } from "deepmerge-ts";
 
@@ -431,9 +431,9 @@ const y = {
 customizedDeepmerge(x, y); // => { foo: { bar: { baz: "special merge", bar: { baz: 6, qux: 7 }, qux: 2 } }, bar: { baz: "special merge", qux: 9 }, }
 
 declare module "deepmerge-ts" {
-  interface DeepMergeMergeFunctionURItoKind<
+  interface DeepMergeFunctionURItoKind<
     Ts extends Readonly<ReadonlyArray<unknown>>,
-    MF extends DeepMergeMergeFunctionsURIs,
+    MF extends DeepMergeFunctionsURIs,
     M, // This is the meta data type
   > {
     readonly KeyPathBasedMerge: Ts[number] extends number
@@ -507,10 +507,10 @@ type CustomizedDeepmergeInto = <
   DeepMergeHKT<
     [Target, ...Ts], // Don't forget to pass the `Target` type here too.
     {
-      DeepMergeRecordsURI: DeepMergeMergeFunctionsDefaultURIs["DeepMergeRecordsURI"]; // Use default behavior.
-      DeepMergeArraysURI: DeepMergeMergeFunctionsDefaultURIs["DeepMergeArraysURI"]; // Use default behavior.
-      DeepMergeSetsURI: DeepMergeMergeFunctionsDefaultURIs["DeepMergeSetsURI"]; // Use default behavior.
-      DeepMergeMapsURI: DeepMergeMergeFunctionsDefaultURIs["DeepMergeMapsURI"]; // Use default behavior.
+      DeepMergeRecordsURI: DeepMergeFunctionsDefaultURIs["DeepMergeRecordsURI"]; // Use default behavior.
+      DeepMergeArraysURI: DeepMergeFunctionsDefaultURIs["DeepMergeArraysURI"]; // Use default behavior.
+      DeepMergeSetsURI: DeepMergeFunctionsDefaultURIs["DeepMergeSetsURI"]; // Use default behavior.
+      DeepMergeMapsURI: DeepMergeFunctionsDefaultURIs["DeepMergeMapsURI"]; // Use default behavior.
       DeepMergeOthersURI: "CustomDeepMergeOthersURI"; // Use custom behavior (see deepmergeCustom's docs above for details).
     },
     DeepMergeBuiltInMetaData // Use default meta data.
diff --git a/src/deepmerge-into.ts b/src/deepmerge-into.ts
index b5128016..1ad0ca88 100644
--- a/src/deepmerge-into.ts
+++ b/src/deepmerge-into.ts
@@ -6,10 +6,10 @@ import {
 import * as defaultMergeIntoFunctions from "./defaults/into";
 import {
   type DeepMergeBuiltInMetaData,
+  type DeepMergeFunctionsDefaultURIs,
   type DeepMergeHKT,
+  type DeepMergeIntoFunctionUtils,
   type DeepMergeIntoOptions,
-  type DeepMergeMergeFunctionsDefaultURIs,
-  type DeepMergeMergeIntoFunctionUtils,
   type Reference,
 } from "./types";
 import { type SimplifyObject } from "./types/utils";
@@ -42,7 +42,7 @@ export function deepmergeInto<
   Target &
     DeepMergeHKT<
       [Target, ...Ts],
-      DeepMergeMergeFunctionsDefaultURIs,
+      DeepMergeFunctionsDefaultURIs,
       DeepMergeBuiltInMetaData
     >
 >;
@@ -57,7 +57,7 @@ export function deepmergeInto<
   Target &
     DeepMergeHKT<
       [Target, ...Ts],
-      DeepMergeMergeFunctionsDefaultURIs,
+      DeepMergeFunctionsDefaultURIs,
       DeepMergeBuiltInMetaData
     >
 > {
@@ -119,7 +119,7 @@ export function deepmergeIntoCustom<
     ...objects: Ts
   ) => void;
 
-  const utils: DeepMergeMergeIntoFunctionUtils<MetaData, MetaMetaData> =
+  const utils: DeepMergeIntoFunctionUtils<MetaData, MetaMetaData> =
     getIntoUtils(options, customizedDeepmergeInto as CustomizedDeepmergeInto);
 
   /**
@@ -150,11 +150,8 @@ function getIntoUtils<
   MM extends DeepMergeBuiltInMetaData = DeepMergeBuiltInMetaData,
 >(
   options: DeepMergeIntoOptions<M, MM>,
-  customizedDeepmergeInto: DeepMergeMergeIntoFunctionUtils<
-    M,
-    MM
-  >["deepmergeInto"],
-): DeepMergeMergeIntoFunctionUtils<M, MM> {
+  customizedDeepmergeInto: DeepMergeIntoFunctionUtils<M, MM>["deepmergeInto"],
+): DeepMergeIntoFunctionUtils<M, MM> {
   return {
     defaultMergeFunctions: defaultMergeIntoFunctions,
     mergeFunctions: {
@@ -170,9 +167,9 @@ function getIntoUtils<
               : [key, option],
           ),
       ),
-    } as DeepMergeMergeIntoFunctionUtils<M, MM>["mergeFunctions"],
+    } as DeepMergeIntoFunctionUtils<M, MM>["mergeFunctions"],
     metaDataUpdater: (options.metaDataUpdater ??
-      defaultMetaDataUpdater) as unknown as DeepMergeMergeIntoFunctionUtils<
+      defaultMetaDataUpdater) as unknown as DeepMergeIntoFunctionUtils<
       M,
       MM
     >["metaDataUpdater"],
@@ -193,7 +190,7 @@ function getIntoUtils<
  */
 export function mergeUnknownsInto<
   Ts extends ReadonlyArray<unknown>,
-  U extends DeepMergeMergeIntoFunctionUtils<M, MM>,
+  U extends DeepMergeIntoFunctionUtils<M, MM>,
   M,
   MM extends DeepMergeBuiltInMetaData = DeepMergeBuiltInMetaData,
 >(
@@ -291,7 +288,7 @@ export function mergeUnknownsInto<
  * @param values - The records.
  */
 function mergeRecordsInto<
-  U extends DeepMergeMergeIntoFunctionUtils<M, MM>,
+  U extends DeepMergeIntoFunctionUtils<M, MM>,
   M,
   MM extends DeepMergeBuiltInMetaData = DeepMergeBuiltInMetaData,
 >(
@@ -324,7 +321,7 @@ function mergeRecordsInto<
  * @param values - The arrays.
  */
 function mergeArraysInto<
-  U extends DeepMergeMergeIntoFunctionUtils<M, MM>,
+  U extends DeepMergeIntoFunctionUtils<M, MM>,
   M,
   MM extends DeepMergeBuiltInMetaData = DeepMergeBuiltInMetaData,
 >(
@@ -352,7 +349,7 @@ function mergeArraysInto<
  * @param values - The sets.
  */
 function mergeSetsInto<
-  U extends DeepMergeMergeIntoFunctionUtils<M, MM>,
+  U extends DeepMergeIntoFunctionUtils<M, MM>,
   M,
   MM extends DeepMergeBuiltInMetaData = DeepMergeBuiltInMetaData,
 >(
@@ -375,7 +372,7 @@ function mergeSetsInto<
  * @param values - The maps.
  */
 function mergeMapsInto<
-  U extends DeepMergeMergeIntoFunctionUtils<M, MM>,
+  U extends DeepMergeIntoFunctionUtils<M, MM>,
   M,
   MM extends DeepMergeBuiltInMetaData = DeepMergeBuiltInMetaData,
 >(
@@ -398,7 +395,7 @@ function mergeMapsInto<
  * @param values - The other things.
  */
 function mergeOthersInto<
-  U extends DeepMergeMergeIntoFunctionUtils<M, MM>,
+  U extends DeepMergeIntoFunctionUtils<M, MM>,
   M,
   MM extends DeepMergeBuiltInMetaData = DeepMergeBuiltInMetaData,
 >(
diff --git a/src/deepmerge.ts b/src/deepmerge.ts
index 23b3666a..adf24efb 100644
--- a/src/deepmerge.ts
+++ b/src/deepmerge.ts
@@ -6,12 +6,12 @@ import {
 import * as defaultMergeFunctions from "./defaults/vanilla";
 import {
   type DeepMergeBuiltInMetaData,
+  type DeepMergeFunctionUtils,
+  type DeepMergeFunctionsDefaultURIs,
+  type DeepMergeFunctionsURIs,
   type DeepMergeHKT,
-  type DeepMergeMergeFunctionUtils,
-  type DeepMergeMergeFunctionsDefaultURIs,
-  type DeepMergeMergeFunctionsURIs,
   type DeepMergeOptions,
-  type GetDeepMergeMergeFunctionsURIs,
+  type GetDeepMergeFunctionsURIs,
 } from "./types";
 import { ObjectType, getObjectType } from "./utils";
 
@@ -22,14 +22,10 @@ import { ObjectType, getObjectType } from "./utils";
  */
 export function deepmerge<Ts extends Readonly<ReadonlyArray<unknown>>>(
   ...objects: readonly [...Ts]
-): DeepMergeHKT<
-  Ts,
-  DeepMergeMergeFunctionsDefaultURIs,
-  DeepMergeBuiltInMetaData
-> {
+): DeepMergeHKT<Ts, DeepMergeFunctionsDefaultURIs, DeepMergeBuiltInMetaData> {
   return deepmergeCustom({})(...objects) as DeepMergeHKT<
     Ts,
-    DeepMergeMergeFunctionsDefaultURIs,
+    DeepMergeFunctionsDefaultURIs,
     DeepMergeBuiltInMetaData
   >;
 }
@@ -41,16 +37,12 @@ export function deepmerge<Ts extends Readonly<ReadonlyArray<unknown>>>(
  */
 export function deepmergeCustom<
   BaseTs = unknown,
-  PMF extends Partial<DeepMergeMergeFunctionsURIs> = {},
+  PMF extends Partial<DeepMergeFunctionsURIs> = {},
 >(
   options: DeepMergeOptions<DeepMergeBuiltInMetaData, DeepMergeBuiltInMetaData>,
 ): <Ts extends ReadonlyArray<BaseTs>>(
   ...objects: Ts
-) => DeepMergeHKT<
-  Ts,
-  GetDeepMergeMergeFunctionsURIs<PMF>,
-  DeepMergeBuiltInMetaData
->;
+) => DeepMergeHKT<Ts, GetDeepMergeFunctionsURIs<PMF>, DeepMergeBuiltInMetaData>;
 
 /**
  * Deeply merge two or more objects using the given options and meta data.
@@ -60,7 +52,7 @@ export function deepmergeCustom<
  */
 export function deepmergeCustom<
   BaseTs = unknown,
-  PMF extends Partial<DeepMergeMergeFunctionsURIs> = {},
+  PMF extends Partial<DeepMergeFunctionsURIs> = {},
   MetaData = DeepMergeBuiltInMetaData,
   MetaMetaData extends DeepMergeBuiltInMetaData = DeepMergeBuiltInMetaData,
 >(
@@ -68,11 +60,11 @@ export function deepmergeCustom<
   rootMetaData?: MetaData,
 ): <Ts extends ReadonlyArray<BaseTs>>(
   ...objects: Ts
-) => DeepMergeHKT<Ts, GetDeepMergeMergeFunctionsURIs<PMF>, MetaData>;
+) => DeepMergeHKT<Ts, GetDeepMergeFunctionsURIs<PMF>, MetaData>;
 
 export function deepmergeCustom<
   BaseTs,
-  PMF extends Partial<DeepMergeMergeFunctionsURIs>,
+  PMF extends Partial<DeepMergeFunctionsURIs>,
   MetaData,
   MetaMetaData extends DeepMergeBuiltInMetaData,
 >(
@@ -80,15 +72,15 @@ export function deepmergeCustom<
   rootMetaData?: MetaData,
 ): <Ts extends ReadonlyArray<BaseTs>>(
   ...objects: Ts
-) => DeepMergeHKT<Ts, GetDeepMergeMergeFunctionsURIs<PMF>, MetaData> {
+) => DeepMergeHKT<Ts, GetDeepMergeFunctionsURIs<PMF>, MetaData> {
   /**
    * The type of the customized deepmerge function.
    */
   type CustomizedDeepmerge = <Ts extends ReadonlyArray<unknown>>(
     ...objects: Ts
-  ) => DeepMergeHKT<Ts, GetDeepMergeMergeFunctionsURIs<PMF>, MetaData>;
+  ) => DeepMergeHKT<Ts, GetDeepMergeFunctionsURIs<PMF>, MetaData>;
 
-  const utils: DeepMergeMergeFunctionUtils<MetaData, MetaMetaData> = getUtils(
+  const utils: DeepMergeFunctionUtils<MetaData, MetaMetaData> = getUtils(
     options,
     customizedDeepmerge as CustomizedDeepmerge,
   );
@@ -100,7 +92,7 @@ export function deepmergeCustom<
     return mergeUnknowns<
       ReadonlyArray<unknown>,
       typeof utils,
-      GetDeepMergeMergeFunctionsURIs<PMF>,
+      GetDeepMergeFunctionsURIs<PMF>,
       MetaData,
       MetaMetaData
     >(objects, utils, rootMetaData);
@@ -119,8 +111,8 @@ function getUtils<
   MM extends DeepMergeBuiltInMetaData = DeepMergeBuiltInMetaData,
 >(
   options: DeepMergeOptions<M, MM>,
-  customizedDeepmerge: DeepMergeMergeFunctionUtils<M, MM>["deepmerge"],
-): DeepMergeMergeFunctionUtils<M, MM> {
+  customizedDeepmerge: DeepMergeFunctionUtils<M, MM>["deepmerge"],
+): DeepMergeFunctionUtils<M, MM> {
   return {
     defaultMergeFunctions,
     mergeFunctions: {
@@ -134,9 +126,9 @@ function getUtils<
               : [key, option],
           ),
       ),
-    } as DeepMergeMergeFunctionUtils<M, MM>["mergeFunctions"],
+    } as DeepMergeFunctionUtils<M, MM>["mergeFunctions"],
     metaDataUpdater: (options.metaDataUpdater ??
-      defaultMetaDataUpdater) as unknown as DeepMergeMergeFunctionUtils<
+      defaultMetaDataUpdater) as unknown as DeepMergeFunctionUtils<
       M,
       MM
     >["metaDataUpdater"],
@@ -157,8 +149,8 @@ function getUtils<
  */
 export function mergeUnknowns<
   Ts extends ReadonlyArray<unknown>,
-  U extends DeepMergeMergeFunctionUtils<M, MM>,
-  MF extends DeepMergeMergeFunctionsURIs,
+  U extends DeepMergeFunctionUtils<M, MM>,
+  MF extends DeepMergeFunctionsURIs,
   M,
   MM extends DeepMergeBuiltInMetaData = DeepMergeBuiltInMetaData,
 >(values: Ts, utils: U, meta: M | undefined): DeepMergeHKT<Ts, MF, M> {
@@ -242,8 +234,8 @@ export function mergeUnknowns<
  * @param values - The records.
  */
 function mergeRecords<
-  U extends DeepMergeMergeFunctionUtils<M, MM>,
-  MF extends DeepMergeMergeFunctionsURIs,
+  U extends DeepMergeFunctionUtils<M, MM>,
+  MF extends DeepMergeFunctionsURIs,
   M,
   MM extends DeepMergeBuiltInMetaData = DeepMergeBuiltInMetaData,
 >(
@@ -278,7 +270,7 @@ function mergeRecords<
  * @param values - The arrays.
  */
 function mergeArrays<
-  U extends DeepMergeMergeFunctionUtils<M, MM>,
+  U extends DeepMergeFunctionUtils<M, MM>,
   M,
   MM extends DeepMergeBuiltInMetaData = DeepMergeBuiltInMetaData,
 >(
@@ -306,7 +298,7 @@ function mergeArrays<
  * @param values - The sets.
  */
 function mergeSets<
-  U extends DeepMergeMergeFunctionUtils<M, MM>,
+  U extends DeepMergeFunctionUtils<M, MM>,
   M,
   MM extends DeepMergeBuiltInMetaData = DeepMergeBuiltInMetaData,
 >(
@@ -333,7 +325,7 @@ function mergeSets<
  * @param values - The maps.
  */
 function mergeMaps<
-  U extends DeepMergeMergeFunctionUtils<M, MM>,
+  U extends DeepMergeFunctionUtils<M, MM>,
   M,
   MM extends DeepMergeBuiltInMetaData = DeepMergeBuiltInMetaData,
 >(
@@ -360,7 +352,7 @@ function mergeMaps<
  * @param values - The other things.
  */
 function mergeOthers<
-  U extends DeepMergeMergeFunctionUtils<M, MM>,
+  U extends DeepMergeFunctionUtils<M, MM>,
   M,
   MM extends DeepMergeBuiltInMetaData = DeepMergeBuiltInMetaData,
 >(values: ReadonlyArray<unknown>, utils: U, meta: M | undefined) {
diff --git a/src/defaults/into.ts b/src/defaults/into.ts
index c4aa2b63..0b8b0786 100644
--- a/src/defaults/into.ts
+++ b/src/defaults/into.ts
@@ -1,7 +1,7 @@
 import { mergeUnknownsInto } from "../deepmerge-into";
 import {
   type DeepMergeBuiltInMetaData,
-  type DeepMergeMergeIntoFunctionUtils,
+  type DeepMergeIntoFunctionUtils,
   type Reference,
 } from "../types";
 import { getIterableOfIterables, getKeys, objectHasProperty } from "../utils";
@@ -25,7 +25,7 @@ export type MergeFunctions = {
  */
 export function mergeRecords<
   Ts extends ReadonlyArray<Record<PropertyKey, unknown>>,
-  U extends DeepMergeMergeIntoFunctionUtils<M, MM>,
+  U extends DeepMergeIntoFunctionUtils<M, MM>,
   M,
   MM extends DeepMergeBuiltInMetaData = DeepMergeBuiltInMetaData,
 >(
diff --git a/src/defaults/vanilla.ts b/src/defaults/vanilla.ts
index 53a2bf77..4bede882 100644
--- a/src/defaults/vanilla.ts
+++ b/src/defaults/vanilla.ts
@@ -3,9 +3,9 @@ import { mergeUnknowns } from "../deepmerge";
 import {
   type DeepMergeArraysDefaultHKT,
   type DeepMergeBuiltInMetaData,
+  type DeepMergeFunctionUtils,
+  type DeepMergeFunctionsURIs,
   type DeepMergeMapsDefaultHKT,
-  type DeepMergeMergeFunctionUtils,
-  type DeepMergeMergeFunctionsURIs,
   type DeepMergeRecordsDefaultHKT,
   type DeepMergeSetsDefaultHKT,
 } from "../types";
@@ -29,8 +29,8 @@ export type MergeFunctions = {
  */
 export function mergeRecords<
   Ts extends ReadonlyArray<Record<PropertyKey, unknown>>,
-  U extends DeepMergeMergeFunctionUtils<M, MM>,
-  MF extends DeepMergeMergeFunctionsURIs,
+  U extends DeepMergeFunctionUtils<M, MM>,
+  MF extends DeepMergeFunctionsURIs,
   M,
   MM extends DeepMergeBuiltInMetaData = DeepMergeBuiltInMetaData,
 >(
@@ -90,7 +90,7 @@ export function mergeRecords<
  */
 export function mergeArrays<
   Ts extends ReadonlyArray<ReadonlyArray<unknown>>,
-  MF extends DeepMergeMergeFunctionsURIs,
+  MF extends DeepMergeFunctionsURIs,
   M,
 >(values: Ts): DeepMergeArraysDefaultHKT<Ts, MF, M> {
   return values.flat() as DeepMergeArraysDefaultHKT<Ts, MF, M>;
diff --git a/src/index.ts b/src/index.ts
index 7dd67524..b572acbf 100644
--- a/src/index.ts
+++ b/src/index.ts
@@ -7,8 +7,8 @@ export {
   objectHasProperty,
 } from "./utils";
 
-export type { MergeFunctions as DeepMergeMergeIntoFunctionsDefaults } from "./defaults/into";
-export type { MergeFunctions as DeepMergeMergeFunctionsDefaults } from "./defaults/vanilla";
+export type { MergeFunctions as DeepMergeIntoFunctionsDefaults } from "./defaults/into";
+export type { MergeFunctions as DeepMergeFunctionsDefaults } from "./defaults/vanilla";
 export type {
   DeepMergeArraysDefaultHKT,
   DeepMergeBuiltInMetaData,
@@ -17,16 +17,16 @@ export type {
   DeepMergeLeafURI,
   DeepMergeNoFilteringURI,
   DeepMergeMapsDefaultHKT,
-  DeepMergeMergeFunctionsDefaultURIs,
-  DeepMergeMergeFunctionsURIs,
-  DeepMergeMergeFunctionURItoKind,
-  DeepMergeMergeFunctionUtils,
-  DeepMergeMergeIntoFunctionUtils,
+  DeepMergeFunctionsDefaultURIs,
+  DeepMergeFunctionsURIs,
+  DeepMergeFunctionURItoKind,
+  DeepMergeFunctionUtils,
+  DeepMergeIntoFunctionUtils,
   DeepMergeOptions,
   DeepMergeIntoOptions,
   DeepMergeRecordsDefaultHKT,
   DeepMergeSetsDefaultHKT,
   Reference as DeepMergeValueReference,
-  GetDeepMergeMergeFunctionsURIs,
+  GetDeepMergeFunctionsURIs,
 } from "./types";
 export type { FilterOut } from "./types/utils";
diff --git a/src/types/defaults.ts b/src/types/defaults.ts
index aff7bc3c..5ad6433a 100644
--- a/src/types/defaults.ts
+++ b/src/types/defaults.ts
@@ -1,8 +1,8 @@
 import {
+  type DeepMergeFunctionURItoKind,
+  type DeepMergeFunctionsURIs,
   type DeepMergeHKT,
   type DeepMergeLeafURI,
-  type DeepMergeMergeFunctionURItoKind,
-  type DeepMergeMergeFunctionsURIs,
 } from "./merging";
 import {
   type FilterOut,
@@ -46,7 +46,7 @@ type DeepMergeFilterValuesDefaultURI = "DeepMergeFilterValuesDefaultURI";
 /**
  * The default merge functions to use when deep merging.
  */
-export type DeepMergeMergeFunctionsDefaultURIs = Readonly<{
+export type DeepMergeFunctionsDefaultURIs = Readonly<{
   DeepMergeRecordsURI: DeepMergeRecordsDefaultURI;
   DeepMergeArraysURI: DeepMergeArraysDefaultURI;
   DeepMergeSetsURI: DeepMergeSetsDefaultURI;
@@ -95,7 +95,7 @@ type RecordToRecordMeta<T extends Record<PropertyKey, unknown>> =
  */
 export type DeepMergeRecordsDefaultHKT<
   Ts extends ReadonlyArray<unknown>,
-  MF extends DeepMergeMergeFunctionsURIs,
+  MF extends DeepMergeFunctionsURIs,
   M,
 > =
   Ts extends ReadonlyArray<Record<PropertyKey, unknown>>
@@ -109,7 +109,7 @@ export type DeepMergeRecordsDefaultHKT<
  */
 type DeepMergeRecordMetaDefaultHKTProps<
   RecordMetas,
-  MF extends DeepMergeMergeFunctionsURIs,
+  MF extends DeepMergeFunctionsURIs,
   M,
 > =
   RecordMetas extends ReadonlyArray<RecordMeta>
@@ -143,7 +143,7 @@ type GroupValuesByKey<Ts> = Ts extends readonly [
     }
   : never;
 
-type CreateRecordFromMeta<Ts, MF extends DeepMergeMergeFunctionsURIs, M> =
+type CreateRecordFromMeta<Ts, MF extends DeepMergeFunctionsURIs, M> =
   Ts extends ReadonlyArray<unknown>
     ? TupleToIntersection<{
         [I in keyof Ts]: Ts[I] extends {
@@ -160,7 +160,7 @@ type CreateRecordForKeyFromMeta<
   Key extends PropertyKey,
   Values extends ReadonlyArray<unknown>,
   Optional extends boolean,
-  MF extends DeepMergeMergeFunctionsURIs,
+  MF extends DeepMergeFunctionsURIs,
   M,
 > = Optional extends true
   ? {
@@ -267,7 +267,7 @@ type DeepMergeRecordPropertyMetaDefaultHKTGetPossibleHelper<
  */
 export type DeepMergeArraysDefaultHKT<
   Ts extends ReadonlyArray<unknown>,
-  MF extends DeepMergeMergeFunctionsURIs,
+  MF extends DeepMergeFunctionsURIs,
   M,
 > = DeepMergeArraysDefaultHKTHelper<Ts, MF, M, []>;
 
@@ -276,7 +276,7 @@ export type DeepMergeArraysDefaultHKT<
  */
 type DeepMergeArraysDefaultHKTHelper<
   Ts extends ReadonlyArray<unknown>,
-  MF extends DeepMergeMergeFunctionsURIs,
+  MF extends DeepMergeFunctionsURIs,
   M,
   Acc extends ReadonlyArray<unknown>,
 > = Ts extends readonly [
@@ -315,42 +315,42 @@ export type DeepMergeFilterValuesDefaultHKT<Ts extends ReadonlyArray<unknown>> =
 /**
  * Get the merge functions with defaults apply from the given subset.
  */
-export type GetDeepMergeMergeFunctionsURIs<
-  PMF extends Partial<DeepMergeMergeFunctionsURIs>,
+export type GetDeepMergeFunctionsURIs<
+  PMF extends Partial<DeepMergeFunctionsURIs>,
 > = Readonly<{
   // prettier-ignore
   DeepMergeRecordsURI:
-    PMF["DeepMergeRecordsURI"] extends keyof DeepMergeMergeFunctionURItoKind<any, any, any>
+    PMF["DeepMergeRecordsURI"] extends keyof DeepMergeFunctionURItoKind<any, any, any>
       ? PMF["DeepMergeRecordsURI"]
       : DeepMergeRecordsDefaultURI;
 
   // prettier-ignore
   DeepMergeArraysURI:
-    PMF["DeepMergeArraysURI"] extends keyof DeepMergeMergeFunctionURItoKind<any, any, any>
+    PMF["DeepMergeArraysURI"] extends keyof DeepMergeFunctionURItoKind<any, any, any>
       ? PMF["DeepMergeArraysURI"]
       : DeepMergeArraysDefaultURI;
 
   // prettier-ignore
   DeepMergeSetsURI:
-    PMF["DeepMergeSetsURI"] extends keyof DeepMergeMergeFunctionURItoKind<any, any, any>
+    PMF["DeepMergeSetsURI"] extends keyof DeepMergeFunctionURItoKind<any, any, any>
       ? PMF["DeepMergeSetsURI"]
       : DeepMergeSetsDefaultURI;
 
   // prettier-ignore
   DeepMergeMapsURI:
-    PMF["DeepMergeMapsURI"] extends keyof DeepMergeMergeFunctionURItoKind<any, any, any>
+    PMF["DeepMergeMapsURI"] extends keyof DeepMergeFunctionURItoKind<any, any, any>
       ? PMF["DeepMergeMapsURI"]
       : DeepMergeMapsDefaultURI;
 
   // prettier-ignore
   DeepMergeOthersURI:
-    PMF["DeepMergeOthersURI"] extends keyof DeepMergeMergeFunctionURItoKind<any, any, any>
+    PMF["DeepMergeOthersURI"] extends keyof DeepMergeFunctionURItoKind<any, any, any>
       ? PMF["DeepMergeOthersURI"]
       : DeepMergeLeafURI;
 
   // prettier-ignore
   DeepMergeFilterValuesURI:
-    PMF["DeepMergeFilterValuesURI"] extends keyof DeepMergeMergeFunctionURItoKind<any, any, any>
+    PMF["DeepMergeFilterValuesURI"] extends keyof DeepMergeFunctionURItoKind<any, any, any>
       ? PMF["DeepMergeFilterValuesURI"]
       : DeepMergeFilterValuesDefaultURI;
 }>;
diff --git a/src/types/merging.ts b/src/types/merging.ts
index a19035a6..4aab0c6c 100644
--- a/src/types/merging.ts
+++ b/src/types/merging.ts
@@ -18,9 +18,9 @@ import {
  * Mapping of merge function URIs to the merge function type.
  */
 // eslint-disable-next-line ts/consistent-type-definitions
-export interface DeepMergeMergeFunctionURItoKind<
+export interface DeepMergeFunctionURItoKind<
   Ts extends ReadonlyArray<unknown>,
-  MF extends DeepMergeMergeFunctionsURIs,
+  MF extends DeepMergeFunctionsURIs,
   in out M,
 > {
   readonly DeepMergeLeafURI: DeepMergeLeaf<Ts>;
@@ -35,55 +35,55 @@ export interface DeepMergeMergeFunctionURItoKind<
 /**
  * Get the type of the given merge function via its URI.
  */
-type DeepMergeMergeFunctionKind<
-  URI extends DeepMergeMergeFunctionURIs,
+type DeepMergeFunctionKind<
+  URI extends DeepMergeFunctionURIs,
   Ts extends ReadonlyArray<unknown>,
-  MF extends DeepMergeMergeFunctionsURIs,
+  MF extends DeepMergeFunctionsURIs,
   M,
-> = DeepMergeMergeFunctionURItoKind<Ts, MF, M>[URI];
+> = DeepMergeFunctionURItoKind<Ts, MF, M>[URI];
 
 /**
  * A union of all valid merge function URIs.
  */
-type DeepMergeMergeFunctionURIs = keyof DeepMergeMergeFunctionURItoKind<
+type DeepMergeFunctionURIs = keyof DeepMergeFunctionURItoKind<
   ReadonlyArray<unknown>,
-  DeepMergeMergeFunctionsURIs,
+  DeepMergeFunctionsURIs,
   unknown
 >;
 
 /**
  * The merge functions to use when deep merging.
  */
-export type DeepMergeMergeFunctionsURIs = Readonly<{
+export type DeepMergeFunctionsURIs = Readonly<{
   /**
    * The merge function to merge records with.
    */
-  DeepMergeRecordsURI: DeepMergeMergeFunctionURIs;
+  DeepMergeRecordsURI: DeepMergeFunctionURIs;
 
   /**
    * The merge function to merge arrays with.
    */
-  DeepMergeArraysURI: DeepMergeMergeFunctionURIs;
+  DeepMergeArraysURI: DeepMergeFunctionURIs;
 
   /**
    * The merge function to merge sets with.
    */
-  DeepMergeSetsURI: DeepMergeMergeFunctionURIs;
+  DeepMergeSetsURI: DeepMergeFunctionURIs;
 
   /**
    * The merge function to merge maps with.
    */
-  DeepMergeMapsURI: DeepMergeMergeFunctionURIs;
+  DeepMergeMapsURI: DeepMergeFunctionURIs;
 
   /**
    * The merge function to merge other things with.
    */
-  DeepMergeOthersURI: DeepMergeMergeFunctionURIs;
+  DeepMergeOthersURI: DeepMergeFunctionURIs;
 
   /**
    * The function to filter values.
    */
-  DeepMergeFilterValuesURI: DeepMergeMergeFunctionURIs;
+  DeepMergeFilterValuesURI: DeepMergeFunctionURIs;
 }>;
 
 /**
@@ -91,7 +91,7 @@ export type DeepMergeMergeFunctionsURIs = Readonly<{
  */
 export type DeepMergeHKT<
   Ts extends ReadonlyArray<unknown>,
-  MF extends DeepMergeMergeFunctionsURIs,
+  MF extends DeepMergeFunctionsURIs,
   M,
 > =
   IsTuple<Ts> extends true
@@ -100,7 +100,7 @@ export type DeepMergeHKT<
       : DeepMergeHKTHelper<FilterValuesHKT<Ts, MF, M>, MF, M>
     : unknown;
 
-type DeepMergeHKTHelper<Ts, MF extends DeepMergeMergeFunctionsURIs, M> =
+type DeepMergeHKTHelper<Ts, MF extends DeepMergeFunctionsURIs, M> =
   Ts extends ReadonlyArray<unknown>
     ? IsTuple<Ts> extends true
       ? Ts extends readonly []
@@ -124,54 +124,54 @@ type DeepMergeHKTHelper<Ts, MF extends DeepMergeMergeFunctionsURIs, M> =
  */
 type DeepMergeRecordsHKT<
   Ts extends ReadonlyArray<unknown>,
-  MF extends DeepMergeMergeFunctionsURIs,
+  MF extends DeepMergeFunctionsURIs,
   M,
-> = DeepMergeMergeFunctionKind<MF["DeepMergeRecordsURI"], Ts, MF, M>;
+> = DeepMergeFunctionKind<MF["DeepMergeRecordsURI"], Ts, MF, M>;
 
 /**
  * Deep merge arrays.
  */
 type DeepMergeArraysHKT<
   Ts extends ReadonlyArray<unknown>,
-  MF extends DeepMergeMergeFunctionsURIs,
+  MF extends DeepMergeFunctionsURIs,
   M,
-> = DeepMergeMergeFunctionKind<MF["DeepMergeArraysURI"], Ts, MF, M>;
+> = DeepMergeFunctionKind<MF["DeepMergeArraysURI"], Ts, MF, M>;
 
 /**
  * Deep merge sets.
  */
 type DeepMergeSetsHKT<
   Ts extends ReadonlyArray<unknown>,
-  MF extends DeepMergeMergeFunctionsURIs,
+  MF extends DeepMergeFunctionsURIs,
   M,
-> = DeepMergeMergeFunctionKind<MF["DeepMergeSetsURI"], Ts, MF, M>;
+> = DeepMergeFunctionKind<MF["DeepMergeSetsURI"], Ts, MF, M>;
 
 /**
  * Deep merge maps.
  */
 type DeepMergeMapsHKT<
   Ts extends ReadonlyArray<unknown>,
-  MF extends DeepMergeMergeFunctionsURIs,
+  MF extends DeepMergeFunctionsURIs,
   M,
-> = DeepMergeMergeFunctionKind<MF["DeepMergeMapsURI"], Ts, MF, M>;
+> = DeepMergeFunctionKind<MF["DeepMergeMapsURI"], Ts, MF, M>;
 
 /**
  * Deep merge other things.
  */
 type DeepMergeOthersHKT<
   Ts extends ReadonlyArray<unknown>,
-  MF extends DeepMergeMergeFunctionsURIs,
+  MF extends DeepMergeFunctionsURIs,
   M,
-> = DeepMergeMergeFunctionKind<MF["DeepMergeOthersURI"], Ts, MF, M>;
+> = DeepMergeFunctionKind<MF["DeepMergeOthersURI"], Ts, MF, M>;
 
 /**
  * Filter values.
  */
 type FilterValuesHKT<
   Ts extends ReadonlyArray<unknown>,
-  MF extends DeepMergeMergeFunctionsURIs,
+  MF extends DeepMergeFunctionsURIs,
   M,
-> = DeepMergeMergeFunctionKind<MF["DeepMergeFilterValuesURI"], Ts, MF, M>;
+> = DeepMergeFunctionKind<MF["DeepMergeFilterValuesURI"], Ts, MF, M>;
 
 /**
  * The merge function that returns a leaf.
diff --git a/src/types/options.ts b/src/types/options.ts
index 360ec0b5..cb629d9f 100644
--- a/src/types/options.ts
+++ b/src/types/options.ts
@@ -31,11 +31,11 @@ type DeepMergeOptionsFull<
   in out M,
   MM extends DeepMergeBuiltInMetaData = DeepMergeBuiltInMetaData,
 > = Readonly<{
-  mergeRecords: DeepMergeMergeFunctions<M, MM>["mergeRecords"] | false;
-  mergeArrays: DeepMergeMergeFunctions<M, MM>["mergeArrays"] | false;
-  mergeMaps: DeepMergeMergeFunctions<M, MM>["mergeMaps"] | false;
-  mergeSets: DeepMergeMergeFunctions<M, MM>["mergeSets"] | false;
-  mergeOthers: DeepMergeMergeFunctions<M, MM>["mergeOthers"];
+  mergeRecords: DeepMergeFunctions<M, MM>["mergeRecords"] | false;
+  mergeArrays: DeepMergeFunctions<M, MM>["mergeArrays"] | false;
+  mergeMaps: DeepMergeFunctions<M, MM>["mergeMaps"] | false;
+  mergeSets: DeepMergeFunctions<M, MM>["mergeSets"] | false;
+  mergeOthers: DeepMergeFunctions<M, MM>["mergeOthers"];
   metaDataUpdater: MetaDataUpdater<M, MM>;
   enableImplicitDefaultMerging: boolean;
   filterValues: DeepMergeUtilityFunctions<M>["filterValues"] | false;
@@ -48,11 +48,11 @@ type DeepMergeIntoOptionsFull<
   in out M,
   MM extends DeepMergeBuiltInMetaData = DeepMergeBuiltInMetaData,
 > = Readonly<{
-  mergeRecords: DeepMergeMergeIntoFunctions<M, MM>["mergeRecords"] | false;
-  mergeArrays: DeepMergeMergeIntoFunctions<M, MM>["mergeArrays"] | false;
-  mergeMaps: DeepMergeMergeIntoFunctions<M, MM>["mergeMaps"] | false;
-  mergeSets: DeepMergeMergeIntoFunctions<M, MM>["mergeSets"] | false;
-  mergeOthers: DeepMergeMergeIntoFunctions<M, MM>["mergeOthers"];
+  mergeRecords: DeepMergeIntoFunctions<M, MM>["mergeRecords"] | false;
+  mergeArrays: DeepMergeIntoFunctions<M, MM>["mergeArrays"] | false;
+  mergeMaps: DeepMergeIntoFunctions<M, MM>["mergeMaps"] | false;
+  mergeSets: DeepMergeIntoFunctions<M, MM>["mergeSets"] | false;
+  mergeOthers: DeepMergeIntoFunctions<M, MM>["mergeOthers"];
   metaDataUpdater: MetaDataUpdater<M, MM>;
   filterValues: DeepMergeUtilityFunctions<M>["filterValues"] | false;
 }>;
@@ -77,13 +77,13 @@ type DeepMergeUtilityFunctions<in M> = Readonly<{
 /**
  * All the merge functions that deepmerge uses.
  */
-type DeepMergeMergeFunctions<
+type DeepMergeFunctions<
   in M,
   MM extends DeepMergeBuiltInMetaData = DeepMergeBuiltInMetaData,
 > = Readonly<{
   mergeRecords: <
     Ts extends ReadonlyArray<Readonly<Record<PropertyKey, unknown>>>,
-    U extends DeepMergeMergeFunctionUtils<M, MM>,
+    U extends DeepMergeFunctionUtils<M, MM>,
   >(
     values: Ts,
     utils: U,
@@ -92,7 +92,7 @@ type DeepMergeMergeFunctions<
 
   mergeArrays: <
     Ts extends ReadonlyArray<ReadonlyArray<unknown>>,
-    U extends DeepMergeMergeFunctionUtils<M, MM>,
+    U extends DeepMergeFunctionUtils<M, MM>,
   >(
     values: Ts,
     utils: U,
@@ -101,7 +101,7 @@ type DeepMergeMergeFunctions<
 
   mergeMaps: <
     Ts extends ReadonlyArray<Readonly<ReadonlyMap<unknown, unknown>>>,
-    U extends DeepMergeMergeFunctionUtils<M, MM>,
+    U extends DeepMergeFunctionUtils<M, MM>,
   >(
     values: Ts,
     utils: U,
@@ -110,7 +110,7 @@ type DeepMergeMergeFunctions<
 
   mergeSets: <
     Ts extends ReadonlyArray<Readonly<ReadonlySet<unknown>>>,
-    U extends DeepMergeMergeFunctionUtils<M, MM>,
+    U extends DeepMergeFunctionUtils<M, MM>,
   >(
     values: Ts,
     utils: U,
@@ -119,7 +119,7 @@ type DeepMergeMergeFunctions<
 
   mergeOthers: <
     Ts extends ReadonlyArray<unknown>,
-    U extends DeepMergeMergeFunctionUtils<M, MM>,
+    U extends DeepMergeFunctionUtils<M, MM>,
   >(
     values: Ts,
     utils: U,
@@ -128,74 +128,74 @@ type DeepMergeMergeFunctions<
 }>;
 
 // eslint-disable-next-line ts/no-invalid-void-type
-type DeepMergeMergeIntoFunctionsReturnType = void | symbol;
+type DeepMergeIntoFunctionsReturnType = void | symbol;
 
 /**
  * All the merge functions that deepmerge uses.
  */
-type DeepMergeMergeIntoFunctions<
+type DeepMergeIntoFunctions<
   in M,
   MM extends DeepMergeBuiltInMetaData = DeepMergeBuiltInMetaData,
 > = Readonly<{
   mergeRecords: <
     Ts extends ReadonlyArray<Readonly<Record<PropertyKey, unknown>>>,
-    U extends DeepMergeMergeIntoFunctionUtils<M, MM>,
+    U extends DeepMergeIntoFunctionUtils<M, MM>,
   >(
     m_target: Reference<Record<PropertyKey, unknown>>,
     values: Ts,
     utils: U,
     meta: M | undefined,
-  ) => DeepMergeMergeIntoFunctionsReturnType;
+  ) => DeepMergeIntoFunctionsReturnType;
 
   mergeArrays: <
     Ts extends ReadonlyArray<ReadonlyArray<unknown>>,
-    U extends DeepMergeMergeIntoFunctionUtils<M, MM>,
+    U extends DeepMergeIntoFunctionUtils<M, MM>,
   >(
     m_target: Reference<unknown[]>,
     values: Ts,
     utils: U,
     meta: M | undefined,
-  ) => DeepMergeMergeIntoFunctionsReturnType;
+  ) => DeepMergeIntoFunctionsReturnType;
 
   mergeMaps: <
     Ts extends ReadonlyArray<Readonly<ReadonlyMap<unknown, unknown>>>,
-    U extends DeepMergeMergeIntoFunctionUtils<M, MM>,
+    U extends DeepMergeIntoFunctionUtils<M, MM>,
   >(
     m_target: Reference<Map<unknown, unknown>>,
     values: Ts,
     utils: U,
     meta: M | undefined,
-  ) => DeepMergeMergeIntoFunctionsReturnType;
+  ) => DeepMergeIntoFunctionsReturnType;
 
   mergeSets: <
     Ts extends ReadonlyArray<Readonly<ReadonlySet<unknown>>>,
-    U extends DeepMergeMergeIntoFunctionUtils<M, MM>,
+    U extends DeepMergeIntoFunctionUtils<M, MM>,
   >(
     m_target: Reference<Set<unknown>>,
     values: Ts,
     utils: U,
     meta: M | undefined,
-  ) => DeepMergeMergeIntoFunctionsReturnType;
+  ) => DeepMergeIntoFunctionsReturnType;
 
   mergeOthers: <
     Ts extends ReadonlyArray<unknown>,
-    U extends DeepMergeMergeIntoFunctionUtils<M, MM>,
+    U extends DeepMergeIntoFunctionUtils<M, MM>,
   >(
     m_target: Reference<unknown>,
     values: Ts,
     utils: U,
     meta: M | undefined,
-  ) => DeepMergeMergeIntoFunctionsReturnType;
+  ) => DeepMergeIntoFunctionsReturnType;
 }>;
 
 /**
  * The utils provided to the merge functions.
  */
-export type DeepMergeMergeFunctionUtils<
+export type DeepMergeFunctionUtils<
   in out M,
   MM extends DeepMergeBuiltInMetaData = DeepMergeBuiltInMetaData,
 > = Readonly<{
-  mergeFunctions: DeepMergeMergeFunctions<M, MM>;
+  mergeFunctions: DeepMergeFunctions<M, MM>;
   defaultMergeFunctions: MergeFunctions;
   metaDataUpdater: MetaDataUpdater<M, MM>;
   deepmerge: <Ts extends ReadonlyArray<unknown>>(...values: Ts) => unknown;
@@ -210,11 +210,11 @@ export type DeepMergeMergeFunctionUtils<
 /**
  * The utils provided to the merge functions.
  */
-export type DeepMergeMergeIntoFunctionUtils<
+export type DeepMergeIntoFunctionUtils<
   in out M,
   MM extends DeepMergeBuiltInMetaData = DeepMergeBuiltInMetaData,
 > = Readonly<{
-  mergeFunctions: DeepMergeMergeIntoFunctions<M, MM>;
+  mergeFunctions: DeepMergeIntoFunctions<M, MM>;
   defaultMergeFunctions: MergeIntoFunctions;
   metaDataUpdater: MetaDataUpdater<M, MM>;
   deepmergeInto: <Target extends object, Ts extends ReadonlyArray<unknown>>(
diff --git a/tests/deepmerge-custom.test.ts b/tests/deepmerge-custom.test.ts
index 08311915..d312de79 100644
--- a/tests/deepmerge-custom.test.ts
+++ b/tests/deepmerge-custom.test.ts
@@ -2,9 +2,9 @@ import _ from "lodash";
 import { describe, expect, it } from "vitest";
 
 import {
+  type DeepMergeFunctionsURIs,
   type DeepMergeLeaf,
   type DeepMergeLeafURI,
-  type DeepMergeMergeFunctionsURIs,
   type DeepMergeNoFilteringURI,
   type DeepMergeOptions,
   type DeepMergeRecordsDefaultHKT,
@@ -15,9 +15,9 @@ import { type FilterOut } from "../src/types/utils";
 import { areAllNumbers, hasProp } from "./utils";
 
 declare module "../src/types" {
-  interface DeepMergeMergeFunctionURItoKind<
+  interface DeepMergeFunctionURItoKind<
     Ts extends ReadonlyArray<unknown>,
-    MF extends DeepMergeMergeFunctionsURIs,
+    MF extends DeepMergeFunctionsURIs,
     M,
   > {
     readonly CustomArrays1: string[];
@@ -25,9 +25,9 @@ declare module "../src/types" {
 }
 
 declare module "../src/types" {
-  interface DeepMergeMergeFunctionURItoKind<
+  interface DeepMergeFunctionURItoKind<
     Ts extends ReadonlyArray<unknown>,
-    MF extends DeepMergeMergeFunctionsURIs,
+    MF extends DeepMergeFunctionsURIs,
     M,
   > {
     readonly CustomArrays2: Ts extends Readonly<
@@ -40,9 +40,9 @@ declare module "../src/types" {
 }
 
 declare module "../src/types" {
-  interface DeepMergeMergeFunctionURItoKind<
+  interface DeepMergeFunctionURItoKind<
     Ts extends ReadonlyArray<unknown>,
-    MF extends DeepMergeMergeFunctionsURIs,
+    MF extends DeepMergeFunctionsURIs,
     M,
   > {
     readonly CustomRecords3: Entries<DeepMergeRecordsDefaultHKT<Ts, MF, M>>;
@@ -56,9 +56,9 @@ type Entries<T> = Array<
 >;
 
 declare module "../src/types" {
-  interface DeepMergeMergeFunctionURItoKind<
+  interface DeepMergeFunctionURItoKind<
     Ts extends ReadonlyArray<unknown>,
-    MF extends DeepMergeMergeFunctionsURIs,
+    MF extends DeepMergeFunctionsURIs,
     M,
   > {
     readonly NoArrayMerge1: DeepMergeLeaf<Ts>;
@@ -66,9 +66,9 @@ declare module "../src/types" {
 }
 
 declare module "../src/types" {
-  interface DeepMergeMergeFunctionURItoKind<
+  interface DeepMergeFunctionURItoKind<
     Ts extends ReadonlyArray<unknown>,
-    MF extends DeepMergeMergeFunctionsURIs,
+    MF extends DeepMergeFunctionsURIs,
     M,
   > {
     readonly MergeDates1: EveryIsDate<Ts> extends true ? Ts : DeepMergeLeaf<Ts>;
@@ -83,9 +83,9 @@ type EveryIsDate<Ts extends ReadonlyArray<unknown>> =
     : true;
 
 declare module "../src/types" {
-  interface DeepMergeMergeFunctionURItoKind<
+  interface DeepMergeFunctionURItoKind<
     Ts extends Readonly<ReadonlyArray<unknown>>,
-    MF extends DeepMergeMergeFunctionsURIs,
+    MF extends DeepMergeFunctionsURIs,
     M,
   > {
     readonly KeyPathBasedMerge: Ts[number] extends number
@@ -95,9 +95,9 @@ declare module "../src/types" {
 }
 
 declare module "../src/types" {
-  interface DeepMergeMergeFunctionURItoKind<
+  interface DeepMergeFunctionURItoKind<
     Ts extends ReadonlyArray<unknown>,
-    MF extends DeepMergeMergeFunctionsURIs,
+    MF extends DeepMergeFunctionsURIs,
     M,
   > {
     readonly CustomOthers3: Ts[number] extends object
@@ -115,9 +115,9 @@ declare module "../src/types" {
 }
 
 declare module "../src/types" {
-  interface DeepMergeMergeFunctionURItoKind<
+  interface DeepMergeFunctionURItoKind<
     Ts extends ReadonlyArray<unknown>,
-    MF extends DeepMergeMergeFunctionsURIs,
+    MF extends DeepMergeFunctionsURIs,
     M,
   > {
     readonly CustomFilterValues1: FilterOut<Ts, null>;