diff --git a/include/openPMD/LoadStoreChunk.hpp b/include/openPMD/LoadStoreChunk.hpp
index dbc4a08f0c..882b127d05 100644
--- a/include/openPMD/LoadStoreChunk.hpp
+++ b/include/openPMD/LoadStoreChunk.hpp
@@ -41,15 +41,15 @@ namespace internal
 } // namespace internal
 
 template <typename ChildClass = void>
-class ConfigureStoreChunk : protected internal::ConfigureStoreChunkData
+class ConfigureLoadStore : protected internal::ConfigureStoreChunkData
 {
     friend class RecordComponent;
     template <typename>
-    friend class ConfigureStoreChunk;
+    friend class ConfigureLoadStore;
 
 protected:
-    ConfigureStoreChunk(RecordComponent &rc);
-    ConfigureStoreChunk(ConfigureStoreChunkData &&);
+    ConfigureLoadStore(RecordComponent &rc);
+    ConfigureLoadStore(ConfigureStoreChunkData &&);
 
     auto dim() const -> uint8_t;
     auto getOffset() const -> Offset;
@@ -59,7 +59,7 @@ class ConfigureStoreChunk : protected internal::ConfigureStoreChunkData
 public:
     using return_type = std::conditional_t<
         std::is_void_v<ChildClass>,
-        /*then*/ ConfigureStoreChunk<void>,
+        /*then*/ ConfigureLoadStore<void>,
         /*else*/ ChildClass>;
     template <typename T>
     using normalize_dataset_type = std::remove_cv_t<std::remove_extent_t<T>>;
@@ -93,24 +93,24 @@ class ConfigureStoreChunk : protected internal::ConfigureStoreChunkData
                     typename T_ContiguousContainer::value_type> const>>>;
 
     template <typename T>
-    auto enqueue() -> DynamicMemoryView<T>;
+    [[nodiscard]] auto enqueueStore() -> DynamicMemoryView<T>;
     // definition for this one is in RecordComponent.tpp since it needs the
     // definition of class RecordComponent.
     template <typename T, typename F>
-    auto enqueue(F &&createBuffer) -> DynamicMemoryView<T>;
+    [[nodiscard]] auto enqueueStore(F &&createBuffer) -> DynamicMemoryView<T>;
 };
 
 template <typename Ptr_Type>
 class ConfigureStoreChunkFromBuffer
-    : public ConfigureStoreChunk<ConfigureStoreChunkFromBuffer<Ptr_Type>>
+    : public ConfigureLoadStore<ConfigureStoreChunkFromBuffer<Ptr_Type>>
 {
 public:
     using parent_t =
-        ConfigureStoreChunk<ConfigureStoreChunkFromBuffer<Ptr_Type>>;
+        ConfigureLoadStore<ConfigureStoreChunkFromBuffer<Ptr_Type>>;
 
 private:
     template <typename T>
-    friend class ConfigureStoreChunk;
+    friend class ConfigureLoadStore;
 
     Ptr_Type m_buffer;
     std::optional<MemorySelection> m_mem_select;
@@ -126,80 +126,8 @@ class ConfigureStoreChunkFromBuffer
     auto as_parent() & -> parent_t &;
     auto as_parent() const & -> parent_t const &;
 
-    auto enqueue() -> void;
+    auto enqueueStore() -> void;
 };
-
-template <typename ChildClass>
-template <typename T>
-auto ConfigureStoreChunk<ChildClass>::fromSharedPtr(std::shared_ptr<T> data)
-    -> ConfigureStoreChunkFromBuffer<
-        std::shared_ptr<normalize_dataset_type<T> const>>
-{
-    if (!data)
-    {
-        throw std::runtime_error(
-            "Unallocated pointer passed during chunk store.");
-    }
-    return ConfigureStoreChunkFromBuffer<
-        std::shared_ptr<normalize_dataset_type<T> const>>(
-        std::static_pointer_cast<normalize_dataset_type<T> const>(
-            std::move(data)),
-        {std::move(*this)});
-}
-template <typename ChildClass>
-template <typename T>
-auto ConfigureStoreChunk<ChildClass>::fromUniquePtr(UniquePtrWithLambda<T> data)
-    -> ConfigureStoreChunkFromBuffer<
-        UniquePtrWithLambda<normalize_dataset_type<T>>>
-{
-    if (!data)
-    {
-        throw std::runtime_error(
-            "Unallocated pointer passed during chunk store.");
-    }
-    return ConfigureStoreChunkFromBuffer<
-        UniquePtrWithLambda<normalize_dataset_type<T>>>(
-        std::move(data).template static_cast_<normalize_dataset_type<T>>(),
-        {std::move(*this)});
-}
-template <typename ChildClass>
-template <typename T>
-auto ConfigureStoreChunk<ChildClass>::fromRawPtr(T *data)
-    -> ConfigureStoreChunkFromBuffer<
-        std::shared_ptr<normalize_dataset_type<T> const>>
-{
-    if (!data)
-    {
-        throw std::runtime_error(
-            "Unallocated pointer passed during chunk store.");
-    }
-    return ConfigureStoreChunkFromBuffer<
-        std::shared_ptr<normalize_dataset_type<T> const>>(
-        auxiliary::shareRaw(data), {std::move(*this)});
-}
-
-template <typename ChildClass>
-template <typename T, typename Del>
-auto ConfigureStoreChunk<ChildClass>::fromUniquePtr(
-    std::unique_ptr<T, Del> data)
-    -> ConfigureStoreChunkFromBuffer<
-        UniquePtrWithLambda<normalize_dataset_type<T>>>
-{
-    return fromUniquePtr(UniquePtrWithLambda<T>(std::move(data)));
-}
-template <typename ChildClass>
-template <typename T_ContiguousContainer>
-auto ConfigureStoreChunk<ChildClass>::fromContiguousContainer(
-    T_ContiguousContainer &data) ->
-    typename std::enable_if_t<
-        auxiliary::IsContiguousContainer_v<T_ContiguousContainer>,
-        ConfigureStoreChunkFromBuffer<std::shared_ptr<normalize_dataset_type<
-            typename T_ContiguousContainer::value_type> const>>>
-{
-    if (!m_extent.has_value() && dim() == 1)
-    {
-        m_extent = Extent{data.size()};
-    }
-    return fromRawPtr(data.data());
-}
 } // namespace openPMD
+
+#include "openPMD/LoadStoreChunk.tpp"
diff --git a/include/openPMD/LoadStoreChunk.tpp b/include/openPMD/LoadStoreChunk.tpp
new file mode 100644
index 0000000000..215df35302
--- /dev/null
+++ b/include/openPMD/LoadStoreChunk.tpp
@@ -0,0 +1,80 @@
+#pragma once
+
+#include "openPMD/LoadStoreChunk.hpp"
+
+namespace openPMD
+{
+
+template <typename ChildClass>
+template <typename T>
+auto ConfigureLoadStore<ChildClass>::fromSharedPtr(std::shared_ptr<T> data)
+    -> ConfigureStoreChunkFromBuffer<
+        std::shared_ptr<normalize_dataset_type<T> const>>
+{
+    if (!data)
+    {
+        throw std::runtime_error(
+            "Unallocated pointer passed during chunk store.");
+    }
+    return ConfigureStoreChunkFromBuffer<
+        std::shared_ptr<normalize_dataset_type<T> const>>(
+        std::static_pointer_cast<normalize_dataset_type<T> const>(
+            std::move(data)),
+        {std::move(*this)});
+}
+template <typename ChildClass>
+template <typename T>
+auto ConfigureLoadStore<ChildClass>::fromUniquePtr(UniquePtrWithLambda<T> data)
+    -> ConfigureStoreChunkFromBuffer<
+        UniquePtrWithLambda<normalize_dataset_type<T>>>
+{
+    if (!data)
+    {
+        throw std::runtime_error(
+            "Unallocated pointer passed during chunk store.");
+    }
+    return ConfigureStoreChunkFromBuffer<
+        UniquePtrWithLambda<normalize_dataset_type<T>>>(
+        std::move(data).template static_cast_<normalize_dataset_type<T>>(),
+        {std::move(*this)});
+}
+template <typename ChildClass>
+template <typename T>
+auto ConfigureLoadStore<ChildClass>::fromRawPtr(T *data)
+    -> ConfigureStoreChunkFromBuffer<
+        std::shared_ptr<normalize_dataset_type<T> const>>
+{
+    if (!data)
+    {
+        throw std::runtime_error(
+            "Unallocated pointer passed during chunk store.");
+    }
+    return ConfigureStoreChunkFromBuffer<
+        std::shared_ptr<normalize_dataset_type<T> const>>(
+        auxiliary::shareRaw(data), {std::move(*this)});
+}
+
+template <typename ChildClass>
+template <typename T, typename Del>
+auto ConfigureLoadStore<ChildClass>::fromUniquePtr(std::unique_ptr<T, Del> data)
+    -> ConfigureStoreChunkFromBuffer<
+        UniquePtrWithLambda<normalize_dataset_type<T>>>
+{
+    return fromUniquePtr(UniquePtrWithLambda<T>(std::move(data)));
+}
+template <typename ChildClass>
+template <typename T_ContiguousContainer>
+auto ConfigureLoadStore<ChildClass>::fromContiguousContainer(
+    T_ContiguousContainer &data) ->
+    typename std::enable_if_t<
+        auxiliary::IsContiguousContainer_v<T_ContiguousContainer>,
+        ConfigureStoreChunkFromBuffer<std::shared_ptr<normalize_dataset_type<
+            typename T_ContiguousContainer::value_type> const>>>
+{
+    if (!m_extent.has_value() && dim() == 1)
+    {
+        m_extent = Extent{data.size()};
+    }
+    return fromRawPtr(data.data());
+}
+} // namespace openPMD
diff --git a/include/openPMD/RecordComponent.hpp b/include/openPMD/RecordComponent.hpp
index 74fb6fc72c..d7aeab3ec3 100644
--- a/include/openPMD/RecordComponent.hpp
+++ b/include/openPMD/RecordComponent.hpp
@@ -134,7 +134,7 @@ class RecordComponent : public BaseRecordComponent
     friend class internal::RecordComponentData;
     friend class MeshRecordComponent;
     template <typename ChildClass>
-    friend class ConfigureStoreChunk;
+    friend class ConfigureLoadStore;
     template <typename Ptr_Type>
     friend class ConfigureStoreChunkFromBuffer;
 
@@ -288,7 +288,7 @@ class RecordComponent : public BaseRecordComponent
     template <typename T>
     void loadChunkRaw(T *data, Offset offset, Extent extent);
 
-    ConfigureStoreChunk<void> prepareStoreChunk();
+    ConfigureLoadStore<void> prepareStoreChunk();
 
     /** Store a chunk of data from a chunk of memory.
      *
diff --git a/include/openPMD/RecordComponent.tpp b/include/openPMD/RecordComponent.tpp
index 147d4d439d..743d1276f6 100644
--- a/include/openPMD/RecordComponent.tpp
+++ b/include/openPMD/RecordComponent.tpp
@@ -192,7 +192,7 @@ RecordComponent::storeChunk(std::shared_ptr<T> data, Offset o, Extent e)
         .offset(std::move(o))
         .extent(std::move(e))
         .fromSharedPtr(std::move(data))
-        .enqueue();
+        .enqueueStore();
 }
 
 template <typename T>
@@ -203,7 +203,7 @@ RecordComponent::storeChunk(UniquePtrWithLambda<T> data, Offset o, Extent e)
         .offset(std::move(o))
         .extent(std::move(e))
         .fromUniquePtr(std::move(data))
-        .enqueue();
+        .enqueueStore();
 }
 
 template <typename T, typename Del>
@@ -214,7 +214,7 @@ RecordComponent::storeChunk(std::unique_ptr<T, Del> data, Offset o, Extent e)
         .offset(std::move(o))
         .extent(std::move(e))
         .fromUniquePtr(std::move(data))
-        .enqueue();
+        .enqueueStore();
 }
 
 template <typename T>
@@ -224,7 +224,7 @@ void RecordComponent::storeChunkRaw(T *ptr, Offset offset, Extent extent)
         .offset(std::move(offset))
         .extent(std::move(extent))
         .fromRawPtr(ptr)
-        .enqueue();
+        .enqueueStore();
 }
 
 template <typename T_ContiguousContainer>
@@ -244,7 +244,7 @@ RecordComponent::storeChunk(T_ContiguousContainer &data, Offset o, Extent e)
         storeChunkConfig.extent(std::move(e));
     }
 
-    std::move(storeChunkConfig).fromContiguousContainer(data).enqueue();
+    std::move(storeChunkConfig).fromContiguousContainer(data).enqueueStore();
 }
 
 template <typename T, typename F>
@@ -254,7 +254,7 @@ RecordComponent::storeChunk(Offset o, Extent e, F &&createBuffer)
     return prepareStoreChunk()
         .offset(std::move(o))
         .extent(std::move(e))
-        .enqueue<T>(std::forward<F>(createBuffer));
+        .enqueueStore<T>(std::forward<F>(createBuffer));
 }
 
 template <typename T>
@@ -264,7 +264,7 @@ RecordComponent::storeChunk(Offset offset, Extent extent)
     return prepareStoreChunk()
         .offset(std::move(offset))
         .extent(std::move(extent))
-        .enqueue<T>();
+        .enqueueStore<T>();
 }
 
 template <typename T, typename F>
@@ -367,7 +367,7 @@ void RecordComponent::verifyChunk(Offset const &o, Extent const &e) const
 // definitions for LoadStoreChunk.hpp
 template <typename ChildClass>
 template <typename T, typename F>
-auto ConfigureStoreChunk<ChildClass>::enqueue(F &&createBuffer)
+auto ConfigureLoadStore<ChildClass>::enqueueStore(F &&createBuffer)
     -> DynamicMemoryView<T>
 {
     return m_rc.storeChunkSpanCreateBuffer_impl<T>(
diff --git a/src/LoadStoreChunk.cpp b/src/LoadStoreChunk.cpp
index 89712b728e..8b27ae7e41 100644
--- a/src/LoadStoreChunk.cpp
+++ b/src/LoadStoreChunk.cpp
@@ -44,24 +44,24 @@ namespace
 } // namespace
 
 template <typename ChildClass>
-ConfigureStoreChunk<ChildClass>::ConfigureStoreChunk(RecordComponent &rc)
+ConfigureLoadStore<ChildClass>::ConfigureLoadStore(RecordComponent &rc)
     : ConfigureStoreChunkData(rc)
 {}
 
 template <typename ChildClass>
-ConfigureStoreChunk<ChildClass>::ConfigureStoreChunk(
+ConfigureLoadStore<ChildClass>::ConfigureLoadStore(
     internal::ConfigureStoreChunkData &&data)
     : ConfigureStoreChunkData(std::move(data))
 {}
 
 template <typename ChildClass>
-auto ConfigureStoreChunk<ChildClass>::dim() const -> uint8_t
+auto ConfigureLoadStore<ChildClass>::dim() const -> uint8_t
 {
     return m_rc.getDimensionality();
 }
 
 template <typename ChildClass>
-auto ConfigureStoreChunk<ChildClass>::getOffset() const -> Offset
+auto ConfigureLoadStore<ChildClass>::getOffset() const -> Offset
 {
     if (m_offset.has_value())
     {
@@ -81,7 +81,7 @@ auto ConfigureStoreChunk<ChildClass>::getOffset() const -> Offset
 }
 
 template <typename ChildClass>
-auto ConfigureStoreChunk<ChildClass>::getExtent() const -> Extent
+auto ConfigureLoadStore<ChildClass>::getExtent() const -> Extent
 {
     if (m_extent.has_value())
     {
@@ -94,21 +94,21 @@ auto ConfigureStoreChunk<ChildClass>::getExtent() const -> Extent
 }
 
 template <typename ChildClass>
-auto ConfigureStoreChunk<ChildClass>::storeChunkConfig() const
+auto ConfigureLoadStore<ChildClass>::storeChunkConfig() const
     -> internal::StoreChunkConfig
 {
     return internal::StoreChunkConfig{getOffset(), getExtent()};
 }
 
 template <typename ChildClass>
-auto ConfigureStoreChunk<ChildClass>::extent(Extent extent) -> return_type &
+auto ConfigureLoadStore<ChildClass>::extent(Extent extent) -> return_type &
 {
     m_extent = std::move(extent);
     return *static_cast<return_type *>(this);
 }
 
 template <typename ChildClass>
-auto ConfigureStoreChunk<ChildClass>::offset(Offset offset) -> return_type &
+auto ConfigureLoadStore<ChildClass>::offset(Offset offset) -> return_type &
 {
     m_offset = std::move(offset);
     return *static_cast<return_type *>(this);
@@ -116,7 +116,7 @@ auto ConfigureStoreChunk<ChildClass>::offset(Offset offset) -> return_type &
 
 template <typename ChildClass>
 template <typename T>
-auto ConfigureStoreChunk<ChildClass>::enqueue() -> DynamicMemoryView<T>
+auto ConfigureLoadStore<ChildClass>::enqueueStore() -> DynamicMemoryView<T>
 {
     return m_rc.storeChunkSpan_impl<T>(storeChunkConfig());
 }
@@ -161,7 +161,7 @@ auto ConfigureStoreChunkFromBuffer<Ptr_Type>::memorySelection(
 }
 
 template <typename Ptr_Type>
-auto ConfigureStoreChunkFromBuffer<Ptr_Type>::enqueue() -> void
+auto ConfigureStoreChunkFromBuffer<Ptr_Type>::enqueueStore() -> void
 {
     this->m_rc.storeChunk_impl(
         asWriteBuffer(std::move(m_buffer)),
@@ -170,12 +170,12 @@ auto ConfigureStoreChunkFromBuffer<Ptr_Type>::enqueue() -> void
 }
 
 #define INSTANTIATE_METHOD_TEMPLATES(base_class, dtype)                        \
-    template auto base_class::enqueue() -> DynamicMemoryView<dtype>;
+    template auto base_class::enqueueStore() -> DynamicMemoryView<dtype>;
 
 #define INSTANTIATE_METHOD_TEMPLATES_FOR_BASE(dtype)                           \
-    INSTANTIATE_METHOD_TEMPLATES(ConfigureStoreChunk<void>, dtype)
+    INSTANTIATE_METHOD_TEMPLATES(ConfigureLoadStore<void>, dtype)
 
-template class ConfigureStoreChunk<void>;
+template class ConfigureLoadStore<void>;
 OPENPMD_FOREACH_DATASET_DATATYPE(INSTANTIATE_METHOD_TEMPLATES_FOR_BASE)
 
 #undef INSTANTIATE_METHOD_TEMPLATES_FOR_BASE
@@ -183,17 +183,17 @@ OPENPMD_FOREACH_DATASET_DATATYPE(INSTANTIATE_METHOD_TEMPLATES_FOR_BASE)
 #define INSTANTIATE_STORE_CHUNK_FROM_BUFFER(dtype)                             \
     template class ConfigureStoreChunkFromBuffer<                              \
         std::shared_ptr<dtype const>>;                                         \
-    template class ConfigureStoreChunk<                                        \
+    template class ConfigureLoadStore<                                         \
         ConfigureStoreChunkFromBuffer<std::shared_ptr<dtype const>>>;          \
     INSTANTIATE_METHOD_TEMPLATES(                                              \
-        ConfigureStoreChunk<                                                   \
+        ConfigureLoadStore<                                                    \
             ConfigureStoreChunkFromBuffer<std::shared_ptr<dtype const>>>,      \
         dtype)                                                                 \
     template class ConfigureStoreChunkFromBuffer<UniquePtrWithLambda<dtype>>;  \
-    template class ConfigureStoreChunk<                                        \
+    template class ConfigureLoadStore<                                         \
         ConfigureStoreChunkFromBuffer<UniquePtrWithLambda<dtype>>>;            \
     INSTANTIATE_METHOD_TEMPLATES(                                              \
-        ConfigureStoreChunk<                                                   \
+        ConfigureLoadStore<                                                    \
             ConfigureStoreChunkFromBuffer<UniquePtrWithLambda<dtype>>>,        \
         dtype)
 
diff --git a/src/RecordComponent.cpp b/src/RecordComponent.cpp
index 0d8e21c906..4041df127e 100644
--- a/src/RecordComponent.cpp
+++ b/src/RecordComponent.cpp
@@ -66,9 +66,9 @@ RecordComponent::RecordComponent() : BaseRecordComponent(NoInit())
     setData(std::make_shared<Data_t>());
 }
 
-ConfigureStoreChunk<void> RecordComponent::prepareStoreChunk()
+ConfigureLoadStore<void> RecordComponent::prepareStoreChunk()
 {
-    return ConfigureStoreChunk<void>{*this};
+    return ConfigureLoadStore<void>{*this};
 }
 
 namespace
diff --git a/test/ParallelIOTest.cpp b/test/ParallelIOTest.cpp
index 668fa2a749..b530ccc04e 100644
--- a/test/ParallelIOTest.cpp
+++ b/test/ParallelIOTest.cpp
@@ -440,13 +440,13 @@ void available_chunks_test(std::string const &file_ending)
             .fromContiguousContainer(ydata_firstandlastrow)
             .offset({0, 3ul * mpi_rank})
             .extent({1, 3})
-            .enqueue();
+            .enqueueStore();
         E_y.prepareStoreChunk()
             .offset({1, 3ul * mpi_rank})
             .extent({3, 3})
             .fromContiguousContainer(ydata)
             .memorySelection({{1, 1}, {5, 5}})
-            .enqueue();
+            .enqueueStore();
         // if condition checks if this PR is available in ADIOS2:
         // https://github.com/ornladios/ADIOS2/pull/4169
         if constexpr (CanTheMemorySelectionBeReset)
@@ -455,7 +455,7 @@ void available_chunks_test(std::string const &file_ending)
                 .fromContiguousContainer(ydata_firstandlastrow)
                 .offset({4, 3ul * mpi_rank})
                 .extent({1, 3})
-                .enqueue();
+                .enqueueStore();
         }
         it0.close();
     }