diff --git a/sklearn/feature_extraction/_hashing_fast.pyx b/sklearn/feature_extraction/_hashing_fast.pyx
index 8917c1139e5f5..0f3a19786cc46 100644
--- a/sklearn/feature_extraction/_hashing_fast.pyx
+++ b/sklearn/feature_extraction/_hashing_fast.pyx
@@ -6,7 +6,6 @@ from libcpp.vector cimport vector
 
 cimport numpy as cnp
 import numpy as np
-from ..utils._typedefs cimport INT32TYPE_t, INT64TYPE_t
 from ..utils.murmurhash cimport murmurhash3_bytes_s32
 from ..utils._vector_sentinel cimport vector_to_nd_array
 
@@ -24,11 +23,11 @@ def transform(raw_X, Py_ssize_t n_features, dtype,
         For constructing a scipy.sparse.csr_matrix.
 
     """
-    cdef INT32TYPE_t h
+    cdef cnp.int32_t h
     cdef double value
 
-    cdef vector[INT32TYPE_t] indices
-    cdef vector[INT64TYPE_t] indptr
+    cdef vector[cnp.int32_t] indices
+    cdef vector[cnp.int64_t] indptr
     indptr.push_back(0)
 
     # Since Python array does not understand Numpy dtypes, we grow the indices
diff --git a/sklearn/metrics/_pairwise_distances_reduction/_argkmin.pxd.tp b/sklearn/metrics/_pairwise_distances_reduction/_argkmin.pxd.tp
index 37dd7f5836857..98b731d46b47e 100644
--- a/sklearn/metrics/_pairwise_distances_reduction/_argkmin.pxd.tp
+++ b/sklearn/metrics/_pairwise_distances_reduction/_argkmin.pxd.tp
@@ -15,7 +15,6 @@ implementation_specific_values = [
 }}
 
 cimport numpy as cnp
-from ...utils._typedefs cimport ITYPE_t, DTYPE_t
 
 cnp.import_array()
 
@@ -28,22 +27,22 @@ cdef class ArgKmin{{name_suffix}}(BaseDistanceReducer{{name_suffix}}):
     """{{name_suffix}}bit implementation of BaseDistanceReducer{{name_suffix}} for the `ArgKmin` reduction."""
 
     cdef:
-        ITYPE_t k
+        cnp.intp_t k
 
-        ITYPE_t[:, ::1] argkmin_indices
-        DTYPE_t[:, ::1] argkmin_distances
+        cnp.intp_t[:, ::1] argkmin_indices
+        cnp.float64_t[:, ::1] argkmin_distances
 
         # Used as array of pointers to private datastructures used in threads.
-        DTYPE_t ** heaps_r_distances_chunks
-        ITYPE_t ** heaps_indices_chunks
+        cnp.float64_t ** heaps_r_distances_chunks
+        cnp.intp_t ** heaps_indices_chunks
 
 
 cdef class EuclideanArgKmin{{name_suffix}}(ArgKmin{{name_suffix}}):
     """EuclideanDistance-specialized {{name_suffix}}bit implementation of ArgKmin{{name_suffix}}."""
     cdef:
         GEMMTermComputer{{name_suffix}} gemm_term_computer
-        const DTYPE_t[::1] X_norm_squared
-        const DTYPE_t[::1] Y_norm_squared
+        const cnp.float64_t[::1] X_norm_squared
+        const cnp.float64_t[::1] Y_norm_squared
 
         bint use_squared_distances
 
diff --git a/sklearn/metrics/_pairwise_distances_reduction/_argkmin.pyx.tp b/sklearn/metrics/_pairwise_distances_reduction/_argkmin.pyx.tp
index 1c1459e27f210..d13896d0fc2fa 100644
--- a/sklearn/metrics/_pairwise_distances_reduction/_argkmin.pyx.tp
+++ b/sklearn/metrics/_pairwise_distances_reduction/_argkmin.pyx.tp
@@ -23,7 +23,6 @@ from cython.parallel cimport parallel, prange
 
 from ...utils._heap cimport heap_push
 from ...utils._sorting cimport simultaneous_sort
-from ...utils._typedefs cimport ITYPE_t, DTYPE_t
 
 import numpy as np
 import warnings
@@ -32,7 +31,6 @@ from numbers import Integral
 from scipy.sparse import issparse
 from ...utils import check_array, check_scalar, _in_unstable_openblas_configuration
 from ...utils.fixes import threadpool_limits
-from ...utils._typedefs import ITYPE, DTYPE
 
 
 cnp.import_array()
@@ -60,7 +58,7 @@ cdef class ArgKmin{{name_suffix}}(BaseDistanceReducer{{name_suffix}}):
         cls,
         X,
         Y,
-        ITYPE_t k,
+        cnp.intp_t k,
         str metric="euclidean",
         chunk_size=None,
         dict metric_kwargs=None,
@@ -122,7 +120,7 @@ cdef class ArgKmin{{name_suffix}}(BaseDistanceReducer{{name_suffix}}):
         DatasetsPair{{name_suffix}} datasets_pair,
         chunk_size=None,
         strategy=None,
-        ITYPE_t k=1,
+        cnp.intp_t k=1,
     ):
         super().__init__(
             datasets_pair=datasets_pair,
@@ -140,16 +138,16 @@ cdef class ArgKmin{{name_suffix}}(BaseDistanceReducer{{name_suffix}}):
         #   - when parallelizing on Y, the pointers of those heaps are referencing
         #   small heaps which are thread-wise-allocated and whose content will be
         #   merged with the main heaps'.
-        self.heaps_r_distances_chunks = <DTYPE_t **> malloc(
-            sizeof(DTYPE_t *) * self.chunks_n_threads
+        self.heaps_r_distances_chunks = <cnp.float64_t **> malloc(
+            sizeof(cnp.float64_t *) * self.chunks_n_threads
         )
-        self.heaps_indices_chunks = <ITYPE_t **> malloc(
-            sizeof(ITYPE_t *) * self.chunks_n_threads
+        self.heaps_indices_chunks = <cnp.intp_t **> malloc(
+            sizeof(cnp.intp_t *) * self.chunks_n_threads
         )
 
         # Main heaps which will be returned as results by `ArgKmin{{name_suffix}}.compute`.
-        self.argkmin_indices = np.full((self.n_samples_X, self.k), 0, dtype=ITYPE)
-        self.argkmin_distances = np.full((self.n_samples_X, self.k), DBL_MAX, dtype=DTYPE)
+        self.argkmin_indices = np.full((self.n_samples_X, self.k), 0, dtype=np.intp)
+        self.argkmin_distances = np.full((self.n_samples_X, self.k), DBL_MAX, dtype=np.float64)
 
     def __dealloc__(self):
         if self.heaps_indices_chunks is not NULL:
@@ -160,18 +158,18 @@ cdef class ArgKmin{{name_suffix}}(BaseDistanceReducer{{name_suffix}}):
 
     cdef void _compute_and_reduce_distances_on_chunks(
         self,
-        ITYPE_t X_start,
-        ITYPE_t X_end,
-        ITYPE_t Y_start,
-        ITYPE_t Y_end,
-        ITYPE_t thread_num,
+        cnp.intp_t X_start,
+        cnp.intp_t X_end,
+        cnp.intp_t Y_start,
+        cnp.intp_t Y_end,
+        cnp.intp_t thread_num,
     ) nogil:
         cdef:
-            ITYPE_t i, j
-            ITYPE_t n_samples_X = X_end - X_start
-            ITYPE_t n_samples_Y = Y_end - Y_start
-            DTYPE_t *heaps_r_distances = self.heaps_r_distances_chunks[thread_num]
-            ITYPE_t *heaps_indices = self.heaps_indices_chunks[thread_num]
+            cnp.intp_t i, j
+            cnp.intp_t n_samples_X = X_end - X_start
+            cnp.intp_t n_samples_Y = Y_end - Y_start
+            cnp.float64_t *heaps_r_distances = self.heaps_r_distances_chunks[thread_num]
+            cnp.intp_t *heaps_indices = self.heaps_indices_chunks[thread_num]
 
         # Pushing the distances and their associated indices on a heap
         # which by construction will keep track of the argkmin.
@@ -187,9 +185,9 @@ cdef class ArgKmin{{name_suffix}}(BaseDistanceReducer{{name_suffix}}):
 
     cdef void _parallel_on_X_init_chunk(
         self,
-        ITYPE_t thread_num,
-        ITYPE_t X_start,
-        ITYPE_t X_end,
+        cnp.intp_t thread_num,
+        cnp.intp_t X_start,
+        cnp.intp_t X_end,
     ) nogil:
         # As this strategy is embarrassingly parallel, we can set each
         # thread's heaps pointer to the proper position on the main heaps.
@@ -199,12 +197,12 @@ cdef class ArgKmin{{name_suffix}}(BaseDistanceReducer{{name_suffix}}):
     @final
     cdef void _parallel_on_X_prange_iter_finalize(
         self,
-        ITYPE_t thread_num,
-        ITYPE_t X_start,
-        ITYPE_t X_end,
+        cnp.intp_t thread_num,
+        cnp.intp_t X_start,
+        cnp.intp_t X_end,
     ) nogil:
         cdef:
-            ITYPE_t idx, jdx
+            cnp.intp_t idx, jdx
 
         # Sorting the main heaps portion associated to `X[X_start:X_end]`
         # in ascending order w.r.t the distances.
@@ -220,8 +218,8 @@ cdef class ArgKmin{{name_suffix}}(BaseDistanceReducer{{name_suffix}}):
     ) nogil:
         cdef:
             # Maximum number of scalar elements (the last chunks can be smaller)
-            ITYPE_t heaps_size = self.X_n_samples_chunk * self.k
-            ITYPE_t thread_num
+            cnp.intp_t heaps_size = self.X_n_samples_chunk * self.k
+            cnp.intp_t thread_num
 
         # The allocation is done in parallel for data locality purposes: this way
         # the heaps used in each threads are allocated in pages which are closer
@@ -233,18 +231,18 @@ cdef class ArgKmin{{name_suffix}}(BaseDistanceReducer{{name_suffix}}):
             # As chunks of X are shared across threads, so must their
             # heaps. To solve this, each thread has its own heaps
             # which are then synchronised back in the main ones.
-            self.heaps_r_distances_chunks[thread_num] = <DTYPE_t *> malloc(
-                heaps_size * sizeof(DTYPE_t)
+            self.heaps_r_distances_chunks[thread_num] = <cnp.float64_t *> malloc(
+                heaps_size * sizeof(cnp.float64_t)
             )
-            self.heaps_indices_chunks[thread_num] = <ITYPE_t *> malloc(
-                heaps_size * sizeof(ITYPE_t)
+            self.heaps_indices_chunks[thread_num] = <cnp.intp_t *> malloc(
+                heaps_size * sizeof(cnp.intp_t)
             )
 
     cdef void _parallel_on_Y_parallel_init(
         self,
-        ITYPE_t thread_num,
-        ITYPE_t X_start,
-        ITYPE_t X_end,
+        cnp.intp_t thread_num,
+        cnp.intp_t X_start,
+        cnp.intp_t X_end,
     ) nogil:
         # Initialising heaps (memset can't be used here)
         for idx in range(self.X_n_samples_chunk * self.k):
@@ -254,11 +252,11 @@ cdef class ArgKmin{{name_suffix}}(BaseDistanceReducer{{name_suffix}}):
     @final
     cdef void _parallel_on_Y_synchronize(
         self,
-        ITYPE_t X_start,
-        ITYPE_t X_end,
+        cnp.intp_t X_start,
+        cnp.intp_t X_end,
     ) nogil:
         cdef:
-            ITYPE_t idx, jdx, thread_num
+            cnp.intp_t idx, jdx, thread_num
         with nogil, parallel(num_threads=self.effective_n_threads):
             # Synchronising the thread heaps with the main heaps.
             # This is done in parallel sample-wise (no need for locks).
@@ -282,7 +280,7 @@ cdef class ArgKmin{{name_suffix}}(BaseDistanceReducer{{name_suffix}}):
         self,
     ) nogil:
         cdef:
-            ITYPE_t idx, thread_num
+            cnp.intp_t idx, thread_num
 
         with nogil, parallel(num_threads=self.chunks_n_threads):
             # Deallocating temporary datastructures
@@ -302,9 +300,9 @@ cdef class ArgKmin{{name_suffix}}(BaseDistanceReducer{{name_suffix}}):
 
     cdef void compute_exact_distances(self) nogil:
         cdef:
-            ITYPE_t i, j
-            ITYPE_t[:, ::1] Y_indices = self.argkmin_indices
-            DTYPE_t[:, ::1] distances = self.argkmin_distances
+            cnp.intp_t i, j
+            cnp.intp_t[:, ::1] Y_indices = self.argkmin_indices
+            cnp.float64_t[:, ::1] distances = self.argkmin_distances
         for i in prange(self.n_samples_X, schedule='static', nogil=True,
                         num_threads=self.effective_n_threads):
             for j in range(self.k):
@@ -339,7 +337,7 @@ cdef class EuclideanArgKmin{{name_suffix}}(ArgKmin{{name_suffix}}):
         self,
         X,
         Y,
-        ITYPE_t k,
+        cnp.intp_t k,
         bint use_squared_distances=False,
         chunk_size=None,
         strategy=None,
@@ -370,7 +368,7 @@ cdef class EuclideanArgKmin{{name_suffix}}(ArgKmin{{name_suffix}}):
             DenseDenseDatasetsPair{{name_suffix}} datasets_pair = (
             <DenseDenseDatasetsPair{{name_suffix}}> self.datasets_pair
         )
-            ITYPE_t dist_middle_terms_chunks_size = self.Y_n_samples_chunk * self.X_n_samples_chunk
+            cnp.intp_t dist_middle_terms_chunks_size = self.Y_n_samples_chunk * self.X_n_samples_chunk
 
         self.gemm_term_computer = GEMMTermComputer{{name_suffix}}(
             datasets_pair.X,
@@ -407,7 +405,7 @@ cdef class EuclideanArgKmin{{name_suffix}}(ArgKmin{{name_suffix}}):
     @final
     cdef void _parallel_on_X_parallel_init(
         self,
-        ITYPE_t thread_num,
+        cnp.intp_t thread_num,
     ) nogil:
         ArgKmin{{name_suffix}}._parallel_on_X_parallel_init(self, thread_num)
         self.gemm_term_computer._parallel_on_X_parallel_init(thread_num)
@@ -416,9 +414,9 @@ cdef class EuclideanArgKmin{{name_suffix}}(ArgKmin{{name_suffix}}):
     @final
     cdef void _parallel_on_X_init_chunk(
         self,
-        ITYPE_t thread_num,
-        ITYPE_t X_start,
-        ITYPE_t X_end,
+        cnp.intp_t thread_num,
+        cnp.intp_t X_start,
+        cnp.intp_t X_end,
     ) nogil:
         ArgKmin{{name_suffix}}._parallel_on_X_init_chunk(self, thread_num, X_start, X_end)
         self.gemm_term_computer._parallel_on_X_init_chunk(thread_num, X_start, X_end)
@@ -427,11 +425,11 @@ cdef class EuclideanArgKmin{{name_suffix}}(ArgKmin{{name_suffix}}):
     @final
     cdef void _parallel_on_X_pre_compute_and_reduce_distances_on_chunks(
         self,
-        ITYPE_t X_start,
-        ITYPE_t X_end,
-        ITYPE_t Y_start,
-        ITYPE_t Y_end,
-        ITYPE_t thread_num,
+        cnp.intp_t X_start,
+        cnp.intp_t X_end,
+        cnp.intp_t Y_start,
+        cnp.intp_t Y_end,
+        cnp.intp_t thread_num,
     ) nogil:
         ArgKmin{{name_suffix}}._parallel_on_X_pre_compute_and_reduce_distances_on_chunks(
             self,
@@ -448,7 +446,7 @@ cdef class EuclideanArgKmin{{name_suffix}}(ArgKmin{{name_suffix}}):
     cdef void _parallel_on_Y_init(
         self,
     ) nogil:
-        cdef ITYPE_t thread_num
+        cdef cnp.intp_t thread_num
         ArgKmin{{name_suffix}}._parallel_on_Y_init(self)
         self.gemm_term_computer._parallel_on_Y_init()
 
@@ -456,9 +454,9 @@ cdef class EuclideanArgKmin{{name_suffix}}(ArgKmin{{name_suffix}}):
     @final
     cdef void _parallel_on_Y_parallel_init(
         self,
-        ITYPE_t thread_num,
-        ITYPE_t X_start,
-        ITYPE_t X_end,
+        cnp.intp_t thread_num,
+        cnp.intp_t X_start,
+        cnp.intp_t X_end,
     ) nogil:
         ArgKmin{{name_suffix}}._parallel_on_Y_parallel_init(self, thread_num, X_start, X_end)
         self.gemm_term_computer._parallel_on_Y_parallel_init(thread_num, X_start, X_end)
@@ -467,11 +465,11 @@ cdef class EuclideanArgKmin{{name_suffix}}(ArgKmin{{name_suffix}}):
     @final
     cdef void _parallel_on_Y_pre_compute_and_reduce_distances_on_chunks(
         self,
-        ITYPE_t X_start,
-        ITYPE_t X_end,
-        ITYPE_t Y_start,
-        ITYPE_t Y_end,
-        ITYPE_t thread_num,
+        cnp.intp_t X_start,
+        cnp.intp_t X_end,
+        cnp.intp_t Y_start,
+        cnp.intp_t Y_end,
+        cnp.intp_t thread_num,
     ) nogil:
         ArgKmin{{name_suffix}}._parallel_on_Y_pre_compute_and_reduce_distances_on_chunks(
             self,
@@ -487,22 +485,22 @@ cdef class EuclideanArgKmin{{name_suffix}}(ArgKmin{{name_suffix}}):
     @final
     cdef void _compute_and_reduce_distances_on_chunks(
         self,
-        ITYPE_t X_start,
-        ITYPE_t X_end,
-        ITYPE_t Y_start,
-        ITYPE_t Y_end,
-        ITYPE_t thread_num,
+        cnp.intp_t X_start,
+        cnp.intp_t X_end,
+        cnp.intp_t Y_start,
+        cnp.intp_t Y_end,
+        cnp.intp_t thread_num,
     ) nogil:
         cdef:
-            ITYPE_t i, j
-            DTYPE_t squared_dist_i_j
-            ITYPE_t n_X = X_end - X_start
-            ITYPE_t n_Y = Y_end - Y_start
-            DTYPE_t * dist_middle_terms = self.gemm_term_computer._compute_distances_on_chunks(
+            cnp.intp_t i, j
+            cnp.float64_t squared_dist_i_j
+            cnp.intp_t n_X = X_end - X_start
+            cnp.intp_t n_Y = Y_end - Y_start
+            cnp.float64_t * dist_middle_terms = self.gemm_term_computer._compute_distances_on_chunks(
                 X_start, X_end, Y_start, Y_end, thread_num
             )
-            DTYPE_t * heaps_r_distances = self.heaps_r_distances_chunks[thread_num]
-            ITYPE_t * heaps_indices = self.heaps_indices_chunks[thread_num]
+            cnp.float64_t * heaps_r_distances = self.heaps_r_distances_chunks[thread_num]
+            cnp.intp_t * heaps_indices = self.heaps_indices_chunks[thread_num]
 
 
         # Pushing the distance and their associated indices on heaps
diff --git a/sklearn/metrics/_pairwise_distances_reduction/_base.pxd.tp b/sklearn/metrics/_pairwise_distances_reduction/_base.pxd.tp
index 77a689a9e4e94..9253f0b47545e 100644
--- a/sklearn/metrics/_pairwise_distances_reduction/_base.pxd.tp
+++ b/sklearn/metrics/_pairwise_distances_reduction/_base.pxd.tp
@@ -8,7 +8,7 @@ implementation_specific_values = [
     # We also use the float64 dtype and C-type names as defined in
     # `sklearn.utils._typedefs` to maintain consistency.
     #
-    ('64', 'DTYPE_t', 'DTYPE'),
+    ('64', 'cnp.float64_t', 'np.float64'),
     ('32', 'cnp.float32_t', 'np.float32')
 ]
 
@@ -17,7 +17,6 @@ cimport numpy as cnp
 
 from cython cimport final
 
-from ...utils._typedefs cimport ITYPE_t, DTYPE_t
 
 cnp.import_array()
 
@@ -25,9 +24,9 @@ cnp.import_array()
 
 from ._datasets_pair cimport DatasetsPair{{name_suffix}}
 
-cpdef DTYPE_t[::1] _sqeuclidean_row_norms{{name_suffix}}(
+cpdef cnp.float64_t[::1] _sqeuclidean_row_norms{{name_suffix}}(
     const {{INPUT_DTYPE_t}}[:, ::1] X,
-    ITYPE_t num_threads,
+    cnp.intp_t num_threads,
 )
 
 cdef class BaseDistanceReducer{{name_suffix}}:
@@ -56,13 +55,13 @@ cdef class BaseDistanceReducer{{name_suffix}}:
         #
         #                 chunks_n_threads <= effective_n_threads
         #
-        ITYPE_t effective_n_threads
-        ITYPE_t chunks_n_threads
+        cnp.intp_t effective_n_threads
+        cnp.intp_t chunks_n_threads
 
-        ITYPE_t n_samples_chunk, chunk_size
+        cnp.intp_t n_samples_chunk, chunk_size
 
-        ITYPE_t n_samples_X, X_n_samples_chunk, X_n_chunks, X_n_samples_last_chunk
-        ITYPE_t n_samples_Y, Y_n_samples_chunk, Y_n_chunks, Y_n_samples_last_chunk
+        cnp.intp_t n_samples_X, X_n_samples_chunk, X_n_chunks, X_n_samples_last_chunk
+        cnp.intp_t n_samples_Y, Y_n_samples_chunk, Y_n_chunks, Y_n_samples_last_chunk
 
         bint execute_in_parallel_on_Y
 
@@ -76,11 +75,11 @@ cdef class BaseDistanceReducer{{name_suffix}}:
 
     cdef void _compute_and_reduce_distances_on_chunks(
         self,
-        ITYPE_t X_start,
-        ITYPE_t X_end,
-        ITYPE_t Y_start,
-        ITYPE_t Y_end,
-        ITYPE_t thread_num,
+        cnp.intp_t X_start,
+        cnp.intp_t X_end,
+        cnp.intp_t Y_start,
+        cnp.intp_t Y_end,
+        cnp.intp_t thread_num,
     ) nogil
 
 
@@ -90,35 +89,35 @@ cdef class BaseDistanceReducer{{name_suffix}}:
 
     cdef void _parallel_on_X_parallel_init(
         self,
-        ITYPE_t thread_num,
+        cnp.intp_t thread_num,
     ) nogil
 
     cdef void _parallel_on_X_init_chunk(
         self,
-        ITYPE_t thread_num,
-        ITYPE_t X_start,
-        ITYPE_t X_end,
+        cnp.intp_t thread_num,
+        cnp.intp_t X_start,
+        cnp.intp_t X_end,
     ) nogil
 
     cdef void _parallel_on_X_pre_compute_and_reduce_distances_on_chunks(
         self,
-        ITYPE_t X_start,
-        ITYPE_t X_end,
-        ITYPE_t Y_start,
-        ITYPE_t Y_end,
-        ITYPE_t thread_num,
+        cnp.intp_t X_start,
+        cnp.intp_t X_end,
+        cnp.intp_t Y_start,
+        cnp.intp_t Y_end,
+        cnp.intp_t thread_num,
     ) nogil
 
     cdef void _parallel_on_X_prange_iter_finalize(
         self,
-        ITYPE_t thread_num,
-        ITYPE_t X_start,
-        ITYPE_t X_end,
+        cnp.intp_t thread_num,
+        cnp.intp_t X_start,
+        cnp.intp_t X_end,
     ) nogil
 
     cdef void _parallel_on_X_parallel_finalize(
         self,
-        ITYPE_t thread_num
+        cnp.intp_t thread_num
     ) nogil
 
     cdef void _parallel_on_Y_init(
@@ -127,24 +126,24 @@ cdef class BaseDistanceReducer{{name_suffix}}:
 
     cdef void _parallel_on_Y_parallel_init(
         self,
-        ITYPE_t thread_num,
-        ITYPE_t X_start,
-        ITYPE_t X_end,
+        cnp.intp_t thread_num,
+        cnp.intp_t X_start,
+        cnp.intp_t X_end,
     ) nogil
 
     cdef void _parallel_on_Y_pre_compute_and_reduce_distances_on_chunks(
         self,
-        ITYPE_t X_start,
-        ITYPE_t X_end,
-        ITYPE_t Y_start,
-        ITYPE_t Y_end,
-        ITYPE_t thread_num,
+        cnp.intp_t X_start,
+        cnp.intp_t X_end,
+        cnp.intp_t Y_start,
+        cnp.intp_t Y_end,
+        cnp.intp_t thread_num,
     ) nogil
 
     cdef void _parallel_on_Y_synchronize(
         self,
-        ITYPE_t X_start,
-        ITYPE_t X_end,
+        cnp.intp_t X_start,
+        cnp.intp_t X_end,
     ) nogil
 
     cdef void _parallel_on_Y_finalize(
diff --git a/sklearn/metrics/_pairwise_distances_reduction/_base.pyx.tp b/sklearn/metrics/_pairwise_distances_reduction/_base.pyx.tp
index d0c06de0f8761..af6127c8f2567 100644
--- a/sklearn/metrics/_pairwise_distances_reduction/_base.pyx.tp
+++ b/sklearn/metrics/_pairwise_distances_reduction/_base.pyx.tp
@@ -8,7 +8,7 @@ implementation_specific_values = [
     # We also use the float64 dtype and C-type names as defined in
     # `sklearn.utils._typedefs` to maintain consistency.
     #
-    ('64', 'DTYPE_t', 'DTYPE'),
+    ('64', 'cnp.float64_t', 'np.float64'),
     ('32', 'cnp.float32_t', 'np.float32')
 ]
 
@@ -23,7 +23,6 @@ from libcpp.vector cimport vector
 
 from ...utils._cython_blas cimport _dot
 from ...utils._openmp_helpers cimport _openmp_thread_num
-from ...utils._typedefs cimport ITYPE_t, DTYPE_t
 
 import numpy as np
 
@@ -31,15 +30,14 @@ from numbers import Integral
 from sklearn import get_config
 from sklearn.utils import check_scalar
 from ...utils._openmp_helpers import _openmp_effective_n_threads
-from ...utils._typedefs import ITYPE, DTYPE
 
 cnp.import_array()
 
 #####################
 
-cpdef DTYPE_t[::1] _sqeuclidean_row_norms64(
-    const DTYPE_t[:, ::1] X,
-    ITYPE_t num_threads,
+cpdef cnp.float64_t[::1] _sqeuclidean_row_norms64(
+    const cnp.float64_t[:, ::1] X,
+    cnp.intp_t num_threads,
 ):
     """Compute the squared euclidean norm of the rows of X in parallel.
 
@@ -50,11 +48,11 @@ cpdef DTYPE_t[::1] _sqeuclidean_row_norms64(
         # exposed via scipy.linalg.cython_blas aren't reflecting the arguments'
         # const qualifier.
         # See: https://github.com/scipy/scipy/issues/14262
-        DTYPE_t * X_ptr = <DTYPE_t *> &X[0, 0]
-        ITYPE_t idx = 0
-        ITYPE_t n = X.shape[0]
-        ITYPE_t d = X.shape[1]
-        DTYPE_t[::1] squared_row_norms = np.empty(n, dtype=DTYPE)
+        cnp.float64_t * X_ptr = <cnp.float64_t *> &X[0, 0]
+        cnp.intp_t idx = 0
+        cnp.intp_t n = X.shape[0]
+        cnp.intp_t d = X.shape[1]
+        cnp.float64_t[::1] squared_row_norms = np.empty(n, dtype=np.float64)
 
     for idx in prange(n, schedule='static', nogil=True, num_threads=num_threads):
         squared_row_norms[idx] = _dot(d, X_ptr + idx * d, 1, X_ptr + idx * d, 1)
@@ -62,9 +60,9 @@ cpdef DTYPE_t[::1] _sqeuclidean_row_norms64(
     return squared_row_norms
 
 
-cpdef DTYPE_t[::1] _sqeuclidean_row_norms32(
+cpdef cnp.float64_t[::1] _sqeuclidean_row_norms32(
     const cnp.float32_t[:, ::1] X,
-    ITYPE_t num_threads,
+    cnp.intp_t num_threads,
 ):
     """Compute the squared euclidean norm of the rows of X in parallel.
 
@@ -76,15 +74,15 @@ cpdef DTYPE_t[::1] _sqeuclidean_row_norms32(
         # const qualifier.
         # See: https://github.com/scipy/scipy/issues/14262
         cnp.float32_t * X_ptr = <cnp.float32_t *> &X[0, 0]
-        ITYPE_t i = 0, j = 0
-        ITYPE_t thread_num
-        ITYPE_t n = X.shape[0]
-        ITYPE_t d = X.shape[1]
-        DTYPE_t[::1] squared_row_norms = np.empty(n, dtype=DTYPE)
+        cnp.intp_t i = 0, j = 0
+        cnp.intp_t thread_num
+        cnp.intp_t n = X.shape[0]
+        cnp.intp_t d = X.shape[1]
+        cnp.float64_t[::1] squared_row_norms = np.empty(n, dtype=np.float64)
 
         # To upcast the i-th row of X from 32bit to 64bit
-        vector[vector[DTYPE_t]] X_i_upcast = vector[vector[DTYPE_t]](
-            num_threads, vector[DTYPE_t](d)
+        vector[vector[cnp.float64_t]] X_i_upcast = vector[vector[cnp.float64_t]](
+            num_threads, vector[cnp.float64_t](d)
         )
 
     with nogil, parallel(num_threads=num_threads):
@@ -92,7 +90,7 @@ cpdef DTYPE_t[::1] _sqeuclidean_row_norms32(
         for i in prange(n, schedule='static'):
             # Upcasting the i-th row of X from 32bit to 64bit
             for j in range(d):
-                X_i_upcast[thread_num][j] = <DTYPE_t> deref(X_ptr + i * d + j)
+                X_i_upcast[thread_num][j] = <cnp.float64_t> deref(X_ptr + i * d + j)
 
             squared_row_norms[i] = _dot(
                 d, X_i_upcast[thread_num].data(), 1,
@@ -122,7 +120,7 @@ cdef class BaseDistanceReducer{{name_suffix}}:
         strategy=None,
      ):
         cdef:
-            ITYPE_t n_samples_chunk, X_n_full_chunks, Y_n_full_chunks
+            cnp.intp_t n_samples_chunk, X_n_full_chunks, Y_n_full_chunks
 
         if chunk_size is None:
             chunk_size = get_config().get("pairwise_dist_chunk_size", 256)
@@ -207,8 +205,8 @@ cdef class BaseDistanceReducer{{name_suffix}}:
         interact with those datastructures at various stages.
         """
         cdef:
-            ITYPE_t Y_start, Y_end, X_start, X_end, X_chunk_idx, Y_chunk_idx
-            ITYPE_t thread_num
+            cnp.intp_t Y_start, Y_end, X_start, X_end, X_chunk_idx, Y_chunk_idx
+            cnp.intp_t thread_num
 
         with nogil, parallel(num_threads=self.chunks_n_threads):
             thread_num = _openmp_thread_num()
@@ -278,8 +276,8 @@ cdef class BaseDistanceReducer{{name_suffix}}:
         interact with those datastructures at various stages.
         """
         cdef:
-            ITYPE_t Y_start, Y_end, X_start, X_end, X_chunk_idx, Y_chunk_idx
-            ITYPE_t thread_num
+            cnp.intp_t Y_start, Y_end, X_start, X_end, X_chunk_idx, Y_chunk_idx
+            cnp.intp_t thread_num
 
         # Allocating datastructures shared by all threads
         self._parallel_on_Y_init()
@@ -333,11 +331,11 @@ cdef class BaseDistanceReducer{{name_suffix}}:
 
     cdef void _compute_and_reduce_distances_on_chunks(
         self,
-        ITYPE_t X_start,
-        ITYPE_t X_end,
-        ITYPE_t Y_start,
-        ITYPE_t Y_end,
-        ITYPE_t thread_num,
+        cnp.intp_t X_start,
+        cnp.intp_t X_end,
+        cnp.intp_t Y_start,
+        cnp.intp_t Y_end,
+        cnp.intp_t thread_num,
     ) nogil:
         """Compute the pairwise distances on two chunks of X and Y and reduce them.
 
@@ -362,27 +360,27 @@ cdef class BaseDistanceReducer{{name_suffix}}:
 
     cdef void _parallel_on_X_parallel_init(
         self,
-        ITYPE_t thread_num,
+        cnp.intp_t thread_num,
     ) nogil:
         """Allocate datastructures used in a thread given its number."""
         return
 
     cdef void _parallel_on_X_init_chunk(
         self,
-        ITYPE_t thread_num,
-        ITYPE_t X_start,
-        ITYPE_t X_end,
+        cnp.intp_t thread_num,
+        cnp.intp_t X_start,
+        cnp.intp_t X_end,
     ) nogil:
         """Initialize datastructures used in a thread given its number."""
         return
 
     cdef void _parallel_on_X_pre_compute_and_reduce_distances_on_chunks(
         self,
-        ITYPE_t X_start,
-        ITYPE_t X_end,
-        ITYPE_t Y_start,
-        ITYPE_t Y_end,
-        ITYPE_t thread_num,
+        cnp.intp_t X_start,
+        cnp.intp_t X_end,
+        cnp.intp_t Y_start,
+        cnp.intp_t Y_end,
+        cnp.intp_t thread_num,
     ) nogil:
         """Initialize datastructures just before the _compute_and_reduce_distances_on_chunks.
 
@@ -392,16 +390,16 @@ cdef class BaseDistanceReducer{{name_suffix}}:
 
     cdef void _parallel_on_X_prange_iter_finalize(
         self,
-        ITYPE_t thread_num,
-        ITYPE_t X_start,
-        ITYPE_t X_end,
+        cnp.intp_t thread_num,
+        cnp.intp_t X_start,
+        cnp.intp_t X_end,
     ) nogil:
         """Interact with datastructures after a reduction on chunks."""
         return
 
     cdef void _parallel_on_X_parallel_finalize(
         self,
-        ITYPE_t thread_num
+        cnp.intp_t thread_num
     ) nogil:
         """Interact with datastructures after executing all the reductions."""
         return
@@ -414,20 +412,20 @@ cdef class BaseDistanceReducer{{name_suffix}}:
 
     cdef void _parallel_on_Y_parallel_init(
         self,
-        ITYPE_t thread_num,
-        ITYPE_t X_start,
-        ITYPE_t X_end,
+        cnp.intp_t thread_num,
+        cnp.intp_t X_start,
+        cnp.intp_t X_end,
     ) nogil:
         """Initialize datastructures used in a thread given its number."""
         return
 
     cdef void _parallel_on_Y_pre_compute_and_reduce_distances_on_chunks(
         self,
-        ITYPE_t X_start,
-        ITYPE_t X_end,
-        ITYPE_t Y_start,
-        ITYPE_t Y_end,
-        ITYPE_t thread_num,
+        cnp.intp_t X_start,
+        cnp.intp_t X_end,
+        cnp.intp_t Y_start,
+        cnp.intp_t Y_end,
+        cnp.intp_t thread_num,
     ) nogil:
         """Initialize datastructures just before the _compute_and_reduce_distances_on_chunks.
 
@@ -437,8 +435,8 @@ cdef class BaseDistanceReducer{{name_suffix}}:
 
     cdef void _parallel_on_Y_synchronize(
         self,
-        ITYPE_t X_start,
-        ITYPE_t X_end,
+        cnp.intp_t X_start,
+        cnp.intp_t X_end,
     ) nogil:
         """Update thread datastructures before leaving a parallel region."""
         return
diff --git a/sklearn/metrics/_pairwise_distances_reduction/_datasets_pair.pxd.tp b/sklearn/metrics/_pairwise_distances_reduction/_datasets_pair.pxd.tp
index a02d505808a52..18e1a784b978d 100644
--- a/sklearn/metrics/_pairwise_distances_reduction/_datasets_pair.pxd.tp
+++ b/sklearn/metrics/_pairwise_distances_reduction/_datasets_pair.pxd.tp
@@ -7,14 +7,14 @@ implementation_specific_values = [
     #
     # We use DistanceMetric for float64 for backward naming compatibility.
     #
-    ('64', 'DistanceMetric', 'DTYPE_t', 'DTYPE'),
+    ('64', 'DistanceMetric', 'cnp.float64_t', 'np.float64'),
     ('32', 'DistanceMetric32', 'cnp.float32_t', 'np.float32')
 ]
 
 }}
 cimport numpy as cnp
 
-from ...utils._typedefs cimport DTYPE_t, ITYPE_t, SPARSE_INDEX_TYPE_t
+from ...utils._typedefs cimport SPARSE_INDEX_TYPE_t
 from ...metrics._dist_metrics cimport DistanceMetric, DistanceMetric32
 
 {{for name_suffix, DistanceMetric, INPUT_DTYPE_t, INPUT_DTYPE in implementation_specific_values}}
@@ -23,15 +23,15 @@ from ...metrics._dist_metrics cimport DistanceMetric, DistanceMetric32
 cdef class DatasetsPair{{name_suffix}}:
     cdef:
         {{DistanceMetric}} distance_metric
-        ITYPE_t n_features
+        cnp.intp_t n_features
 
-    cdef ITYPE_t n_samples_X(self) nogil
+    cdef cnp.intp_t n_samples_X(self) nogil
 
-    cdef ITYPE_t n_samples_Y(self) nogil
+    cdef cnp.intp_t n_samples_Y(self) nogil
 
-    cdef DTYPE_t dist(self, ITYPE_t i, ITYPE_t j) nogil
+    cdef cnp.float64_t dist(self, cnp.intp_t i, cnp.intp_t j) nogil
 
-    cdef DTYPE_t surrogate_dist(self, ITYPE_t i, ITYPE_t j) nogil
+    cdef cnp.float64_t surrogate_dist(self, cnp.intp_t i, cnp.intp_t j) nogil
 
 
 cdef class DenseDenseDatasetsPair{{name_suffix}}(DatasetsPair{{name_suffix}}):
@@ -59,7 +59,7 @@ cdef class SparseDenseDatasetsPair{{name_suffix}}(DatasetsPair{{name_suffix}}):
 
         const {{INPUT_DTYPE_t}}[:] Y_data
         const SPARSE_INDEX_TYPE_t[:] Y_indices
-        ITYPE_t n_Y
+        cnp.intp_t n_Y
 
 
 cdef class DenseSparseDatasetsPair{{name_suffix}}(DatasetsPair{{name_suffix}}):
diff --git a/sklearn/metrics/_pairwise_distances_reduction/_datasets_pair.pyx.tp b/sklearn/metrics/_pairwise_distances_reduction/_datasets_pair.pyx.tp
index cfa37a004f17a..ff7e23610da56 100644
--- a/sklearn/metrics/_pairwise_distances_reduction/_datasets_pair.pyx.tp
+++ b/sklearn/metrics/_pairwise_distances_reduction/_datasets_pair.pyx.tp
@@ -7,7 +7,7 @@ implementation_specific_values = [
     #
     # We use DistanceMetric for float64 for backward naming compatibility.
     #
-    ('64', 'DistanceMetric', 'DTYPE_t', 'DTYPE'),
+    ('64', 'DistanceMetric', 'cnp.float64_t', 'np.float64'),
     ('32', 'DistanceMetric32', 'cnp.float32_t', 'np.float32')
 ]
 
@@ -17,7 +17,6 @@ cimport numpy as cnp
 
 from cython cimport final
 
-from ...utils._typedefs cimport DTYPE_t, ITYPE_t
 from ...metrics._dist_metrics cimport DistanceMetric
 
 from scipy.sparse import issparse, csr_matrix
@@ -130,28 +129,28 @@ cdef class DatasetsPair{{name_suffix}}:
         X_indptr = np.asarray(X.indptr, dtype=SPARSE_INDEX_TYPE)
         return X_data, X_indices, X_indptr
 
-    def __init__(self, {{DistanceMetric}} distance_metric, ITYPE_t n_features):
+    def __init__(self, {{DistanceMetric}} distance_metric, cnp.intp_t n_features):
         self.distance_metric = distance_metric
         self.n_features = n_features
 
-    cdef ITYPE_t n_samples_X(self) nogil:
+    cdef cnp.intp_t n_samples_X(self) nogil:
         """Number of samples in X."""
         # This is a abstract method.
         # This _must_ always be overwritten in subclasses.
         # TODO: add "with gil: raise" here when supporting Cython 3.0
         return -999
 
-    cdef ITYPE_t n_samples_Y(self) nogil:
+    cdef cnp.intp_t n_samples_Y(self) nogil:
         """Number of samples in Y."""
         # This is a abstract method.
         # This _must_ always be overwritten in subclasses.
         # TODO: add "with gil: raise" here when supporting Cython 3.0
         return -999
 
-    cdef DTYPE_t surrogate_dist(self, ITYPE_t i, ITYPE_t j) nogil:
+    cdef cnp.float64_t surrogate_dist(self, cnp.intp_t i, cnp.intp_t j) nogil:
         return self.dist(i, j)
 
-    cdef DTYPE_t dist(self, ITYPE_t i, ITYPE_t j) nogil:
+    cdef cnp.float64_t dist(self, cnp.intp_t i, cnp.intp_t j) nogil:
         # This is a abstract method.
         # This _must_ always be overwritten in subclasses.
         # TODO: add "with gil: raise" here when supporting Cython 3.0
@@ -186,19 +185,19 @@ cdef class DenseDenseDatasetsPair{{name_suffix}}(DatasetsPair{{name_suffix}}):
         self.Y = Y
 
     @final
-    cdef ITYPE_t n_samples_X(self) nogil:
+    cdef cnp.intp_t n_samples_X(self) nogil:
         return self.X.shape[0]
 
     @final
-    cdef ITYPE_t n_samples_Y(self) nogil:
+    cdef cnp.intp_t n_samples_Y(self) nogil:
         return self.Y.shape[0]
 
     @final
-    cdef DTYPE_t surrogate_dist(self, ITYPE_t i, ITYPE_t j) nogil:
+    cdef cnp.float64_t surrogate_dist(self, cnp.intp_t i, cnp.intp_t j) nogil:
         return self.distance_metric.rdist(&self.X[i, 0], &self.Y[j, 0], self.n_features)
 
     @final
-    cdef DTYPE_t dist(self, ITYPE_t i, ITYPE_t j) nogil:
+    cdef cnp.float64_t dist(self, cnp.intp_t i, cnp.intp_t j) nogil:
         return self.distance_metric.dist(&self.X[i, 0], &self.Y[j, 0], self.n_features)
 
 
@@ -226,15 +225,15 @@ cdef class SparseSparseDatasetsPair{{name_suffix}}(DatasetsPair{{name_suffix}}):
         self.Y_data, self.Y_indices, self.Y_indptr = self.unpack_csr_matrix(Y)
 
     @final
-    cdef ITYPE_t n_samples_X(self) nogil:
+    cdef cnp.intp_t n_samples_X(self) nogil:
         return self.X_indptr.shape[0] - 1
 
     @final
-    cdef ITYPE_t n_samples_Y(self) nogil:
+    cdef cnp.intp_t n_samples_Y(self) nogil:
         return self.Y_indptr.shape[0] - 1
 
     @final
-    cdef DTYPE_t surrogate_dist(self, ITYPE_t i, ITYPE_t j) nogil:
+    cdef cnp.float64_t surrogate_dist(self, cnp.intp_t i, cnp.intp_t j) nogil:
         return self.distance_metric.rdist_csr(
             x1_data=&self.X_data[0],
             x1_indices=self.X_indices,
@@ -248,7 +247,7 @@ cdef class SparseSparseDatasetsPair{{name_suffix}}(DatasetsPair{{name_suffix}}):
         )
 
     @final
-    cdef DTYPE_t dist(self, ITYPE_t i, ITYPE_t j) nogil:
+    cdef cnp.float64_t dist(self, cnp.intp_t i, cnp.intp_t j) nogil:
         return self.distance_metric.dist_csr(
             x1_data=&self.X_data[0],
             x1_indices=self.X_indices,
@@ -319,15 +318,15 @@ cdef class SparseDenseDatasetsPair{{name_suffix}}(DatasetsPair{{name_suffix}}):
         self.Y_indices = np.arange(self.n_features, dtype=SPARSE_INDEX_TYPE)
 
     @final
-    cdef ITYPE_t n_samples_X(self) nogil:
+    cdef cnp.intp_t n_samples_X(self) nogil:
         return self.X_indptr.shape[0] - 1
 
     @final
-    cdef ITYPE_t n_samples_Y(self) nogil:
+    cdef cnp.intp_t n_samples_Y(self) nogil:
         return self.n_Y
 
     @final
-    cdef DTYPE_t surrogate_dist(self, ITYPE_t i, ITYPE_t j) nogil:
+    cdef cnp.float64_t surrogate_dist(self, cnp.intp_t i, cnp.intp_t j) nogil:
         return self.distance_metric.rdist_csr(
             x1_data=&self.X_data[0],
             x1_indices=self.X_indices,
@@ -343,7 +342,7 @@ cdef class SparseDenseDatasetsPair{{name_suffix}}(DatasetsPair{{name_suffix}}):
         )
 
     @final
-    cdef DTYPE_t dist(self, ITYPE_t i, ITYPE_t j) nogil:
+    cdef cnp.float64_t dist(self, cnp.intp_t i, cnp.intp_t j) nogil:
 
         return self.distance_metric.dist_csr(
             x1_data=&self.X_data[0],
@@ -383,22 +382,22 @@ cdef class DenseSparseDatasetsPair{{name_suffix}}(DatasetsPair{{name_suffix}}):
         self.datasets_pair = SparseDenseDatasetsPair{{name_suffix}}(Y, X, distance_metric)
 
     @final
-    cdef ITYPE_t n_samples_X(self) nogil:
+    cdef cnp.intp_t n_samples_X(self) nogil:
         # Swapping interface
         return self.datasets_pair.n_samples_Y()
 
     @final
-    cdef ITYPE_t n_samples_Y(self) nogil:
+    cdef cnp.intp_t n_samples_Y(self) nogil:
         # Swapping interface
         return self.datasets_pair.n_samples_X()
 
     @final
-    cdef DTYPE_t surrogate_dist(self, ITYPE_t i, ITYPE_t j) nogil:
+    cdef cnp.float64_t surrogate_dist(self, cnp.intp_t i, cnp.intp_t j) nogil:
         # Swapping arguments on the same interface
         return self.datasets_pair.surrogate_dist(j, i)
 
     @final
-    cdef DTYPE_t dist(self, ITYPE_t i, ITYPE_t j) nogil:
+    cdef cnp.float64_t dist(self, cnp.intp_t i, cnp.intp_t j) nogil:
         # Swapping arguments on the same interface
         return self.datasets_pair.dist(j, i)
 
diff --git a/sklearn/metrics/_pairwise_distances_reduction/_radius_neighborhood.pxd.tp b/sklearn/metrics/_pairwise_distances_reduction/_radius_neighborhood.pxd.tp
index 9bbe186589f20..5b7e3b0860adf 100644
--- a/sklearn/metrics/_pairwise_distances_reduction/_radius_neighborhood.pxd.tp
+++ b/sklearn/metrics/_pairwise_distances_reduction/_radius_neighborhood.pxd.tp
@@ -19,25 +19,23 @@ from libcpp.memory cimport shared_ptr
 from libcpp.vector cimport vector
 from cython cimport final
 
-from ...utils._typedefs cimport ITYPE_t, DTYPE_t
-
 cnp.import_array()
 
 ######################
 ## std::vector to np.ndarray coercion
 # As type covariance is not supported for C++ containers via Cython,
 # we need to redefine fused types.
-ctypedef fused vector_DITYPE_t:
-    vector[ITYPE_t]
-    vector[DTYPE_t]
+ctypedef fused vector_INTP_FLOAT64_t:
+    vector[cnp.intp_t]
+    vector[cnp.float64_t]
 
 
-ctypedef fused vector_vector_DITYPE_t:
-    vector[vector[ITYPE_t]]
-    vector[vector[DTYPE_t]]
+ctypedef fused vector_vector_INTP_FLOAT64_t:
+    vector[vector[cnp.intp_t]]
+    vector[vector[cnp.float64_t]]
 
 cdef cnp.ndarray[object, ndim=1] coerce_vectors_to_nd_arrays(
-    shared_ptr[vector_vector_DITYPE_t] vecs
+    shared_ptr[vector_vector_INTP_FLOAT64_t] vecs
 )
 
 #####################
@@ -53,13 +51,13 @@ cdef class RadiusNeighbors{{name_suffix}}(BaseDistanceReducer{{name_suffix}}):
     """
 
     cdef:
-        DTYPE_t radius
+        cnp.float64_t radius
 
         # DistanceMetric{{name_suffix}} compute rank-preserving surrogate distance via rdist
         # which are proxies necessitating less computations.
         # We get the equivalent for the radius to be able to compare it against
         # vectors' rank-preserving surrogate distances.
-        DTYPE_t r_radius
+        cnp.float64_t r_radius
 
         # Neighbors indices and distances are returned as np.ndarrays of np.ndarrays.
         #
@@ -79,20 +77,20 @@ cdef class RadiusNeighbors{{name_suffix}}(BaseDistanceReducer{{name_suffix}}):
         # Shared pointers (defined via shared_ptr) are use for safer memory management.
         # Unique pointers (defined via unique_ptr) can't be used as datastructures
         # are shared across threads for parallel_on_X; see _parallel_on_X_init_chunk.
-        shared_ptr[vector[vector[ITYPE_t]]] neigh_indices
-        shared_ptr[vector[vector[DTYPE_t]]] neigh_distances
+        shared_ptr[vector[vector[cnp.intp_t]]] neigh_indices
+        shared_ptr[vector[vector[cnp.float64_t]]] neigh_distances
 
         # Used as array of pointers to private datastructures used in threads.
-        vector[shared_ptr[vector[vector[ITYPE_t]]]] neigh_indices_chunks
-        vector[shared_ptr[vector[vector[DTYPE_t]]]] neigh_distances_chunks
+        vector[shared_ptr[vector[vector[cnp.intp_t]]]] neigh_indices_chunks
+        vector[shared_ptr[vector[vector[cnp.float64_t]]]] neigh_distances_chunks
 
         bint sort_results
 
     @final
     cdef void _merge_vectors(
         self,
-        ITYPE_t idx,
-        ITYPE_t num_threads,
+        cnp.intp_t idx,
+        cnp.intp_t num_threads,
     ) nogil
 
 
@@ -100,8 +98,8 @@ cdef class EuclideanRadiusNeighbors{{name_suffix}}(RadiusNeighbors{{name_suffix}
     """EuclideanDistance-specialized {{name_suffix}}bit implementation for RadiusNeighbors{{name_suffix}}."""
     cdef:
         GEMMTermComputer{{name_suffix}} gemm_term_computer
-        const DTYPE_t[::1] X_norm_squared
-        const DTYPE_t[::1] Y_norm_squared
+        const cnp.float64_t[::1] X_norm_squared
+        const cnp.float64_t[::1] Y_norm_squared
 
         bint use_squared_distances
 
diff --git a/sklearn/metrics/_pairwise_distances_reduction/_radius_neighborhood.pyx.tp b/sklearn/metrics/_pairwise_distances_reduction/_radius_neighborhood.pyx.tp
index 8d50a6e04abf9..cb25486e118b4 100644
--- a/sklearn/metrics/_pairwise_distances_reduction/_radius_neighborhood.pyx.tp
+++ b/sklearn/metrics/_pairwise_distances_reduction/_radius_neighborhood.pyx.tp
@@ -24,7 +24,6 @@ from cython.operator cimport dereference as deref
 from cython.parallel cimport parallel, prange
 
 from ...utils._sorting cimport simultaneous_sort
-from ...utils._typedefs cimport ITYPE_t, DTYPE_t
 from ...utils._vector_sentinel cimport vector_to_nd_array
 
 from numbers import Real
@@ -43,11 +42,11 @@ cdef extern from "<algorithm>" namespace "std" nogil:
 ######################
 
 cdef cnp.ndarray[object, ndim=1] coerce_vectors_to_nd_arrays(
-    shared_ptr[vector_vector_DITYPE_t] vecs
+    shared_ptr[vector_vector_INTP_FLOAT64_t] vecs
 ):
     """Coerce a std::vector of std::vector to a ndarray of ndarray."""
     cdef:
-        ITYPE_t n = deref(vecs).size()
+        cnp.intp_t n = deref(vecs).size()
         cnp.ndarray[object, ndim=1] nd_arrays_of_nd_arrays = np.empty(n, dtype=np.ndarray)
 
     for i in range(n):
@@ -82,7 +81,7 @@ cdef class RadiusNeighbors{{name_suffix}}(BaseDistanceReducer{{name_suffix}}):
         cls,
         X,
         Y,
-        DTYPE_t radius,
+        cnp.float64_t radius,
         str metric="euclidean",
         chunk_size=None,
         dict metric_kwargs=None,
@@ -146,7 +145,7 @@ cdef class RadiusNeighbors{{name_suffix}}(BaseDistanceReducer{{name_suffix}}):
     def __init__(
         self,
         DatasetsPair{{name_suffix}} datasets_pair,
-        DTYPE_t radius,
+        cnp.float64_t radius,
         chunk_size=None,
         strategy=None,
         sort_results=False,
@@ -170,29 +169,29 @@ cdef class RadiusNeighbors{{name_suffix}}(BaseDistanceReducer{{name_suffix}}):
         #   - when parallelizing on Y, the pointers of those heaps are referencing
         #   std::vectors of std::vectors which are thread-wise-allocated and whose
         #   content will be merged into self.neigh_distances and self.neigh_indices.
-        self.neigh_distances_chunks = vector[shared_ptr[vector[vector[DTYPE_t]]]](
+        self.neigh_distances_chunks = vector[shared_ptr[vector[vector[cnp.float64_t]]]](
             self.chunks_n_threads
         )
-        self.neigh_indices_chunks = vector[shared_ptr[vector[vector[ITYPE_t]]]](
+        self.neigh_indices_chunks = vector[shared_ptr[vector[vector[cnp.intp_t]]]](
             self.chunks_n_threads
         )
 
         # Temporary datastructures which will be coerced to numpy arrays on before
         # RadiusNeighbors.compute "return" and will be then freed.
-        self.neigh_distances = make_shared[vector[vector[DTYPE_t]]](self.n_samples_X)
-        self.neigh_indices = make_shared[vector[vector[ITYPE_t]]](self.n_samples_X)
+        self.neigh_distances = make_shared[vector[vector[cnp.float64_t]]](self.n_samples_X)
+        self.neigh_indices = make_shared[vector[vector[cnp.intp_t]]](self.n_samples_X)
 
     cdef void _compute_and_reduce_distances_on_chunks(
         self,
-        ITYPE_t X_start,
-        ITYPE_t X_end,
-        ITYPE_t Y_start,
-        ITYPE_t Y_end,
-        ITYPE_t thread_num,
+        cnp.intp_t X_start,
+        cnp.intp_t X_end,
+        cnp.intp_t Y_start,
+        cnp.intp_t Y_end,
+        cnp.intp_t thread_num,
     ) nogil:
         cdef:
-            ITYPE_t i, j
-            DTYPE_t r_dist_i_j
+            cnp.intp_t i, j
+            cnp.float64_t r_dist_i_j
 
         for i in range(X_start, X_end):
             for j in range(Y_start, Y_end):
@@ -215,9 +214,9 @@ cdef class RadiusNeighbors{{name_suffix}}(BaseDistanceReducer{{name_suffix}}):
 
     cdef void _parallel_on_X_init_chunk(
         self,
-        ITYPE_t thread_num,
-        ITYPE_t X_start,
-        ITYPE_t X_end,
+        cnp.intp_t thread_num,
+        cnp.intp_t X_start,
+        cnp.intp_t X_end,
     ) nogil:
 
         # As this strategy is embarrassingly parallel, we can set the
@@ -228,12 +227,12 @@ cdef class RadiusNeighbors{{name_suffix}}(BaseDistanceReducer{{name_suffix}}):
     @final
     cdef void _parallel_on_X_prange_iter_finalize(
         self,
-        ITYPE_t thread_num,
-        ITYPE_t X_start,
-        ITYPE_t X_end,
+        cnp.intp_t thread_num,
+        cnp.intp_t X_start,
+        cnp.intp_t X_end,
     ) nogil:
         cdef:
-            ITYPE_t idx, jdx
+            cnp.intp_t idx, jdx
 
         # Sorting neighbors for each query vector of X
         if self.sort_results:
@@ -248,24 +247,24 @@ cdef class RadiusNeighbors{{name_suffix}}(BaseDistanceReducer{{name_suffix}}):
         self,
     ) nogil:
         cdef:
-            ITYPE_t thread_num
+            cnp.intp_t thread_num
         # As chunks of X are shared across threads, so must datastructures to avoid race
         # conditions: each thread has its own vectors of n_samples_X vectors which are
         # then merged back in the main n_samples_X vectors.
         for thread_num in range(self.chunks_n_threads):
-            self.neigh_distances_chunks[thread_num] = make_shared[vector[vector[DTYPE_t]]](self.n_samples_X)
-            self.neigh_indices_chunks[thread_num] = make_shared[vector[vector[ITYPE_t]]](self.n_samples_X)
+            self.neigh_distances_chunks[thread_num] = make_shared[vector[vector[cnp.float64_t]]](self.n_samples_X)
+            self.neigh_indices_chunks[thread_num] = make_shared[vector[vector[cnp.intp_t]]](self.n_samples_X)
 
     @final
     cdef void _merge_vectors(
         self,
-        ITYPE_t idx,
-        ITYPE_t num_threads,
+        cnp.intp_t idx,
+        cnp.intp_t num_threads,
     ) nogil:
         cdef:
-            ITYPE_t thread_num
-            ITYPE_t idx_n_elements = 0
-            ITYPE_t last_element_idx = deref(self.neigh_indices)[idx].size()
+            cnp.intp_t thread_num
+            cnp.intp_t idx_n_elements = 0
+            cnp.intp_t last_element_idx = deref(self.neigh_indices)[idx].size()
 
         # Resizing buffers only once for the given number of elements.
         for thread_num in range(num_threads):
@@ -294,7 +293,7 @@ cdef class RadiusNeighbors{{name_suffix}}(BaseDistanceReducer{{name_suffix}}):
         self,
     ) nogil:
         cdef:
-            ITYPE_t idx, jdx, thread_num, idx_n_element, idx_current
+            cnp.intp_t idx, jdx, thread_num, idx_n_element, idx_current
 
         with nogil, parallel(num_threads=self.effective_n_threads):
             # Merge vectors used in threads into the main ones.
@@ -321,7 +320,7 @@ cdef class RadiusNeighbors{{name_suffix}}(BaseDistanceReducer{{name_suffix}}):
     cdef void compute_exact_distances(self) nogil:
         """Convert rank-preserving distances to pairwise distances in parallel."""
         cdef:
-            ITYPE_t i, j
+            cnp.intp_t i, j
 
         for i in prange(self.n_samples_X, nogil=True, schedule='static',
                         num_threads=self.effective_n_threads):
@@ -346,7 +345,7 @@ cdef class EuclideanRadiusNeighbors{{name_suffix}}(RadiusNeighbors{{name_suffix}
         self,
         X,
         Y,
-        DTYPE_t radius,
+        cnp.float64_t radius,
         bint use_squared_distances=False,
         chunk_size=None,
         strategy=None,
@@ -379,7 +378,7 @@ cdef class EuclideanRadiusNeighbors{{name_suffix}}(RadiusNeighbors{{name_suffix}
             DenseDenseDatasetsPair{{name_suffix}} datasets_pair = (
                 <DenseDenseDatasetsPair{{name_suffix}}> self.datasets_pair
             )
-            ITYPE_t dist_middle_terms_chunks_size = self.Y_n_samples_chunk * self.X_n_samples_chunk
+            cnp.intp_t dist_middle_terms_chunks_size = self.Y_n_samples_chunk * self.X_n_samples_chunk
 
         self.gemm_term_computer = GEMMTermComputer{{name_suffix}}(
             datasets_pair.X,
@@ -416,7 +415,7 @@ cdef class EuclideanRadiusNeighbors{{name_suffix}}(RadiusNeighbors{{name_suffix}
     @final
     cdef void _parallel_on_X_parallel_init(
         self,
-        ITYPE_t thread_num,
+        cnp.intp_t thread_num,
     ) nogil:
         RadiusNeighbors{{name_suffix}}._parallel_on_X_parallel_init(self, thread_num)
         self.gemm_term_computer._parallel_on_X_parallel_init(thread_num)
@@ -424,9 +423,9 @@ cdef class EuclideanRadiusNeighbors{{name_suffix}}(RadiusNeighbors{{name_suffix}
     @final
     cdef void _parallel_on_X_init_chunk(
         self,
-        ITYPE_t thread_num,
-        ITYPE_t X_start,
-        ITYPE_t X_end,
+        cnp.intp_t thread_num,
+        cnp.intp_t X_start,
+        cnp.intp_t X_end,
     ) nogil:
         RadiusNeighbors{{name_suffix}}._parallel_on_X_init_chunk(self, thread_num, X_start, X_end)
         self.gemm_term_computer._parallel_on_X_init_chunk(thread_num, X_start, X_end)
@@ -434,11 +433,11 @@ cdef class EuclideanRadiusNeighbors{{name_suffix}}(RadiusNeighbors{{name_suffix}
     @final
     cdef void _parallel_on_X_pre_compute_and_reduce_distances_on_chunks(
         self,
-        ITYPE_t X_start,
-        ITYPE_t X_end,
-        ITYPE_t Y_start,
-        ITYPE_t Y_end,
-        ITYPE_t thread_num,
+        cnp.intp_t X_start,
+        cnp.intp_t X_end,
+        cnp.intp_t Y_start,
+        cnp.intp_t Y_end,
+        cnp.intp_t thread_num,
     ) nogil:
         RadiusNeighbors{{name_suffix}}._parallel_on_X_pre_compute_and_reduce_distances_on_chunks(
             self,
@@ -454,16 +453,16 @@ cdef class EuclideanRadiusNeighbors{{name_suffix}}(RadiusNeighbors{{name_suffix}
     cdef void _parallel_on_Y_init(
         self,
     ) nogil:
-        cdef ITYPE_t thread_num
+        cdef cnp.intp_t thread_num
         RadiusNeighbors{{name_suffix}}._parallel_on_Y_init(self)
         self.gemm_term_computer._parallel_on_Y_init()
 
     @final
     cdef void _parallel_on_Y_parallel_init(
         self,
-        ITYPE_t thread_num,
-        ITYPE_t X_start,
-        ITYPE_t X_end,
+        cnp.intp_t thread_num,
+        cnp.intp_t X_start,
+        cnp.intp_t X_end,
     ) nogil:
         RadiusNeighbors{{name_suffix}}._parallel_on_Y_parallel_init(self, thread_num, X_start, X_end)
         self.gemm_term_computer._parallel_on_Y_parallel_init(thread_num, X_start, X_end)
@@ -471,11 +470,11 @@ cdef class EuclideanRadiusNeighbors{{name_suffix}}(RadiusNeighbors{{name_suffix}
     @final
     cdef void _parallel_on_Y_pre_compute_and_reduce_distances_on_chunks(
         self,
-        ITYPE_t X_start,
-        ITYPE_t X_end,
-        ITYPE_t Y_start,
-        ITYPE_t Y_end,
-        ITYPE_t thread_num,
+        cnp.intp_t X_start,
+        cnp.intp_t X_end,
+        cnp.intp_t Y_start,
+        cnp.intp_t Y_end,
+        cnp.intp_t thread_num,
     ) nogil:
         RadiusNeighbors{{name_suffix}}._parallel_on_Y_pre_compute_and_reduce_distances_on_chunks(
             self,
@@ -495,18 +494,18 @@ cdef class EuclideanRadiusNeighbors{{name_suffix}}(RadiusNeighbors{{name_suffix}
     @final
     cdef void _compute_and_reduce_distances_on_chunks(
         self,
-        ITYPE_t X_start,
-        ITYPE_t X_end,
-        ITYPE_t Y_start,
-        ITYPE_t Y_end,
-        ITYPE_t thread_num,
+        cnp.intp_t X_start,
+        cnp.intp_t X_end,
+        cnp.intp_t Y_start,
+        cnp.intp_t Y_end,
+        cnp.intp_t thread_num,
     ) nogil:
         cdef:
-            ITYPE_t i, j
-            DTYPE_t squared_dist_i_j
-            ITYPE_t n_X = X_end - X_start
-            ITYPE_t n_Y = Y_end - Y_start
-            DTYPE_t *dist_middle_terms = self.gemm_term_computer._compute_distances_on_chunks(
+            cnp.intp_t i, j
+            cnp.float64_t squared_dist_i_j
+            cnp.intp_t n_X = X_end - X_start
+            cnp.intp_t n_Y = Y_end - Y_start
+            cnp.float64_t *dist_middle_terms = self.gemm_term_computer._compute_distances_on_chunks(
                 X_start, X_end, Y_start, Y_end, thread_num
             )
 
diff --git a/sklearn/utils/_vector_sentinel.pxd b/sklearn/utils/_vector_sentinel.pxd
index b3d9a3ff32613..ff8d46ae428c3 100644
--- a/sklearn/utils/_vector_sentinel.pxd
+++ b/sklearn/utils/_vector_sentinel.pxd
@@ -1,12 +1,11 @@
 cimport numpy as cnp
 
 from libcpp.vector cimport vector
-from ..utils._typedefs cimport ITYPE_t, DTYPE_t, INT32TYPE_t, INT64TYPE_t
 
 ctypedef fused vector_typed:
-    vector[DTYPE_t]
-    vector[ITYPE_t]
-    vector[INT32TYPE_t]
-    vector[INT64TYPE_t]
+    vector[cnp.float64_t]
+    vector[cnp.intp_t]
+    vector[cnp.int32_t]
+    vector[cnp.int64_t]
 
 cdef cnp.ndarray vector_to_nd_array(vector_typed * vect_ptr)
diff --git a/sklearn/utils/_vector_sentinel.pyx b/sklearn/utils/_vector_sentinel.pyx
index 45c48de9dac68..95c95f192d7eb 100644
--- a/sklearn/utils/_vector_sentinel.pyx
+++ b/sklearn/utils/_vector_sentinel.pyx
@@ -2,17 +2,16 @@ from cython.operator cimport dereference as deref
 from cpython.ref cimport Py_INCREF
 cimport numpy as cnp
 
-from ._typedefs cimport DTYPECODE, ITYPECODE, INT32TYPECODE, INT64TYPECODE
 
 cnp.import_array()
 
 
 cdef StdVectorSentinel _create_sentinel(vector_typed * vect_ptr):
-    if vector_typed is vector[DTYPE_t]:
+    if vector_typed is vector[cnp.float64_t]:
         return StdVectorSentinelFloat64.create_for(vect_ptr)
-    elif vector_typed is vector[INT32TYPE_t]:
+    elif vector_typed is vector[cnp.int32_t]:
         return StdVectorSentinelInt32.create_for(vect_ptr)
-    elif vector_typed is vector[INT64TYPE_t]:
+    elif vector_typed is vector[cnp.int64_t]:
         return StdVectorSentinelInt64.create_for(vect_ptr)
     else:
         return StdVectorSentinelIntP.create_for(vect_ptr)
@@ -33,10 +32,10 @@ cdef class StdVectorSentinel:
 
 
 cdef class StdVectorSentinelFloat64(StdVectorSentinel):
-    cdef vector[DTYPE_t] vec
+    cdef vector[cnp.float64_t] vec
 
     @staticmethod
-    cdef StdVectorSentinel create_for(vector[DTYPE_t] * vect_ptr):
+    cdef StdVectorSentinel create_for(vector[cnp.float64_t] * vect_ptr):
         # This initializes the object directly without calling __init__
         # See: https://cython.readthedocs.io/en/latest/src/userguide/extension_types.html#instantiation-from-existing-c-c-pointers # noqa
         cdef StdVectorSentinelFloat64 sentinel = StdVectorSentinelFloat64.__new__(StdVectorSentinelFloat64)
@@ -47,14 +46,14 @@ cdef class StdVectorSentinelFloat64(StdVectorSentinel):
         return self.vec.data()
 
     cdef int get_typenum(self):
-        return DTYPECODE
+        return cnp.NPY_FLOAT64
 
 
 cdef class StdVectorSentinelIntP(StdVectorSentinel):
-    cdef vector[ITYPE_t] vec
+    cdef vector[cnp.intp_t] vec
 
     @staticmethod
-    cdef StdVectorSentinel create_for(vector[ITYPE_t] * vect_ptr):
+    cdef StdVectorSentinel create_for(vector[cnp.intp_t] * vect_ptr):
         # This initializes the object directly without calling __init__
         # See: https://cython.readthedocs.io/en/latest/src/userguide/extension_types.html#instantiation-from-existing-c-c-pointers # noqa
         cdef StdVectorSentinelIntP sentinel = StdVectorSentinelIntP.__new__(StdVectorSentinelIntP)
@@ -65,14 +64,14 @@ cdef class StdVectorSentinelIntP(StdVectorSentinel):
         return self.vec.data()
 
     cdef int get_typenum(self):
-        return ITYPECODE
+        return cnp.NPY_INTP
 
 
 cdef class StdVectorSentinelInt32(StdVectorSentinel):
-    cdef vector[INT32TYPE_t] vec
+    cdef vector[cnp.int32_t] vec
 
     @staticmethod
-    cdef StdVectorSentinel create_for(vector[INT32TYPE_t] * vect_ptr):
+    cdef StdVectorSentinel create_for(vector[cnp.int32_t] * vect_ptr):
         # This initializes the object directly without calling __init__
         # See: https://cython.readthedocs.io/en/latest/src/userguide/extension_types.html#instantiation-from-existing-c-c-pointers # noqa
         cdef StdVectorSentinelInt32 sentinel = StdVectorSentinelInt32.__new__(StdVectorSentinelInt32)
@@ -83,14 +82,14 @@ cdef class StdVectorSentinelInt32(StdVectorSentinel):
         return self.vec.data()
 
     cdef int get_typenum(self):
-        return INT32TYPECODE
+        return cnp.NPY_INT32
 
 
 cdef class StdVectorSentinelInt64(StdVectorSentinel):
-    cdef vector[INT64TYPE_t] vec
+    cdef vector[cnp.int64_t] vec
 
     @staticmethod
-    cdef StdVectorSentinel create_for(vector[INT64TYPE_t] * vect_ptr):
+    cdef StdVectorSentinel create_for(vector[cnp.int64_t] * vect_ptr):
         # This initializes the object directly without calling __init__
         # See: https://cython.readthedocs.io/en/latest/src/userguide/extension_types.html#instantiation-from-existing-c-c-pointers # noqa
         cdef StdVectorSentinelInt64 sentinel = StdVectorSentinelInt64.__new__(StdVectorSentinelInt64)
@@ -101,7 +100,7 @@ cdef class StdVectorSentinelInt64(StdVectorSentinel):
         return self.vec.data()
 
     cdef int get_typenum(self):
-        return INT64TYPECODE
+        return cnp.NPY_INT64
 
 
 cdef cnp.ndarray vector_to_nd_array(vector_typed * vect_ptr):