Repository: aeon-toolkit/aeon
Pull request #1014 (2023-12-29 18:56:41)

[BUG] fix tag errors, refactor comments np.array -> np.ndarray
whilst removing datatypes references, I noticed a tag in y_type  

```python
    (
        "y_inner_type",
        ["forecaster", "transformer"],
        (
            "list",
            [
                "pd.Series",
                "pd.DataFrame",
                "np.array",
                "nested_univ",
                "pd-multiindex",
                "numpy3D",
                "df-list",
            ],
        ),
```
this is not a valid type even in the complete madness of datatypes, since this

```
x = mtype_to_scitype("np.array")
```
gives an error ValueError: np.array is not a supported mtype

Also noticed many forecasters assign     "pd_multiindex_hier" to y_inner_type, so I have also added that to the tag registry. 

I then look further and see many references in comments to np.array, which as I understand it is a function to create an array, whereas the type should be np.ndarray, so I have refactored them,.

X_inner_types also had np.array tag, and also was listed for "forecaster" only, when in truth this tag is used in all collection estimators


aeon-actions-bot[bot]: 
## Thank you for contributing to `aeon`!

I have added the following labels to this PR based on the title: **[ $\\color{#d73a4a}{\\textsf{bug}}$ ]**.
This PR changes too many different packages (>3) for automatic addition of labels, please manually add package labels if relevant.

The [Checks](https://github.com/aeon-toolkit/aeon/pull/1014/checks) tab will show the status of our automated tests. You can click on individual test runs in the tab or "Details" in the panel below to see more information if there is a failure.

If our `pre-commit` code quality check fails, any trivial fixes will automatically be pushed to your PR unless it is a draft.

Don't hesitate to ask questions on the `aeon` [Slack](https://join.slack.com/t/aeon-toolkit/shared_invite/zt-22vwvut29-HDpCu~7VBUozyfL_8j3dLA) channel if you have any!
    

Patch:
diff --git a/aeon/classification/_delegate.py b/aeon/classification/_delegate.py
index 1211ea73..bcdb58ee 100644
--- a/aeon/classification/_delegate.py
+++ b/aeon/classification/_delegate.py
@@ -56,7 +56,7 @@ class _DelegatedClassifier(BaseClassifier):
             of shape ``[n_instances]``, 2D np.array ``(n_channels, n_timepoints_i)``,
             where ``n_timepoints_i`` is length of series ``i``. Other types are
             allowed and converted into one of the above.
-        y: np.array
+        y: np.ndarray
             shape ``(n_instances)`` - class labels for fitting indices correspond to
             instance indices in X.
 
@@ -81,7 +81,7 @@ class _DelegatedClassifier(BaseClassifier):
 
         Parameters
         ----------
-        X : 3D np.ndarray
+        X : np.ndarray
             Input data, any number of channels, equal length series of shape ``(
             n_instances, n_channels, n_timepoints)``
             or 2D np.array (univariate, equal length series) of shape
@@ -93,8 +93,9 @@ class _DelegatedClassifier(BaseClassifier):
 
         Returns
         -------
-        y : 1D np.array of int, of shape [n_instances] - predicted class labels
-            indices correspond to instance indices in X
+        np.array
+            1D of int, of shape [n_instances] - predicted class labels indices
+            correspond to instance indices in X.
         """
         estimator = self._get_delegate()
         return estimator.predict(X=X)
@@ -112,7 +113,7 @@ class _DelegatedClassifier(BaseClassifier):
 
         Parameters
         ----------
-        X : 3D np.ndarray
+        X : np.ndarray
             Input data, any number of channels, equal length series of shape ``(
             n_instances, n_channels, n_timepoints)``
             or 2D np.array (univariate, equal length series) of shape
@@ -124,7 +125,8 @@ class _DelegatedClassifier(BaseClassifier):
 
         Returns
         -------
-        y : 2D array of shape [n_instances, n_classes] - predicted class probabilities
+        np.ndarray
+            2D array of shape [n_instances, n_classes] - predicted class probabilities
             1st dimension indices correspond to instance indices in X
             2nd dimension indices correspond to possible labels (integers)
             (i, j)-th entry is predictive probability that i-th instance is of class j
diff --git a/aeon/classification/_dummy.py b/aeon/classification/_dummy.py
index 0c7d9d95..a93cf7a4 100644
--- a/aeon/classification/_dummy.py
+++ b/aeon/classification/_dummy.py
@@ -83,8 +83,10 @@ class DummyClassifier(BaseClassifier):
 
         Parameters
         ----------
-        X : 3D np.ndarray of shape = [n_instances, n_channels, series_length]
-        y : array-like, shape = [n_instances] - the class labels
+        X : np.ndarray
+            training data shape ``(n_instances, n_channels, series_length)``
+        y : np.ndarray
+            class labels, shape ``(n_instances)`` - the class labels
 
         Returns
         -------
diff --git a/aeon/classification/base.py b/aeon/classification/base.py
index e0dfafaf..402b1abb 100644
--- a/aeon/classification/base.py
+++ b/aeon/classification/base.py
@@ -118,7 +118,7 @@ class BaseClassifier(BaseCollectionEstimator, ABC):
 
         Parameters
         ----------
-        X : 3D np.ndarray
+        X : np.ndarray
             Input data, any number of channels, equal length series of shape ``(
             n_instances, n_channels, n_timepoints)``
             or 2D np.array (univariate, equal length series) of shape
@@ -127,7 +127,7 @@ class BaseClassifier(BaseCollectionEstimator, ABC):
             of shape ``[n_instances]``, 2D np.array ``(n_channels, n_timepoints_i)``,
             where ``n_timepoints_i`` is length of series ``i``. Other types are
             allowed and converted into one of the above.
-        y : np.array
+        np.ndarray
             shape ``(n_instances)`` - class labels for fitting indices correspond to
             instance indices in X.
 
@@ -165,7 +165,7 @@ class BaseClassifier(BaseCollectionEstimator, ABC):
 
         Parameters
         ----------
-        X : 3D np.ndarray
+        X : np.ndarray
             Input data, any number of channels, equal length series of shape ``(
             n_instances, n_channels, n_timepoints)``
             or 2D np.array (univariate, equal length series) of shape
@@ -177,7 +177,7 @@ class BaseClassifier(BaseCollectionEstimator, ABC):
 
         Returns
         -------
-        np.array
+        np.ndarray
             shape ``[n_instances]`` - predicted class labels indices correspond to
             instance indices in X
         """
@@ -195,7 +195,7 @@ class BaseClassifier(BaseCollectionEstimator, ABC):
 
         Parameters
         ----------
-        X : 3D np.ndarray
+        X : np.ndarray
             Input data, any number of channels, equal length series of shape ``(
             n_instances, n_channels, n_timepoints)``
             or 2D np.array (univariate, equal length series) of shape
@@ -227,15 +227,17 @@ class BaseClassifier(BaseCollectionEstimator, ABC):
 
         Parameters
         ----------
-        X : 3D np.ndarray (any number of channels, equal length series)
-                of shape (n_instances, n_channels, n_timepoints)
-            or 2D np.array (univariate, equal length series)
-                of shape (n_instances, n_timepoints)
+        X : np.ndarray
+            Input data, any number of channels, equal length series of shape ``(
+            n_instances, n_channels, n_timepoints)``
+            or 2D np.array (univariate, equal length series) of shape
+            ``(n_instances, n_timepoints)``
             or list of numpy arrays (any number of channels, unequal length series)
-                of shape [n_instances], 2D np.array (n_channels, n_timepoints_i), where
-                n_timepoints_i is length of series i.
-            other types are allowed and converted into one of the above.
-        y : 1D np.ndarray of shape [n_instances] - class labels (ground truth)
+            of shape ``[n_instances]``, 2D np.array ``(n_channels, n_timepoints_i)``,
+            where ``n_timepoints_i`` is length of series ``i``. other types are
+            allowed and converted into one of the above.
+        y : np.ndarray
+            array shape ``(n_instances)`` - class labels (ground truth)
             indices correspond to instance indices in X.
 
         Returns
@@ -277,12 +279,14 @@ class BaseClassifier(BaseCollectionEstimator, ABC):
 
         Parameters
         ----------
-        X : guaranteed to be of a type in self.get_tag("X_inner_type")
-            if self.get_tag("X_inner_type") = "numpy3D":
-                3D np.ndarray of shape = (n_instances, n_channels, n_timepoints)
-            if self.get_tag("X_inner_type") = "np-list":
-                list of 2D np.ndarray of shape = [n_instances]
-        y : 1D np.array of int, of shape (n_instances,) - class labels for fitting
+        X : Train data
+            guaranteed to be of a type in self.get_tag("X_inner_type")
+            if ``self.get_tag("X_inner_type")`` equals "numpy3D":
+                3D np.ndarray of shape ``(n_instances, n_channels, n_timepoints)``
+            if ``self.get_tag("X_inner_type")`` equals "np-list":
+                list of 2D np.ndarray of shape ``(n_instances)``
+        y : np.array
+            1D of int, of shape ``(n_instances,)`` - class labels for fitting
             indices correspond to instance indices in X
 
         Returns
@@ -305,11 +309,12 @@ class BaseClassifier(BaseCollectionEstimator, ABC):
 
         Parameters
         ----------
-        X : guaranteed to be of a type in self.get_tag("X_inner_type")
-            if self.get_tag("X_inner_type") = "numpy3D":
-                3D np.ndarray of shape = (n_instances, n_channels, n_timepoints)
-            if self.get_tag("X_inner_type") = "np-list":
-                list of 2D np.ndarray of length = [n_instances]
+        X : Train data
+            guaranteed to be of a type in self.get_tag("X_inner_type")
+            if ``self.get_tag("X_inner_type")`` equals "numpy3D":
+                3D np.ndarray of shape ``(n_instances, n_channels, n_timepoints)``
+            if ``self.get_tag("X_inner_type")`` equals "np-list":
+                list of 2D np.ndarray of shape ``(n_instances)``
 
         Returns
         -------
@@ -327,11 +332,12 @@ class BaseClassifier(BaseCollectionEstimator, ABC):
 
         Parameters
         ----------
-        X : guaranteed to be of a type in self.get_tag("X_inner_type")
-            if self.get_tag("X_inner_type") = "numpy3D":
-                3D np.ndarray of shape = (n_instances, n_channels, n_timepoints)
-            if self.get_tag("X_inner_type") = "np-list":
-                list of 2D np.ndarray of shape = (n_instances,)
+        X : Train data
+            guaranteed to be of a type in self.get_tag("X_inner_type")
+            if ``self.get_tag("X_inner_type")`` equals "numpy3D":
+                3D np.ndarray of shape ``(n_instances, n_channels, n_timepoints)``
+            if ``self.get_tag("X_inner_type")`` equals "np-list":
+                list of 2D np.ndarray of shape ``(n_instances)``
 
         Returns
         -------
diff --git a/aeon/datasets/_data_generators.py b/aeon/datasets/_data_generators.py
index 96e80895..07674fa4 100644
--- a/aeon/datasets/_data_generators.py
+++ b/aeon/datasets/_data_generators.py
@@ -229,7 +229,7 @@ def _convert_tsf_to_hierarchical(
     Returns
     -------
     pd.DataFrame
-        aeon pd_multiindex_hier mtype
+        hierarchical multiindex pd.Dataframe
     """
     df = data.copy()
 
diff --git a/aeon/datasets/_data_loaders.py b/aeon/datasets/_data_loaders.py
index 6656842c..33b796ca 100644
--- a/aeon/datasets/_data_loaders.py
+++ b/aeon/datasets/_data_loaders.py
@@ -672,7 +672,7 @@ def _convert_tsf_to_hierarchical(
     Returns
     -------
     pd.DataFrame
-        aeon pd_multiindex_hier mtype
+        hierarchical multiindex pd.Dataframe
     """
     df = data.copy()
 
diff --git a/aeon/datatypes/__init__.py b/aeon/datatypes/__init__.py
index 3bbb9f4d..1c7f18a1 100644
--- a/aeon/datatypes/__init__.py
+++ b/aeon/datatypes/__init__.py
@@ -12,15 +12,15 @@ from aeon.datatypes._check import (
 from aeon.datatypes._convert import convert, convert_to
 from aeon.datatypes._examples import get_examples
 from aeon.datatypes._registry import (
-    ALL_TIME_SERIES_MTYPES,
+    ALL_TIME_SERIES_TYPES,
     DATATYPE_REGISTER,
-    MTYPE_LIST_HIERARCHICAL,
-    MTYPE_LIST_PANEL,
-    MTYPE_LIST_PROBA,
-    MTYPE_LIST_SERIES,
-    MTYPE_LIST_TABLE,
-    MTYPE_REGISTER,
     SCITYPE_LIST,
+    TYPE_LIST_HIERARCHICAL,
+    TYPE_LIST_PANEL,
+    TYPE_LIST_PROBA,
+    TYPE_LIST_SERIES,
+    TYPE_LIST_TABLE,
+    TYPE_REGISTER,
     mtype_to_scitype,
     scitype_to_mtype,
 )
@@ -28,7 +28,7 @@ from aeon.datatypes._utilities import get_cutoff, update_data
 from aeon.datatypes._vectorize import VectorizedDF
 
 __all__ = [
-    "ALL_TIME_SERIES_MTYPES",
+    "ALL_TIME_SERIES_TYPES",
     "check_is_mtype",
     "check_is_scitype",
     "check_raise",
@@ -38,12 +38,12 @@ __all__ = [
     "get_cutoff",
     "get_examples",
     "mtype_to_scitype",
-    "MTYPE_REGISTER",
-    "MTYPE_LIST_HIERARCHICAL",
-    "MTYPE_LIST_PANEL",
-    "MTYPE_LIST_PROBA",
-    "MTYPE_LIST_SERIES",
-    "MTYPE_LIST_TABLE",
+    "TYPE_REGISTER",
+    "TYPE_LIST_HIERARCHICAL",
+    "TYPE_LIST_PANEL",
+    "TYPE_LIST_PROBA",
+    "TYPE_LIST_SERIES",
+    "TYPE_LIST_TABLE",
     "scitype",
     "scitype_to_mtype",
     "SCITYPE_LIST",
diff --git a/aeon/datatypes/_check.py b/aeon/datatypes/_check.py
index 9ff98b61..cb892a11 100644
--- a/aeon/datatypes/_check.py
+++ b/aeon/datatypes/_check.py
@@ -102,7 +102,7 @@ def check_is_mtype(
     ----------
     obj - object to check
     mtype: str or list of str, mtype to check obj as
-        valid mtype strings are in datatypes.MTYPE_REGISTER (1st column)
+        valid mtype strings are in datatypes.TYPE_REGISTER (1st column)
     scitype: str, optional, scitype to check obj as; default = inferred from mtype
         if inferred from mtype, list elements of mtype need not have same scitype
         valid mtype strings are in datatypes.DATATYPE_REGISTER (1st column)
@@ -212,7 +212,7 @@ def check_raise(obj, mtype: str, scitype: str = None, var_name: str = "input"):
     ----------
     obj - object to check
     mtype: str or list of str, mtype to check obj as
-        valid mtype strings are in datatypes.MTYPE_REGISTER (1st column)
+        valid mtype strings are in datatypes.TYPE_REGISTER (1st column)
     scitype: str, optional, scitype to check obj as; default = inferred from mtype
         if inferred from mtype, list elements of mtype need not have same scitype
         valid mtype strings are in datatypes.DATATYPE_REGISTER (1st column)
@@ -268,7 +268,7 @@ def mtype(
     -------
     str - the inferred mtype of "obj", a valid mtype string
             or None, if obj is None
-        mtype strings with explanation are in datatypes.MTYPE_REGISTER
+        mtype strings with explanation are in datatypes.TYPE_REGISTER
 
     Raises
     ------
@@ -363,7 +363,7 @@ def check_is_scitype(
         Fields depend on scitpe.
         Always returned:
             "mtype": str, mtype of obj (assumed or inferred)
-                mtype strings with explanation are in datatypes.MTYPE_REGISTER
+                mtype strings with explanation are in datatypes.TYPE_REGISTER
             "scitype": str, scitype of obj (assumed or inferred)
                 scitype strings with explanation are in datatypes.DATATYPE_REGISTER
         For scitype "Series":
@@ -451,7 +451,7 @@ def scitype(obj, candidate_scitypes=SCITYPE_LIST, exclude_mtypes=AMBIGUOUS_MTYPE
         valid scitype strings are in datatypes.DATATYPE_REGISTER
     exclude_mtypes : list of str, default = AMBIGUOUS_MTYPES
         which mtypes to ignore in inferring mtype, default = ambiguous ones
-        valid mtype strings are in datatypes.MTYPE_REGISTER
+        valid mtype strings are in datatypes.TYPE_REGISTER
 
     Returns
     -------
diff --git a/aeon/datatypes/_convert.py b/aeon/datatypes/_convert.py
index 6e01da5f..7f9cc916 100644
--- a/aeon/datatypes/_convert.py
+++ b/aeon/datatypes/_convert.py
@@ -99,9 +99,9 @@ def convert(
     ----------
     obj : object to convert - any type, should comply with mtype spec for as_scitype
     from_type : str - the type to convert "obj" to, a valid mtype string
-        valid mtype strings, with explanation, are in datatypes.MTYPE_REGISTER
+        valid mtype strings, with explanation, are in datatypes.TYPE_REGISTER
     to_type : str - the type to convert "obj" to, a valid mtype string
-        valid mtype strings, with explanation, are in datatypes.MTYPE_REGISTER
+        valid mtype strings, with explanation, are in datatypes.TYPE_REGISTER
     as_scitype : str, optional - name of scitype the object "obj" is considered as
         default = inferred from from_type
         valid scitype strings, with explanation, are in datatypes.DATATYPE_REGISTER
@@ -189,7 +189,7 @@ def convert_to(
     obj : object to convert - any type, should comply with mtype spec for as_scitype
     to_type : str - the type to convert "obj" to, a valid mtype string
             or list of str, this specifies admissible types for conversion to
-        valid mtype strings, with explanation, are in datatypes.MTYPE_REGISTER
+        valid mtype strings, with explanation, are in datatypes.TYPE_REGISTER
     as_scitype : str, optional - name of scitype the object "obj" is considered as
         pre-specifying the scitype reduces the number of checks done in type inference
         valid scitype strings, with explanation, are in datatypes.DATATYPE_REGISTER
diff --git a/aeon/datatypes/_examples.py b/aeon/datatypes/_examples.py
index 396c262f..2ffa2ebc 100644
--- a/aeon/datatypes/_examples.py
+++ b/aeon/datatypes/_examples.py
@@ -80,7 +80,7 @@ def get_examples(
     Parameters
     ----------
     mtype: str - name of the mtype for the example, a valid mtype string
-        valid mtype strings, with explanation, are in datatypes.MTYPE_REGISTER
+        valid mtype strings, with explanation, are in datatypes.TYPE_REGISTER
     as_scitype : str, optional - name of scitype of the example, a valid scitype string
         valid scitype strings, with explanation, are in datatypes.DATATYPE_REGISTER
         default = inferred from mtype of obj
diff --git a/aeon/datatypes/_hierarchical/__init__.py b/aeon/datatypes/_hierarchical/__init__.py
index 3a4abcfe..e904e165 100644
--- a/aeon/datatypes/_hierarchical/__init__.py
+++ b/aeon/datatypes/_hierarchical/__init__.py
@@ -14,16 +14,16 @@ from aeon.datatypes._hierarchical._examples import (
     example_dict_metadata as example_dict_metadata_Hierarchical,
 )
 from aeon.datatypes._hierarchical._registry import (
-    MTYPE_LIST_HIERARCHICAL,
-    MTYPE_REGISTER_HIERARCHICAL,
+    TYPE_LIST_HIERARCHICAL,
+    TYPE_REGISTER_HIERARCHICAL,
 )
 
 __all__ = [
     "check_dict_Hierarchical",
     "convert_dict_Hierarchical",
     "infer_mtype_dict_Hierarchical",
-    "MTYPE_LIST_HIERARCHICAL",
-    "MTYPE_REGISTER_HIERARCHICAL",
+    "TYPE_LIST_HIERARCHICAL",
+    "TYPE_REGISTER_HIERARCHICAL",
     "example_dict_Hierarchical",
     "example_dict_lossy_Hierarchical",
     "example_dict_metadata_Hierarchical",
diff --git a/aeon/datatypes/_hierarchical/_convert.py b/aeon/datatypes/_hierarchical/_convert.py
index ae5a033e..aeca8bca 100644
--- a/aeon/datatypes/_hierarchical/_convert.py
+++ b/aeon/datatypes/_hierarchical/_convert.py
@@ -3,7 +3,7 @@ __all__ = [
 ]
 
 from aeon.datatypes._convert_utils._convert import _extend_conversions
-from aeon.datatypes._hierarchical._registry import MTYPE_LIST_HIERARCHICAL
+from aeon.datatypes._hierarchical._registry import TYPE_LIST_HIERARCHICAL
 from aeon.utils.validation._dependencies import _check_soft_dependencies
 
 # dictionary indexed by triples of types
@@ -20,7 +20,7 @@ def convert_identity(obj, store=None):
 
 
 # assign identity function to type conversion to self
-for tp in MTYPE_LIST_HIERARCHICAL:
+for tp in TYPE_LIST_HIERARCHICAL:
     convert_dict[(tp, tp, "Hierarchical")] = convert_identity
 
 
@@ -48,5 +48,5 @@ if _check_soft_dependencies("dask", severity="none"):
         "dask_hierarchical",
         "pd_multiindex_hier",
         convert_dict,
-        mtype_universe=MTYPE_LIST_HIERARCHICAL,
+        mtype_universe=TYPE_LIST_HIERARCHICAL,
     )
diff --git a/aeon/datatypes/_hierarchical/_registry.py b/aeon/datatypes/_hierarchical/_registry.py
index 32087bfa..e3a2918d 100644
--- a/aeon/datatypes/_hierarchical/_registry.py
+++ b/aeon/datatypes/_hierarchical/_registry.py
@@ -3,13 +3,13 @@
 import pandas as pd
 
 __all__ = [
-    "MTYPE_REGISTER_HIERARCHICAL",
-    "MTYPE_LIST_HIERARCHICAL",
-    "MTYPE_SOFT_DEPS_HIERARCHICAL",
+    "TYPE_REGISTER_HIERARCHICAL",
+    "TYPE_LIST_HIERARCHICAL",
+    "TYPE_SOFT_DEPS_HIERARCHICAL",
 ]
 
 
-MTYPE_REGISTER_HIERARCHICAL = [
+TYPE_REGISTER_HIERARCHICAL = [
     (
         "pd_multiindex_hier",
         "Hierarchical",
@@ -22,6 +22,6 @@ MTYPE_REGISTER_HIERARCHICAL = [
     ),
 ]
 
-MTYPE_SOFT_DEPS_HIERARCHICAL = {"dask_hierarchical": "dask"}
+TYPE_SOFT_DEPS_HIERARCHICAL = {"dask_hierarchical": "dask"}
 
-MTYPE_LIST_HIERARCHICAL = pd.DataFrame(MTYPE_REGISTER_HIERARCHICAL)[0].values
+TYPE_LIST_HIERARCHICAL = pd.DataFrame(TYPE_REGISTER_HIERARCHICAL)[0].values
diff --git a/aeon/datatypes/_panel/__init__.py b/aeon/datatypes/_panel/__init__.py
index 00c7e98a..0231e929 100644
--- a/aeon/datatypes/_panel/__init__.py
+++ b/aeon/datatypes/_panel/__init__.py
@@ -9,14 +9,14 @@ from aeon.datatypes._panel._examples import (
 from aeon.datatypes._panel._examples import (
     example_dict_metadata as example_dict_metadata_Panel,
 )
-from aeon.datatypes._panel._registry import MTYPE_LIST_PANEL, MTYPE_REGISTER_PANEL
+from aeon.datatypes._panel._registry import TYPE_LIST_PANEL, TYPE_REGISTER_PANEL
 
 __all__ = [
     "check_dict_Panel",
     "convert_dict_Panel",
     "infer_mtype_dict_Panel",
-    "MTYPE_LIST_PANEL",
-    "MTYPE_REGISTER_PANEL",
+    "TYPE_LIST_PANEL",
+    "TYPE_REGISTER_PANEL",
     "example_dict_Panel",
     "example_dict_lossy_Panel",
     "example_dict_metadata_Panel",
diff --git a/aeon/datatypes/_panel/_convert.py b/aeon/datatypes/_panel/_convert.py
index fadfeecf..f9998f2d 100644
--- a/aeon/datatypes/_panel/_convert.py
+++ b/aeon/datatypes/_panel/_convert.py
@@ -34,7 +34,7 @@ __all__ = [
 ]
 
 from aeon.datatypes._convert_utils._convert import _extend_conversions
-from aeon.datatypes._panel._registry import MTYPE_LIST_PANEL
+from aeon.datatypes._panel._registry import TYPE_LIST_PANEL
 from aeon.utils.validation._dependencies import _check_soft_dependencies
 
 # dictionary indexed by triples of types
@@ -51,7 +51,7 @@ def convert_identity(obj, store=None):
 
 
 # assign identity function to type conversion to self
-for tp in MTYPE_LIST_PANEL:
+for tp in TYPE_LIST_PANEL:
     convert_dict[(tp, tp, "Panel")] = convert_identity
 
 
@@ -1091,7 +1091,7 @@ def from_numpy2d_to_numpy3d(obj, store=None):
 
 convert_dict[("numpy2D", "numpy3D", "Panel")] = from_numpy2d_to_numpy3d
 
-_extend_conversions("numpy2D", "numpy3D", convert_dict, mtype_universe=MTYPE_LIST_PANEL)
+_extend_conversions("numpy2D", "numpy3D", convert_dict, mtype_universe=TYPE_LIST_PANEL)
 
 
 if _check_soft_dependencies("dask", severity="none"):
@@ -1111,5 +1111,5 @@ if _check_soft_dependencies("dask", severity="none"):
     convert_dict[("pd-multiindex", "dask_panel", "Panel")] = convert_pd_to_dask_as_panel
 
     _extend_conversions(
-        "dask_panel", "pd-multiindex", convert_dict, mtype_universe=MTYPE_LIST_PANEL
+        "dask_panel", "pd-multiindex", convert_dict, mtype_universe=TYPE_LIST_PANEL
     )
diff --git a/aeon/datatypes/_panel/_registry.py b/aeon/datatypes/_panel/_registry.py
index 9daee2de..e7f1b5dd 100644
--- a/aeon/datatypes/_panel/_registry.py
+++ b/aeon/datatypes/_panel/_registry.py
@@ -3,13 +3,13 @@
 import pandas as pd
 
 __all__ = [
-    "MTYPE_REGISTER_PANEL",
-    "MTYPE_LIST_PANEL",
-    "MTYPE_SOFT_DEPS_PANEL",
+    "TYPE_REGISTER_PANEL",
+    "TYPE_LIST_PANEL",
+    "TYPE_SOFT_DEPS_PANEL",
 ]
 
 
-MTYPE_REGISTER_PANEL = [
+TYPE_REGISTER_PANEL = [
     (
         "nested_univ",
         "Panel",
@@ -46,6 +46,6 @@ MTYPE_REGISTER_PANEL = [
     ),
 ]
 
-MTYPE_SOFT_DEPS_PANEL = {"xr.DataArray": "xarray", "dask_panel": "dask"}
+TYPE_SOFT_DEPS_PANEL = {"xr.DataArray": "xarray", "dask_panel": "dask"}
 
-MTYPE_LIST_PANEL = pd.DataFrame(MTYPE_REGISTER_PANEL)[0].values
+TYPE_LIST_PANEL = pd.DataFrame(TYPE_REGISTER_PANEL)[0].values
diff --git a/aeon/datatypes/_proba/__init__.py b/aeon/datatypes/_proba/__init__.py
index 6f3fee02..f612c31d 100644
--- a/aeon/datatypes/_proba/__init__.py
+++ b/aeon/datatypes/_proba/__init__.py
@@ -9,13 +9,13 @@ from aeon.datatypes._proba._examples import (
 from aeon.datatypes._proba._examples import (
     example_dict_metadata as example_dict_metadata_Proba,
 )
-from aeon.datatypes._proba._registry import MTYPE_LIST_PROBA, MTYPE_REGISTER_PROBA
+from aeon.datatypes._proba._registry import TYPE_LIST_PROBA, TYPE_REGISTER_PROBA
 
 __all__ = [
     "check_dict_Proba",
     "convert_dict_Proba",
-    "MTYPE_LIST_PROBA",
-    "MTYPE_REGISTER_PROBA",
+    "TYPE_LIST_PROBA",
+    "TYPE_REGISTER_PROBA",
     "example_dict_Proba",
     "example_dict_lossy_Proba",
     "example_dict_metadata_Proba",
diff --git a/aeon/datatypes/_proba/_convert.py b/aeon/datatypes/_proba/_convert.py
index b9b29466..9ab4d7b8 100644
--- a/aeon/datatypes/_proba/_convert.py
+++ b/aeon/datatypes/_proba/_convert.py
@@ -33,7 +33,7 @@ __all__ = ["convert_dict"]
 import numpy as np
 import pandas as pd
 
-from aeon.datatypes._proba._registry import MTYPE_LIST_PROBA
+from aeon.datatypes._proba._registry import TYPE_LIST_PROBA
 
 ##############################################################
 # methods to convert one machine type to another machine type
@@ -47,7 +47,7 @@ def convert_identity(obj, store=None):
 
 
 # assign identity function to type conversion to self
-for tp in MTYPE_LIST_PROBA:
+for tp in TYPE_LIST_PROBA:
     convert_dict[(tp, tp, "Proba")] = convert_identity
 
 
diff --git a/aeon/datatypes/_proba/_registry.py b/aeon/datatypes/_proba/_registry.py
index fd46445c..ab1ce42d 100644
--- a/aeon/datatypes/_proba/_registry.py
+++ b/aeon/datatypes/_proba/_registry.py
@@ -1,16 +1,16 @@
 import pandas as pd
 
 __all__ = [
-    "MTYPE_REGISTER_PROBA",
-    "MTYPE_LIST_PROBA",
+    "TYPE_REGISTER_PROBA",
+    "TYPE_LIST_PROBA",
 ]
 
 
-MTYPE_REGISTER_PROBA = [
+TYPE_REGISTER_PROBA = [
     ("pred_interval", "Proba", "predictive intervals"),
     ("pred_quantiles", "Proba", "quantile predictions"),
     ("pred_var", "Proba", "variance predictions"),
     # ("pred_dost", "Proba", "full distribution predictions, tensorflow-probability"),
 ]
 
-MTYPE_LIST_PROBA = pd.DataFrame(MTYPE_REGISTER_PROBA)[0].values
+TYPE_LIST_PROBA = pd.DataFrame(TYPE_REGISTER_PROBA)[0].values
diff --git a/aeon/datatypes/_registry.py b/aeon/datatypes/_registry.py
index ffbd2767..fedde3fe 100644
--- a/aeon/datatypes/_registry.py
+++ b/aeon/datatypes/_registry.py
@@ -16,7 +16,7 @@ each tuple corresponds to an mtype tag, elements as follows:
 
 ---
 
-MTYPE_REGISTER - list of tuples
+TYPE_REGISTER - list of tuples
 
 each tuple corresponds to an mtype, elements as follows:
     0 : string - name of the mtype as used throughout aeon and in datatypes
@@ -38,53 +38,53 @@ mtype_to_scitype(mtype: str) - convenience function that returns scitype for an
 """
 
 from aeon.datatypes._hierarchical._registry import (
-    MTYPE_LIST_HIERARCHICAL,
-    MTYPE_REGISTER_HIERARCHICAL,
-    MTYPE_SOFT_DEPS_HIERARCHICAL,
+    TYPE_LIST_HIERARCHICAL,
+    TYPE_REGISTER_HIERARCHICAL,
+    TYPE_SOFT_DEPS_HIERARCHICAL,
 )
 from aeon.datatypes._panel._registry import (
-    MTYPE_LIST_PANEL,
-    MTYPE_REGISTER_PANEL,
-    MTYPE_SOFT_DEPS_PANEL,
+    TYPE_LIST_PANEL,
+    TYPE_REGISTER_PANEL,
+    TYPE_SOFT_DEPS_PANEL,
 )
-from aeon.datatypes._proba._registry import MTYPE_LIST_PROBA, MTYPE_REGISTER_PROBA
+from aeon.datatypes._proba._registry import TYPE_LIST_PROBA, TYPE_REGISTER_PROBA
 from aeon.datatypes._series._registry import (
-    MTYPE_LIST_SERIES,
-    MTYPE_REGISTER_SERIES,
     MTYPE_SOFT_DEPS_SERIES,
+    TYPE_LIST_SERIES,
+    TYPE_REGISTER_SERIES,
 )
-from aeon.datatypes._table._registry import MTYPE_LIST_TABLE, MTYPE_REGISTER_TABLE
+from aeon.datatypes._table._registry import TYPE_LIST_TABLE, TYPE_REGISTER_TABLE
 
-MTYPE_REGISTER = []
-MTYPE_REGISTER += MTYPE_REGISTER_SERIES
-MTYPE_REGISTER += MTYPE_REGISTER_PANEL
-MTYPE_REGISTER += MTYPE_REGISTER_HIERARCHICAL
-MTYPE_REGISTER += MTYPE_REGISTER_TABLE
-MTYPE_REGISTER += MTYPE_REGISTER_PROBA
+TYPE_REGISTER = []
+TYPE_REGISTER += TYPE_REGISTER_SERIES
+TYPE_REGISTER += TYPE_REGISTER_PANEL
+TYPE_REGISTER += TYPE_REGISTER_HIERARCHICAL
+TYPE_REGISTER += TYPE_REGISTER_TABLE
+TYPE_REGISTER += TYPE_REGISTER_PROBA
 
 MTYPE_SOFT_DEPS = {}
 MTYPE_SOFT_DEPS.update(MTYPE_SOFT_DEPS_SERIES)
-MTYPE_SOFT_DEPS.update(MTYPE_SOFT_DEPS_PANEL)
-MTYPE_SOFT_DEPS.update(MTYPE_SOFT_DEPS_HIERARCHICAL)
+MTYPE_SOFT_DEPS.update(TYPE_SOFT_DEPS_PANEL)
+MTYPE_SOFT_DEPS.update(TYPE_SOFT_DEPS_HIERARCHICAL)
 
 
 # mtypes to exclude in checking since they are ambiguous and rare
 AMBIGUOUS_MTYPES = ["numpy2D"]
 
 # all time series mtypes excluding ambiguous ones
-ALL_TIME_SERIES_MTYPES = (
-    list(MTYPE_LIST_PANEL) + list(MTYPE_LIST_SERIES) + list(MTYPE_LIST_HIERARCHICAL)
+ALL_TIME_SERIES_TYPES = (
+    list(TYPE_LIST_PANEL) + list(TYPE_LIST_SERIES) + list(TYPE_LIST_HIERARCHICAL)
 )
-ALL_TIME_SERIES_MTYPES = list(set(ALL_TIME_SERIES_MTYPES).difference(AMBIGUOUS_MTYPES))
+ALL_TIME_SERIES_TYPES = list(set(ALL_TIME_SERIES_TYPES).difference(AMBIGUOUS_MTYPES))
 
 
 __all__ = [
-    "MTYPE_REGISTER",
-    "MTYPE_LIST_HIERARCHICAL",
-    "MTYPE_LIST_PANEL",
-    "MTYPE_LIST_SERIES",
-    "MTYPE_LIST_TABLE",
-    "MTYPE_LIST_PROBA",
+    "TYPE_REGISTER",
+    "TYPE_LIST_HIERARCHICAL",
+    "TYPE_LIST_PANEL",
+    "TYPE_LIST_SERIES",
+    "TYPE_LIST_TABLE",
+    "TYPE_LIST_PROBA",
     "MTYPE_SOFT_DEPS",
     "DATATYPE_REGISTER",
 ]
@@ -108,7 +108,7 @@ def mtype_to_scitype(mtype: str, return_unique=False, coerce_to_list=False):
     ----------
     mtype : str, or list of str, or nested list/str object, or None
         mtype(s) to find scitype of, a valid mtype string
-        valid mtype strings, with explanation, are in datatypes.MTYPE_REGISTER
+        valid mtype strings, with explanation, are in datatypes.TYPE_REGISTER
 
     Returns
     -------
@@ -145,7 +145,7 @@ def mtype_to_scitype(mtype: str, return_unique=False, coerce_to_list=False):
             "mtype must be str, or list of str, nested list/str object, or None"
         )
 
-    scitype = [k[1] for k in MTYPE_REGISTER if k[0] == mtype]
+    scitype = [k[1] for k in TYPE_REGISTER if k[0] == mtype]
 
     if len(scitype) > 1:
         raise ValueError("multiple scitypes match the mtype, specify scitype")
@@ -207,7 +207,7 @@ def scitype_to_mtype(scitype: str, softdeps: str = "exclude"):
             f'"{scitype}" is not a valid type string, see datatypes.DATATYPE_REGISTER'
         )
 
-    mtypes = [k[0] for k in MTYPE_REGISTER if k[1] == scitype]
+    mtypes = [k[0] for k in TYPE_REGISTER if k[1] == scitype]
 
     if len(mtypes) == 0:
         # if there are no mtypes, this must have been reached by mistake/bug
diff --git a/aeon/datatypes/_series/__init__.py b/aeon/datatypes/_series/__init__.py
index 4f2871b6..415acac5 100644
--- a/aeon/datatypes/_series/__init__.py
+++ b/aeon/datatypes/_series/__init__.py
@@ -9,13 +9,13 @@ from aeon.datatypes._series._examples import (
 from aeon.datatypes._series._examples import (
     example_dict_metadata as example_dict_metadata_Series,
 )
-from aeon.datatypes._series._registry import MTYPE_LIST_SERIES, MTYPE_REGISTER_SERIES
+from aeon.datatypes._series._registry import TYPE_LIST_SERIES, TYPE_REGISTER_SERIES
 
 __all__ = [
     "check_dict_Series",
     "convert_dict_Series",
-    "MTYPE_LIST_SERIES",
-    "MTYPE_REGISTER_SERIES",
+    "TYPE_LIST_SERIES",
+    "TYPE_REGISTER_SERIES",
     "example_dict_Series",
     "example_dict_lossy_Series",
     "example_dict_metadata_Series",
diff --git a/aeon/datatypes/_series/_convert.py b/aeon/datatypes/_series/_convert.py
index 38d6f514..2b3396f9 100644
--- a/aeon/datatypes/_series/_convert.py
+++ b/aeon/datatypes/_series/_convert.py
@@ -37,7 +37,7 @@ import pandas as pd
 # methods to convert one machine type to another machine type
 ##############################################################
 from aeon.datatypes._convert_utils._convert import _extend_conversions
-from aeon.datatypes._registry import MTYPE_LIST_SERIES
+from aeon.datatypes._registry import TYPE_LIST_SERIES
 from aeon.utils.validation._dependencies import _check_soft_dependencies
 
 convert_dict = dict()
@@ -48,7 +48,7 @@ def convert_identity(obj, store=None):
 
 
 # assign identity function to type conversion to self
-for tp in MTYPE_LIST_SERIES:
+for tp in TYPE_LIST_SERIES:
     convert_dict[(tp, tp, "Series")] = convert_identity
 
 
@@ -207,7 +207,7 @@ if _check_soft_dependencies("xarray", severity="none"):
     ] = convert_Mvs_to_xrdatarray_as_Series
 
     _extend_conversions(
-        "xr.DataArray", "pd.DataFrame", convert_dict, mtype_universe=MTYPE_LIST_SERIES
+        "xr.DataArray", "pd.DataFrame", convert_dict, mtype_universe=TYPE_LIST_SERIES
     )
 
 
@@ -232,5 +232,5 @@ if _check_soft_dependencies("dask", severity="none"):
     ] = convert_mvs_to_dask_as_series
 
     _extend_conversions(
-        "dask_series", "pd.DataFrame", convert_dict, mtype_universe=MTYPE_LIST_SERIES
+        "dask_series", "pd.DataFrame", convert_dict, mtype_universe=TYPE_LIST_SERIES
     )
diff --git a/aeon/datatypes/_series/_registry.py b/aeon/datatypes/_series/_registry.py
index a4c43ce4..22d85935 100644
--- a/aeon/datatypes/_series/_registry.py
+++ b/aeon/datatypes/_series/_registry.py
@@ -3,13 +3,13 @@
 import pandas as pd
 
 __all__ = [
-    "MTYPE_REGISTER_SERIES",
-    "MTYPE_LIST_SERIES",
+    "TYPE_REGISTER_SERIES",
+    "TYPE_LIST_SERIES",
     "MTYPE_SOFT_DEPS_SERIES",
 ]
 
 
-MTYPE_REGISTER_SERIES = [
+TYPE_REGISTER_SERIES = [
     ("pd.Series", "Series", "pd.Series representation of a univariate series"),
     (
         "pd.DataFrame",
@@ -35,4 +35,4 @@ MTYPE_REGISTER_SERIES = [
 
 MTYPE_SOFT_DEPS_SERIES = {"xr.DataArray": "xarray", "dask_series": "dask"}
 
-MTYPE_LIST_SERIES = pd.DataFrame(MTYPE_REGISTER_SERIES)[0].values
+TYPE_LIST_SERIES = pd.DataFrame(TYPE_REGISTER_SERIES)[0].values
diff --git a/aeon/datatypes/_table/__init__.py b/aeon/datatypes/_table/__init__.py
index cf76588f..bb49e4f4 100644
--- a/aeon/datatypes/_table/__init__.py
+++ b/aeon/datatypes/_table/__init__.py
@@ -9,13 +9,13 @@ from aeon.datatypes._table._examples import (
 from aeon.datatypes._table._examples import (
     example_dict_metadata as example_dict_metadata_Table,
 )
-from aeon.datatypes._table._registry import MTYPE_LIST_TABLE, MTYPE_REGISTER_TABLE
+from aeon.datatypes._table._registry import TYPE_LIST_TABLE, TYPE_REGISTER_TABLE
 
 __all__ = [
     "check_dict_Table",
     "convert_dict_Table",
-    "MTYPE_LIST_TABLE",
-    "MTYPE_REGISTER_TABLE",
+    "TYPE_LIST_TABLE",
+    "TYPE_REGISTER_TABLE",
     "example_dict_Table",
     "example_dict_lossy_Table",
     "example_dict_metadata_Table",
diff --git a/aeon/datatypes/_table/_convert.py b/aeon/datatypes/_table/_convert.py
index 6cad440f..9d9f4a8d 100644
--- a/aeon/datatypes/_table/_convert.py
+++ b/aeon/datatypes/_table/_convert.py
@@ -34,7 +34,7 @@ import numpy as np
 import pandas as pd
 
 from aeon.datatypes._convert_utils._convert import _extend_conversions
-from aeon.datatypes._table._registry import MTYPE_LIST_TABLE
+from aeon.datatypes._table._registry import TYPE_LIST_TABLE
 
 ##############################################################
 # methods to convert one machine type to another machine type
@@ -48,7 +48,7 @@ def convert_identity(obj, store=None):
 
 
 # assign identity function to type conversion to self
-for tp in MTYPE_LIST_TABLE:
+for tp in TYPE_LIST_TABLE:
     convert_dict[(tp, tp, "Table")] = convert_identity
 
 
@@ -233,8 +233,6 @@ convert_dict[
 
 
 _extend_conversions(
-    "pd_Series_Table", "pd_DataFrame_Table", convert_dict, MTYPE_LIST_TABLE
-)
-_extend_conversions(
-    "list_of_dict", "pd_DataFrame_Table", convert_dict, MTYPE_LIST_TABLE
+    "pd_Series_Table", "pd_DataFrame_Table", convert_dict, TYPE_LIST_TABLE
 )
+_extend_conversions("list_of_dict", "pd_DataFrame_Table", convert_dict, TYPE_LIST_TABLE)
diff --git a/aeon/datatypes/_table/_registry.py b/aeon/datatypes/_table/_registry.py
index e22549f8..5b7c929a 100644
--- a/aeon/datatypes/_table/_registry.py
+++ b/aeon/datatypes/_table/_registry.py
@@ -1,12 +1,12 @@
 import pandas as pd
 
 __all__ = [
-    "MTYPE_REGISTER_TABLE",
-    "MTYPE_LIST_TABLE",
+    "TYPE_REGISTER_TABLE",
+    "TYPE_LIST_TABLE",
 ]
 
 
-MTYPE_REGISTER_TABLE = [
+TYPE_REGISTER_TABLE = [
     ("pd_DataFrame_Table", "Table", "pd.DataFrame representation of a data table"),
     ("numpy1D", "Table", "1D np.narray representation of a univariate table"),
     ("numpy_Table", "Table", "2D np.narray representation of a univariate table"),
@@ -14,4 +14,4 @@ MTYPE_REGISTER_TABLE = [
     ("list_of_dict", "Table", "list of dictionaries with primitive entries"),
 ]
 
-MTYPE_LIST_TABLE = pd.DataFrame(MTYPE_REGISTER_TABLE)[0].values
+TYPE_LIST_TABLE = pd.DataFrame(TYPE_REGISTER_TABLE)[0].values
diff --git a/aeon/datatypes/_utilities.py b/aeon/datatypes/_utilities.py
index 1f074bfd..87498d44 100644
--- a/aeon/datatypes/_utilities.py
+++ b/aeon/datatypes/_utilities.py
@@ -88,7 +88,7 @@ def get_index_for_series(obj, cutoff=0):
     return pd.RangeIndex(cutoff, cutoff + obj.shape[0])
 
 
-GET_CUTOFF_SUPPORTED_MTYPES = [
+GET_CUTOFF_SUPPORTED_TYPES = [
     "pd.DataFrame",
     "pd.Series",
     "np.ndarray",
@@ -185,7 +185,7 @@ def get_cutoff(
     obj : aeon compatible time series data container or pandas.Index
         if aeon time series, must be of Series, Panel, or Hierarchical scitype
         all mtypes are supported via conversion to internally supported types
-        to avoid conversions, pass data in one of GET_CUTOFF_SUPPORTED_MTYPES
+        to avoid conversions, pass data in one of GET_CUTOFF_SUPPORTED_TYPES
         if pandas.Index, it is assumed that last level is time-like or integer,
         e.g., as in the pd.DataFrame, pd-multiindex, or pd_multiindex_hier mtypes
     cutoff : int, optional, default=0
@@ -201,7 +201,7 @@ def get_cutoff(
         whether to check input for validity, i.e., is it one of the scitypes
     convert_input : bool, optional, default=True
         whether to convert the input (True), or skip conversion (False)
-        if skipped, function assumes that inputs are one of GET_CUTOFF_SUPPORTED_MTYPES
+        if skipped, function assumes that inputs are one of GET_CUTOFF_SUPPORTED_TYPES
 
     Returns
     -------
@@ -230,7 +230,7 @@ def get_cutoff(
             raise ValueError("obj must be of Series, Panel, or Hierarchical scitype")
 
     if convert_input:
-        obj = convert_to(obj, GET_CUTOFF_SUPPORTED_MTYPES)
+        obj = convert_to(obj, GET_CUTOFF_SUPPORTED_TYPES)
 
     if cutoff is None:
         cutoff = 0
diff --git a/aeon/forecasting/base/_base.py b/aeon/forecasting/base/_base.py
index 165545e7..afc91b93 100644
--- a/aeon/forecasting/base/_base.py
+++ b/aeon/forecasting/base/_base.py
@@ -1,9 +1,9 @@
 """
-Base class template for forecaster scitype.
+Base class template for forecaster.
 
     class name: BaseForecaster
 
-Scitype defining methods:
+Defining methods:
     fitting            - fit(y, X=None, fh=None)
     forecasting        - predict(fh=None, X=None)
     updating           - update(y, X=None, update_params=True)
@@ -292,12 +292,12 @@ class BaseForecaster(BaseEstimator):
         y : time series in aeon compatible data container format
                 Time series to which to fit the forecaster.
             y can be in one of the following formats:
-            Series scitype: pd.Series, pd.DataFrame, or np.ndarray (1D or 2D)
+            Series abstract type: pd.Series, pd.DataFrame, or np.ndarray (1D or 2D)
                 for vanilla forecasting, one time series
-            Panel scitype: pd.DataFrame with 2-level row MultiIndex,
+            Panel abstract type: pd.DataFrame with 2-level row MultiIndex,
                 3D np.ndarray, list of Series pd.DataFrame, or nested pd.DataFrame
                 for global or panel forecasting
-            Hierarchical scitype: pd.DataFrame with 3 or more level row MultiIndex
+            Hierarchical abstract type: pd.DataFrame with 3 or more level row MultiIndex
                 for hierarchical forecasting
             Number of columns admissible depend on the "y_input_type" tag:
                 if self.get_tag("y_input_type")=="univariate":
@@ -310,7 +310,7 @@ class BaseForecaster(BaseEstimator):
                 on specification of formats, examples/datasets
         X : time series in aeon compatible format, optional (default=None)
                 Exogeneous time series to fit to
-            Should be of same scitype (Series, Panel, or Hierarchical) as y
+            Should be of same abstract type (Series, Panel, or Hierarchical) as y
             if self.get_tag("X-y-must-have-same-index"), X.index must contain y.index
             there are no restrictions on number of columns (unlike for y).
         fh : int, list, np.array or ForecastingHorizon, optional (default=None)
@@ -377,7 +377,7 @@ class BaseForecaster(BaseEstimator):
             if has not been passed in fit, must be passed, not optional.
         X : time series in aeon compatible format, optional (default=None)
                 Exogeneous time series to fit to
-            Should be of same scitype (Series, Panel, or Hierarchical) as y in fit
+            Should be of same abstract type (Series, Panel, or Hierarchical) as y in fit
             if self.get_tag("X-y-must-have-same-index"), X.index must contain fh.index
             there are no restrictions on number of columns (unlike for y).
 
@@ -386,7 +386,7 @@ class BaseForecaster(BaseEstimator):
         y_pred : time series in aeon compatible data container format
             Point forecasts at fh, with same index as fh
             y_pred has same type as the y that has been passed most recently:
-                Series, Panel, Hierarchical scitype, same format (see above).
+                Series, Panel, Hierarchical abstract type, same format (see above).
         """
         # handle inputs
 
@@ -431,12 +431,12 @@ class BaseForecaster(BaseEstimator):
         y : time series in aeon compatible data container format
                 Time series to which to fit the forecaster.
             y can be in one of the following formats:
-            Series scitype: pd.Series, pd.DataFrame, or np.ndarray (1D or 2D)
+            Series abstract type: pd.Series, pd.DataFrame, or np.ndarray (1D or 2D)
                 for vanilla forecasting, one time series
-            Panel scitype: pd.DataFrame with 2-level row MultiIndex,
+            Panel abstract type: pd.DataFrame with 2-level row MultiIndex,
                 3D np.ndarray, list of Series pd.DataFrame, or nested pd.DataFrame
                 for global or panel forecasting
-            Hierarchical scitype: pd.DataFrame with 3 or more level row MultiIndex
+            Hierarchical abstract type: pd.DataFrame with 3 or more level row MultiIndex
                 for hierarchical forecasting
             Number of columns admissible depend on the "y_input_type" tag:
                 if self.get_tag("y_input_type")=="univariate":
@@ -452,7 +452,7 @@ class BaseForecaster(BaseEstimator):
             if has not been passed in fit, must be passed, not optional
         X : time series in aeon compatible format, optional (default=None)
                 Exogeneous time series to fit to
-            Should be of same scitype (Series, Panel, or Hierarchical) as y in fit
+            Should be of same abstract type (Series, Panel, or Hierarchical) as y in fit
             if self.get_tag("X-y-must-have-same-index"),
                 X.index must contain fh.index and y.index both
         fh : int, list, np.array or ForecastingHorizon (not optional)
@@ -464,7 +464,7 @@ class BaseForecaster(BaseEstimator):
         y_pred : time series in aeon compatible data container format
             Point forecasts at fh, with same index as fh
             y_pred has same type as the y that has been passed most recently:
-                Series, Panel, Hierarchical scitype, same format (see above)
+                Series, Panel, Hierarchical abstract type, same format (see above)
         """
         # if fit is called, fitted state is re-set
         self._is_fitted = False
@@ -515,7 +515,7 @@ class BaseForecaster(BaseEstimator):
             if has not been passed in fit, must be passed, not optional
         X : time series in aeon compatible format, optional (default=None)
                 Exogeneous time series to fit to
-            Should be of same scitype (Series, Panel, or Hierarchical) as y in fit
+            Should be of same abstract type (Series, Panel, or Hierarchical) as y in fit
             if self.get_tag("X-y-must-have-same-index"), must contain fh.index
         alpha : float or list of float of unique values, optional (default=[0.05, 0.95])
             A probability or list of, at which quantile forecasts are computed.
@@ -591,7 +591,7 @@ class BaseForecaster(BaseEstimator):
             if has not been passed in fit, must be passed, not optional.
         X : time series in aeon compatible format, optional (default=None)
                 Exogeneous time series to fit to
-            Should be of same scitype (Series, Panel, or Hierarchical) as y in fit
+            Should be of same abstract type (Series, Panel, or Hierarchical) as y in fit
             if self.get_tag("X-y-must-have-same-index"), must contain fh.index.
         coverage : float or list of float of unique values, default=0.9
             Nominal coverage(s) of predictive interval(s).
@@ -661,7 +661,7 @@ class BaseForecaster(BaseEstimator):
             if has not been passed in fit, must be passed, not optional
         X : time series in aeon compatible format, optional (default=None)
                 Exogeneous time series to fit to
-            Should be of same scitype (Series, Panel, or Hierarchical) as y in fit
+            Should be of same abstract type (Series, Panel, or Hierarchical) as y in fit
             if self.get_tag("X-y-must-have-same-index"),
                 X.index must contain fh.index and y.index both
         cov : bool, optional (default=False)
@@ -734,7 +734,7 @@ class BaseForecaster(BaseEstimator):
             if has not been passed in fit, must be passed, not optional.
         X : time series in aeon compatible format, default=None
                 Exogeneous time series to fit to.
-            Should be of same scitype (Series, Panel, or Hierarchical) as y in fit
+            Should be of same abstract type (Series, Panel, or Hierarchical) as y in fit
             if self.get_tag("X-y-must-have-same-index"), must contain fh.index.
         marginal : bool, default=True
             Whether returned distribution is marginal by time index.
@@ -810,13 +810,13 @@ class BaseForecaster(BaseEstimator):
         ----------
         y : time series in aeon compatible data container format
                 Time series to which to fit the forecaster in the update.
-            y can be in one of the following formats, must be same scitype as in fit:
-            Series scitype: pd.Series, pd.DataFrame, or np.ndarray (1D or 2D)
+            y can be in one of the following formats, must be same abstract type as in
+            fit: Series abstract type: pd.Series, pd.DataFrame, or np.ndarray (1D or 2D)
                 for vanilla forecasting, one time series
-            Panel scitype: pd.DataFrame with 2-level row MultiIndex,
+            Panel abstract type: pd.DataFrame with 2-level row MultiIndex,
                 3D np.ndarray, list of Series pd.DataFrame, or nested pd.DataFrame
                 for global or panel forecasting
-            Hierarchical scitype: pd.DataFrame with 3 or more level row MultiIndex
+            Hierarchical abstract type: pd.DataFrame with 3 or more level row MultiIndex
                 for hierarchical forecasting
             Number of columns admissible depend on the "y_input_type" tag:
                 if self.get_tag("y_input_type")=="univariate":
@@ -890,13 +890,13 @@ class BaseForecaster(BaseEstimator):
         ----------
         y : time series in aeon compatible data container format
                 Time series to which to fit the forecaster in the update.
-            y can be in one of the following formats, must be same scitype as in fit:
-            Series scitype: pd.Series, pd.DataFrame, or np.ndarray (1D or 2D)
-                for vanilla forecasting, one time series
-            Panel scitype: pd.DataFrame with 2-level row MultiIndex,
+            y can be in one of the following formats, must be same abstract type as
+            in fit: Series abstract type: pd.Series, pd.DataFrame, or np.ndarray (1D
+            or 2D) for vanilla forecasting, one time series
+            Panel abstract type: pd.DataFrame with 2-level row MultiIndex,
                 3D np.ndarray, list of Series pd.DataFrame, or nested pd.DataFrame
                 for global or panel forecasting
-            Hierarchical scitype: pd.DataFrame with 3 or more level row MultiIndex
+            Hierarchical abstract type: pd.DataFrame with 3 or more level row MultiIndex
                 for hierarchical forecasting
             Number of columns admissible depend on the "y_input_type" tag:
                 if self.get_tag("y_input_type")=="univariate":
@@ -912,7 +912,7 @@ class BaseForecaster(BaseEstimator):
                 `initial_window = 1`, `step_length = 1` and `fh = 1`
         X : time series in aeon compatible format, optional (default=None)
             Exogeneous time series for updating and forecasting
-            Should be of same scitype (Series, Panel, or Hierarchical) as y
+            Should be of same abstract type (Series, Panel, or Hierarchical) as y
             if self.get_tag("X-y-must-have-same-index"),
                 X.index must contain y.index and fh.index both
             there are no restrictions on number of columns (unlike for y).
@@ -933,7 +933,7 @@ class BaseForecaster(BaseEstimator):
                 type is time series in aeon compatible data container format
                 cutoff is suppressed in output
                 has same type as the y that has been passed most recently:
-                Series, Panel, Hierarchical scitype, same format (see above)
+                Series, Panel, Hierarchical abstract type, same format (see above)
             if collection of absolute horizon points is not unique:
                 type is a pandas DataFrame, with row and col index being time stamps
                 row index corresponds to cutoffs that are predicted from
@@ -994,13 +994,13 @@ class BaseForecaster(BaseEstimator):
         ----------
         y : time series in aeon compatible data container format
             Time series to which to fit the forecaster in the update.
-            y can be in one of the following formats, must be same scitype as in fit:
-            Series scitype: pd.Series, pd.DataFrame, or np.ndarray (1D or 2D)
-                for vanilla forecasting, one time series
-            Panel scitype: pd.DataFrame with 2-level row MultiIndex,
+            y can be in one of the following formats, must be same abstract type as
+            in fit: Series abstract type: pd.Series, pd.DataFrame, or np.ndarray (1D
+            or 2D) for vanilla forecasting, one time series
+            Panel abstract type: pd.DataFrame with 2-level row MultiIndex,
                 3D np.ndarray, list of Series pd.DataFrame, or nested pd.DataFrame
                 for global or panel forecasting
-            Hierarchical scitype: pd.DataFrame with 3 or more level row MultiIndex
+            Hierarchical abstract type: pd.DataFrame with 3 or more level row MultiIndex
                 for hierarchical forecasting
             Number of columns admissible depend on the "y_input_type" tag:
                 if self.get_tag("y_input_type")=="univariate":
@@ -1014,7 +1014,7 @@ class BaseForecaster(BaseEstimator):
             if has not been passed in fit, must be passed, not optional.
         X : time series in aeon compatible format, optional (default=None)
                 Exogeneous time series for updating and forecasting
-            Should be of same scitype (Series, Panel, or Hierarchical) as y
+            Should be of same abstract type (Series, Panel, or Hierarchical) as y
             if self.get_tag("X-y-must-have-same-index"),
                 X.index must contain y.index and fh.index both.
         update_params : bool, optional (default=False)
@@ -1025,7 +1025,7 @@ class BaseForecaster(BaseEstimator):
             Point forecasts at fh, with same index as fh
             if fh was relative, index is relative to cutoff after update with y
             y_pred has same type as the y that has been passed most recently:
-                Series, Panel, Hierarchical scitype, same format (see above)
+                Series, Panel, Hierarchical abstract type, same format (see above)
         """
         if y is None or (hasattr(y, "__len__") and len(y) == 0):
             warn("empty y passed to update_predict, no update was carried out")
@@ -1104,7 +1104,7 @@ class BaseForecaster(BaseEstimator):
         y_res : time series in aeon compatible data container format
             Forecast residuals at fh, with same index as fh
             y_res has same type as the y that has been passed most recently:
-                Series, Panel, Hierarchical scitype, same format (see above)
+                Series, Panel, Hierarchical abstract type, same format (see above)
         """
         self.check_is_fitted()
 
@@ -1263,18 +1263,18 @@ class BaseForecaster(BaseEstimator):
         -------
         y_inner : Series, Panel, or Hierarchical object, or VectorizedDF
                 compatible with self.get_tag("y_inner_type") format
-            Case 1: self.get_tag("y_inner_type") supports scitype of y, then
+            Case 1: self.get_tag("y_inner_type") supports abstract type of y, then
                 converted/coerced version of y, mtype determined by "y_inner_type" tag
-            Case 2: self.get_tag("y_inner_type") does not support scitype of y, then
-                VectorizedDF of y, iterated as the most complex supported scitype
-                    (complexity order: Hierarchical > Panel > Series)
+            Case 2: self.get_tag("y_inner_type") does not support abstract type of y,
+                then VectorizedDF of y, iterated as the most complex supported abstract
+                type (complexity order: Hierarchical > Panel > Series)
             Case 3: None if y was None
         X_inner : Series, Panel, or Hierarchical object, or VectorizedDF
                 compatible with self.get_tag("X_inner_type") format
-            Case 1: self.get_tag("X_inner_type") supports scitype of X, then
+            Case 1: self.get_tag("X_inner_type") supports abstract type of X, then
                 converted/coerced version of X, mtype determined by "X_inner_type" tag
-            Case 2: self.get_tag("X_inner_type") does not support scitype of X, then
-                VectorizedDF of X, iterated as the most complex supported scitype
+            Case 2: self.get_tag("X_inner_type") does not support abstract type of X,
+            then VectorizedDF of X, iterated as the most complex supported abstract type
             Case 3: None if X was None
 
         Raises
@@ -1295,16 +1295,19 @@ class BaseForecaster(BaseEstimator):
         if X is None and y is None:
             return None, None
 
-        def _most_complex_scitype(scitypes, smaller_equal_than=None):
-            """Return most complex scitype in a list of str."""
-            if "Hierarchical" in scitypes and smaller_equal_than == "Hierarchical":
+        def _most_complex_abstract_type(abstract_types, smaller_equal_than=None):
+            """Return most complex abstract type in a list of str."""
+            if (
+                "Hierarchical" in abstract_types
+                and smaller_equal_than == "Hierarchical"
+            ):
                 return "Hierarchical"
-            elif "Panel" in scitypes and smaller_equal_than != "Series":
+            elif "Panel" in abstract_types and smaller_equal_than != "Series":
                 return "Panel"
-            elif "Series" in scitypes:
+            elif "Series" in abstract_types:
                 return "Series"
             else:
-                raise ValueError("no series scitypes supported, bug in estimator")
+                raise ValueError("no series abstract types supported, bug in estimator")
 
         def _check_missing(metadata, obj_name):
             """Check input metadata against self's missing capability tag."""
@@ -1325,25 +1328,25 @@ class BaseForecaster(BaseEstimator):
         # retrieve supported mtypes
         y_inner_type = _coerce_to_list(self.get_tag("y_inner_type"))
         X_inner_type = _coerce_to_list(self.get_tag("X_inner_type"))
-        y_inner_scitype = mtype_to_scitype(y_inner_type, return_unique=True)
-        X_inner_scitype = mtype_to_scitype(X_inner_type, return_unique=True)
+        y_inner_abstract_type = mtype_to_scitype(y_inner_type, return_unique=True)
+        X_inner_abstract_type = mtype_to_scitype(X_inner_type, return_unique=True)
 
-        ALLOWED_SCITYPES = ["Series", "Panel", "Hierarchical"]
-        FORBIDDEN_MTYPES = ["numpy2D", "pd-wide"]
+        ALLOWED_ABSTRACT_TYPES = ["Series", "Panel", "Hierarchical"]
+        FORBIDDEN_TYPES = ["numpy2D", "pd-wide"]
 
-        for scitype in ALLOWED_SCITYPES:
-            mtypes = set(scitype_to_mtype(scitype))
-            mtypes = list(mtypes.difference(FORBIDDEN_MTYPES))
-            mtypes_msg = f'"For {scitype} scitype: {mtypes}. '
+        for abs in ALLOWED_ABSTRACT_TYPES:
+            types = set(scitype_to_mtype(abs))
+            types = list(types.difference(FORBIDDEN_TYPES))
+            mtypes_msg = f'"For {abs} type: {types}. '
 
         # checking y
         if y is not None:
             y_valid, _, y_metadata = check_is_scitype(
-                y, scitype=ALLOWED_SCITYPES, return_metadata=True, var_name="y"
+                y, scitype=ALLOWED_ABSTRACT_TYPES, return_metadata=True, var_name="y"
             )
             msg = (
                 "y must be in an aeon compatible format, "
-                "of scitype Series, Panel or Hierarchical, "
+                "of abstract type Series, Panel or Hierarchical, "
                 "for instance a pandas.DataFrame with aeon compatible time indices, "
                 "or with MultiIndex and last(-1) level an aeon compatible time index."
                 "For further details see  examples/forecasting, or examples/datasets"
@@ -1355,10 +1358,10 @@ class BaseForecaster(BaseEstimator):
             if not y_valid:
                 raise TypeError(msg + mtypes_msg)
 
-            y_scitype = y_metadata["scitype"]
+            y_type = y_metadata["scitype"]
             self._y_mtype_last_seen = y_metadata["mtype"]
 
-            req_vec_because_rows = y_scitype not in y_inner_scitype
+            req_vec_because_rows = y_type not in y_inner_abstract_type
             req_vec_because_cols = (
                 self.get_tag("y_input_type") == "univariate"
                 and not y_metadata["is_univariate"]
@@ -1376,20 +1379,19 @@ class BaseForecaster(BaseEstimator):
             _check_missing(y_metadata, "y")
 
         else:
-            # y_scitype is used below - set to None if y is None
-            y_scitype = None
+            y_type = None
             requires_vectorization = False
         # end checking y
 
         # checking X
         if X is not None:
             X_valid, _, X_metadata = check_is_scitype(
-                X, scitype=ALLOWED_SCITYPES, return_metadata=True, var_name="X"
+                X, scitype=ALLOWED_ABSTRACT_TYPES, return_metadata=True, var_name="X"
             )
 
             msg = (
                 "X must be either None, or in an aeon compatible format, "
-                "of scitype Series, Panel or Hierarchical, "
+                "of abstract type Series, Panel or Hierarchical, "
                 "for instance a pandas.DataFrame with aeon compatible time indices, "
                 "or with MultiIndex and last(-1) level an aeon compatible time index."
                 "For further details see  examples/forecasting, or examples/datasets."
@@ -1401,31 +1403,30 @@ class BaseForecaster(BaseEstimator):
             if not X_valid:
                 raise TypeError(msg + mtypes_msg)
 
-            X_scitype = X_metadata["scitype"]
-            X_requires_vectorization = X_scitype not in X_inner_scitype
+            X_type = X_metadata["scitype"]
+            X_requires_vectorization = X_type not in X_inner_abstract_type
             requires_vectorization = requires_vectorization or X_requires_vectorization
 
             _check_missing(X_metadata, "X")
 
         else:
-            # X_scitype is used below - set to None if X is None
-            X_scitype = None
+            X_type = None
 
         # extra check: if X is ignored by inner methods, pass None to them
         if self.get_tag("ignores-exogeneous-X"):
             X = None
-            X_scitype = None
+            X_type = None
         # end checking X
 
         # compatibility checks between X and y
         if X is not None and y is not None:
             if self.get_tag("X-y-must-have-same-index"):
                 # currently, check_equal_time_index only works for Series
-                if not self.get_tag("ignores-exogeneous-X") and X_scitype == "Series":
+                if not self.get_tag("ignores-exogeneous-X") and X_type == "Series":
                     check_equal_time_index(X, y, mode="contains")
 
-            if y_scitype != X_scitype:
-                raise TypeError("X and y must have the same scitype")
+            if y_type != X_type:
+                raise TypeError("X and y must have the same abstract type")
         # end compatibility checking X and y
 
         # convert X & y to supported inner type, if necessary
@@ -1441,7 +1442,7 @@ class BaseForecaster(BaseEstimator):
             y_inner = convert_to(
                 y,
                 to_type=y_inner_type,
-                as_scitype=y_scitype,  # we are dealing with series
+                as_scitype=y_type,  # we are dealing with series
                 store=self._converter_store_y,
                 store_behaviour="reset",
             )
@@ -1450,23 +1451,23 @@ class BaseForecaster(BaseEstimator):
             X_inner = convert_to(
                 X,
                 to_type=X_inner_type,
-                as_scitype=X_scitype,  # we are dealing with series
+                as_scitype=X_type,  # we are dealing with series
             )
         else:
-            iterate_as = _most_complex_scitype(
-                y_inner_scitype, smaller_equal_than=y_scitype
+            iterate_as = _most_complex_abstract_type(
+                y_inner_abstract_type, smaller_equal_than=y_type
             )
             if y is not None:
                 y_inner = VectorizedDF(
                     X=y,
                     iterate_as=iterate_as,
-                    is_scitype=y_scitype,
+                    is_scitype=y_type,
                     iterate_cols=req_vec_because_cols,
                 )
             else:
                 y_inner = None
             if X is not None:
-                X_inner = VectorizedDF(X=X, iterate_as=iterate_as, is_scitype=X_scitype)
+                X_inner = VectorizedDF(X=X, iterate_as=iterate_as, is_scitype=X_type)
             else:
                 X_inner = None
 
@@ -1594,9 +1595,9 @@ class BaseForecaster(BaseEstimator):
         ----------
         y : aeon compatible time series data container
             must be of one of the following mtypes:
-                pd.Series, pd.DataFrame, np.ndarray, of Series scitype
-                pd.multiindex, numpy3D, nested_univ, df-list, of Panel scitype
-                pd_multiindex_hier, of Hierarchical scitype
+                pd.Series, pd.DataFrame, np.ndarray, of Series abstract type
+                pd.multiindex, numpy3D, nested_univ, df-list, of Panel abstract type
+                pd_multiindex_hier, of Hierarchical abstract type
         Notes
         -----
         Set self._cutoff to pandas.Index containing latest index seen in `y`.
@@ -2227,13 +2228,13 @@ class BaseForecaster(BaseEstimator):
         ----------
         y : time series in aeon compatible data container format
                 Time series to which to fit the forecaster in the update.
-            y can be in one of the following formats, must be same scitype as in fit:
-            Series scitype: pd.Series, pd.DataFrame, or np.ndarray (1D or 2D)
+            y can be in one of the following formats, must be same abstract type as in
+            fit: Series abstract type: pd.Series, pd.DataFrame, or np.ndarray (1D or 2D)
                 for vanilla forecasting, one time series
-            Panel scitype: pd.DataFrame with 2-level row MultiIndex,
+            Panel abstract type: pd.DataFrame with 2-level row MultiIndex,
                 3D np.ndarray, list of Series pd.DataFrame, or nested pd.DataFrame
                 for global or panel forecasting
-            Hierarchical scitype: pd.DataFrame with 3 or more level row MultiIndex
+            Hierarchical abstract type: pd.DataFrame with 3 or more level row MultiIndex
                 for hierarchical forecasting
             Number of columns admissible depend on the "y_input_type" tag:
                 if self.get_tag("y_input_type")=="univariate":
@@ -2245,7 +2246,7 @@ class BaseForecaster(BaseEstimator):
         cv : temporal cross-validation generator, optional (default=None)
         X : time series in aeon compatible format, optional (default=None)
                 Exogeneous time series for updating and forecasting
-            Should be of same scitype (Series, Panel, or Hierarchical) as y
+            Should be of same abstract type (Series, Panel, or Hierarchical) as y
             if self.get_tag("X-y-must-have-same-index"),
                 X.index must contain y.index and fh.index both
             there are no restrictions on number of columns (unlike for y)
diff --git a/aeon/forecasting/compose/_grouped.py b/aeon/forecasting/compose/_grouped.py
index d3cfa095..43d1c569 100644
--- a/aeon/forecasting/compose/_grouped.py
+++ b/aeon/forecasting/compose/_grouped.py
@@ -1,6 +1,6 @@
 """Implements compositors for performing forecasting by group."""
 
-from aeon.datatypes import ALL_TIME_SERIES_MTYPES, mtype_to_scitype
+from aeon.datatypes import ALL_TIME_SERIES_TYPES, mtype_to_scitype
 from aeon.forecasting.base._delegate import _DelegatedForecaster
 
 __author__ = ["fkiraly"]
@@ -55,8 +55,8 @@ class ForecastByLevel(_DelegatedForecaster):
         "requires-fh-in-fit": False,
         "capability:missing_values": True,
         "y_input_type": "both",
-        "y_inner_type": ALL_TIME_SERIES_MTYPES,
-        "X_inner_type": ALL_TIME_SERIES_MTYPES,
+        "y_inner_type": ALL_TIME_SERIES_TYPES,
+        "X_inner_type": ALL_TIME_SERIES_TYPES,
         "fit_is_empty": False,
     }
 
@@ -89,7 +89,7 @@ class ForecastByLevel(_DelegatedForecaster):
                 f"but found {groupby}"
             )
 
-        mtypes = [x for x in ALL_TIME_SERIES_MTYPES if mtype_to_scitype(x) in scitypes]
+        mtypes = [x for x in ALL_TIME_SERIES_TYPES if mtype_to_scitype(x) in scitypes]
 
         # this ensures that we convert in the inner estimator
         # but vectorization/broadcasting happens at the level of groupby
diff --git a/aeon/forecasting/compose/_multiplexer.py b/aeon/forecasting/compose/_multiplexer.py
index c93d8ba9..2d9355c8 100644
--- a/aeon/forecasting/compose/_multiplexer.py
+++ b/aeon/forecasting/compose/_multiplexer.py
@@ -1,7 +1,7 @@
 """Implements forecaster for selecting among different model classes."""
 
 from aeon.base import _HeterogenousMetaEstimator
-from aeon.datatypes import ALL_TIME_SERIES_MTYPES
+from aeon.datatypes import ALL_TIME_SERIES_TYPES
 from aeon.forecasting.base._base import BaseForecaster
 from aeon.forecasting.base._delegate import _DelegatedForecaster
 
@@ -79,8 +79,8 @@ class MultiplexForecaster(_HeterogenousMetaEstimator, _DelegatedForecaster):
         "requires-fh-in-fit": False,
         "capability:missing_values": False,
         "y_input_type": "both",
-        "y_inner_type": ALL_TIME_SERIES_MTYPES,
-        "X_inner_type": ALL_TIME_SERIES_MTYPES,
+        "y_inner_type": ALL_TIME_SERIES_TYPES,
+        "X_inner_type": ALL_TIME_SERIES_TYPES,
         "fit_is_empty": False,
     }
 
@@ -120,8 +120,8 @@ class MultiplexForecaster(_HeterogenousMetaEstimator, _DelegatedForecaster):
         self.clone_tags(self.forecaster_)
         self.set_tags(**{"fit_is_empty": False})
         # this ensures that we convert in the inner estimator, not in the multiplexer
-        self.set_tags(**{"y_inner_type": ALL_TIME_SERIES_MTYPES})
-        self.set_tags(**{"X_inner_type": ALL_TIME_SERIES_MTYPES})
+        self.set_tags(**{"y_inner_type": ALL_TIME_SERIES_TYPES})
+        self.set_tags(**{"X_inner_type": ALL_TIME_SERIES_TYPES})
 
     @property
     def _forecasters(self):
diff --git a/aeon/forecasting/compose/_pipeline.py b/aeon/forecasting/compose/_pipeline.py
index f28015ca..b325b32e 100644
--- a/aeon/forecasting/compose/_pipeline.py
+++ b/aeon/forecasting/compose/_pipeline.py
@@ -6,7 +6,7 @@ __all__ = ["TransformedTargetForecaster", "ForecastingPipeline", "ForecastX"]
 import pandas as pd
 
 from aeon.base import _HeterogenousMetaEstimator
-from aeon.datatypes import ALL_TIME_SERIES_MTYPES
+from aeon.datatypes import ALL_TIME_SERIES_TYPES
 from aeon.forecasting.base._base import BaseForecaster
 from aeon.forecasting.base._delegate import _DelegatedForecaster
 from aeon.transformations.base import BaseTransformer
@@ -1597,8 +1597,8 @@ class Permute(_DelegatedForecaster, BaseForecaster, _HeterogenousMetaEstimator):
 
     _tags = {
         "y_input_type": "both",
-        "y_inner_type": ALL_TIME_SERIES_MTYPES,
-        "X_inner_type": ALL_TIME_SERIES_MTYPES,
+        "y_inner_type": ALL_TIME_SERIES_TYPES,
+        "X_inner_type": ALL_TIME_SERIES_TYPES,
         "ignores-exogeneous-X": False,
         "requires-fh-in-fit": False,
         "capability:missing_values": True,
diff --git a/aeon/forecasting/stream/_update.py b/aeon/forecasting/stream/_update.py
index 404104aa..3c08b01c 100644
--- a/aeon/forecasting/stream/_update.py
+++ b/aeon/forecasting/stream/_update.py
@@ -4,7 +4,7 @@ __author__ = ["fkiraly"]
 
 import pandas as pd
 
-from aeon.datatypes import ALL_TIME_SERIES_MTYPES
+from aeon.datatypes import ALL_TIME_SERIES_TYPES
 from aeon.datatypes._utilities import get_window
 from aeon.forecasting.base._delegate import _DelegatedForecaster
 
@@ -51,8 +51,8 @@ class UpdateRefitsEvery(_DelegatedForecaster):
     _tags = {
         "fit_is_empty": False,
         "requires-fh-in-fit": False,
-        "y_inner_type": ALL_TIME_SERIES_MTYPES,
-        "X_inner_type": ALL_TIME_SERIES_MTYPES,
+        "y_inner_type": ALL_TIME_SERIES_TYPES,
+        "X_inner_type": ALL_TIME_SERIES_TYPES,
     }
 
     def __init__(
@@ -236,8 +236,8 @@ class UpdateEvery(_DelegatedForecaster):
     _tags = {
         "fit_is_empty": False,
         "requires-fh-in-fit": False,
-        "y_inner_type": ALL_TIME_SERIES_MTYPES,
-        "X_inner_type": ALL_TIME_SERIES_MTYPES,
+        "y_inner_type": ALL_TIME_SERIES_TYPES,
+        "X_inner_type": ALL_TIME_SERIES_TYPES,
     }
 
     def __init__(self, forecaster, update_interval=None):
@@ -401,8 +401,8 @@ class DontUpdate(_DelegatedForecaster):
     _tags = {
         "fit_is_empty": False,
         "requires-fh-in-fit": False,
-        "y_inner_type": ALL_TIME_SERIES_MTYPES,
-        "X_inner_type": ALL_TIME_SERIES_MTYPES,
+        "y_inner_type": ALL_TIME_SERIES_TYPES,
+        "X_inner_type": ALL_TIME_SERIES_TYPES,
     }
 
     def __init__(self, forecaster):
diff --git a/aeon/transformations/_delegate.py b/aeon/transformations/_delegate.py
index 5848f2b0..7479fe5d 100644
--- a/aeon/transformations/_delegate.py
+++ b/aeon/transformations/_delegate.py
@@ -41,7 +41,7 @@ class _DelegatedTransformer(BaseTransformer):
 
         Parameters
         ----------
-        X : Series or Panel, any supported mtype
+        X : Series or Panel, any supported type
             Data to fit transform to, of python type as follows:
                 Series: pd.Series, pd.DataFrame, or np.ndarray (1D or 2D)
                 Panel: pd.DataFrame with 2-level MultiIndex, list of pd.DataFrame,
@@ -62,7 +62,7 @@ class _DelegatedTransformer(BaseTransformer):
 
         Parameters
         ----------
-        X : Series or Panel, any supported mtype
+        X : Series or Panel, any supported type
             Data to be transformed, of python type as follows:
                 Series: pd.Series, pd.DataFrame, or np.ndarray (1D or 2D)
                 Panel: pd.DataFrame with 2-level MultiIndex, list of pd.DataFrame,
@@ -113,7 +113,7 @@ class _DelegatedTransformer(BaseTransformer):
 
         Parameters
         ----------
-        X : Series or Panel, any supported mtype
+        X : Series or Panel, any supported type
             Data to be inverse transformed, of python type as follows:
                 Series: pd.Series, pd.DataFrame, or np.ndarray (1D or 2D)
                 Panel: pd.DataFrame with 2-level MultiIndex, list of pd.DataFrame,
@@ -141,7 +141,7 @@ class _DelegatedTransformer(BaseTransformer):
 
         Parameters
         ----------
-        X : Series or Panel, any supported mtype
+        X : Series or Panel, any supported type
             Data to fit transform to, of python type as follows:
                 Series: pd.Series, pd.DataFrame, or np.ndarray (1D or 2D)
                 Panel: pd.DataFrame with 2-level MultiIndex, list of pd.DataFrame,
diff --git a/aeon/transformations/acf.py b/aeon/transformations/acf.py
index fff6fc3f..6763a006 100644
--- a/aeon/transformations/acf.py
+++ b/aeon/transformations/acf.py
@@ -65,12 +65,12 @@ class AutoCorrelationTransformer(BaseTransformer):
 
     _tags = {
         "input_data_type": "Series",
-        # what is the scitype of X: Series, or Panel
+        # what is the abstract type of X: Series, or Panel
         "output_data_type": "Series",
-        # what scitype is returned: Primitives, Series, Panel
+        # what abstract type is returned: Primitives, Series, Panel
         "instancewise": True,  # is this an instance-wise transform?
-        "X_inner_type": "pd.Series",  # which mtypes do _fit/_predict support for X?
-        "y_inner_type": "None",  # which mtypes do _fit/_predict support for y?
+        "X_inner_type": "pd.Series",
+        "y_inner_type": "None",
         "univariate-only": True,
         "fit_is_empty": True,
         "python_dependencies": "statsmodels",
@@ -197,12 +197,12 @@ class PartialAutoCorrelationTransformer(BaseTransformer):
 
     _tags = {
         "input_data_type": "Series",
-        # what is the scitype of X: Series, or Panel
+        # what is the abstract type of X: Series, or Panel
         "output_data_type": "Series",
-        # what scitype is returned: Primitives, Series, Panel
-        "instancewise": True,  # is this an instance-wise transform?
-        "X_inner_type": "pd.Series",  # which mtypes do _fit/_predict support for X?
-        "y_inner_type": "None",  # which mtypes do _fit/_predict support for y?
+        # what abstract type is returned: Primitives, Series, Panel
+        "instancewise": True,
+        "X_inner_type": "pd.Series",
+        "y_inner_type": "None",
         "univariate-only": True,
         "fit_is_empty": True,
         "python_dependencies": "statsmodels",
diff --git a/aeon/transformations/adapt.py b/aeon/transformations/adapt.py
index 93f36203..273106d4 100644
--- a/aeon/transformations/adapt.py
+++ b/aeon/transformations/adapt.py
@@ -86,12 +86,12 @@ class TabularToSeriesAdaptor(BaseTransformer):
 
     _tags = {
         "input_data_type": "Series",
-        # what is the scitype of X: Series, or Panel
+        # what is the abstract type of X: Series, or Panel
         "output_data_type": "Series",
-        # what scitype is returned: Primitives, Series, Panel
+        # what abstract type is returned: Primitives, Series, Panel
         "instancewise": True,  # is this an instance-wise transform?
-        "X_inner_type": "np.ndarray",  # which mtypes do _fit/_predict support for X?
-        "y_inner_type": "None",  # which mtypes do _fit/_predict support for y?
+        "X_inner_type": "np.ndarray",
+        "y_inner_type": "None",
         "univariate-only": False,
         "transform-returns-same-time-index": True,
         "fit_is_empty": False,
@@ -261,17 +261,17 @@ class PandasTransformAdaptor(BaseTransformer):
 
     _tags = {
         "input_data_type": "Series",
-        # what is the scitype of X: Series, or Panel
+        # what is the abstract type of X: Series, or Panel
         "output_data_type": "Series",
-        # what scitype is returned: Primitives, Series, Panel
-        "instancewise": True,  # is this an instance-wise transform?
-        "X_inner_type": "pd.DataFrame",  # which mtypes do _fit/_predict support for X?
-        "y_inner_type": "None",  # which mtypes do _fit/_predict support for y?
+        # what abstract type is returned: Primitives, Series, Panel
+        "instancewise": True,
+        "X_inner_type": "pd.DataFrame",
+        "y_inner_type": "None",
         "univariate-only": False,
         "transform-returns-same-time-index": False,
         "fit_is_empty": False,
         "capability:inverse_transform": False,
-        "remember_data": False,  # remember all data seen as _X
+        "remember_data": False,
     }
 
     def __init__(self, method, kwargs=None, apply_to="call"):
diff --git a/aeon/transformations/base.py b/aeon/transformations/base.py
index c74c979f..7d58ed23 100644
--- a/aeon/transformations/base.py
+++ b/aeon/transformations/base.py
@@ -100,9 +100,9 @@ class BaseTransformer(BaseEstimator):
         "transform_labels": "None",
         "instancewise": True,
         "univariate-only": False,  # can the transformer handle multivariate X?
-        "X_inner_type": "pd.DataFrame",  # which mtypes do _fit/_predict support for X?
+        "X_inner_type": "pd.DataFrame",
         # this can be a Panel mtype even if transform-input is Series, vectorized
-        "y_inner_type": "None",  # which mtypes do _fit/_predict support for y?
+        "y_inner_type": "None",
         "requires_y": False,  # does y need to be passed in fit?
         "enforce_index_type": None,  # index type that needs to be enforced in X/y
         "fit_is_empty": True,  # is fit empty and can be skipped? Yes = True
@@ -354,7 +354,7 @@ class BaseTransformer(BaseEstimator):
 
         Parameters
         ----------
-        X : Series or Panel, any supported mtype
+        X : Series or Panel, any supported type
             Data to fit transform to, of python type as follows:
                 Series: pd.Series, pd.DataFrame, or np.ndarray (1D or 2D)
                 Panel: pd.DataFrame with 2-level MultiIndex, list of pd.DataFrame,
@@ -403,7 +403,7 @@ class BaseTransformer(BaseEstimator):
 
         Parameters
         ----------
-        X : Series or Panel, any supported mtype
+        X : Series or Panel, any supported type
             Data to be transformed, of python type as follows:
                 Series: pd.Series, pd.DataFrame, or np.ndarray (1D or 2D)
                 Panel: pd.DataFrame with 2-level MultiIndex, list of pd.DataFrame,
@@ -428,7 +428,7 @@ class BaseTransformer(BaseEstimator):
 
         Explicitly, with examples:
             if `X` is `Series` (e.g., `pd.DataFrame`) and `transform-output` is `Series`
-                then the return is a single `Series` of the same mtype
+                then the return is a single `Series` of the same type
                 Example: detrending a single series
             if `X` is `Panel` (e.g., `pd-multiindex`) and `transform-output` is `Series`
                 then the return is `Panel` with same number of instances as `X`
@@ -475,7 +475,7 @@ class BaseTransformer(BaseEstimator):
 
         Parameters
         ----------
-        X : Series or Panel, any supported mtype
+        X : Series or Panel, any supported type
             Data to be transformed, of python type as follows:
                 Series: pd.Series, pd.DataFrame, or np.ndarray (1D or 2D)
                 Panel: pd.DataFrame with 2-level MultiIndex, list of pd.DataFrame,
@@ -551,7 +551,7 @@ class BaseTransformer(BaseEstimator):
 
         Parameters
         ----------
-        X : Series or Panel, any supported mtype
+        X : Series or Panel, any supported type
             Data to be inverse transformed, of python type as follows:
                 Series: pd.Series, pd.DataFrame, or np.ndarray (1D or 2D)
                 Panel: pd.DataFrame with 2-level MultiIndex, list of pd.DataFrame,
@@ -608,7 +608,7 @@ class BaseTransformer(BaseEstimator):
 
         Parameters
         ----------
-        X : Series or Panel, any supported mtype
+        X : Series or Panel, any supported type
             Data to fit transform to, of python type as follows:
                 Series: pd.Series, pd.DataFrame, or np.ndarray (1D or 2D)
                 Panel: pd.DataFrame with 2-level MultiIndex, list of pd.DataFrame,
@@ -731,22 +731,26 @@ class BaseTransformer(BaseEstimator):
         -------
         X_inner : Series, Panel, or Hierarchical object, or VectorizedDF
                 compatible with self.get_tag("X_inner_type") format
-            Case 1: self.get_tag("X_inner_type") supports scitype of X, then
+            Case 1: self.get_tag("X_inner_type") supports abstract type of X, then
                 converted/coerced version of X, mtype determined by "X_inner_type" tag
-            Case 2: self.get_tag("X_inner_type") supports *higher* scitype than X
-                then X converted to "one-Series" or "one-Panel" sub-case of that scitype
-                always pd-multiindex (Panel) or pd_multiindex_hier (Hierarchical)
-            Case 3: self.get_tag("X_inner_type") supports only *simpler* scitype than X
-                then VectorizedDF of X, iterated as the most complex supported scitype
+            Case 2: self.get_tag("X_inner_type") supports *higher* abstract type than X
+                then X converted to "one-Series" or "one-Panel" sub-case of that
+                abstract type always pd-multiindex (Panel) or pd_multiindex_hier (
+                Hierarchical)
+            Case 3: self.get_tag("X_inner_type") supports only *simpler* abstract
+            type than X then VectorizedDF of X, iterated as the most complex
+            supported abstract type
         y_inner : Series, Panel, or Hierarchical object, or VectorizedDF
                 compatible with self.get_tag("y_inner_type") format
-            Case 1: self.get_tag("y_inner_type") supports scitype of y, then
-                converted/coerced version of y, mtype determined by "y_inner_type" tag
-            Case 2: self.get_tag("y_inner_type") supports *higher* scitype than y
-                then X converted to "one-Series" or "one-Panel" sub-case of that scitype
-                always pd-multiindex (Panel) or pd_multiindex_hier (Hierarchical)
-            Case 3: self.get_tag("y_inner_type") supports only *simpler* scitype than y
-                then VectorizedDF of X, iterated as the most complex supported scitype
+            Case 1: self.get_tag("y_inner_type") supports abstract type of y, then
+                converted/coerced version of y, type determined by "y_inner_type" tag
+            Case 2: self.get_tag("y_inner_type") supports *higher* abstract type than y
+                then X converted to "one-Series" or "one-Panel" sub-case of that
+                abstract type always pd-multiindex (Panel) or pd_multiindex_hier (
+                Hierarchical)
+            Case 3: self.get_tag("y_inner_type") supports only *simpler* abstract
+                type than y then VectorizedDF of X, iterated as the most complex
+                supported abstract type
             Case 4: None if y was None, or self.get_tag("y_inner_type") is "None"
 
             Complexity order above: Hierarchical > Panel > Series
@@ -755,10 +759,10 @@ class BaseTransformer(BaseEstimator):
             dictionary with str keys, contents as follows
             _converter_store_X : dict, metadata from X conversion, for back-conversion
             _X_mtype_last_seen : str, mtype of X seen last
-            _X_input_scitype : str, scitype of X seen last
+            _X_input_type : str, abstract type of X seen last
             _convert_case : str, coversion case (see above), one of
-                "case 1: scitype supported"
-                "case 2: higher scitype supported"
+                "case 1: abstract type supported"
+                "case 2: higher abstract type supported"
                 "case 3: requires vectorization"
 
         Raises
@@ -776,7 +780,7 @@ class BaseTransformer(BaseEstimator):
         metadata["_converter_store_X"] = dict()
 
         def _most_complex_scitype(scitypes, smaller_equal_than=None):
-            """Return most complex scitype in a list of str."""
+            """Return most complex abstract type in a list of str."""
             if "Hierarchical" in scitypes and smaller_equal_than == "Hierarchical":
                 return "Hierarchical"
             elif "Panel" in scitypes and smaller_equal_than != "Series":
@@ -1024,7 +1028,7 @@ class BaseTransformer(BaseEstimator):
                 if not valid:
                     raise TypeError(
                         f"_transform output of {type(self)} does not comply "
-                        "with aeon mtype specifications. See datatypes.MTYPE_REGISTER"
+                        "with aeon mtype specifications. See datatypes.TYPE_REGISTER"
                         " for mtype specifications. Returned error message:"
                         f" {msg}. Returned object: {Xt}"
                     )
@@ -1133,7 +1137,7 @@ class BaseTransformer(BaseEstimator):
 
         Parameters
         ----------
-        X : Series or Panel of mtype X_inner_type
+        X: data structure of type X_inner_type
             if X_inner_type is list, _fit must support all types in it
             Data to fit transform to
         y : Series or Panel of type y_inner_type, default=None
@@ -1155,7 +1159,7 @@ class BaseTransformer(BaseEstimator):
 
         Parameters
         ----------
-        X : Series or Panel of mtype X_inner_type
+        X: data structure of type X_inner_type
             if X_inner_type is list, _transform must support all types in it
             Data to be transformed
         y : Series or Panel, default=None
@@ -1189,7 +1193,7 @@ class BaseTransformer(BaseEstimator):
 
         Parameters
         ----------
-        X : Series or Panel of mtype X_inner_type
+        X: data structure of type X_inner_type
             if X_inner_type is list, _fit_transform must support all types in it
             Data to fit transform to
         y : Series or Panel of type y_inner_type, default=None
@@ -1213,7 +1217,7 @@ class BaseTransformer(BaseEstimator):
 
         Parameters
         ----------
-        X : Series or Panel of mtype X_inner_type
+        X: data structure of type X_inner_type
             if X_inner_type is list, _inverse_transform must support all types in it
             Data to be transformed
         y : Series or Panel, default=None
@@ -1222,7 +1226,7 @@ class BaseTransformer(BaseEstimator):
         Returns
         -------
         inverse transformed version of X
-            of the same type as X, and conforming to mtype format specifications
+            of the same type as X, and conforming to type format specifications
 
         See extension_templates/transformer.py for implementation details.
         """
@@ -1235,7 +1239,7 @@ class BaseTransformer(BaseEstimator):
 
         Parameters
         ----------
-        X : Series or Panel of mtype X_inner_type
+        X: data structure of type X_inner_type
             if X_inner_type is list, _update must support all types in it
             Data to update transformer with
         y : Series or Panel of type y_inner_type, default=None
diff --git a/aeon/transformations/binning.py b/aeon/transformations/binning.py
index af8b30b6..7f2342af 100644
--- a/aeon/transformations/binning.py
+++ b/aeon/transformations/binning.py
@@ -56,12 +56,11 @@ class TimeBinAggregate(BaseTransformer):
         "fit_is_empty": True,
         "univariate-only": False,
         "input_data_type": "Series",
-        # what is the scitype of X: Series, or Panel
+        # what is the abstract type of X: Series, or Panel
         "output_data_type": "Series",
-        # what is the scitype of y: None (not needed), Primitives, Series, Panel
-        "instancewise": True,  # is this an instance-wise transform?
+        # what is the abstract type of y: None (not needed), Primitives, Series, Panel
+        "instancewise": True,
         "X_inner_type": ["pd.DataFrame"],
-        # which mtypes do _fit/_predict support for X?
         "y_inner_type": "None",  # and for y?
         "capability:missing_values": True,
         "capability:unequal_length": True,
@@ -101,10 +100,10 @@ class TimeBinAggregate(BaseTransformer):
 
         Parameters
         ----------
-        X : Series or Panel of mtype X_inner_type
+        X: data structure of type X_inner_type
             if X_inner_type is list, _transform must support all types in it
             Data to be transformed
-        y : Series or Panel of mtype y_inner_type, default=None
+        y : data structure of type y_inner_type, default=None
             Additional data, e.g., labels for transformation
 
         Returns
diff --git a/aeon/transformations/bkfilter.py b/aeon/transformations/bkfilter.py
index 1a22d920..98816151 100644
--- a/aeon/transformations/bkfilter.py
+++ b/aeon/transformations/bkfilter.py
@@ -66,25 +66,19 @@ class BKFilter(BaseTransformer):
 
     _tags = {
         "input_data_type": "Series",
-        # what is the scitype of X: Series, or Panel
+        # what is the abstract type of X: Series, or Panel
         "output_data_type": "Series",
-        # what scitype is returned: Primitives, Series, Panel
-        "instancewise": True,  # is this an instance-wise transform?
-        "univariate-only": False,  # can the transformer handle multivariate X?
-        "X_inner_type": "np.ndarray",  # which mtypes do _fit/_predict support for X?
-        # this can be a Panel mtype even if transform-input is Series, vectorized
-        "y_inner_type": "None",  # which mtypes do _fit/_predict support for y?
-        "requires_y": False,  # does y need to be passed in fit?
-        "enforce_index_type": [
-            pd.RangeIndex
-        ],  # index type that needs to be enforced in X/y
-        "fit_is_empty": True,  # is fit empty and can be skipped? Yes = True
+        # what abstract type is returned: Primitives, Series, Panel
+        "instancewise": True,
+        "univariate-only": False,
+        "X_inner_type": "np.ndarray",
+        "y_inner_type": "None",
+        "enforce_index_type": [pd.RangeIndex],
+        "fit_is_empty": True,
         "transform-returns-same-time-index": False,
-        # does transform return have the same time index as input X
         "capability:unequal_length": True,
-        # can the transformer handle unequal length time series (if passed Panel)?
-        "capability:missing_values": False,  # can estimator handle missing data?
-        "remember_data": False,  # whether all data seen is remembered as self._X
+        "capability:missing_values": False,
+        "remember_data": False,
         "python_dependencies": "statsmodels",
     }
 
diff --git a/aeon/transformations/bootstrap/_mbb.py b/aeon/transformations/bootstrap/_mbb.py
index bf2f45c7..10c57af3 100644
--- a/aeon/transformations/bootstrap/_mbb.py
+++ b/aeon/transformations/bootstrap/_mbb.py
@@ -168,9 +168,9 @@ class STLBootstrapTransformer(BaseTransformer):
         "output_data_type": "Panel",
         "transform_labels": "None",
         "instancewise": True,  # is this an instance-wise transform?
-        "X_inner_type": "pd.DataFrame",  # which mtypes do _fit/_predict support for X?
+        "X_inner_type": "pd.DataFrame",
         # X_inner_type can be Panel mtype even if transform-input is Series, vectorized
-        "y_inner_type": "None",  # which mtypes do _fit/_predict support for y?
+        "y_inner_type": "None",
         "capability:inverse_transform": False,
         "skip-inverse-transform": True,  # is inverse-transform skipped when called?
         "univariate-only": True,  # can the transformer handle multivariate X?
@@ -479,9 +479,9 @@ class MovingBlockBootstrapTransformer(BaseTransformer):
         "output_data_type": "Panel",
         "transform_labels": "None",
         "instancewise": True,  # is this an instance-wise transform?
-        "X_inner_type": "pd.DataFrame",  # which mtypes do _fit/_predict support for X?
+        "X_inner_type": "pd.DataFrame",
         # X_inner_type can be Panel mtype even if transform-input is Series, vectorized
-        "y_inner_type": "None",  # which mtypes do _fit/_predict support for y?
+        "y_inner_type": "None",
         "capability:inverse_transform": False,
         "skip-inverse-transform": True,  # is inverse-transform skipped when called?
         "univariate-only": True,  # can the transformer handle multivariate X?
@@ -515,10 +515,10 @@ class MovingBlockBootstrapTransformer(BaseTransformer):
 
         Parameters
         ----------
-        X : Series or Panel of mtype X_inner_type
+        X: data structure of type X_inner_type
             if X_inner_type is list, _transform must support all types in it
             Data to be transformed
-        y : Series or Panel of mtype y_inner_type, default=None
+        y : data structure of type y_inner_type, default=None
             Additional data, e.g., labels for transformation
 
         Returns
diff --git a/aeon/transformations/boxcox.py b/aeon/transformations/boxcox.py
index b5b8f051..165bd25f 100644
--- a/aeon/transformations/boxcox.py
+++ b/aeon/transformations/boxcox.py
@@ -117,12 +117,12 @@ class BoxCoxTransformer(BaseTransformer):
 
     _tags = {
         "input_data_type": "Series",
-        # what is the scitype of X: Series, or Panel
+        # what is the abstract type of X: Series, or Panel
         "output_data_type": "Series",
-        # what scitype is returned: Primitives, Series, Panel
+        # what abstract type is returned: Primitives, Series, Panel
         "instancewise": True,  # is this an instance-wise transform?
-        "X_inner_type": "np.ndarray",  # which mtypes do _fit/_predict support for X?
-        "y_inner_type": "None",  # which mtypes do _fit/_predict support for y?
+        "X_inner_type": "np.ndarray",
+        "y_inner_type": "None",
         "transform-returns-same-time-index": True,
         "fit_is_empty": False,
         "univariate-only": True,
@@ -248,12 +248,12 @@ class LogTransformer(BaseTransformer):
 
     _tags = {
         "input_data_type": "Series",
-        # what is the scitype of X: Series, or Panel
+        # what is the abstract type of X: Series, or Panel
         "output_data_type": "Series",
-        # what scitype is returned: Primitives, Series, Panel
-        "instancewise": True,  # is this an instance-wise transform?
-        "X_inner_type": "np.ndarray",  # which mtypes do _fit/_predict support for X?
-        "y_inner_type": "None",  # which mtypes do _fit/_predict support for y?
+        # what abstract type is returned: Primitives, Series, Panel
+        "instancewise": True,
+        "X_inner_type": "np.ndarray",
+        "y_inner_type": "None",
         "transform-returns-same-time-index": True,
         "fit_is_empty": True,
         "univariate-only": False,
diff --git a/aeon/transformations/clasp.py b/aeon/transformations/clasp.py
index aeff010c..8665e641 100644
--- a/aeon/transformations/clasp.py
+++ b/aeon/transformations/clasp.py
@@ -392,12 +392,12 @@ class ClaSPTransformer(BaseTransformer):
 
     _tags = {
         "input_data_type": "Series",
-        # what is the scitype of X: Series, or Panel
+        # what is the abstract type of X: Series, or Panel
         "output_data_type": "Series",
-        # what scitype is returned: Primitives, Series, Panel
-        "instancewise": True,  # is this an instance-wise transform?
-        "X_inner_type": "np.ndarray",  # which mtypes do _fit/_predict support for X?
-        "y_inner_type": "None",  # which mtypes do _fit/_predict support for y?
+        # what abstract type is returned: Primitives, Series, Panel
+        "instancewise": True,
+        "X_inner_type": "np.ndarray",
+        "y_inner_type": "None",
         "univariate-only": True,
         "fit_is_empty": True,
     }
diff --git a/aeon/transformations/clear_sky.py b/aeon/transformations/clear_sky.py
index c25a0b65..d8be1c8d 100644
--- a/aeon/transformations/clear_sky.py
+++ b/aeon/transformations/clear_sky.py
@@ -78,8 +78,8 @@ class ClearSky(BaseTransformer):
         "univariate-only": True,  # can the transformer handle multivariate X?
         "X_inner_type": [
             "pd.Series",
-        ],  # which mtypes do _fit/_predict support for X?
-        "y_inner_type": "None",  # which mtypes do _fit/_predict support for y?
+        ],
+        "y_inner_type": "None",
         "requires_y": False,  # does y need to be passed in fit?
         "enforce_index_type": [
             pd.DatetimeIndex,
diff --git a/aeon/transformations/collection/feature_based/_tsfresh.py b/aeon/transformations/collection/feature_based/_tsfresh.py
index b64df169..af211f5b 100644
--- a/aeon/transformations/collection/feature_based/_tsfresh.py
+++ b/aeon/transformations/collection/feature_based/_tsfresh.py
@@ -536,7 +536,7 @@ class TSFreshRelevantFeatureExtractor(_TSFreshFeatureExtractor):
 
         Parameters
         ----------
-        X : Series or Panel, any supported mtype
+        X : Series or Panel, any supported type
             Data to be transformed, of python type as follows:
                 Series: pd.Series, pd.DataFrame, or np.ndarray (1D or 2D)
                 Panel: pd.DataFrame with 2-level MultiIndex, list of pd.DataFrame,
diff --git a/aeon/transformations/compose.py b/aeon/transformations/compose.py
index 9654741d..e547b833 100644
--- a/aeon/transformations/compose.py
+++ b/aeon/transformations/compose.py
@@ -7,7 +7,7 @@ import pandas as pd
 from sklearn import clone
 
 from aeon.base import _HeterogenousMetaEstimator
-from aeon.datatypes import ALL_TIME_SERIES_MTYPES
+from aeon.datatypes import ALL_TIME_SERIES_TYPES
 from aeon.transformations._delegate import _DelegatedTransformer
 from aeon.transformations.base import BaseTransformer
 from aeon.utils.multiindex import flatten_multiindex
@@ -33,9 +33,7 @@ __all__ = [
 ]
 
 
-# mtypes for Series, Panel, Hierarchical,
-# with exception of some ambiguous and discouraged mtypes
-CORE_MTYPES = [
+CORE_TYPES = [
     "pd.DataFrame",
     "np.ndarray",
     "pd.Series",
@@ -158,7 +156,7 @@ class TransformerPipeline(_HeterogenousMetaEstimator, BaseTransformer):
 
     _tags = {
         # we let all X inputs through to be handled by first transformer
-        "X_inner_type": CORE_MTYPES,
+        "X_inner_type": CORE_TYPES,
         "univariate-only": False,
     }
 
@@ -186,7 +184,6 @@ class TransformerPipeline(_HeterogenousMetaEstimator, BaseTransformer):
         first_trafo = ests[0][1]
         last_trafo = ests[-1][1]
 
-        # input mtype and input type are as of the first estimator
         self.clone_tags(first_trafo, ["input_data_type"])
         # output type is that of last estimator, if no "Primitives" occur in the middle
         # if "Primitives" occur in the middle, then output is set to that too
@@ -300,7 +297,7 @@ class TransformerPipeline(_HeterogenousMetaEstimator, BaseTransformer):
 
         Parameters
         ----------
-        X : Series or Panel of mtype X_inner_type
+        X: data structure of type X_inner_type
             if X_inner_type is list, _fit must support all types in it
             Data to fit transform to
         y : Series or Panel of type y_inner_type, default=None
@@ -325,7 +322,7 @@ class TransformerPipeline(_HeterogenousMetaEstimator, BaseTransformer):
 
         Parameters
         ----------
-        X : Series or Panel of mtype X_inner_type
+        X: data structure of type X_inner_type
             if X_inner_type is list, _transform must support all types in it
             Data to be transformed
         y : Series or Panel of type y_inner_type, default=None
@@ -351,7 +348,7 @@ class TransformerPipeline(_HeterogenousMetaEstimator, BaseTransformer):
 
         Parameters
         ----------
-        X : Series or Panel of mtype X_inner_type
+        X: data structure of type X_inner_type
             if X_inner_type is list, _inverse_transform must support all types in it
             Data to be inverse transformed
         y : Series or Panel of type y_inner_type, optional (default=None)
@@ -377,7 +374,7 @@ class TransformerPipeline(_HeterogenousMetaEstimator, BaseTransformer):
 
         Parameters
         ----------
-        X : Series or Panel of mtype X_inner_type
+        X: data structure of type X_inner_type
             if X_inner_type is list, _update must support all types in it
             Data to update transformer with
         y : Series or Panel of type y_inner_type, default=None
@@ -458,7 +455,7 @@ class FeatureUnion(_HeterogenousMetaEstimator, BaseTransformer):
     flatten_transform_index : bool, optional (default=True)
         if True, columns of return DataFrame are flat, by "transformer__variablename"
         if False, columns are MultiIndex (transformer, variablename)
-        has no effect if return mtype is one without column names
+        has no effect if return type is one without column names
     """
 
     _tags = {
@@ -732,7 +729,7 @@ class FitInTransform(BaseTransformer):
 
         Parameters
         ----------
-        X : Series or Panel of mtype X_inner_type
+        X: data structure of type X_inner_type
             if X_inner_type is list, _transform must support all types in it
             Data to be transformed
         y : Series or Panel of type y_inner_type, default=None
@@ -751,7 +748,7 @@ class FitInTransform(BaseTransformer):
 
         Parameters
         ----------
-        X : Series or Panel of mtype X_inner_type
+        X: data structure of type X_inner_type
             if X_inner_type is list, _inverse_transform must support all types in it
             Data to be inverse transformed
         y : Series or Panel of type y_inner_type, optional (default=None)
@@ -883,7 +880,7 @@ class MultiplexTransformer(_HeterogenousMetaEstimator, _DelegatedTransformer):
     _tags = {
         "fit_is_empty": False,
         "univariate-only": False,
-        "X_inner_type": ALL_TIME_SERIES_MTYPES,
+        "X_inner_type": ALL_TIME_SERIES_TYPES,
     }
 
     # attribute for _DelegatedTransformer, which then delegates
@@ -920,7 +917,7 @@ class MultiplexTransformer(_HeterogenousMetaEstimator, _DelegatedTransformer):
         self.clone_tags(self.transformer_)
         self.set_tags(**{"fit_is_empty": False})
         # this ensures that we convert in the inner estimator, not in the multiplexer
-        self.set_tags(**{"X_inner_type": ALL_TIME_SERIES_MTYPES})
+        self.set_tags(**{"X_inner_type": ALL_TIME_SERIES_TYPES})
 
     @property
     def _transformers(self):
@@ -1070,13 +1067,12 @@ class InvertTransform(_DelegatedTransformer):
 
     _tags = {
         "input_data_type": "Series",
-        # what is the scitype of X: Series, or Panel
+        # what is the abstract type of X: Series, or Panel
         "output_data_type": "Series",
-        # what scitype is returned: Primitives, Series, Panel
+        # what abstract type is returned: Primitives, Series, Panel
         "instancewise": True,  # is this an instance-wise transform?
         "X_inner_type": ["pd.DataFrame", "pd.Series"],
-        # which mtypes do _fit/_predict support for X?
-        "y_inner_type": "None",  # which mtypes do _fit/_predict support for y?
+        "y_inner_type": "None",
         "univariate-only": False,
         "fit_is_empty": False,
         "capability:inverse_transform": True,
@@ -1203,9 +1199,9 @@ class Id(BaseTransformer):
     _tags = {
         "capability:inverse_transform": True,  # can the transformer inverse transform?
         "univariate-only": False,  # can the transformer handle multivariate X?
-        "X_inner_type": CORE_MTYPES,  # which mtypes do _fit/_predict support for X?
+        "X_inner_type": CORE_TYPES,
         # this can be a Panel mtype even if transform-input is Series, vectorized
-        "y_inner_type": "None",  # which mtypes do _fit/_predict support for y?
+        "y_inner_type": "None",
         "fit_is_empty": True,  # is fit empty and can be skipped? Yes = True
         "transform-returns-same-time-index": True,
         # does transform return have the same time index as input X
@@ -1326,13 +1322,12 @@ class OptionalPassthrough(_DelegatedTransformer):
 
     _tags = {
         "input_data_type": "Series",
-        # what is the scitype of X: Series, or Panel
+        # what is the abstract type of X: Series, or Panel
         "output_data_type": "Series",
-        # what scitype is returned: Primitives, Series, Panel
-        "instancewise": True,  # is this an instance-wise transform?
-        "X_inner_type": CORE_MTYPES,
-        # which mtypes do _fit/_predict support for X?
-        "y_inner_type": "None",  # which mtypes do _fit/_predict support for y?
+        # what abstract type is returned: Primitives, Series, Panel
+        "instancewise": True,
+        "X_inner_type": CORE_TYPES,
+        "y_inner_type": "None",
         "univariate-only": False,
         "fit_is_empty": False,
         "capability:inverse_transform": True,
@@ -1432,13 +1427,12 @@ class ColumnwiseTransformer(BaseTransformer):
 
     _tags = {
         "input_data_type": "Series",
-        # what is the scitype of X: Series, or Panel
+        # what is the abstract type of X: Series, or Panel
         "output_data_type": "Series",
-        # what scitype is returned: Primitives, Series, Panel
+        # what abstract type is returned: Primitives, Series, Panel
         "instancewise": True,  # is this an instance-wise transform?
         "X_inner_type": "pd.DataFrame",
-        # which mtypes do _fit/_predict support for X?
-        "y_inner_type": "None",  # which mtypes do _fit/_predict support for y?
+        "y_inner_type": "None",
         "univariate-only": False,
         "fit_is_empty": False,
     }
@@ -1639,14 +1633,13 @@ class ColumnConcatenator(BaseTransformer):
 
     _tags = {
         "input_data_type": "Series",
-        # what is the scitype of X: Series, or Panel
+        # what is the abstract type of X: Series, or Panel
         "output_data_type": "Series",
-        # what scitype is returned: Primitives, Series, Panel
-        "instancewise": False,  # is this an instance-wise transform?
+        # what abstract type is returned: Primitives, Series, Panel
+        "instancewise": False,
         "X_inner_type": ["pd-multiindex", "pd_multiindex_hier"],
-        # which mtypes do _fit/_predict support for X?
-        "y_inner_type": "None",  # which mtypes do _fit/_predict support for X?
-        "fit_is_empty": True,  # is fit empty and can be skipped? Yes = True
+        "y_inner_type": "None",
+        "fit_is_empty": True,
     }
 
     def _transform(self, X, y=None):
@@ -1740,7 +1733,7 @@ class YtoX(BaseTransformer):
 
         Parameters
         ----------
-        X : Series or Panel of mtype X_inner_type
+        X: data structure of type X_inner_type
             if X_inner_type is list, _inverse_transform must support all types in it
             Data to be inverse transformed
         y : Series or Panel of type y_inner_type, optional (default=None)
diff --git a/aeon/transformations/cos.py b/aeon/transformations/cos.py
index 3c8208e1..9e8c835a 100644
--- a/aeon/transformations/cos.py
+++ b/aeon/transformations/cos.py
@@ -28,17 +28,16 @@ class CosineTransformer(BaseTransformer):
 
     _tags = {
         "input_data_type": "Series",
-        # what is the scitype of X: Series, or Panel
+        # what is the abstract type of X: Series, or Panel
         "output_data_type": "Series",
-        # what scitype is returned: Primitives, Series, Panel
-        "instancewise": True,  # is this an instance-wise transform?
-        "X_inner_type": "np.ndarray",  # which mtypes do _fit/_predict support for X?
-        "y_inner_type": "None",  # which mtypes do _fit/_predict support for y?
+        # what abstract type is returned: Primitives, Series, Panel
+        "instancewise": True,
+        "X_inner_type": "np.ndarray",
+        "y_inner_type": "None",
         "univariate-only": False,
         "fit_is_empty": True,
         "transform-returns-same-time-index": True,
         "capability:inverse_transform": False,
-        # switching off, since cos is not invertible outside [-pi, pi], fails test
     }
 
     def _transform(self, X, y=None):
diff --git a/aeon/transformations/date.py b/aeon/transformations/date.py
index 5650478c..1816914e 100644
--- a/aeon/transformations/date.py
+++ b/aeon/transformations/date.py
@@ -110,9 +110,9 @@ class DateTimeFeatures(BaseTransformer):
 
     _tags = {
         "input_data_type": "Series",
-        # what is the scitype of X: Series, or Panel
+        # what is the abstract type of X: Series, or Panel
         "output_data_type": "Series",
-        # what scitype is returned: Primitives, Series, Panel
+        # what abstract type is returned: Primitives, Series, Panel
         "instancewise": True,  # is this an instance-wise transform?
         "X_inner_type": [
             "pd.Series",
@@ -120,8 +120,7 @@ class DateTimeFeatures(BaseTransformer):
             "pd-multiindex",
             "pd_multiindex_hier",
         ],
-        # which mtypes do _fit/_predict support for X?
-        "y_inner_type": "None",  # which mtypes do _fit/_predict support for y?
+        "y_inner_type": "None",
         "univariate-only": False,
         "fit_is_empty": True,
         "transform-returns-same-time-index": True,
diff --git a/aeon/transformations/detrend/_deseasonalize.py b/aeon/transformations/detrend/_deseasonalize.py
index 7bc08363..b8989c0a 100644
--- a/aeon/transformations/detrend/_deseasonalize.py
+++ b/aeon/transformations/detrend/_deseasonalize.py
@@ -62,13 +62,12 @@ class Deseasonalizer(BaseTransformer):
 
     _tags = {
         "input_data_type": "Series",
-        # what is the scitype of X: Series, or Panel
+        # what is the abstract type of X: Series, or Panel
         "output_data_type": "Series",
-        # what scitype is returned: Primitives, Series, Panel
+        # what abstract type is returned: Primitives, Series, Panel
         "instancewise": True,  # is this an instance-wise transform?
         "X_inner_type": "pd.Series",
-        # which mtypes do _fit/_predict support for X?
-        "y_inner_type": "None",  # which mtypes do _fit/_predict support for y?
+        "y_inner_type": "None",
         "fit_is_empty": False,
         "capability:inverse_transform": True,
         "transform-returns-same-time-index": True,
@@ -450,12 +449,12 @@ class STLTransformer(BaseTransformer):
 
     _tags = {
         "input_data_type": "Series",
-        # what is the scitype of X: Series, or Panel
+        # what is the abstract type of X: Series, or Panel
         "output_data_type": "Series",
-        # what scitype is returned: Primitives, Series, Panel
-        "instancewise": True,  # is this an instance-wise transform?
-        "X_inner_type": "pd.Series",  # which mtypes do _fit/_predict support for X?
-        "y_inner_type": "pd.Series",  # which mtypes do _fit/_predict support for y?
+        # what abstract type is returned: Primitives, Series, Panel
+        "instancewise": True,
+        "X_inner_type": "pd.Series",
+        "y_inner_type": "pd.Series",
         "transform-returns-same-time-index": True,
         "univariate-only": True,
         "fit_is_empty": False,
diff --git a/aeon/transformations/detrend/_detrend.py b/aeon/transformations/detrend/_detrend.py
index 8e62be3a..32c29267 100644
--- a/aeon/transformations/detrend/_detrend.py
+++ b/aeon/transformations/detrend/_detrend.py
@@ -67,14 +67,12 @@ class Detrender(BaseTransformer):
 
     _tags = {
         "input_data_type": "Series",
-        # what is the scitype of X: Series, or Panel
+        # what is the abstract type of X: Series, or Panel
         "output_data_type": "Series",
-        # what scitype is returned: Primitives, Series, Panel
+        # what abstract type is returned: Primitives, Series, Panel
         "instancewise": True,  # is this an instance-wise transform?
         "X_inner_type": ["pd.DataFrame", "pd-multiindex", "pd_multiindex_hier"],
-        # which mtypes do _fit/_predict support for X?
         "y_inner_type": ["pd.DataFrame", "pd-multiindex", "pd_multiindex_hier"],
-        # which mtypes do _fit/_predict support for y?
         "univariate-only": False,
         "fit_is_empty": False,
         "capability:inverse_transform": True,
diff --git a/aeon/transformations/difference.py b/aeon/transformations/difference.py
index 4557cd19..966f7b25 100644
--- a/aeon/transformations/difference.py
+++ b/aeon/transformations/difference.py
@@ -217,13 +217,12 @@ class Differencer(BaseTransformer):
 
     _tags = {
         "input_data_type": "Series",
-        # what is the scitype of X: Series, or Panel
+        # what is the abstract type of X: Series, or Panel
         "output_data_type": "Series",
-        # what scitype is returned: Primitives, Series, Panel
-        "instancewise": True,  # is this an instance-wise transform?
+        # what abstract type is returned: Primitives, Series, Panel
+        "instancewise": True,
         "X_inner_type": ["pd.DataFrame", "pd.Series"],
-        # which mtypes do _fit/_predict support for X?
-        "y_inner_type": "None",  # which mtypes do _fit/_predict support for y?
+        "y_inner_type": "None",
         "fit_is_empty": False,
         "transform-returns-same-time-index": False,
         "univariate-only": False,
diff --git a/aeon/transformations/dobin.py b/aeon/transformations/dobin.py
index 774402d0..e376c6d1 100644
--- a/aeon/transformations/dobin.py
+++ b/aeon/transformations/dobin.py
@@ -100,9 +100,9 @@ class DOBIN(BaseTransformer):
 
         Parameters
         ----------
-        X : Series of mtype X_inner_type
+        X : Series of type X_inner_type
             Data to be transformed
-        y : Series of mtype y_inner_type, default=None
+        y : Series of type y_inner_type, default=None
             Not required for this unsupervised transform.
 
         Returns
@@ -187,9 +187,9 @@ class DOBIN(BaseTransformer):
 
         Parameters
         ----------
-        X : Series of mtype X_inner_type
+        X : Series of type X_inner_type
             Data to be transformed
-        y : Series of mtype y_inner_type, default=None
+        y : Series of type y_inner_type, default=None
             Not required for this unsupervised transform.
 
         Returns
diff --git a/aeon/transformations/exponent.py b/aeon/transformations/exponent.py
index 5c16061e..2495d596 100644
--- a/aeon/transformations/exponent.py
+++ b/aeon/transformations/exponent.py
@@ -70,13 +70,12 @@ class ExponentTransformer(BaseTransformer):
 
     _tags = {
         "input_data_type": "Series",
-        # what is the scitype of X: Series, or Panel
+        # what is the abstract type of X: Series, or Panel
         "output_data_type": "Series",
-        # what scitype is returned: Primitives, Series, Panel
+        # what abstract type is returned: Primitives, Series, Panel
         "instancewise": True,  # is this an instance-wise transform?
         "X_inner_type": ["pd.DataFrame", "pd.Series"],
-        # which mtypes do _fit/_predict support for X?
-        "y_inner_type": "None",  # which mtypes do _fit/_predict support for y?
+        "y_inner_type": "None",
         "fit_is_empty": True,
         "transform-returns-same-time-index": True,
         "univariate-only": False,
diff --git a/aeon/transformations/feature_selection.py b/aeon/transformations/feature_selection.py
index 07717d88..1cee3ec5 100644
--- a/aeon/transformations/feature_selection.py
+++ b/aeon/transformations/feature_selection.py
@@ -70,13 +70,12 @@ class FeatureSelection(BaseTransformer):
 
     _tags = {
         "input_data_type": "Series",
-        # what is the scitype of X: Series, or Panel
+        # what is the abstract type of X: Series, or Panel
         "output_data_type": "Series",
-        # what scitype is returned: Primitives, Series, Panel
-        "instancewise": True,  # is this an instance-wise transform?
+        # what abstract type is returned: Primitives, Series, Panel
+        "instancewise": True,
         "X_inner_type": ["pd.DataFrame", "pd.Series"],
-        # which mtypes do _fit/_predict support for X?
-        "y_inner_type": "pd.DataFrame",  # which mtypes do _fit/_predict support for y?
+        "y_inner_type": "pd.DataFrame",
         "fit_is_empty": False,
         "transform-returns-same-time-index": True,
         "skip-inverse-transform": True,
diff --git a/aeon/transformations/filter.py b/aeon/transformations/filter.py
index 89c2c6d3..745ece90 100644
--- a/aeon/transformations/filter.py
+++ b/aeon/transformations/filter.py
@@ -36,12 +36,12 @@ class Filter(BaseTransformer):
     # default tag values for "Series-to-Series"
     _tags = {
         "input_data_type": "Series",
-        # what is the scitype of X: Series, or Panel
+        # what is the abstract type of X: Series, or Panel
         "output_data_type": "Series",
-        # what scitype is returned: Primitives, Series, Panel
+        # what abstract type is returned: Primitives, Series, Panel
         "instancewise": True,  # is this an instance-wise transform?
         "X_inner_type": ["np.ndarray", "numpy3D"],
-        "y_inner_type": "None",  # which mtypes do _fit/_predict support for X?
+        "y_inner_type": "None",
         "fit_is_empty": True,  # is fit empty and can be skipped? Yes = True
         "python_dependencies": "mne",
     }
diff --git a/aeon/transformations/fourier.py b/aeon/transformations/fourier.py
index 658aaa9f..572ad153 100644
--- a/aeon/transformations/fourier.py
+++ b/aeon/transformations/fourier.py
@@ -70,17 +70,16 @@ class FourierFeatures(BaseTransformer):
 
     _tags = {
         "input_data_type": "Series",
-        # what is the scitype of X: Series, or Panel
+        # what is the abstract type of X: Series, or Panel
         "output_data_type": "Series",
-        # what scitype is returned: Primitives, Series, Panel
+        # what abstract type is returned: Primitives, Series, Panel
         "transform_labels": "None",
-        # what is the scitype of y: None (not needed), Primitives, Series, Panel
-        "instancewise": True,  # is this an instance-wise transform?
-        "capability:inverse_transform": False,  # can the transformer inverse transform?
-        "univariate-only": False,  # can the transformer handle multivariate X?
-        "X_inner_type": "pd.DataFrame",  # which mtypes do _fit/_predict support for X?
-        # this can be a Panel mtype even if transform-input is Series, vectorized
-        "y_inner_type": "None",  # which mtypes do _fit/_predict support for y?
+        # what is the abstract type of y: None (not needed), Primitives, Series, Panel
+        "instancewise": True,
+        "capability:inverse_transform": False,
+        "univariate-only": False,
+        "X_inner_type": "pd.DataFrame",
+        "y_inner_type": "None",
         "requires_y": False,  # does y need to be passed in fit?
         "enforce_index_type": [
             pd.PeriodIndex,
@@ -135,10 +134,10 @@ class FourierFeatures(BaseTransformer):
 
         Parameters
         ----------
-        X : Series or Panel of mtype X_inner_type
+        X: data structure of type X_inner_type
             If X_inner_type is list, _fit must support all types in it
             Data to fit transform to.
-        y : Series or Panel of mtype y_inner_type, default=None
+        y : data structure of type y_inner_type, default=None
             Additional data, e.g., labels for transformation.
         freq : str, optional, default = None
             Only used when X has a pd.DatetimeIndex without a specified frequency.
@@ -195,10 +194,10 @@ class FourierFeatures(BaseTransformer):
 
         Parameters
         ----------
-        X : Series or Panel of mtype X_inner_type
+        X: data structure of type X_inner_type
             If X_inner_type is list, _transform must support all types in it
             Data to be transformed.
-        y : Series or Panel of mtype y_inner_type, default=None
+        y : data structure of type y_inner_type, default=None
             Additional data, e.g., labels for transformation.
 
         Returns
diff --git a/aeon/transformations/func_transform.py b/aeon/transformations/func_transform.py
index b3f469d9..b34f2252 100644
--- a/aeon/transformations/func_transform.py
+++ b/aeon/transformations/func_transform.py
@@ -75,13 +75,12 @@ class FunctionTransformer(BaseTransformer):
 
     _tags = {
         "input_data_type": "Series",
-        # what is the scitype of X: Series, or Panel
+        # what is the abstract type of X: Series, or Panel
         "output_data_type": "Series",
-        # what scitype is returned: Primitives, Series, Panel
+        # what abstract type is returned: Primitives, Series, Panel
         "instancewise": True,  # is this an instance-wise transform?
         "X_inner_type": ["pd.DataFrame", "pd.Series", "np.ndarray"],
-        # which mtypes do _fit/_predict support for X?
-        "y_inner_type": "None",  # which mtypes do _fit/_predict support for y?
+        "y_inner_type": "None",
         "fit_is_empty": True,
         "capability:missing_values": True,
         "capability:inverse_transform": True,
diff --git a/aeon/transformations/hidalgo.py b/aeon/transformations/hidalgo.py
index 6dfc4a9a..57d5d39e 100644
--- a/aeon/transformations/hidalgo.py
+++ b/aeon/transformations/hidalgo.py
@@ -86,9 +86,8 @@ class Hidalgo(BaseTransformer):
 
     _tags = {
         "input_data_type": "Series",
-        # what is the scitype of X: Series, or Panel
         "output_data_type": "Series",
-        # what scitype is returned: Primitives, Series, Panel
+        # what abstract type is returned: Primitives, Series, Panel
         "transform-returns-same-time-index": True,
         "univariate-only": False,
         "fit_is_empty": False,
@@ -659,10 +658,10 @@ class Hidalgo(BaseTransformer):
 
         Parameters
         ----------
-        X : Series of mtype X_inner_type
+        X : Series of type X_inner_type
             if X_inner_type is list, _transform must support all types in it
             Data to be transformed
-        y : Series of mtype y_inner_type, default=None
+        y : Series of type y_inner_type, default=None
             Not used in this unsupervised implementation
 
         Returns
diff --git a/aeon/transformations/hierarchical/aggregate.py b/aeon/transformations/hierarchical/aggregate.py
index 25193000..c915aa4b 100644
--- a/aeon/transformations/hierarchical/aggregate.py
+++ b/aeon/transformations/hierarchical/aggregate.py
@@ -57,7 +57,7 @@ class Aggregator(BaseTransformer):
             "pd-multiindex",
             "pd_multiindex_hier",
         ],
-        "y_inner_type": "None",  # which mtypes do _fit/_predict support for y?
+        "y_inner_type": "None",
         "capability:inverse_transform": False,  # does transformer have inverse
         "skip-inverse-transform": True,  # is inverse-transform skipped when called?
         "univariate-only": False,  # can the transformer handle multivariate X?
diff --git a/aeon/transformations/hierarchical/reconcile.py b/aeon/transformations/hierarchical/reconcile.py
index 2e4bf72e..bea2559d 100644
--- a/aeon/transformations/hierarchical/reconcile.py
+++ b/aeon/transformations/hierarchical/reconcile.py
@@ -81,7 +81,7 @@ class Reconciler(BaseTransformer):
             "pd-multiindex",
             "pd_multiindex_hier",
         ],
-        "y_inner_type": "None",  # which mtypes do _fit/_predict support for y?
+        "y_inner_type": "None",
         "capability:inverse_transform": False,
         "skip-inverse-transform": True,  # is inverse-transform skipped when called?
         "univariate-only": True,  # can the transformer handle multivariate X?
@@ -111,7 +111,7 @@ class Reconciler(BaseTransformer):
 
         Parameters
         ----------
-        X : Panel of mtype pd_multiindex_hier
+        X : hierarchical multiindex pd.DataFrame
             Data to fit transform to
         y :  Ignored argument for interface compatibility.
 
@@ -156,7 +156,7 @@ class Reconciler(BaseTransformer):
 
         Parameters
         ----------
-        X : Panel of mtype pd_multiindex_hier
+        X : hierarchical multiindex pd.DataFrame
             Data to be transformed
         y : Ignored argument for interface compatibility.
 
@@ -245,7 +245,7 @@ def _get_s_matrix(X):
 
     Parameters
     ----------
-    X :  Panel of mtype pd_multiindex_hier
+    X :  hierarchical multiindex pd.DataFrame
 
     Returns
     -------
@@ -307,7 +307,7 @@ def _get_g_matrix_bu(X):
 
     Parameters
     ----------
-    X :  Panel of mtype pd_multiindex_hier
+    X :  hierarchical multiindex pd.DataFrame
 
     Returns
     -------
@@ -354,7 +354,7 @@ def _get_g_matrix_ols(X):
 
     Parameters
     ----------
-    X :  Panel of mtype pd_multiindex_hier
+    X :  hierarchical multiindex pd.DataFrame
 
     Returns
     -------
@@ -393,7 +393,7 @@ def _get_g_matrix_wls_str(X):
 
     Parameters
     ----------
-    X :  Panel of mtype pd_multiindex_hier
+    X :  hierarchical multiindex pd.DataFrame
 
     Returns
     -------
@@ -441,7 +441,7 @@ def _get_g_matrix_td_fcst(X):
 
     Parameters
     ----------
-    X :  Panel of mtype pd_multiindex_hier
+    X :  hierarchical multiindex pd.DataFrame
 
     Returns
     -------
diff --git a/aeon/transformations/impute.py b/aeon/transformations/impute.py
index de8fdcdd..09224e65 100644
--- a/aeon/transformations/impute.py
+++ b/aeon/transformations/impute.py
@@ -80,21 +80,19 @@ class Imputer(BaseTransformer):
 
     _tags = {
         "input_data_type": "Series",
-        # what is the scitype of X: Series, or Panel
+        # what is the abstract type of X: Series, or Panel
         "output_data_type": "Series",
-        # what scitype is returned: Primitives, Series, Panel
+        # what abstract type is returned: Primitives, Series, Panel
         "instancewise": True,  # is this an instance-wise transform?
         "X_inner_type": ["pd.DataFrame"],
-        # which mtypes do _fit/_predict support for X?
-        "y_inner_type": "None",  # which mtypes do _fit/_predict support for y?
+        "y_inner_type": "None",
         "fit_is_empty": False,
         "capability:missing_values": True,
         "skip-inverse-transform": True,
         "capability:inverse_transform": True,
         "univariate-only": False,
         "capability:missing_values:removes": True,
-        # is transform result always guaranteed to contain no missing values?
-        "remember_data": False,  # remember all data seen as _X
+        "remember_data": False,
     }
 
     def __init__(
@@ -124,10 +122,10 @@ class Imputer(BaseTransformer):
 
         Parameters
         ----------
-        X : Series or Panel of mtype X_inner_type
+        X: data structure of type X_inner_type
             if X_inner_type is list, _fit must support all types in it
             Data to fit transform to
-        y : Series or Panel of mtype y_inner_type, default=None
+        y : data structure of type y_inner_type, default=None
             Additional data, e.g., labels for transformation
 
         Returns
diff --git a/aeon/transformations/kalman_filter.py b/aeon/transformations/kalman_filter.py
index 24163664..f9347499 100644
--- a/aeon/transformations/kalman_filter.py
+++ b/aeon/transformations/kalman_filter.py
@@ -443,16 +443,12 @@ class KalmanFilterTransformer(BaseKalmanFilter, BaseTransformer):
 
     _tags = {
         "transform_labels": "Series",
-        # what is the scitype of y: None (not needed), Primitives, Series, Panel
-        "X_inner_type": "np.ndarray",  # which mtypes do _fit/_predict support for X?
-        # this can be a Panel mtype even if transform-input is Series, vectorized
-        "y_inner_type": "np.ndarray",  # which mtypes do _fit/_predict support for y?
-        "fit_is_empty": False,  # is fit empty and can be skipped? Yes = True
+        "X_inner_type": "np.ndarray",
+        "y_inner_type": "np.ndarray",
+        "fit_is_empty": False,
         "capability:unequal_length": False,
-        # can the transformer handle unequal length time series (if passed Panel)?
         "capability:missing_values": True,  # can estimator handle missing data?
         "capability:missing_values:removes": False,
-        # is transform result always guaranteed to contain no missing values?
         "instancewise": True,  # is this an instance-wise transform?
         "python_dependencies": ["filterpy", "numpy<1.24.0"],
     }
diff --git a/aeon/transformations/lag.py b/aeon/transformations/lag.py
index 37703520..9eac4141 100644
--- a/aeon/transformations/lag.py
+++ b/aeon/transformations/lag.py
@@ -109,14 +109,14 @@ class Lag(BaseTransformer):
 
     _tags = {
         "input_data_type": "Series",
-        # what is the scitype of X: Series, or Panel
+        # what is the abstract type of X: Series, or Panel
         "output_data_type": "Series",
-        # what scitype is returned: Primitives, Series, Panel
+        # what abstract type is returned: Primitives, Series, Panel
         "instancewise": True,  # is this an instance-wise transform?
         "capability:inverse_transform": False,  # can the transformer inverse transform?
         "univariate-only": False,  # can the transformer handle multivariate X?
-        "X_inner_type": "pd.DataFrame",  # which mtypes do _fit/_predict support for X?
-        "y_inner_type": "None",  # which mtypes do _fit/_predict support for y?
+        "X_inner_type": "pd.DataFrame",
+        "y_inner_type": "None",
         "fit_is_empty": False,  # is fit empty and can be skipped? Yes = True
         "transform-returns-same-time-index": False,
         # does transform return have the same time index as input X
@@ -397,14 +397,14 @@ class ReducerTransform(BaseTransformer):
 
     _tags = {
         "input_data_type": "Series",
-        # what is the scitype of X: Series, or Panel
+        # what is the abstract type of X: Series, or Panel
         "output_data_type": "Series",
         # what scitype is returned: Primitives, Series, Panel
         "instancewise": True,  # is this an instance-wise transform?
         "capability:inverse_transform": False,  # can the transformer inverse transform?
         "univariate-only": False,  # can the transformer handle multivariate X?
-        "X_inner_type": "pd.DataFrame",  # which mtypes do _fit/_predict support for X?
-        "y_inner_type": "pd.DataFrame",  # which mtypes do _fit/_predict support for y?
+        "X_inner_type": "pd.DataFrame",
+        "y_inner_type": "pd.DataFrame",
         "fit_is_empty": False,  # is fit empty and can be skipped? Yes = True
         "transform-returns-same-time-index": False,
         # does transform return have the same time index as input X
diff --git a/aeon/transformations/matrix_profile.py b/aeon/transformations/matrix_profile.py
index a5ae43ca..cdd16540 100644
--- a/aeon/transformations/matrix_profile.py
+++ b/aeon/transformations/matrix_profile.py
@@ -38,13 +38,12 @@ class MatrixProfileTransformer(BaseTransformer):
 
     _tags = {
         "input_data_type": "Series",
-        # what is the scitype of X: Series, or Panel
+        # what is the abstract type of X: Series, or Panel
         "output_data_type": "Series",
-        # what scitype is returned: Primitives, Series, Panel
+        # what abstract type is returned: Primitives, Series, Panel
         "instancewise": True,  # is this an instance-wise transform?
         "X_inner_type": ["np.ndarray"],
-        # which mtypes do _fit/_predict support for X?
-        "y_inner_type": "None",  # which mtypes do _fit/_predict support for y?,
+        "y_inner_type": "None",
         "univariate-only": True,
         "fit_is_empty": True,  # for unit test cases
         "python_dependencies": "stumpy",
diff --git a/aeon/transformations/outlier_detection.py b/aeon/transformations/outlier_detection.py
index bda24390..2947b324 100644
--- a/aeon/transformations/outlier_detection.py
+++ b/aeon/transformations/outlier_detection.py
@@ -51,13 +51,12 @@ class HampelFilter(BaseTransformer):
 
     _tags = {
         "input_data_type": "Series",
-        # what is the scitype of X: Series, or Panel
+        # what is the abstract type of X: Series, or Panel
         "output_data_type": "Series",
-        # what scitype is returned: Primitives, Series, Panel
+        # what abstract type is returned: Primitives, Series, Panel
         "instancewise": True,  # is this an instance-wise transform?
         "X_inner_type": ["pd.DataFrame", "pd.Series"],
-        # which mtypes do _fit/_predict support for X?
-        "y_inner_type": "None",  # which mtypes do _fit/_predict support for y?
+        "y_inner_type": "None",
         "fit_is_empty": True,
         "capability:missing_values": True,
         "skip-inverse-transform": True,
diff --git a/aeon/transformations/pca.py b/aeon/transformations/pca.py
index 06009565..a954f776 100644
--- a/aeon/transformations/pca.py
+++ b/aeon/transformations/pca.py
@@ -104,12 +104,12 @@ class PCATransformer(BaseTransformer):
 
     _tags = {
         "input_data_type": "Series",
-        # what is the scitype of X: Series, or Panel
+        # what is the abstract type of X: Series, or Panel
         "output_data_type": "Series",
-        # what scitype is returned: Primitives, Series, Panel
+        # what abstract type is returned: Primitives, Series, Panel
         "instancewise": False,  # is this an instance-wise transform?
-        "X_inner_type": "pd.DataFrame",  # which mtypes do _fit/_predict support for X?
-        "y_inner_type": "None",  # which mtypes do _fit/_predict support for X?
+        "X_inner_type": "pd.DataFrame",
+        "y_inner_type": "None",
         "univariate-only": False,
         "fit_is_empty": False,
         "capability:missing_values": False,
@@ -146,7 +146,7 @@ class PCATransformer(BaseTransformer):
 
         Parameters
         ----------
-        X : Series or Panel of mtype X_inner_type
+        X: data structure of type X_inner_type
             if X_inner_type is list, _fit must support all types in it
             Data to fit transform to
         y : Ignored
@@ -177,7 +177,7 @@ class PCATransformer(BaseTransformer):
 
         Parameters
         ----------
-        X : Series or Panel of mtype X_inner_type
+        X: data structure of type X_inner_type
             if X_inner_type is list, _transform must support all types in it
             Data to be transformed
         y : Ignored
diff --git a/aeon/transformations/scaledlogit.py b/aeon/transformations/scaledlogit.py
index c287f283..c33113a5 100644
--- a/aeon/transformations/scaledlogit.py
+++ b/aeon/transformations/scaledlogit.py
@@ -90,12 +90,12 @@ class ScaledLogitTransformer(BaseTransformer):
 
     _tags = {
         "input_data_type": "Series",
-        # what is the scitype of X: Series, or Panel
+        # what is the abstract type of X: Series, or Panel
         "output_data_type": "Series",
-        # what scitype is returned: Primitives, Series, Panel
+        # what abstract type is returned: Primitives, Series, Panel
         "instancewise": True,  # is this an instance-wise transform?
-        "X_inner_type": "np.ndarray",  # which mtypes do _fit/_predict support for X?
-        "y_inner_type": "None",  # which mtypes do _fit/_predict support for y?
+        "X_inner_type": "np.ndarray",
+        "y_inner_type": "None",
         "transform-returns-same-time-index": True,
         "fit_is_empty": True,
         "univariate-only": False,
@@ -118,7 +118,7 @@ class ScaledLogitTransformer(BaseTransformer):
         ----------
         X : 2D np.ndarray
             Data to be transformed
-        y : Series or Panel of mtype y_inner_type, default=None
+        y : data structure of type y_inner_type, default=None
             Ignored argument for interface compatibility
 
         Returns
diff --git a/aeon/transformations/subset.py b/aeon/transformations/subset.py
index 8fab7251..00dd9eea 100644
--- a/aeon/transformations/subset.py
+++ b/aeon/transformations/subset.py
@@ -37,9 +37,9 @@ class IndexSubset(BaseTransformer):
 
     _tags = {
         "input_data_type": "Series",
-        # what is the scitype of X: Series, or Panel
+        # what is the abstract type of X: Series, or Panel
         "output_data_type": "Series",
-        # what scitype is returned: Primitives, Series, Panel
+        # what abstract type is returned: Primitives, Series, Panel
         "instancewise": True,  # is this an instance-wise transform?
         "X_inner_type": ["pd.DataFrame", "pd.Series"],
         "y_inner_type": ["pd.DataFrame", "pd.Series"],
@@ -150,9 +150,9 @@ class ColumnSelect(BaseTransformer):
 
     _tags = {
         "input_data_type": "Series",
-        # what is the scitype of X: Series, or Panel
+        # what is the abstract type of X: Series, or Panel
         "output_data_type": "Series",
-        # what scitype is returned: Primitives, Series, Panel
+        # what abstract type is returned: Primitives, Series, Panel
         "instancewise": True,  # is this an instance-wise transform?
         "X_inner_type": "pd.DataFrame",
         "y_inner_type": "None",
diff --git a/aeon/transformations/summarize.py b/aeon/transformations/summarize.py
index fb88cb98..640c8a47 100644
--- a/aeon/transformations/summarize.py
+++ b/aeon/transformations/summarize.py
@@ -186,7 +186,7 @@ class WindowSummarizer(BaseTransformer):
             "pd-multiindex",
             "pd.DataFrame",
             "pd_multiindex_hier",
-        ],  # which mtypes do _fit/_predict support for X?
+        ],
         "skip-inverse-transform": True,  # is inverse-transform skipped when called?
         "univariate-only": False,  # can the transformer handle multivariate X?
         "capability:missing_values": True,  # can estimator handle missing data?
@@ -632,13 +632,12 @@ class SummaryTransformer(BaseTransformer):
 
     _tags = {
         "input_data_type": "Series",
-        # what is the scitype of X: Series, or Panel
+        # what is the abstract type of X: Series, or Panel
         "output_data_type": "Primitives",
-        # what scitype is returned: Primitives, Series, Panel
+        # what abstract type is returned: Primitives, Series, Panel
         "instancewise": True,  # is this an instance-wise transform?
         "X_inner_type": ["pd.DataFrame", "pd.Series"],
-        # which mtypes do _fit/_predict support for X?
-        "y_inner_type": "None",  # which mtypes do _fit/_predict support for X?
+        "y_inner_type": "None",
         "fit_is_empty": True,
     }
 
@@ -841,12 +840,12 @@ class FittedParamExtractor(BaseTransformer):
         "fit_is_empty": True,
         "univariate-only": True,
         "input_data_type": "Series",
-        # what is the scitype of X: Series, or Panel
+        # what is the abstract type of X: Series, or Panel
         "output_data_type": "Primitives",
-        # what is the scitype of y: None (not needed), Primitives, Series, Panel
-        "instancewise": True,  # is this an instance-wise transform?
-        "X_inner_type": "numpy3D",  # which mtypes do _fit/_predict support for X?
-        "y_inner_type": "None",  # which mtypes do _fit/_predict support for y?
+        # what is the abstract type of y: None (not needed), Primitives, Series, Panel
+        "instancewise": True,
+        "X_inner_type": "numpy3D",
+        "y_inner_type": "None",
     }
 
     def __init__(self, forecaster, param_names, n_jobs=None):
diff --git a/aeon/transformations/theta.py b/aeon/transformations/theta.py
index 025ec96c..d68053fb 100644
--- a/aeon/transformations/theta.py
+++ b/aeon/transformations/theta.py
@@ -59,13 +59,12 @@ class ThetaLinesTransformer(BaseTransformer):
 
     _tags = {
         "input_data_type": "Series",
-        # what is the scitype of X: Series, or Panel
+        # what is the abstract type of X: Series, or Panel
         "output_data_type": "Series",
-        # what scitype is returned: Primitives, Series, Panel
+        # what abstract type is returned: Primitives, Series, Panel
         "instancewise": True,  # is this an instance-wise transform?
         "X_inner_type": ["pd.DataFrame", "pd.Series"],
-        # which mtypes do _fit/_predict support for X?
-        "y_inner_type": "None",  # which mtypes do _fit/_predict support for y?
+        "y_inner_type": "None",
         "transform-returns-same-time-index": True,
         "univariate-only": True,
         "fit_is_empty": True,
diff --git a/aeon/transformations/time_since.py b/aeon/transformations/time_since.py
index dacc8380..3288f9f3 100644
--- a/aeon/transformations/time_since.py
+++ b/aeon/transformations/time_since.py
@@ -70,9 +70,9 @@ class TimeSince(BaseTransformer):
     """
 
     _tags = {
-        # what is the scitype of X: Series, or Panel
+        # what is the abstract type of X: Series, or Panel
         "input_data_type": "Series",
-        # what scitype is returned: Primitives, Series, Panel
+        # what abstract type is returned: Primitives, Series, Panel
         "output_data_type": "Series",
         "instancewise": True,  # is this an instance-wise transform?
         "transform_labels": "None",
@@ -116,10 +116,10 @@ class TimeSince(BaseTransformer):
 
         Parameters
         ----------
-        X : Series or Panel of mtype X_inner_type
+        X: data structure of type X_inner_type
             if X_inner_type is list, _fit must support all types in it
             Data to fit transform to
-        y : Series or Panel of mtype y_inner_type, default=None
+        y : data structure of type y_inner_type, default=None
             Additional data, e.g., labels for transformation
 
         Returns
@@ -200,10 +200,10 @@ class TimeSince(BaseTransformer):
 
         Parameters
         ----------
-        X : Series or Panel of mtype X_inner_type
+        X: data structure of type X_inner_type
             if X_inner_type is list, _transform must support all types in it
             Data to be transformed
-        y : Series or Panel of mtype y_inner_type, default=None
+        y : data structure of type y_inner_type, default=None
             Additional data, e.g., labels for transformation
 
         Returns
diff --git a/aeon/utils/estimator_checks.py b/aeon/utils/estimator_checks.py
index 7a61b1b1..a6212ae9 100644
--- a/aeon/utils/estimator_checks.py
+++ b/aeon/utils/estimator_checks.py
@@ -133,12 +133,12 @@ def check_estimator(
         results.update(results_estimator)
 
     try:
-        scitype_of_estimator = get_identifiers(estimator)
+        type_of_estimator = get_identifiers(estimator)
     except Exception:
-        scitype_of_estimator = ""
+        type_of_estimator = ""
 
-    if scitype_of_estimator in testclass_dict.keys():
-        results_scitype = testclass_dict[scitype_of_estimator]().run_tests(
+    if type_of_estimator in testclass_dict.keys():
+        results_type = testclass_dict[type_of_estimator]().run_tests(
             estimator=estimator,
             raise_exceptions=raise_exceptions,
             tests_to_run=tests_to_run,
@@ -146,7 +146,7 @@ def check_estimator(
             tests_to_exclude=tests_to_exclude,
             fixtures_to_exclude=fixtures_to_exclude,
         )
-        results.update(results_scitype)
+        results.update(results_type)
 
     failed_tests = [key for key in results.keys() if results[key] != "PASSED"]
     if len(failed_tests) > 0:
diff --git a/aeon/utils/validation/series.py b/aeon/utils/validation/series.py
index 1e0733c3..bef8c910 100644
--- a/aeon/utils/validation/series.py
+++ b/aeon/utils/validation/series.py
@@ -33,9 +33,8 @@ def get_index_for_series(obj, cutoff=0):
 
     Parameters
     ----------
-    obj : aeon data container
-        must be of one of the following mtypes:
-            pd.Series, pd.DataFrame, np.ndarray, of Series scitype
+    obj : data structure
+        must be of one of pd.Series, pd.DataFrame, np.ndarray
     cutoff : int, or pd.datetime, optional, default=0
         current cutoff, used to offset index if obj is np.ndarray
 
@@ -112,7 +111,7 @@ def check_series(
     allow_index_names=False,
     var_name="input",
 ):
-    """Validate input data to be a valid mtype for Series.
+    """Validate input data to be a valid type for Series.
 
     Parameters
     ----------
@@ -141,7 +140,7 @@ def check_series(
 
     Raises
     ------
-    TypeError - if Z is not in a valid type or format for scitype Series
+    TypeError - if Z is not in a valid type for Series
     if enforce_univariate is True:
         ValueError if Z has 2 or more columns
     if enforce_multivariate is True:
@@ -266,7 +265,6 @@ def check_equal_time_index(*ys, mode="equal"):
         must be pd.Series, pd.DataFrame or 1/2D np.ndarray, or None
         can be Series, Panel, Hierarchical, but must be pandas or numpy
         note: this assumption is not checked by the function itself
-            if check is needed, use check_is_scitype or check_is_mtype before call
     mode : str, "equal" or "contained", optional, default = "equal"
         if "equal" will check for all indices being exactly equal
         if "contained", will check whether all indices are subset of ys[0].index
diff --git a/docs/developer_guide/add_estimators.rst b/docs/developer_guide/add_estimators.rst
index c7dbe0ad..5c41879f 100644
--- a/docs/developer_guide/add_estimators.rst
+++ b/docs/developer_guide/add_estimators.rst
@@ -82,7 +82,7 @@ Extension templates typically have the following ``todo``:
     Other tags determine the format of inputs seen in the "inner" methods ``_fit``
 etc, these tags are usually called ``X_inner_type`` or similar.
     This is useful in case the inner functionality assumes ``numpy.ndarray``, or ``pandas.DataFrame``, and helps avoid conversion boilerplate.
-    The type strings can be found in ``datatypes.MTYPE_REGISTER``. For a tutorial on data type conventions, see ``examples/AA_datatypes_and_datasets``.
+    The type strings can be found in ``datatypes.TYPE_REGISTER``. For a tutorial on data type conventions, see ``examples/AA_datatypes_and_datasets``.
 *   Filling in the "inner" methods, e.g., ``_fit`` and ``_predict``. The docstrings and comments in the extension template should be followed here.
     The docstrings also describe the guarantees on the inputs to the "inner" methods, which are typically stronger than the guarantees on
     inputs to the public methods, and determined by values of tags that have been set.
diff --git a/examples/forecasting/forecasting_hierarchical_global.ipynb b/examples/forecasting/forecasting_hierarchical_global.ipynb
index 81c2eee0..c7e43796 100644
--- a/examples/forecasting/forecasting_hierarchical_global.ipynb
+++ b/examples/forecasting/forecasting_hierarchical_global.ipynb
@@ -499,7 +499,7 @@
    "source": [
     "ARIMA supports only one `Series` level mtype.\n",
     "For a register of all mtype codes and their corresponding scitype (series, panel or hierarchical),\\\n",
-    "see `aeon.datatypes.MTYPE_REGISTER` (convert to `pandas.DataFrame` for pretty-printing)"
+    "see `aeon.datatypes.TYPE_REGISTER` (convert to `pandas.DataFrame` for pretty-printing)"
    ]
   },
   {
@@ -525,9 +525,9 @@
    "source": [
     "import pandas as pd\n",
     "\n",
-    "from aeon.datatypes import MTYPE_REGISTER\n",
+    "from aeon.datatypes import TYPE_REGISTER\n",
     "\n",
-    "pd.DataFrame(MTYPE_REGISTER)"
+    "pd.DataFrame(TYPE_REGISTER)"
    ]
   },
   {
diff --git a/extension_templates/forecasting.py b/extension_templates/forecasting.py
index 0f53c1b2..cbd03a5d 100644
--- a/extension_templates/forecasting.py
+++ b/extension_templates/forecasting.py
@@ -90,7 +90,7 @@ class MyForecaster(BaseForecaster):
         "y_inner_type": "pd.Series",
         "X_inner_type": "pd.DataFrame",
         # valid values: str and list of str
-        # if str, must be a valid mtype str, in aeon.datatypes.MTYPE_REGISTER
+        # if str, must be a valid mtype str, in aeon.datatypes.TYPE_REGISTER
         #   of scitype Series, Panel (panel data) or Hierarchical (hierarchical series)
         #   in that case, all inputs are converted to that one type
         # if list of str, must be a list of valid str specifiers
diff --git a/extension_templates/forecasting_simple.py b/extension_templates/forecasting_simple.py
index 24b008e2..ae36d916 100644
--- a/extension_templates/forecasting_simple.py
+++ b/extension_templates/forecasting_simple.py
@@ -77,7 +77,7 @@ class MyForecaster(BaseForecaster):
         "y_inner_type": "pd.Series",
         "X_inner_type": "pd.DataFrame",
         # valid values: str and list of str
-        # if str, must be a valid mtype str, in aeon.datatypes.MTYPE_REGISTER
+        # if str, must be a valid mtype str, in aeon.datatypes.TYPE_REGISTER
         #   of scitype Series, Panel (panel data) or Hierarchical (hierarchical series)
         #   in that case, all inputs are converted to that one type
         # if list of str, must be a list of valid str specifiers
diff --git a/extension_templates/transformer.py b/extension_templates/transformer.py
index fdbb2084..2879bf91 100644
--- a/extension_templates/transformer.py
+++ b/extension_templates/transformer.py
@@ -83,7 +83,7 @@ class MyTransformer(BaseTransformer):
     #   X_inner_type - the internal mtype used for X in _fit and _transform
     #   y_inner_type - if y is used, the internal mtype used for y; usually "None"
     #   setting this guarantees that X, y passed to _fit, _transform are of above types
-    #   for possible mtypes see datatypes.MTYPE_REGISTER, or the datatypes tutorial
+    #   for possible mtypes see datatypes.TYPE_REGISTER, or the datatypes tutorial
     #
     #  when input_data_type is set to Panel:
     #   X_inner_type must be changed to one or a list of aeon Panel mtypes
@@ -132,7 +132,7 @@ class MyTransformer(BaseTransformer):
         "X_inner_type": "pd.DataFrame",
         "y_inner_type": "None",
         # valid values: str and list of str
-        # if str, must be a valid mtype str, in aeon.datatypes.MTYPE_REGISTER
+        # if str, must be a valid mtype str, in aeon.datatypes.TYPE_REGISTER
         #   of scitype Series, Panel (panel data) or Hierarchical (hierarchical series)
         #   y_inner_type can also be of scitype Table (one row/instance per series)
         #   in that case, all inputs are converted to that one type
diff --git a/extension_templates/transformer_simple.py b/extension_templates/transformer_simple.py
index 7a498f2d..0fa712c0 100644
--- a/extension_templates/transformer_simple.py
+++ b/extension_templates/transformer_simple.py
@@ -75,7 +75,7 @@ class MyTransformer(BaseTransformer):
     #   X_inner_type - the internal mtype used for X in _fit and _transform
     #   y_inner_type - if y is used, the internal mtype used for y; usually "None"
     #   setting this guarantees that X, y passed to _fit, _transform are of above types
-    #   for possible mtypes see datatypes.MTYPE_REGISTER, or the datatypes tutorial
+    #   for possible mtypes see datatypes.TYPE_REGISTER, or the datatypes tutorial
     #
     #  when input_data_type is set to Panel:
     #   X_inner_type must be changed to one or a list of aeon Panel mtypes
@@ -124,7 +124,7 @@ class MyTransformer(BaseTransformer):
         "X_inner_type": "pd.DataFrame",
         "y_inner_type": "None",
         # valid values: str and list of str
-        # if str, must be a valid mtype str, in aeon.datatypes.MTYPE_REGISTER
+        # if str, must be a valid mtype str, in aeon.datatypes.TYPE_REGISTER
         #   of type Series, Panel (panel data) or Hierarchical (hierarchical series)
         #   y_inner_type can also be of type Table (one row/instance per series)
         #   in that case, all inputs are converted to that one type


Test patch:
diff --git a/aeon/datasets/tests/test_data_loaders.py b/aeon/datasets/tests/test_data_loaders.py
index 3fc82b09..47473de8 100644
--- a/aeon/datasets/tests/test_data_loaders.py
+++ b/aeon/datasets/tests/test_data_loaders.py
@@ -301,7 +301,6 @@ def test_load_provided_dataset(return_X_y, return_type):
         assert isinstance(X, np.ndarray) and X.ndim == 3
     elif return_type == "numpy2D":
         assert isinstance(X, np.ndarray) and X.ndim == 2
-    # Check whether object is same mtype or not, via bool
 
 
 @pytest.mark.skipif(
diff --git a/aeon/datatypes/tests/test_lookup.py b/aeon/datatypes/tests/test_lookup.py
index 6e638ad5..922563be 100644
--- a/aeon/datatypes/tests/test_lookup.py
+++ b/aeon/datatypes/tests/test_lookup.py
@@ -6,14 +6,14 @@ import pytest
 
 from aeon.datatypes._registry import (
     AMBIGUOUS_MTYPES,
-    MTYPE_REGISTER,
     MTYPE_SOFT_DEPS,
+    TYPE_REGISTER,
     mtype_to_scitype,
     scitype_to_mtype,
 )
 from aeon.utils.validation._dependencies import _check_soft_dependencies
 
-MTYPE_SCITYPE_PAIRS = [(k[0], k[1]) for k in MTYPE_REGISTER]
+MTYPE_SCITYPE_PAIRS = [(k[0], k[1]) for k in TYPE_REGISTER]
 
 
 @pytest.mark.parametrize("mtype, scitype", MTYPE_SCITYPE_PAIRS)
@@ -54,9 +54,9 @@ def test_mtype_to_scitype_list():
     AssertionError mtype_to_scitype does not convert mtype to scitype
     Exception if any is raised by mtype_to_scitype
     """
-    mtype_list = [k[0] for k in MTYPE_REGISTER if k[0] not in AMBIGUOUS_MTYPES]
+    mtype_list = [k[0] for k in TYPE_REGISTER if k[0] not in AMBIGUOUS_MTYPES]
     expected_scitype_list = [
-        k[1] for k in MTYPE_REGISTER if k[0] not in AMBIGUOUS_MTYPES
+        k[1] for k in TYPE_REGISTER if k[0] not in AMBIGUOUS_MTYPES
     ]
 
     result = mtype_to_scitype(mtype_list)
diff --git a/aeon/datatypes/tests/test_vectorize.py b/aeon/datatypes/tests/test_vectorize.py
index 30f09a09..2de78421 100644
--- a/aeon/datatypes/tests/test_vectorize.py
+++ b/aeon/datatypes/tests/test_vectorize.py
@@ -6,7 +6,7 @@ import numpy as np
 import pandas as pd
 import pytest
 
-from aeon.datatypes import DATATYPE_REGISTER, MTYPE_REGISTER
+from aeon.datatypes import DATATYPE_REGISTER, TYPE_REGISTER
 from aeon.datatypes._check import AMBIGUOUS_MTYPES, check_is_mtype
 from aeon.datatypes._examples import get_examples
 from aeon.datatypes._vectorize import VectorizedDF, _enforce_index_freq
@@ -28,7 +28,7 @@ def _get_all_mtypes_for_scitype(scitype):
     """
     if scitype not in [s[0] for s in DATATYPE_REGISTER]:
         raise RuntimeError(scitype + " is not in the DATATYPE_REGISTER")
-    mtypes = [key[0] for key in MTYPE_REGISTER if key[1] == scitype]
+    mtypes = [key[0] for key in TYPE_REGISTER if key[1] == scitype]
     mtypes = [mtype for mtype in mtypes if mtype not in AMBIGUOUS_MTYPES]
 
     if len(mtypes) == 0:
diff --git a/aeon/transformations/tests/test_base.py b/aeon/transformations/tests/test_base.py
index d00f480f..d7ef99c1 100644
--- a/aeon/transformations/tests/test_base.py
+++ b/aeon/transformations/tests/test_base.py
@@ -303,7 +303,7 @@ class _DummyThree(BaseTransformer):
     _tags = {
         "input_data_type": "Series",
         "output_data_type": "Series",
-        "X_inner_type": "np.ndarray",  # which mtypes do _fit/_predict support for X?
+        "X_inner_type": "np.ndarray",
         "fit_is_empty": True,
     }
 
diff --git a/aeon/utils/_testing/hierarchical.py b/aeon/utils/_testing/hierarchical.py
index ffa8c2e9..3dafeebf 100644
--- a/aeon/utils/_testing/hierarchical.py
+++ b/aeon/utils/_testing/hierarchical.py
@@ -24,7 +24,7 @@ def _make_hierarchical(
     random_state: Union[int, np.random.RandomState] = None,
     add_nan: bool = False,
 ) -> pd.DataFrame:
-    """Generate hierarchical multiindex mtype for testing.
+    """Generate hierarchical multiindex type for testing.
 
     Parameters
     ----------
@@ -52,7 +52,7 @@ def _make_hierarchical(
     Returns
     -------
     pd.DataFrame
-        hierarchical mtype dataframe
+        hierarchical dataframe
     """
     levels = [
         [f"h{i}_{j}" for j in range(hierarchy_levels[i])]
diff --git a/aeon/utils/_testing/scenarios_transformers.py b/aeon/utils/_testing/scenarios_transformers.py
index 85141796..b02a61c1 100644
--- a/aeon/utils/_testing/scenarios_transformers.py
+++ b/aeon/utils/_testing/scenarios_transformers.py
@@ -72,13 +72,13 @@ class TransformerTestScenario(TestScenario, BaseObject):
             True if self is applicable to obj, False if not
         """
         # pre-refactor classes can't deal with Series *and* Panel both
-        X_scitype = self.get_tag("X_type")
-        y_scitype = self.get_tag("y_type", None, raise_error=False)
+        X_type = self.get_tag("X_type")
+        y_type = self.get_tag("y_type", None, raise_error=False)
 
         if (
             isinstance(obj, BaseCollectionTransformer)
             or (inspect.isclass(obj) and issubclass(obj, BaseCollectionTransformer))
-        ) and X_scitype != "Panel":
+        ) and X_type != "Panel":
             return False
 
         # if transformer requires y, the scenario also must pass y
@@ -88,11 +88,11 @@ class TransformerTestScenario(TestScenario, BaseObject):
 
         # the case that we would need to vectorize with y, skip
         X_inner_type = get_tag(obj, "X_inner_type")
-        X_inner_scitypes = mtype_to_scitype(
+        X_inner_abstract_types = mtype_to_scitype(
             X_inner_type, return_unique=True, coerce_to_list=True
         )
         # we require vectorization from of a Series trafo to Panel data ...
-        if X_scitype == "Panel" and "Panel" not in X_inner_scitypes:
+        if X_type == "Panel" and "Panel" not in X_inner_abstract_types:
             # ... but y is passed and y is not ignored internally ...
             if self.get_tag("has_y") and get_tag(obj, "y_inner_type") != "None":
                 # ... this would raise an error since vectorization is not defined
@@ -101,10 +101,10 @@ class TransformerTestScenario(TestScenario, BaseObject):
         # ensure scenario y matches type of inner y
         y_inner_type = get_tag(obj, "y_inner_type")
         if y_inner_type not in [None, "None"]:
-            y_inner_scitypes = mtype_to_scitype(
+            y_inner_abstract_types = mtype_to_scitype(
                 y_inner_type, return_unique=True, coerce_to_list=True
             )
-            if y_scitype not in y_inner_scitypes:
+            if y_type not in y_inner_abstract_types:
                 return False
 
         # only applicable if X of supported index type
@@ -141,19 +141,19 @@ class TransformerTestScenario(TestScenario, BaseObject):
             if obj is None:
                 raise ValueError('if key="inverse_transform", obj must be provided')
 
-            X_scitype = self.get_tag("X_type")
+            X_type = self.get_tag("X_type")
 
-            X_out_scitype = get_tag(obj, "output_data_type")
+            X_out_type = get_tag(obj, "output_data_type")
             X_panel = get_tag(obj, "instancewise")
 
-            X_out_series = X_out_scitype == "Series"
-            X_out_prim = X_out_scitype == "Primitives"
+            X_out_series = X_out_type == "Series"
+            X_out_prim = X_out_type == "Primitives"
 
-            # determine output by X_out_scitype
-            s2s = X_scitype == "Series" and X_out_series
-            s2p = X_scitype == "Series" and X_out_prim
-            p2t = X_scitype == "Panel" and X_out_prim
-            p2p = X_scitype == "Panel" and X_out_series
+            # determine output by X_type
+            s2s = X_type == "Series" and X_out_series
+            s2p = X_type == "Series" and X_out_prim
+            p2t = X_type == "Panel" and X_out_prim
+            p2p = X_type == "Panel" and X_out_series
 
             # expected input type of inverse_transform is expected output of transform
             if s2p:
@@ -171,7 +171,7 @@ class TransformerTestScenario(TestScenario, BaseObject):
             else:
                 raise RuntimeError(
                     "transformer with unexpected combination of tags: "
-                    f"X_out_scitype = {X_out_scitype}, instancewise = {X_panel}"
+                    f"X_out_type = {X_out_type}, instancewise = {X_panel}"
                 )
 
         else:
diff --git a/aeon/utils/_testing/tests/test_testscenario_getter.py b/aeon/utils/_testing/tests/test_testscenario_getter.py
index 68a1eb05..1f3a6dcc 100644
--- a/aeon/utils/_testing/tests/test_testscenario_getter.py
+++ b/aeon/utils/_testing/tests/test_testscenario_getter.py
@@ -20,10 +20,10 @@ def test_get_scenarios_for_class(estimator_class):
     ), "return of retrieve_scenarios is not a list of scenarios"
 
 
-@pytest.mark.parametrize("scitype_string", BASE_CLASS_IDENTIFIER_LIST)
-def test_get_scenarios_for_string(scitype_string):
+@pytest.mark.parametrize("type_string", BASE_CLASS_IDENTIFIER_LIST)
+def test_get_scenarios_for_string(type_string):
     """Test retrieval of scenarios by string."""
-    scenarios = retrieve_scenarios(obj=scitype_string)
+    scenarios = retrieve_scenarios(obj=type_string)
 
     assert isinstance(scenarios, list), "return of retrieve_scenarios is not a list"
     assert np.all(
diff --git a/aeon/utils/estimators/tests/test_forecasters.py b/aeon/utils/estimators/tests/test_forecasters.py
index ec23ba4c..0e58c675 100644
--- a/aeon/utils/estimators/tests/test_forecasters.py
+++ b/aeon/utils/estimators/tests/test_forecasters.py
@@ -37,7 +37,7 @@ def test_mock_univariate_forecaster_log(y, X_train, X_pred, fh):
     Tests the following:
     - log format and content
     - All the private methods that have logging enabled are in the log
-    - the correct inner mtypes are preserved, according to the forecaster tags
+    - the correct inner types are preserved, according to the forecaster tags
     """
     forecaster = MockUnivariateForecasterLogger()
     forecaster.fit(y, X_train, fh)