diff --git a/include/openPMD/LoadStoreChunk.hpp b/include/openPMD/LoadStoreChunk.hpp
index 197e3459fc..864b7f9472 100644
--- a/include/openPMD/LoadStoreChunk.hpp
+++ b/include/openPMD/LoadStoreChunk.hpp
@@ -99,15 +99,15 @@ class ConfigureLoadStore : protected internal::ConfigureLoadStoreData
 
     // @todo rvalue references..?
     template <typename T>
-    auto fromSharedPtr(std::shared_ptr<T>) -> shared_ptr_return_type<T>;
+    auto withSharedPtr(std::shared_ptr<T>) -> shared_ptr_return_type<T>;
     template <typename T>
-    auto fromUniquePtr(UniquePtrWithLambda<T>) -> unique_ptr_return_type<T>;
+    auto withUniquePtr(UniquePtrWithLambda<T>) -> unique_ptr_return_type<T>;
     template <typename T, typename Del>
-    auto fromUniquePtr(std::unique_ptr<T, Del>) -> unique_ptr_return_type<T>;
+    auto withUniquePtr(std::unique_ptr<T, Del>) -> unique_ptr_return_type<T>;
     template <typename T>
-    auto fromRawPtr(T *data) -> shared_ptr_return_type<T>;
+    auto withRawPtr(T *data) -> shared_ptr_return_type<T>;
     template <typename T_ContiguousContainer>
-    auto fromContiguousContainer(T_ContiguousContainer &data)
+    auto withContiguousContainer(T_ContiguousContainer &data)
         -> std::enable_if_t<
             auxiliary::IsContiguousContainer_v<T_ContiguousContainer>,
             shared_ptr_return_type<typename T_ContiguousContainer::value_type>>;
diff --git a/include/openPMD/LoadStoreChunk.tpp b/include/openPMD/LoadStoreChunk.tpp
index 63b4b14263..f91f61b5e0 100644
--- a/include/openPMD/LoadStoreChunk.tpp
+++ b/include/openPMD/LoadStoreChunk.tpp
@@ -6,7 +6,7 @@ namespace openPMD
 {
 template <typename ChildClass>
 template <typename T>
-auto ConfigureLoadStore<ChildClass>::fromSharedPtr(std::shared_ptr<T> data)
+auto ConfigureLoadStore<ChildClass>::withSharedPtr(std::shared_ptr<T> data)
     -> shared_ptr_return_type<T>
 {
     if (!data)
@@ -20,7 +20,7 @@ auto ConfigureLoadStore<ChildClass>::fromSharedPtr(std::shared_ptr<T> data)
 }
 template <typename ChildClass>
 template <typename T>
-auto ConfigureLoadStore<ChildClass>::fromUniquePtr(UniquePtrWithLambda<T> data)
+auto ConfigureLoadStore<ChildClass>::withUniquePtr(UniquePtrWithLambda<T> data)
     -> unique_ptr_return_type<T>
 
 {
@@ -35,7 +35,7 @@ auto ConfigureLoadStore<ChildClass>::fromUniquePtr(UniquePtrWithLambda<T> data)
 }
 template <typename ChildClass>
 template <typename T>
-auto ConfigureLoadStore<ChildClass>::fromRawPtr(T *data)
+auto ConfigureLoadStore<ChildClass>::withRawPtr(T *data)
     -> shared_ptr_return_type<T>
 {
     if (!data)
@@ -49,14 +49,14 @@ auto ConfigureLoadStore<ChildClass>::fromRawPtr(T *data)
 
 template <typename ChildClass>
 template <typename T, typename Del>
-auto ConfigureLoadStore<ChildClass>::fromUniquePtr(std::unique_ptr<T, Del> data)
+auto ConfigureLoadStore<ChildClass>::withUniquePtr(std::unique_ptr<T, Del> data)
     -> unique_ptr_return_type<T>
 {
-    return fromUniquePtr(UniquePtrWithLambda<T>(std::move(data)));
+    return withUniquePtr(UniquePtrWithLambda<T>(std::move(data)));
 }
 template <typename ChildClass>
 template <typename T_ContiguousContainer>
-auto ConfigureLoadStore<ChildClass>::fromContiguousContainer(
+auto ConfigureLoadStore<ChildClass>::withContiguousContainer(
     T_ContiguousContainer &data)
     -> std::enable_if_t<
         auxiliary::IsContiguousContainer_v<T_ContiguousContainer>,
@@ -66,6 +66,6 @@ auto ConfigureLoadStore<ChildClass>::fromContiguousContainer(
     {
         m_extent = Extent{data.size()};
     }
-    return fromRawPtr(data.data());
+    return withRawPtr(data.data());
 }
 } // namespace openPMD
diff --git a/include/openPMD/RecordComponent.tpp b/include/openPMD/RecordComponent.tpp
index 72241dd1c1..3d5f874736 100644
--- a/include/openPMD/RecordComponent.tpp
+++ b/include/openPMD/RecordComponent.tpp
@@ -99,7 +99,7 @@ RecordComponent::loadChunkAllocate_impl(internal::LoadStoreConfig cfg)
     prepareLoadStore()
         .offset(std::move(o))
         .extent(std::move(e))
-        .fromSharedPtr(newData)
+        .withSharedPtr(newData)
         .enqueueLoad();
     return newData;
 #else
@@ -107,7 +107,7 @@ RecordComponent::loadChunkAllocate_impl(internal::LoadStoreConfig cfg)
     prepareLoadStore()
         .offset(std::move(o))
         .extent(std::move(e))
-        .fromSharedPtr(newData)
+        .withSharedPtr(newData)
         .enqueueLoad();
     return std::static_pointer_cast<T>(std::move(newData));
 #endif
@@ -134,7 +134,7 @@ inline void RecordComponent::loadChunk(
         operation.extent(std::move(e));
     }
 
-    operation.fromSharedPtr(std::move(data)).enqueueLoad();
+    operation.withSharedPtr(std::move(data)).enqueueLoad();
 }
 
 template <typename T_with_extent>
@@ -207,7 +207,7 @@ inline void RecordComponent::loadChunkRaw(T *ptr, Offset offset, Extent extent)
     prepareLoadStore()
         .offset(std::move(offset))
         .extent(std::move(extent))
-        .fromRawPtr(ptr)
+        .withRawPtr(ptr)
         .enqueueLoad();
 }
 
@@ -218,7 +218,7 @@ RecordComponent::storeChunk(std::shared_ptr<T> data, Offset o, Extent e)
     prepareLoadStore()
         .offset(std::move(o))
         .extent(std::move(e))
-        .fromSharedPtr(std::move(data))
+        .withSharedPtr(std::move(data))
         .enqueueStore();
 }
 
@@ -229,7 +229,7 @@ RecordComponent::storeChunk(UniquePtrWithLambda<T> data, Offset o, Extent e)
     prepareLoadStore()
         .offset(std::move(o))
         .extent(std::move(e))
-        .fromUniquePtr(std::move(data))
+        .withUniquePtr(std::move(data))
         .enqueueStore();
 }
 
@@ -240,7 +240,7 @@ RecordComponent::storeChunk(std::unique_ptr<T, Del> data, Offset o, Extent e)
     prepareLoadStore()
         .offset(std::move(o))
         .extent(std::move(e))
-        .fromUniquePtr(std::move(data))
+        .withUniquePtr(std::move(data))
         .enqueueStore();
 }
 
@@ -250,7 +250,7 @@ void RecordComponent::storeChunkRaw(T *ptr, Offset offset, Extent extent)
     prepareLoadStore()
         .offset(std::move(offset))
         .extent(std::move(extent))
-        .fromRawPtr(ptr)
+        .withRawPtr(ptr)
         .enqueueStore();
 }
 
@@ -271,7 +271,7 @@ RecordComponent::storeChunk(T_ContiguousContainer &data, Offset o, Extent e)
         storeChunkConfig.extent(std::move(e));
     }
 
-    std::move(storeChunkConfig).fromContiguousContainer(data).enqueueStore();
+    std::move(storeChunkConfig).withContiguousContainer(data).enqueueStore();
 }
 
 template <typename T, typename F>
diff --git a/test/ParallelIOTest.cpp b/test/ParallelIOTest.cpp
index d7350789f3..5a55990001 100644
--- a/test/ParallelIOTest.cpp
+++ b/test/ParallelIOTest.cpp
@@ -437,14 +437,14 @@ void available_chunks_test(std::string const &file_ending)
         auto E_y = it0.meshes["E"]["y"];
         E_y.resetDataset({Datatype::INT, {5, 3ul * mpi_size}});
         E_y.prepareLoadStore()
-            .fromContiguousContainer(ydata_firstandlastrow)
+            .withContiguousContainer(ydata_firstandlastrow)
             .offset({0, 3ul * mpi_rank})
             .extent({1, 3})
             .enqueueStore();
         E_y.prepareLoadStore()
             .offset({1, 3ul * mpi_rank})
             .extent({3, 3})
-            .fromContiguousContainer(ydata)
+            .withContiguousContainer(ydata)
             .memorySelection({{1, 1}, {5, 5}})
             .enqueueStore();
         // if condition checks if this PR is available in ADIOS2:
@@ -452,7 +452,7 @@ void available_chunks_test(std::string const &file_ending)
         if constexpr (CanTheMemorySelectionBeReset)
         {
             E_y.prepareLoadStore()
-                .fromContiguousContainer(ydata_firstandlastrow)
+                .withContiguousContainer(ydata_firstandlastrow)
                 .offset({4, 3ul * mpi_rank})
                 .extent({1, 3})
                 .enqueueStore();