diff --git a/source/RobotAPI/libraries/armem/server/MemoryToIceAdapter.cpp b/source/RobotAPI/libraries/armem/server/MemoryToIceAdapter.cpp
index b70d98e4fb09a9d209c151dfcede09c551828367..858f715c4ec5728edbf646e587cd4f02d5958798 100644
--- a/source/RobotAPI/libraries/armem/server/MemoryToIceAdapter.cpp
+++ b/source/RobotAPI/libraries/armem/server/MemoryToIceAdapter.cpp
@@ -286,10 +286,7 @@ namespace armarx::armem::server
 
             // append result to return memory and sanity check
             wmResult.append(ltmResult);
-            if (wmResult.empty())
-            {
-                ARMARX_ERROR << "A merged Memory has no data although at least the LTM result contains data. This indicates that something is wrong.";
-            }
+            ARMARX_CHECK(not wmResult.empty());
 
             // Ist das wirklich notwendig?
             // query again to limit output size (TODO: Skip if querytype is all)
diff --git a/source/RobotAPI/libraries/armem/server/ltm/base/converter/Converter.h b/source/RobotAPI/libraries/armem/server/ltm/base/converter/Converter.h
index c42e9c0d57d64f4776f7c1f586ea3eba3a4af75a..0ed3d9b08188179d17e5baaf0087b0c33e75eaa0 100644
--- a/source/RobotAPI/libraries/armem/server/ltm/base/converter/Converter.h
+++ b/source/RobotAPI/libraries/armem/server/ltm/base/converter/Converter.h
@@ -26,7 +26,7 @@ namespace armarx::armem::server::ltm
         virtual ~Converter() = default;
 
         virtual std::pair<std::vector<unsigned char>, std::string> convert(const aron::data::VariantPtr& data) = 0;
-        virtual aron::data::VariantPtr convert(const std::vector<unsigned char>& data, const std::string&) = 0;
+        virtual aron::data::VariantPtr convert(const std::vector<unsigned char>& data, const armarx::aron::Path& p, const std::string&) = 0;
 
     public:
         const ConverterType type;
diff --git a/source/RobotAPI/libraries/armem/server/ltm/base/converter/image/Converter.cpp b/source/RobotAPI/libraries/armem/server/ltm/base/converter/image/Converter.cpp
index 39b4d94b015841467ccadf14e34bf6ab1bf00ef0..30349fd4faa55ab513d6c080251138cb16bafe77 100644
--- a/source/RobotAPI/libraries/armem/server/ltm/base/converter/image/Converter.cpp
+++ b/source/RobotAPI/libraries/armem/server/ltm/base/converter/image/Converter.cpp
@@ -9,9 +9,9 @@ namespace armarx::armem::server::ltm
         return _convert(d);
     }
 
-    aron::data::VariantPtr ImageConverter::convert(const std::vector<unsigned char>& data, const std::string& m)
+    aron::data::VariantPtr ImageConverter::convert(const std::vector<unsigned char>& data, const armarx::aron::Path& p, const std::string& m)
     {
-        auto d = _convert(data, m);
+        auto d = _convert(data, p, m);
         return d;
     }
 
diff --git a/source/RobotAPI/libraries/armem/server/ltm/base/converter/image/Converter.h b/source/RobotAPI/libraries/armem/server/ltm/base/converter/image/Converter.h
index 8cb070f09d46f4f7ce4bc069920f082c30ba1763..440c1c6c50815eb56576fca2cd1bb65d1185f0ec 100644
--- a/source/RobotAPI/libraries/armem/server/ltm/base/converter/image/Converter.h
+++ b/source/RobotAPI/libraries/armem/server/ltm/base/converter/image/Converter.h
@@ -21,10 +21,10 @@ namespace armarx::armem::server::ltm
         virtual ~ImageConverter() = default;
 
         std::pair<std::vector<unsigned char>, std::string> convert(const aron::data::VariantPtr& data) final;
-        aron::data::VariantPtr convert(const std::vector<unsigned char>& data, const std::string&) final;
+        aron::data::VariantPtr convert(const std::vector<unsigned char>& data, const armarx::aron::Path& p, const std::string&) final;
 
     protected:
         virtual std::pair<std::vector<unsigned char>, std::string> _convert(const aron::data::NDArrayPtr& data) = 0;
-        virtual aron::data::NDArrayPtr _convert(const std::vector<unsigned char>& data, const std::string&) = 0;
+        virtual aron::data::NDArrayPtr _convert(const std::vector<unsigned char>& data, const armarx::aron::Path& p, const std::string&) = 0;
     };
 }
diff --git a/source/RobotAPI/libraries/armem/server/ltm/base/converter/image/exr/ExrConverter.cpp b/source/RobotAPI/libraries/armem/server/ltm/base/converter/image/exr/ExrConverter.cpp
index c5eee777b60ac5b7e1c97606e5902107afdb0221..6bf18cff45eea27f018c9dc7c371becbb5baf90a 100644
--- a/source/RobotAPI/libraries/armem/server/ltm/base/converter/image/exr/ExrConverter.cpp
+++ b/source/RobotAPI/libraries/armem/server/ltm/base/converter/image/exr/ExrConverter.cpp
@@ -25,9 +25,9 @@ namespace armarx::armem::server::ltm::converter::image
         return std::make_pair(buffer, "");
     }
 
-    aron::data::NDArrayPtr ExrConverter::_convert(const std::vector<unsigned char>& data, const std::string& m)
+    aron::data::NDArrayPtr ExrConverter::_convert(const std::vector<unsigned char>& data, const armarx::aron::Path& p, const std::string& m)
     {
         cv::Mat img = cv::imdecode(data, cv::IMREAD_ANYDEPTH);
-        return aron::converter::AronOpenCVConverter::ConvertFromMat(img);
+        return aron::converter::AronOpenCVConverter::ConvertFromMat(img, p);
     }
 }
diff --git a/source/RobotAPI/libraries/armem/server/ltm/base/converter/image/exr/ExrConverter.h b/source/RobotAPI/libraries/armem/server/ltm/base/converter/image/exr/ExrConverter.h
index ad4b1bfa2f4b517a55136ace72942d4440404c9f..07e94a5b2c8ef2951949854600e25f4a901d6478 100644
--- a/source/RobotAPI/libraries/armem/server/ltm/base/converter/image/exr/ExrConverter.h
+++ b/source/RobotAPI/libraries/armem/server/ltm/base/converter/image/exr/ExrConverter.h
@@ -16,6 +16,6 @@ namespace armarx::armem::server::ltm::converter::image
 
     protected:
         std::pair<std::vector<unsigned char>, std::string> _convert(const aron::data::NDArrayPtr& data) final;
-        aron::data::NDArrayPtr _convert(const std::vector<unsigned char>& data, const std::string&) final;
+        aron::data::NDArrayPtr _convert(const std::vector<unsigned char>& data, const armarx::aron::Path& p, const std::string&) final;
     };
 }
diff --git a/source/RobotAPI/libraries/armem/server/ltm/base/converter/image/png/PngConverter.cpp b/source/RobotAPI/libraries/armem/server/ltm/base/converter/image/png/PngConverter.cpp
index e8536cf64841d23712e7264ce76282039b893189..03453e6f6c4432e1efd0445ae393d1d14242a4bd 100644
--- a/source/RobotAPI/libraries/armem/server/ltm/base/converter/image/png/PngConverter.cpp
+++ b/source/RobotAPI/libraries/armem/server/ltm/base/converter/image/png/PngConverter.cpp
@@ -39,23 +39,23 @@ namespace armarx::armem::server::ltm::converter::image
         return std::make_pair(buffer, "");
     }
 
-    aron::data::NDArrayPtr PngConverter::_convert(const std::vector<unsigned char>& data, const std::string& m)
+    aron::data::NDArrayPtr PngConverter::_convert(const std::vector<unsigned char>& data, const armarx::aron::Path& p, const std::string& m)
     {
         if (m == ".rgb")
         {
             cv::Mat img = cv::imdecode(data, cv::IMREAD_COLOR);
             cv::cvtColor(img, img, CV_BGR2RGB);
-            return aron::converter::AronOpenCVConverter::ConvertFromMat(img);
+            return aron::converter::AronOpenCVConverter::ConvertFromMat(img, p);
         }
 
         if (m == ".gs")
         {
             cv::Mat img = cv::imdecode(data, cv::IMREAD_GRAYSCALE);
-            return aron::converter::AronOpenCVConverter::ConvertFromMat(img);
+            return aron::converter::AronOpenCVConverter::ConvertFromMat(img, p);
         }
 
         // try to load without conversion
         cv::Mat img = cv::imdecode(data, cv::IMREAD_ANYCOLOR);
-        return aron::converter::AronOpenCVConverter::ConvertFromMat(img);
+        return aron::converter::AronOpenCVConverter::ConvertFromMat(img, p);
     }
 }
diff --git a/source/RobotAPI/libraries/armem/server/ltm/base/converter/image/png/PngConverter.h b/source/RobotAPI/libraries/armem/server/ltm/base/converter/image/png/PngConverter.h
index 5b6c80134319a52b77565dba322349985fed2267..0c443fa794d22a6a7a6f5c837565693f8cf2e28c 100644
--- a/source/RobotAPI/libraries/armem/server/ltm/base/converter/image/png/PngConverter.h
+++ b/source/RobotAPI/libraries/armem/server/ltm/base/converter/image/png/PngConverter.h
@@ -16,6 +16,6 @@ namespace armarx::armem::server::ltm::converter::image
 
     protected:
         std::pair<std::vector<unsigned char>, std::string> _convert(const aron::data::NDArrayPtr& data) final;
-        aron::data::NDArrayPtr _convert(const std::vector<unsigned char>& data, const std::string&) final;
+        aron::data::NDArrayPtr _convert(const std::vector<unsigned char>& data, const armarx::aron::Path& p, const std::string&) final;
     };
 }
diff --git a/source/RobotAPI/libraries/armem/server/ltm/base/converter/object/Converter.cpp b/source/RobotAPI/libraries/armem/server/ltm/base/converter/object/Converter.cpp
index 4f0808a6f03f1739e76cf6fc02a9a155be334be8..e6c3345028e9c3af35636d0f509412c4e8ca925a 100644
--- a/source/RobotAPI/libraries/armem/server/ltm/base/converter/object/Converter.cpp
+++ b/source/RobotAPI/libraries/armem/server/ltm/base/converter/object/Converter.cpp
@@ -9,9 +9,9 @@ namespace armarx::armem::server::ltm
         return _convert(d);
     }
 
-    aron::data::VariantPtr ObjectConverter::convert(const std::vector<unsigned char>& data, const std::string& m)
+    aron::data::VariantPtr ObjectConverter::convert(const std::vector<unsigned char>& data, const armarx::aron::Path& p, const std::string& m)
     {
-        auto d = _convert(data, m);
+        auto d = _convert(data, p, m);
         return d;
     }
 
diff --git a/source/RobotAPI/libraries/armem/server/ltm/base/converter/object/Converter.h b/source/RobotAPI/libraries/armem/server/ltm/base/converter/object/Converter.h
index 35f1a9d968221565184a823e3e57a20d83565546..113dd7a5b726f9b75efa07875f0a07fa443fc3a1 100644
--- a/source/RobotAPI/libraries/armem/server/ltm/base/converter/object/Converter.h
+++ b/source/RobotAPI/libraries/armem/server/ltm/base/converter/object/Converter.h
@@ -21,10 +21,10 @@ namespace armarx::armem::server::ltm
         virtual ~ObjectConverter() = default;
 
         std::pair<std::vector<unsigned char>, std::string> convert(const aron::data::VariantPtr& data) final;
-        aron::data::VariantPtr convert(const std::vector<unsigned char>& data, const std::string&) final;
+        aron::data::VariantPtr convert(const std::vector<unsigned char>& data, const armarx::aron::Path& p, const std::string&) final;
 
     protected:
         virtual std::pair<std::vector<unsigned char>, std::string> _convert(const aron::data::DictPtr& data) = 0;
-        virtual aron::data::DictPtr _convert(const std::vector<unsigned char>& data, const std::string&) = 0;
+        virtual aron::data::DictPtr _convert(const std::vector<unsigned char>& data, const armarx::aron::Path& p, const std::string&) = 0;
     };
 }
diff --git a/source/RobotAPI/libraries/armem/server/ltm/base/converter/object/bson/BsonConverter.cpp b/source/RobotAPI/libraries/armem/server/ltm/base/converter/object/bson/BsonConverter.cpp
index 8465201f3bd078b7bd93bec2cbd26378dfd119ab..4155808d3c7dc5818bfb48112a6e77f41a74b681 100644
--- a/source/RobotAPI/libraries/armem/server/ltm/base/converter/object/bson/BsonConverter.cpp
+++ b/source/RobotAPI/libraries/armem/server/ltm/base/converter/object/bson/BsonConverter.cpp
@@ -24,13 +24,13 @@ namespace armarx::armem::server::ltm::converter::object
         return std::make_pair(bson, str);
     }
 
-    aron::data::DictPtr BsonConverter::_convert(const std::vector<unsigned char>& data, const std::string& m)
+    aron::data::DictPtr BsonConverter::_convert(const std::vector<unsigned char>& data, const armarx::aron::Path& p, const std::string& m)
     {
         bsoncxx::document::view view(data.data(), data.size());
         nlohmann::json json = bsoncxx::to_json(view);
         std::string str = json.dump(2);
         std::vector<unsigned char> jsonVec(str.begin(), str.end());
-        auto v = jsonConverter.convert(jsonVec, m);
+        auto v = jsonConverter.convert(jsonVec, p, m);
         return aron::data::Dict::DynamicCast(v);
     }
 }
diff --git a/source/RobotAPI/libraries/armem/server/ltm/base/converter/object/bson/BsonConverter.h b/source/RobotAPI/libraries/armem/server/ltm/base/converter/object/bson/BsonConverter.h
index 6eb183be2c5998a3eb43251ff7018a6e336260ea..fddf6870f2bbcbc6580e1eb8bf8907e40416e3a0 100644
--- a/source/RobotAPI/libraries/armem/server/ltm/base/converter/object/bson/BsonConverter.h
+++ b/source/RobotAPI/libraries/armem/server/ltm/base/converter/object/bson/BsonConverter.h
@@ -20,7 +20,7 @@ namespace armarx::armem::server::ltm::converter::object
 
     protected:
         std::pair<std::vector<unsigned char>, std::string> _convert(const aron::data::DictPtr& data) final;
-        aron::data::DictPtr _convert(const std::vector<unsigned char>& data, const std::string&) final;
+        aron::data::DictPtr _convert(const std::vector<unsigned char>& data, const armarx::aron::Path& p, const std::string&) final;
 
     private:
         JsonConverter jsonConverter;
diff --git a/source/RobotAPI/libraries/armem/server/ltm/base/converter/object/json/JsonConverter.cpp b/source/RobotAPI/libraries/armem/server/ltm/base/converter/object/json/JsonConverter.cpp
index 1495b275baa88a14aecb9487db781ac0236b57d5..c24125140309ee7c3c597fbd2a57eba5fff4caaa 100644
--- a/source/RobotAPI/libraries/armem/server/ltm/base/converter/object/json/JsonConverter.cpp
+++ b/source/RobotAPI/libraries/armem/server/ltm/base/converter/object/json/JsonConverter.cpp
@@ -12,10 +12,10 @@ namespace armarx::armem::server::ltm::converter::object
         return std::make_pair(std::vector<unsigned char>(str.begin(), str.end()), "");
     }
 
-    aron::data::DictPtr JsonConverter::_convert(const std::vector<unsigned char>& data, const std::string&)
+    aron::data::DictPtr JsonConverter::_convert(const std::vector<unsigned char>& data, const armarx::aron::Path& p, const std::string&)
     {
         std::string str(data.begin(), data.end());
         nlohmann::json j = nlohmann::json::parse(str);
-        return aron::converter::AronNlohmannJSONConverter::ConvertFromNlohmannJSONObject(j);
+        return aron::converter::AronNlohmannJSONConverter::ConvertFromNlohmannJSONObject(j, p);
     }
 }
diff --git a/source/RobotAPI/libraries/armem/server/ltm/base/converter/object/json/JsonConverter.h b/source/RobotAPI/libraries/armem/server/ltm/base/converter/object/json/JsonConverter.h
index 1b9f86ee93cda46983201be6e7910e4596734b3e..0c6d71d119396ff7e0293ea5196c252c9ba3cc7c 100644
--- a/source/RobotAPI/libraries/armem/server/ltm/base/converter/object/json/JsonConverter.h
+++ b/source/RobotAPI/libraries/armem/server/ltm/base/converter/object/json/JsonConverter.h
@@ -19,6 +19,6 @@ namespace armarx::armem::server::ltm::converter::object
 
     protected:
         std::pair<std::vector<unsigned char>, std::string> _convert(const aron::data::DictPtr& data) final;
-        aron::data::DictPtr _convert(const std::vector<unsigned char>& data, const std::string&) final;
+        aron::data::DictPtr _convert(const std::vector<unsigned char>& data, const armarx::aron::Path& p, const std::string&) final;
     };
 }
diff --git a/source/RobotAPI/libraries/armem/server/ltm/disk/CoreSegment.cpp b/source/RobotAPI/libraries/armem/server/ltm/disk/CoreSegment.cpp
index cfc859a5f89418247c1d7f383cfea1b5bce8aa2a..a6a7aa48e28f697254755e857df6c7c70ceb01e3 100644
--- a/source/RobotAPI/libraries/armem/server/ltm/disk/CoreSegment.cpp
+++ b/source/RobotAPI/libraries/armem/server/ltm/disk/CoreSegment.cpp
@@ -8,7 +8,7 @@
 
 namespace armarx::armem::server::ltm::disk
 {
-    CoreSegment::CoreSegment(const std::filesystem::path& p, const MemoryID& id, const std::shared_ptr<Processors>& filters, const DiskMemoryItem::MemoryEncodingMode mode, const unsigned long e) :
+    CoreSegment::CoreSegment(const std::filesystem::path& p, const MemoryID& id /* UNESCAPED */, const std::shared_ptr<Processors>& filters, const DiskMemoryItem::MemoryEncodingMode mode, const unsigned long e) :
         CoreSegmentBase(id, filters),
         DiskMemoryItem(p, EscapeSegmentName(id.memoryName), std::filesystem::path(EscapeSegmentName(id.coreSegmentName))),
         currentMode(mode),
@@ -20,6 +20,7 @@ namespace armarx::armem::server::ltm::disk
     {
         auto mPath = getMemoryBasePathForMode(currentMode, currentExport);
         auto relPath = getRelativePathForMode(currentMode);
+
         if (!util::checkIfBasePathExists(mPath) || !util::checkIfFolderExists(mPath, relPath))
         {
             return false;
diff --git a/source/RobotAPI/libraries/armem/server/ltm/disk/Entity.cpp b/source/RobotAPI/libraries/armem/server/ltm/disk/Entity.cpp
index 8b00d8d39b8fa49de6c31d8b617549d97e6a45cb..ea5ad1757f2d71e955d41a80a416a2c10474feb7 100644
--- a/source/RobotAPI/libraries/armem/server/ltm/disk/Entity.cpp
+++ b/source/RobotAPI/libraries/armem/server/ltm/disk/Entity.cpp
@@ -67,6 +67,7 @@ namespace armarx::armem::server::ltm::disk
                         continue;
                     }
 
+
                     EntitySnapshot c(memoryParentPath, id().withTimestamp(timeFromStringMicroSeconds(usecName)), processors, currentMode, currentExport);
                     func(c);
                 }
@@ -77,7 +78,7 @@ namespace armarx::armem::server::ltm::disk
 
     bool Entity::forEachSnapshotInIndexRange(long first, long last, std::function<void(EntitySnapshot&)> func) const
     {
-        ARMARX_WARNING << "PLEASE NOTE THAT QUERYING THE LTM INDEX WISE MAY BE BUGGY BECAUSE THE FILESYSTEM ITERATOR IS UNSORTED!";
+        //ARMARX_WARNING << "PLEASE NOTE THAT QUERYING THE LTM INDEX WISE MAY BE BUGGY BECAUSE THE FILESYSTEM ITERATOR IS UNSORTED!";
 
         if (first < 0 or last < 0)
         {
@@ -96,11 +97,11 @@ namespace armarx::armem::server::ltm::disk
         long checked = 0;
         auto f = [&](EntitySnapshot& e)
         {
-            checked++;
             if (checked >= first && checked <= last)
             {
                 func(e);
             }
+            checked++;
         };
 
         return forEachSnapshot(std::move(f));
diff --git a/source/RobotAPI/libraries/armem/server/ltm/disk/EntitySnapshot.cpp b/source/RobotAPI/libraries/armem/server/ltm/disk/EntitySnapshot.cpp
index f1706a545a0f3d81cee3637e3bef3f5eb7df0e17..aea0141b662e58a1dda66b261ccec875bcdf0768 100644
--- a/source/RobotAPI/libraries/armem/server/ltm/disk/EntitySnapshot.cpp
+++ b/source/RobotAPI/libraries/armem/server/ltm/disk/EntitySnapshot.cpp
@@ -12,7 +12,7 @@
 
 namespace armarx::armem::server::ltm::disk
 {
-    EntitySnapshot::EntitySnapshot(const std::filesystem::path& p, const MemoryID& id, const std::shared_ptr<Processors>& filters, const DiskMemoryItem::MemoryEncodingMode mode, const unsigned long e) :
+    EntitySnapshot::EntitySnapshot(const std::filesystem::path& p, const MemoryID& id /* UNESCAPED */, const std::shared_ptr<Processors>& filters, const DiskMemoryItem::MemoryEncodingMode mode, const unsigned long e) :
         EntitySnapshotBase(id, filters),
         DiskMemoryItem(p, EscapeSegmentName(id.memoryName),
                        std::filesystem::path(EscapeSegmentName(id.coreSegmentName))
@@ -29,6 +29,7 @@ namespace armarx::armem::server::ltm::disk
     {
         auto mPath = getMemoryBasePathForMode(currentMode, currentExport);
         auto relPath = getRelativePathForMode(currentMode);
+
         if (!util::checkIfBasePathExists(mPath) || !util::checkIfFolderExists(mPath, relPath))
         {
             return;
@@ -82,10 +83,10 @@ namespace armarx::armem::server::ltm::disk
                 {
                     //ARMARX_INFO << "Convert data for entity " << id();
                     auto datafilecontent = util::readDataFromFile(mPath, relDataPath);
-                    auto dataaron = dictConverter.convert(datafilecontent, "");
+                    auto dataaron = dictConverter.convert(datafilecontent, {}, "");
                     datadict = aron::data::Dict::DynamicCastAndCheck(dataaron);
 
-                    // check for special members
+                    // check for special members TODO: only allowed for direct children?
                     for (const auto& [key, m] : datadict->getElements())
                     {
                         for (auto& [t, f] : processors->converters)
@@ -98,7 +99,7 @@ namespace armarx::armem::server::ltm::disk
                                     std::string mode = simox::alg::remove_suffix(simox::alg::remove_prefix(filename, key), f->suffix);
 
                                     auto memberfilecontent = util::readDataFromFile(mPath, relMemberPath);
-                                    auto memberaron = f->convert(memberfilecontent, mode);
+                                    auto memberaron = f->convert(memberfilecontent, armarx::aron::Path(datadict->getPath(), std::vector<std::string>{key}), mode);
                                     datadict->setElement(key, memberaron);
                                     break;
                                 }
@@ -115,7 +116,7 @@ namespace armarx::armem::server::ltm::disk
                 if (std::find(allFilesInIndexFolder.begin(), allFilesInIndexFolder.end(), metadataFilename) != allFilesInIndexFolder.end())
                 {
                     auto metadatafilecontent = util::readDataFromFile(mPath, relMetadataPath);
-                    auto metadataaron = dictConverter.convert(metadatafilecontent, "");
+                    auto metadataaron = dictConverter.convert(metadatafilecontent, {}, "");
                     metadatadict = aron::data::Dict::DynamicCastAndCheck(metadataaron);
                 }
                 else
diff --git a/source/RobotAPI/libraries/armem/server/ltm/disk/Memory.cpp b/source/RobotAPI/libraries/armem/server/ltm/disk/Memory.cpp
index a2a374c6de24e4fd1dca370149841d79f85de027..31f5bd8106a32172540db9692b166cdd7fb9d858 100644
--- a/source/RobotAPI/libraries/armem/server/ltm/disk/Memory.cpp
+++ b/source/RobotAPI/libraries/armem/server/ltm/disk/Memory.cpp
@@ -71,6 +71,7 @@ namespace armarx::armem::server::ltm::disk
         {
             MemoryEncodingMode mode = i == 0 ? MemoryEncodingMode::FILESYSTEM : defaultExportEncodingMode;
             auto mPath = getMemoryBasePathForMode(mode, i);
+
             if (util::checkIfBasePathExists(mPath))
             {
                 for (const auto& subdirName : util::getAllDirectories(mPath, getRelativePathForMode(mode)))
diff --git a/source/RobotAPI/libraries/armem/server/ltm/disk/ProviderSegment.cpp b/source/RobotAPI/libraries/armem/server/ltm/disk/ProviderSegment.cpp
index 32500f7d6a799f678d5fdf1fce09024d93c4a796..631461f464f25977fddbb518c9332bc51e273ce9 100644
--- a/source/RobotAPI/libraries/armem/server/ltm/disk/ProviderSegment.cpp
+++ b/source/RobotAPI/libraries/armem/server/ltm/disk/ProviderSegment.cpp
@@ -10,7 +10,7 @@
 
 namespace armarx::armem::server::ltm::disk
 {
-    ProviderSegment::ProviderSegment(const std::filesystem::path& p, const MemoryID& id, const std::shared_ptr<Processors>& filters, const DiskMemoryItem::MemoryEncodingMode mode, const unsigned long e) :
+    ProviderSegment::ProviderSegment(const std::filesystem::path& p, const MemoryID& id /* UNESCAPED */, const std::shared_ptr<Processors>& filters, const DiskMemoryItem::MemoryEncodingMode mode, const unsigned long e) :
         ProviderSegmentBase(id, filters),
         DiskMemoryItem(p, EscapeSegmentName(id.memoryName), std::filesystem::path(EscapeSegmentName(id.coreSegmentName)) / EscapeSegmentName(id.providerSegmentName)),
         currentMode(mode),
@@ -22,6 +22,7 @@ namespace armarx::armem::server::ltm::disk
     {
         auto mPath = getMemoryBasePathForMode(currentMode, currentExport);
         auto relPath = getRelativePathForMode(currentMode);
+
         if (!util::checkIfBasePathExists(mPath) || !util::checkIfFolderExists(mPath, relPath))
         {
             return false;
@@ -30,7 +31,7 @@ namespace armarx::armem::server::ltm::disk
         for (const auto& subdirName : util::getAllDirectories(mPath, relPath))
         {
             std::string segmentName = UnescapeSegmentName(subdirName);
-            Entity c(memoryParentPath, id().withEntityName(subdirName), processors, currentMode, currentExport);
+            Entity c(memoryParentPath, id().withEntityName(segmentName), processors, currentMode, currentExport);
             func(c);
         }
         return true;
diff --git a/source/RobotAPI/libraries/armem/server/query_proc/ltm/detail/EntityQueryProcessorBase.h b/source/RobotAPI/libraries/armem/server/query_proc/ltm/detail/EntityQueryProcessorBase.h
index 42b87df82d95dcf6e264319dc5b6a7e868dbde94..5d3f9b0ed7e2128be282661107886986c6edc1da 100644
--- a/source/RobotAPI/libraries/armem/server/query_proc/ltm/detail/EntityQueryProcessorBase.h
+++ b/source/RobotAPI/libraries/armem/server/query_proc/ltm/detail/EntityQueryProcessorBase.h
@@ -2,6 +2,8 @@
 
 #include "../../base/EntityQueryProcessorBase.h"
 
+#include <ArmarXCore/core/logging/Logging.h>
+
 
 namespace armarx::armem::server::query_proc::ltm::detail
 {
diff --git a/source/RobotAPI/libraries/armem_skills/CMakeLists.txt b/source/RobotAPI/libraries/armem_skills/CMakeLists.txt
index 40e112f8b56f762ff8da6c57f1995b09bc5243bf..f0d624155b4f8e7abadd86f158c445ca4484d49e 100644
--- a/source/RobotAPI/libraries/armem_skills/CMakeLists.txt
+++ b/source/RobotAPI/libraries/armem_skills/CMakeLists.txt
@@ -13,6 +13,7 @@ armarx_add_library(
         RobotAPI::armem_server
         RobotAPI::skills
         aronjsonconverter
+        aroncommonconverter
     SOURCES  
         ./aron_conversions.cpp
 
diff --git a/source/RobotAPI/libraries/armem_skills/aron/Skill.xml b/source/RobotAPI/libraries/armem_skills/aron/Skill.xml
index 84b9840794dbd1a618b51e5219732924949c1b8e..abd89ebd82a7d30d19c1945444d1dd8f5d650bfd 100644
--- a/source/RobotAPI/libraries/armem_skills/aron/Skill.xml
+++ b/source/RobotAPI/libraries/armem_skills/aron/Skill.xml
@@ -31,11 +31,11 @@ The memory should look like the following:
             </ObjectChild>
 
             <ObjectChild key='timeoutMs'>
-                <long />
+                <int64 />
             </ObjectChild>
 
             <ObjectChild key='acceptedType'>
-                <string /> <!-- TODO REPLACE! -->
+                <AnyObject shared_ptr="1" />
             </ObjectChild>
 
         </Object>
diff --git a/source/RobotAPI/libraries/armem_skills/server/segment/ExecutableSkillLibrarySegment.cpp b/source/RobotAPI/libraries/armem_skills/server/segment/ExecutableSkillLibrarySegment.cpp
index df0f6da140cce0cca44a8a25c1b5d70fa96aa8a4..1a342fe0cde09bd59821bb93374025cd8866e782 100644
--- a/source/RobotAPI/libraries/armem_skills/server/segment/ExecutableSkillLibrarySegment.cpp
+++ b/source/RobotAPI/libraries/armem_skills/server/segment/ExecutableSkillLibrarySegment.cpp
@@ -4,6 +4,7 @@
 #include <SimoxUtility/algorithm/string.h>
 
 #include <RobotAPI/libraries/aron/converter/json/NLohmannJSONConverter.h>
+#include <RobotAPI/libraries/aron/converter/common/DatatypeConverter.h>
 
 #include <RobotAPI/libraries/armem_skills/aron/Skill.aron.generated.h>
 
@@ -43,13 +44,19 @@ namespace armarx::skills::segment
             if (desc.acceptedType)
             {
                 auto t = aron::type::Object::FromAronObjectDTO(desc.acceptedType);
-                skillDescription.acceptedType = aron::converter::AronNlohmannJSONConverter::ConvertToNlohmannJSON(t).dump(2);
+
+                aron::converter::DatatypeConverter c;
+                aron::type::visit(c, t);
+
+                skillDescription.acceptedType = aron::data::Dict::DynamicCastAndCheck(c.latest);
             }
 
             armem::Commit commit;
             auto& entityUpdate = commit.add();
             entityUpdate.confidence = 1.0;
             entityUpdate.referencedTime = armem::Time::Now();
+            entityUpdate.sentTime = armem::Time::Now();
+            entityUpdate.arrivedTime = armem::Time::Now();
             entityUpdate.instancesData = {skillDescription.toAron()};
             entityUpdate.entityID = provId.withEntityName(skillDescription.skillName);
 
diff --git a/source/RobotAPI/libraries/aron/converter/common/CMakeLists.txt b/source/RobotAPI/libraries/aron/converter/common/CMakeLists.txt
index ad1ddc3669b4672d4d9a2f9def8cb4643b8d6821..fcc6342d5c779174e6322ff0c45bd9ca610758c2 100644
--- a/source/RobotAPI/libraries/aron/converter/common/CMakeLists.txt
+++ b/source/RobotAPI/libraries/aron/converter/common/CMakeLists.txt
@@ -10,11 +10,13 @@ set(LIBS
 set(LIB_FILES
     Converter.cpp
     VectorConverter.cpp
+    DatatypeConverter.cpp
 )
 
 set(LIB_HEADERS
     Converter.h
     VectorConverter.h
+    DatatypeConverter.h
 )
 
 armarx_add_library("${LIB_NAME}" "${LIB_FILES}" "${LIB_HEADERS}" "${LIBS}")
diff --git a/source/RobotAPI/libraries/aron/converter/common/DatatypeConverter.cpp b/source/RobotAPI/libraries/aron/converter/common/DatatypeConverter.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..77743613df7297b67273debdbcb0c71c0d346dff
--- /dev/null
+++ b/source/RobotAPI/libraries/aron/converter/common/DatatypeConverter.cpp
@@ -0,0 +1,151 @@
+#include "DatatypeConverter.h"
+
+namespace armarx::aron::converter
+{
+    void DatatypeConverter::visitAronVariant(const type::ObjectPtr& el)
+    {
+        auto dict = aron::make_dict(el->getPath());
+        auto type = aron::make_string(el->getFullName(), Path(el->getPath(), {typeMemberName}));
+        dict->addElement(typeMemberName, type);
+
+        for (const auto& [key, child] : el->getMemberTypes())
+        {
+            DatatypeConverter converter;
+            aron::type::visit(converter, child);
+
+            dict->addElement(key, converter.latest);
+        }
+
+        latest = dict;
+    }
+
+    void DatatypeConverter::visitAronVariant(const type::DictPtr& el)
+    {
+        auto dict = aron::make_dict(el->getPath());
+        auto type = aron::make_string(el->getFullName(), Path(el->getPath(), {typeMemberName}));
+        dict->addElement(typeMemberName, type);
+
+        auto acceptedType = el->getAcceptedType();
+        DatatypeConverter converter;
+        aron::type::visit(converter, acceptedType);
+        dict->addElement(acceptedTypeMemberName, converter.latest);
+
+        latest = dict;
+    }
+
+    void DatatypeConverter::visitAronVariant(const type::ListPtr& el)
+    {
+        auto dict = aron::make_dict(el->getPath());
+        auto type = aron::make_string(el->getFullName(), Path(el->getPath(), {typeMemberName}));
+        dict->addElement(typeMemberName, type);
+
+        auto acceptedType = el->getAcceptedType();
+        DatatypeConverter converter;
+        aron::type::visit(converter, acceptedType);
+        dict->addElement(acceptedTypeMemberName, converter.latest);
+
+        latest = dict;
+    }
+
+    void DatatypeConverter::visitAronVariant(const type::PairPtr& el)
+    {
+        auto dict = aron::make_dict(el->getPath());
+        auto type = aron::make_string(el->getFullName(), Path(el->getPath(), {typeMemberName}));
+        dict->addElement(typeMemberName, type);
+
+        auto acceptedType1 = el->getFirstAcceptedType();
+        DatatypeConverter converter1;
+        aron::type::visit(converter1, acceptedType1);
+        dict->addElement(firstAcceptedTypeMemberName, converter1.latest);
+
+        auto acceptedType2 = el->getSecondAcceptedType();
+        DatatypeConverter converter2;
+        aron::type::visit(converter2, acceptedType2);
+        dict->addElement(secondAcceptedTypeMemberName, converter2.latest);
+
+        latest = dict;
+    }
+
+    void DatatypeConverter::visitAronVariant(const type::TuplePtr& el)
+    {
+        auto dict = aron::make_dict(el->getPath());
+        auto type = aron::make_string(el->getFullName(), Path(el->getPath(), {typeMemberName}));
+        dict->addElement(typeMemberName, type);
+
+        int i = 0;
+        for (const auto& child : el->getAcceptedTypes())
+        {
+            DatatypeConverter converter;
+            aron::type::visit(converter, child);
+
+            dict->addElement(acceptedTypeMemberName + "_" + std::to_string(i++), converter.latest);
+        }
+
+        latest = dict;
+    }
+
+    void DatatypeConverter::visitAronVariant(const type::MatrixPtr& el)
+    {
+        latest = aron::make_string(el->getFullName(), el->getPath());
+    }
+
+    void DatatypeConverter::visitAronVariant(const type::NDArrayPtr& el)
+    {
+        latest = aron::make_string(el->getFullName(), el->getPath());
+    }
+
+    void DatatypeConverter::visitAronVariant(const type::QuaternionPtr& el)
+    {
+        latest = aron::make_string(el->getFullName(), el->getPath());
+    }
+
+    void DatatypeConverter::visitAronVariant(const type::PointCloudPtr& el)
+    {
+        latest = aron::make_string(el->getFullName(), el->getPath());
+    }
+
+    void DatatypeConverter::visitAronVariant(const type::ImagePtr& el)
+    {
+        latest = aron::make_string(el->getFullName(), el->getPath());
+    }
+
+    void DatatypeConverter::visitAronVariant(const type::IntEnumPtr& el)
+    {
+        latest = aron::make_string(el->getFullName(), el->getPath());
+    }
+
+    void DatatypeConverter::visitAronVariant(const type::IntPtr& el)
+    {
+        latest = aron::make_string(el->getFullName(), el->getPath());
+    }
+
+    void DatatypeConverter::visitAronVariant(const type::LongPtr& el)
+    {
+        latest = aron::make_string(el->getFullName(), el->getPath());
+    }
+
+    void DatatypeConverter::visitAronVariant(const type::FloatPtr& el)
+    {
+        latest = aron::make_string(el->getFullName(), el->getPath());
+    }
+
+    void DatatypeConverter::visitAronVariant(const type::DoublePtr& el)
+    {
+        latest = aron::make_string(el->getFullName(), el->getPath());
+    }
+
+    void DatatypeConverter::visitAronVariant(const type::BoolPtr& el)
+    {
+        latest = aron::make_string(el->getFullName(), el->getPath());
+    }
+
+    void DatatypeConverter::visitAronVariant(const type::StringPtr& el)
+    {
+        latest = aron::make_string(el->getFullName(), el->getPath());
+    }
+
+    void DatatypeConverter::visitAronVariant(const type::AnyObjectPtr& el)
+    {
+        latest = aron::make_string(el->getFullName(), el->getPath());
+    }
+}
diff --git a/source/RobotAPI/libraries/aron/converter/common/DatatypeConverter.h b/source/RobotAPI/libraries/aron/converter/common/DatatypeConverter.h
new file mode 100644
index 0000000000000000000000000000000000000000..34201b359d763ac81901135b475fd875714ab05c
--- /dev/null
+++ b/source/RobotAPI/libraries/aron/converter/common/DatatypeConverter.h
@@ -0,0 +1,62 @@
+/*
+ * This file is part of ArmarX.
+ *
+ * ArmarX is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ *
+ * ArmarX is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ *
+ * @author     Fabian Peller ( fabian dot peller at kit dot edu )
+ * @date       2023
+ * @copyright  http://www.gnu.org/licenses/gpl-2.0.txt
+ *             GNU General Public License
+ */
+
+#pragma once
+
+#include <algorithm>
+#include <vector>
+
+#include <RobotAPI/libraries/aron/core/data/variant/All.h>
+#include <RobotAPI/libraries/aron/core/type/visitor/variant/VariantVisitor.h>
+
+namespace armarx::aron::converter
+{
+    class DatatypeConverter :
+        public aron::type::ConstVariantVisitor
+    {
+        const std::string typeMemberName = "_aron_type";
+        const std::string acceptedTypeMemberName = "_aron_accepted_type";
+        const std::string firstAcceptedTypeMemberName = "_aron_first_accepted_type";
+        const std::string secondAcceptedTypeMemberName = "_aron_second_accepted_type";
+
+        void visitAronVariant(const type::ObjectPtr&) override;
+        void visitAronVariant(const type::DictPtr&) override;
+        void visitAronVariant(const type::ListPtr&) override;
+        void visitAronVariant(const type::PairPtr&) override;
+        void visitAronVariant(const type::TuplePtr&) override;
+        void visitAronVariant(const type::MatrixPtr&) override;
+        void visitAronVariant(const type::NDArrayPtr&) override;
+        void visitAronVariant(const type::QuaternionPtr&) override;
+        void visitAronVariant(const type::PointCloudPtr&) override;
+        void visitAronVariant(const type::ImagePtr&) override;
+        void visitAronVariant(const type::IntEnumPtr&) override;
+        void visitAronVariant(const type::IntPtr&) override;
+        void visitAronVariant(const type::LongPtr&) override;
+        void visitAronVariant(const type::FloatPtr&) override;
+        void visitAronVariant(const type::DoublePtr&) override;
+        void visitAronVariant(const type::BoolPtr&) override;
+        void visitAronVariant(const type::StringPtr&) override;
+        void visitAronVariant(const type::AnyObjectPtr&) override;
+
+    public:
+        aron::data::VariantPtr latest;
+    };
+}
diff --git a/source/RobotAPI/libraries/aron/converter/common/VectorConverter.h b/source/RobotAPI/libraries/aron/converter/common/VectorConverter.h
index 096e4830c37276c492d805515e47dd863301f545..14b3ffc96765308ddc49fb684e69fb78b3fa5b5f 100644
--- a/source/RobotAPI/libraries/aron/converter/common/VectorConverter.h
+++ b/source/RobotAPI/libraries/aron/converter/common/VectorConverter.h
@@ -37,37 +37,97 @@ namespace armarx::aron::converter
 {
     class AronVectorConverter
     {
+    private:
+        template<typename T>
+        static std::vector<T> convert_to_1d_vector(const unsigned char* data, const int elements, const int offset, const int size)
+        {
+            ARMARX_CHECK_NOT_NULL(data);
+            ARMARX_CHECK(elements * sizeof(T) == size);
+
+            std::vector<T> v(elements);
+            memcpy(v.data(), data, size);
+
+            return v;
+        }
+
     public:
         AronVectorConverter() = delete;
 
         template<typename T>
-        static std::vector<T> ConvertToVector(const data::NDArrayPtr& nav)
+        static std::vector<std::vector<T>> ConvertTo2DVector(const data::NDArray& nav)
         {
-            ARMARX_CHECK_NOT_NULL(nav);
+            const auto& dims = nav.getShape();
 
-            const auto& dims = nav->getShape();
+            if (dims.size() != 3)
+            {
+                throw error::AronException(__PRETTY_FUNCTION__, "The NDArray must have 3 dimensions.", nav.getPath());
+            }
 
-            if (dims.size() != 2)
+            if (dims.at(dims.size()-1) != sizeof(T))
             {
-                throw error::AronException(__PRETTY_FUNCTION__, "The NDArray must have two dimensions.", nav->getPath());
+                throw error::AronException(__PRETTY_FUNCTION__, "Last dimension of the array has to match the element size.", nav.getPath());
             }
 
-            if (dims.at(1) != sizeof(T))
+            const int one_row_size = dims.at(1) * dims.at(2);
+            std::vector<std::vector<T>> v(dims.at(0));
+            for (int i = 0; i < dims.at(0); i++)
             {
-                throw error::AronException(__PRETTY_FUNCTION__, "Dimension 1 of the array has to match the element size.", nav->getPath());
+                v[i] = convert_to_1d_vector<T>(nav.getData(), dims.at(1), i * one_row_size, one_row_size);
             }
 
-            const int size = std::accumulate(std::begin(dims), std::end(dims), 1, std::multiplies<>());
+            return v;
+        }
+
+        template<typename T>
+        static std::vector<std::vector<T>> ConvertTo2DVector(const data::NDArrayPtr& nav)
+        {
+            ARMARX_CHECK_NOT_NULL(nav);
 
-            std::vector<T> v(dims.at(0));
-            memcpy(v.data(), nav->getData(), size);
+            return ConvertTo2DVector<T>(*nav);
+        }
 
+        template<typename T>
+        static std::vector<T> ConvertTo1DVector(const data::NDArray& nav, const bool allowFlatten = false)
+        {
+            const auto& dims = nav.getShape();
+
+            if (!allowFlatten && dims.size() != 2)
+            {
+                throw error::AronException(__PRETTY_FUNCTION__, "The NDArray must have 2 dimensions.", nav.getPath());
+            }
+
+            if (dims.at(dims.size()-1) != sizeof(T))
+            {
+                throw error::AronException(__PRETTY_FUNCTION__, "Last dimension of the array has to match the element size.", nav.getPath());
+            }
+
+            ARMARX_CHECK(dims.size() >= 1);
+
+            const int elements = std::accumulate(std::begin(dims), std::prev(std::end(dims)), 1, std::multiplies<>());
+            const int all_size = std::accumulate(std::begin(dims), std::end(dims), 1, std::multiplies<>());
+            std::vector<T> v = convert_to_1d_vector<T>(nav.getData(), elements, 0, all_size);
             return v;
         }
 
+        template<typename T>
+        static std::vector<T> ConvertTo1DVector(const data::NDArrayPtr& nav, const bool allowFlatten = false)
+        {
+            ARMARX_CHECK_NOT_NULL(nav);
 
+            return ConvertTo1DVector<T>(*nav, allowFlatten);
+        }
+
+        // alias
         template<typename T>
-        static data::NDArrayPtr ConvertFromVector(const std::vector<T>& data)
+        static std::vector<T> ConvertToVector(const data::NDArrayPtr& nav, const bool allowFlatten = false)
+        {
+            return ConvertTo1DVector<T>(nav, allowFlatten);
+        }
+
+
+        // Attention: If a vector was flattened, the reconstruction is flattened as well!
+        template<typename T>
+        static data::NDArrayPtr ConvertFrom1DVector(const std::vector<T>& data)
         {
             data::NDArrayPtr ndArr(new data::NDArray);
 
@@ -77,6 +137,13 @@ namespace armarx::aron::converter
             return ndArr;
         }
 
+        // alias
+        template<typename T>
+        static data::NDArrayPtr ConvertFromVector(const std::vector<T>& data)
+        {
+            return ConvertFrom1DVector<T>(data);
+        }
+
     };
 
 }  // namespace armarx::aron::converter
diff --git a/source/RobotAPI/libraries/aron/converter/json/NLohmannJSONConverter.cpp b/source/RobotAPI/libraries/aron/converter/json/NLohmannJSONConverter.cpp
index 3729e90a5812a192c256f2deaaa13bbecad71bab..e083d47104d5c4747470d97b162028d7fee5a3a7 100644
--- a/source/RobotAPI/libraries/aron/converter/json/NLohmannJSONConverter.cpp
+++ b/source/RobotAPI/libraries/aron/converter/json/NLohmannJSONConverter.cpp
@@ -28,18 +28,19 @@ namespace armarx::aron::converter
         j = aron::type::readAndWrite<type::FromVariantConverter<type::writer::NlohmannJSONWriter>>(aron);
     }
 
-    data::DictPtr AronNlohmannJSONConverter::ConvertFromNlohmannJSONObject(const nlohmann::json& j)
+    data::DictPtr AronNlohmannJSONConverter::ConvertFromNlohmannJSONObject(const nlohmann::json& j, const armarx::aron::Path& p)
     {
         // TODO Switch case over json type and add other methods, e.g. for float, array, ...
         // TODO add check if json is object_t
-        data::VariantPtr aron = std::make_shared<aron::data::Dict>();
+        data::VariantPtr aron = std::make_shared<aron::data::Dict>(p);
         ConvertFromNlohmannJSON(aron, j);
         return data::Dict::DynamicCastAndCheck(aron);
     }
 
-    type::ObjectPtr AronNlohmannJSONConverter::ConvertFromNlohmannJSONTypeObject(const nlohmann::json& j)
+    type::ObjectPtr AronNlohmannJSONConverter::ConvertFromNlohmannJSONTypeObject(const nlohmann::json& j, const armarx::aron::Path& p)
     {
-        type::VariantPtr aron = std::make_shared<aron::type::Object>("foo"); // foo is just a placeholder
+        type::ObjectPtr foo = std::make_shared<aron::type::Object>("foo"); // foo is just a placeholder
+        type::VariantPtr aron = std::make_shared<aron::type::Object>(*foo, p);
         ConvertFromNlohmannJSON(aron, j);
         return type::Object::DynamicCastAndCheck(aron);
     }
diff --git a/source/RobotAPI/libraries/aron/converter/json/NLohmannJSONConverter.h b/source/RobotAPI/libraries/aron/converter/json/NLohmannJSONConverter.h
index 6cce4d7e363795f6a70184faf4fd60110516590f..0902ed0c3c133fcec75e0cf2502801f8fcce218a 100644
--- a/source/RobotAPI/libraries/aron/converter/json/NLohmannJSONConverter.h
+++ b/source/RobotAPI/libraries/aron/converter/json/NLohmannJSONConverter.h
@@ -38,10 +38,10 @@ namespace armarx::aron::converter
         static nlohmann::json ConvertToNlohmannJSON(const type::VariantPtr&);
         static void ConvertToNlohmannJSON(const type::VariantPtr&, nlohmann::json&);
 
-        static data::DictPtr ConvertFromNlohmannJSONObject(const nlohmann::json&);
+        static data::DictPtr ConvertFromNlohmannJSONObject(const nlohmann::json&, const armarx::aron::Path& p = {});
         static void ConvertFromNlohmannJSON(data::VariantPtr&, const nlohmann::json&, const aron::type::VariantPtr& = nullptr);
 
-        static type::ObjectPtr ConvertFromNlohmannJSONTypeObject(const nlohmann::json& j);
+        static type::ObjectPtr ConvertFromNlohmannJSONTypeObject(const nlohmann::json& j, const armarx::aron::Path& p = {});
         static void ConvertFromNlohmannJSON(aron::type::VariantPtr& a, const nlohmann::json& e);
     };
 }
diff --git a/source/RobotAPI/libraries/aron/converter/opencv/OpenCVConverter.cpp b/source/RobotAPI/libraries/aron/converter/opencv/OpenCVConverter.cpp
index 6208bd9b451862e74c1f137d70e61711b49299b2..d232500c20754beb3d2f212a79b6f16939812ef7 100644
--- a/source/RobotAPI/libraries/aron/converter/opencv/OpenCVConverter.cpp
+++ b/source/RobotAPI/libraries/aron/converter/opencv/OpenCVConverter.cpp
@@ -45,7 +45,7 @@ namespace armarx::aron::converter
         return ret;
     }
 
-    data::NDArrayPtr AronOpenCVConverter::ConvertFromMat(const cv::Mat& mat)
+    data::NDArrayPtr AronOpenCVConverter::ConvertFromMat(const cv::Mat& mat, const armarx::aron::Path& p)
     {
         std::vector<int> dims;
         for (int i = 0; i < mat.dims; ++i)
@@ -54,7 +54,7 @@ namespace armarx::aron::converter
         }
         dims.push_back(mat.elemSize());
 
-        auto ret = std::make_shared<data::NDArray>();
+        auto ret = std::make_shared<data::NDArray>(p);
         ret->setShape(dims);
         ret->setType(std::to_string(mat.type()));
         ret->setData(std::accumulate(std::begin(dims), std::end(dims), 1, std::multiplies<int>()), reinterpret_cast<const unsigned char*>(mat.data));
diff --git a/source/RobotAPI/libraries/aron/converter/opencv/OpenCVConverter.h b/source/RobotAPI/libraries/aron/converter/opencv/OpenCVConverter.h
index 5223ce3da2a5ca471ebb1d8dcc54a70a347e02be..fb4f21487b413272fc6b1b4cbb340cf819a8a5a7 100644
--- a/source/RobotAPI/libraries/aron/converter/opencv/OpenCVConverter.h
+++ b/source/RobotAPI/libraries/aron/converter/opencv/OpenCVConverter.h
@@ -41,7 +41,7 @@ namespace armarx::aron::converter
 
     public:
         static cv::Mat ConvertToMat(const data::NDArrayPtr&);
-        static data::NDArrayPtr ConvertFromMat(const cv::Mat&);
+        static data::NDArrayPtr ConvertFromMat(const cv::Mat&, const armarx::aron::Path& = {});
     };
 
 }
diff --git a/source/RobotAPI/libraries/aron/core/type/variant/container/Dict.cpp b/source/RobotAPI/libraries/aron/core/type/variant/container/Dict.cpp
index 482c762d1426fef9c589a5c49e1ef14689cb6dcd..edaeccf90a02ec918fdbc90733a8209616e0bc1b 100644
--- a/source/RobotAPI/libraries/aron/core/type/variant/container/Dict.cpp
+++ b/source/RobotAPI/libraries/aron/core/type/variant/container/Dict.cpp
@@ -80,6 +80,16 @@ namespace armarx::aron::type
         return "armarx::aron::type::Dict<" + acceptedType->getFullName() + ">";
     }
 
+    std::string Dict::GetFullNamePrefix()
+    {
+        return "armarx::aron::type::Dict";
+    }
+
+    std::string Dict::GetNamePrefix()
+    {
+        return "Dict";
+    }
+
     VariantPtr Dict::navigateAbsolute(const Path& path) const
     {
         if (!path.hasElement())
diff --git a/source/RobotAPI/libraries/aron/core/type/variant/container/Dict.h b/source/RobotAPI/libraries/aron/core/type/variant/container/Dict.h
index 4dfdd35e238b39b729d67c583ec9378fc19f5c0e..7ebbf72eaa7a7582d9b33157279b857c14756540 100644
--- a/source/RobotAPI/libraries/aron/core/type/variant/container/Dict.h
+++ b/source/RobotAPI/libraries/aron/core/type/variant/container/Dict.h
@@ -59,6 +59,9 @@ namespace armarx::aron::type
         std::vector<VariantPtr> getChildren() const override;
         size_t childrenSize() const override;
 
+        static std::string GetFullNamePrefix();
+        static std::string GetNamePrefix();
+
     private:
         // members
         VariantPtr acceptedType;
diff --git a/source/RobotAPI/libraries/aron/core/type/variant/container/List.cpp b/source/RobotAPI/libraries/aron/core/type/variant/container/List.cpp
index 7ee464bc121f8059dcd075dc29752e32be9761d4..958596b7e60f201e565d7082d2e26c7107d7ce05 100644
--- a/source/RobotAPI/libraries/aron/core/type/variant/container/List.cpp
+++ b/source/RobotAPI/libraries/aron/core/type/variant/container/List.cpp
@@ -80,6 +80,16 @@ namespace armarx::aron::type
         return "armarx::aron::type::List<" + acceptedType->getFullName() + ">";
     }
 
+    std::string List::GetFullNamePrefix()
+    {
+        return "armarx::aron::type::List";
+    }
+
+    std::string List::GetNamePrefix()
+    {
+        return "List";
+    }
+
     VariantPtr List::navigateAbsolute(const Path& path) const
     {
         if (!path.hasElement())
diff --git a/source/RobotAPI/libraries/aron/core/type/variant/container/List.h b/source/RobotAPI/libraries/aron/core/type/variant/container/List.h
index 532146e010bf8217c4669649ee2da9771c0623ec..67db861e299cc4031f560fbaa6507b20f1f3fbc5 100644
--- a/source/RobotAPI/libraries/aron/core/type/variant/container/List.h
+++ b/source/RobotAPI/libraries/aron/core/type/variant/container/List.h
@@ -58,6 +58,9 @@ namespace armarx::aron::type
         std::vector<VariantPtr> getChildren() const override;
         size_t childrenSize() const override;
 
+        static std::string GetFullNamePrefix();
+        static std::string GetNamePrefix();
+
     private:
         // members
         VariantPtr acceptedType;
diff --git a/source/RobotAPI/libraries/aron/core/type/variant/container/Object.cpp b/source/RobotAPI/libraries/aron/core/type/variant/container/Object.cpp
index 526cc9f053d5e7bbf1e96c5f38bbe1f49a52cfbe..4ff701603aacaebbfde78dcac172c37f5ba51ae1 100644
--- a/source/RobotAPI/libraries/aron/core/type/variant/container/Object.cpp
+++ b/source/RobotAPI/libraries/aron/core/type/variant/container/Object.cpp
@@ -266,6 +266,16 @@ namespace armarx::aron::type
         return "armarx::aron::type::Object<" + this->aron->objectName + (extends ? (" : " + extends->getFullName()) : "") + ">";
     }
 
+    std::string Object::GetFullNamePrefix()
+    {
+        return "armarx::aron::type::Object";
+    }
+
+    std::string Object::GetNamePrefix()
+    {
+        return "Object";
+    }
+
     VariantPtr Object::navigateAbsolute(const Path& path) const
     {
         if (!path.hasElement())
diff --git a/source/RobotAPI/libraries/aron/core/type/variant/container/Object.h b/source/RobotAPI/libraries/aron/core/type/variant/container/Object.h
index 9924c2cbd5e53a633122fa665b970cbc28bd6043..ccaf50b572c9551538e0fb12f13fbfc2412e8538 100644
--- a/source/RobotAPI/libraries/aron/core/type/variant/container/Object.h
+++ b/source/RobotAPI/libraries/aron/core/type/variant/container/Object.h
@@ -86,6 +86,9 @@ namespace armarx::aron::type
         std::vector<VariantPtr> getChildren() const override;
         size_t childrenSize() const override;
 
+        static std::string GetFullNamePrefix();
+        static std::string GetNamePrefix();
+
     private:
         // members
         std::shared_ptr<Object> extends;
diff --git a/source/RobotAPI/libraries/aron/core/type/variant/container/Pair.cpp b/source/RobotAPI/libraries/aron/core/type/variant/container/Pair.cpp
index 40b3cac3beb89df0323e08ffc681bde47ff29881..c147bd3dd3ab17a66b9e0068e6d3e044c663e67d 100644
--- a/source/RobotAPI/libraries/aron/core/type/variant/container/Pair.cpp
+++ b/source/RobotAPI/libraries/aron/core/type/variant/container/Pair.cpp
@@ -115,6 +115,16 @@ namespace armarx::aron::type
         return "armarx::aron::type::Pair<" + acceptedType1->getFullName() + ", " + acceptedType2->getFullName() + ">";
     }
 
+    std::string Pair::GetFullNamePrefix()
+    {
+        return "armarx::aron::type::Pair";
+    }
+
+    std::string Pair::GetNamePrefix()
+    {
+        return "Pair";
+    }
+
     VariantPtr Pair::navigateAbsolute(const Path& path) const
     {
         if (!path.hasElement())
diff --git a/source/RobotAPI/libraries/aron/core/type/variant/container/Pair.h b/source/RobotAPI/libraries/aron/core/type/variant/container/Pair.h
index a63f6819406ce2b328e97a4026aeae21127d7b09..e8bb11cd6fa82d711d87b39cf50b1dcfbd6f71fd 100644
--- a/source/RobotAPI/libraries/aron/core/type/variant/container/Pair.h
+++ b/source/RobotAPI/libraries/aron/core/type/variant/container/Pair.h
@@ -62,6 +62,9 @@ namespace armarx::aron::type
         std::vector<VariantPtr> getChildren() const override;
         size_t childrenSize() const override;
 
+        static std::string GetFullNamePrefix();
+        static std::string GetNamePrefix();
+
     private:
         // members
         VariantPtr acceptedType1;
diff --git a/source/RobotAPI/libraries/aron/core/type/variant/container/Tuple.cpp b/source/RobotAPI/libraries/aron/core/type/variant/container/Tuple.cpp
index 51d45e3975bb162460fd06893e91f388ac52b9f1..cdcd605f2d475d4e8e83ab1d25a25914cc32e99a 100644
--- a/source/RobotAPI/libraries/aron/core/type/variant/container/Tuple.cpp
+++ b/source/RobotAPI/libraries/aron/core/type/variant/container/Tuple.cpp
@@ -112,6 +112,16 @@ namespace armarx::aron::type
         return "armarx::aron::type::Tuple<" + simox::alg::to_string(names, ", ") + ">";
     }
 
+    std::string Tuple::GetFullNamePrefix()
+    {
+        return "armarx::aron::type::Tuple";
+    }
+
+    std::string Tuple::GetNamePrefix()
+    {
+        return "Tuple";
+    }
+
     VariantPtr Tuple::navigateAbsolute(const Path& path) const
     {
         if (!path.hasElement())
diff --git a/source/RobotAPI/libraries/aron/core/type/variant/container/Tuple.h b/source/RobotAPI/libraries/aron/core/type/variant/container/Tuple.h
index 3281584c15d6b4bb3e50c83ce598634a2bbec324..070bed6264c8a2d9c19751d1b7866794e6e3bfb8 100644
--- a/source/RobotAPI/libraries/aron/core/type/variant/container/Tuple.h
+++ b/source/RobotAPI/libraries/aron/core/type/variant/container/Tuple.h
@@ -60,6 +60,9 @@ namespace armarx::aron::type
         std::vector<VariantPtr> getChildren() const override;
         size_t childrenSize() const override;
 
+        static std::string GetFullNamePrefix();
+        static std::string GetNamePrefix();
+
     private:
         std::vector<VariantPtr> acceptedTypes;
     };
diff --git a/source/RobotAPI/libraries/aron/core/type/variant/forward_declarations.h b/source/RobotAPI/libraries/aron/core/type/variant/forward_declarations.h
index ce0d34761f476da47b41db3afc6af464e7ac3146..a15811e6330d35b4d879202bf45859d5cc0e95ff 100644
--- a/source/RobotAPI/libraries/aron/core/type/variant/forward_declarations.h
+++ b/source/RobotAPI/libraries/aron/core/type/variant/forward_declarations.h
@@ -31,5 +31,7 @@ namespace armarx::aron::type
     using StringPtr = std::shared_ptr<class String>;
     using BoolPtr = std::shared_ptr<class Bool>;
 
+    using AnyObjectPtr = std::shared_ptr<class AnyObject>;
+
 }
 
diff --git a/source/RobotAPI/libraries/aron/core/type/visitor/RecursiveVisitor.h b/source/RobotAPI/libraries/aron/core/type/visitor/RecursiveVisitor.h
index a2f46088a7b0f2261f67fac9931597cd97934f2b..0a132de3166df5d582652f07295fa084ecc05c9b 100644
--- a/source/RobotAPI/libraries/aron/core/type/visitor/RecursiveVisitor.h
+++ b/source/RobotAPI/libraries/aron/core/type/visitor/RecursiveVisitor.h
@@ -151,9 +151,6 @@ namespace armarx::aron::type
         virtual void visitMatrix(Input&) {};
         virtual void visitNDArray(Input&) {};
         virtual void visitQuaternion(Input&) {};
-        virtual void visitOrientation(Input&) {};
-        virtual void visitPosition(Input&) {};
-        virtual void visitPose(Input&) {};
         virtual void visitImage(Input&) {};
         virtual void visitPointCloud(Input&) {};
         virtual void visitIntEnum(Input&) {};
diff --git a/source/RobotAPI/libraries/aron/core/type/visitor/variant/VariantVisitor.cpp b/source/RobotAPI/libraries/aron/core/type/visitor/variant/VariantVisitor.cpp
index d2b1c19a07e2b04fbf1e547d1cc39859793c90cc..72e02863e6ca67aea5be0b20ed9999a091893292 100644
--- a/source/RobotAPI/libraries/aron/core/type/visitor/variant/VariantVisitor.cpp
+++ b/source/RobotAPI/libraries/aron/core/type/visitor/variant/VariantVisitor.cpp
@@ -147,6 +147,12 @@ namespace armarx::aron::type
         visitAronVariant(aron);
     }
 
+    void ConstVariantVisitor::visitAnyObject(Input& i)
+    {
+        auto aron = type::AnyObject::DynamicCastAndCheck(i);
+        visitAronVariant(aron);
+    }
+
     void ConstVariantVisitor::visitAronVariant(const type::ObjectPtr&) {}
     void ConstVariantVisitor::visitAronVariant(const type::DictPtr&) {}
     void ConstVariantVisitor::visitAronVariant(const type::PairPtr&) {}
@@ -164,6 +170,7 @@ namespace armarx::aron::type
     void ConstVariantVisitor::visitAronVariant(const type::DoublePtr&) {}
     void ConstVariantVisitor::visitAronVariant(const type::BoolPtr&) {}
     void ConstVariantVisitor::visitAronVariant(const type::StringPtr&) {}
+    void ConstVariantVisitor::visitAronVariant(const type::AnyObjectPtr&) {}
 
     /****************************************************************************
      * RecursiveVariantVisitor
@@ -227,4 +234,166 @@ namespace armarx::aron::type
     {
         return GetTupleAcceptedTypes(t);
     }
+
+    void RecursiveConstVariantVisitor::visitObjectOnEnter(Input& i)
+    {
+        auto aron = type::Object::DynamicCastAndCheck(i);
+        visitAronVariantEnter(aron);
+    }
+
+    void RecursiveConstVariantVisitor::visitObjectOnExit(Input& i)
+    {
+        auto aron = type::Object::DynamicCastAndCheck(i);
+        visitAronVariantExit(aron);
+    }
+
+    void RecursiveConstVariantVisitor::visitDictOnEnter(Input& i)
+    {
+        auto aron = type::Dict::DynamicCastAndCheck(i);
+        visitAronVariantEnter(aron);
+    }
+
+    void RecursiveConstVariantVisitor::visitDictOnExit(Input& i)
+    {
+        auto aron = type::Dict::DynamicCastAndCheck(i);
+        visitAronVariantExit(aron);
+    }
+
+    void RecursiveConstVariantVisitor::visitPairOnEnter(Input& i)
+    {
+        auto aron = type::Pair::DynamicCastAndCheck(i);
+        visitAronVariantEnter(aron);
+    }
+
+    void RecursiveConstVariantVisitor::visitPairOnExit(Input& i)
+    {
+        auto aron = type::Pair::DynamicCastAndCheck(i);
+        visitAronVariantExit(aron);
+    }
+
+    void RecursiveConstVariantVisitor::visitTupleOnEnter(Input& i)
+    {
+        auto aron = type::Tuple::DynamicCastAndCheck(i);
+        visitAronVariantEnter(aron);
+    }
+
+    void RecursiveConstVariantVisitor::visitTupleOnExit(Input& i)
+    {
+        auto aron = type::Tuple::DynamicCastAndCheck(i);
+        visitAronVariantExit(aron);
+    }
+
+    void RecursiveConstVariantVisitor::visitListOnEnter(Input& i)
+    {
+        auto aron = type::List::DynamicCastAndCheck(i);
+        visitAronVariantEnter(aron);
+    }
+
+    void RecursiveConstVariantVisitor::visitListOnExit(Input& i)
+    {
+        auto aron = type::List::DynamicCastAndCheck(i);
+        visitAronVariantExit(aron);
+    }
+
+    void RecursiveConstVariantVisitor::visitMatrix(Input& i)
+    {
+        auto aron = type::Matrix::DynamicCastAndCheck(i);
+        visitAronVariant(aron);
+    }
+
+    void RecursiveConstVariantVisitor::visitNDArray(Input& i)
+    {
+        auto aron = type::NDArray::DynamicCastAndCheck(i);
+        visitAronVariant(aron);
+    }
+
+    void RecursiveConstVariantVisitor::visitQuaternion(Input & i)
+    {
+        auto aron = type::Quaternion::DynamicCastAndCheck(i);
+        visitAronVariant(aron);
+    }
+
+    void RecursiveConstVariantVisitor::visitImage(Input& i)
+    {
+        auto aron = type::Image::DynamicCastAndCheck(i);
+        visitAronVariant(aron);
+    }
+
+    void RecursiveConstVariantVisitor::visitPointCloud(Input& i)
+    {
+        auto aron = type::PointCloud::DynamicCastAndCheck(i);
+        visitAronVariant(aron);
+    }
+
+    void RecursiveConstVariantVisitor::visitIntEnum(Input& i)
+    {
+        auto aron = type::IntEnum::DynamicCastAndCheck(i);
+        visitAronVariant(aron);
+    }
+
+    void RecursiveConstVariantVisitor::visitInt(Input& i)
+    {
+        auto aron = type::Int::DynamicCastAndCheck(i);
+        visitAronVariant(aron);
+    }
+
+    void RecursiveConstVariantVisitor::visitLong(Input& i)
+    {
+        auto aron = type::Long::DynamicCastAndCheck(i);
+        visitAronVariant(aron);
+    }
+
+    void RecursiveConstVariantVisitor::visitFloat(Input& i)
+    {
+        auto aron = type::Float::DynamicCastAndCheck(i);
+        visitAronVariant(aron);
+    }
+
+    void RecursiveConstVariantVisitor::visitDouble(Input& i)
+    {
+        auto aron = type::Double::DynamicCastAndCheck(i);
+        visitAronVariant(aron);
+    }
+
+    void RecursiveConstVariantVisitor::visitBool(Input& i)
+    {
+        auto aron = type::Bool::DynamicCastAndCheck(i);
+        visitAronVariant(aron);
+    }
+
+    void RecursiveConstVariantVisitor::visitString(Input& i)
+    {
+        auto aron = type::String::DynamicCastAndCheck(i);
+        visitAronVariant(aron);
+    }
+
+    void RecursiveConstVariantVisitor::visitAnyObject(Input& i)
+    {
+        auto aron = type::AnyObject::DynamicCastAndCheck(i);
+        visitAronVariant(aron);
+    }
+
+    void RecursiveConstVariantVisitor::visitAronVariantEnter(const type::ObjectPtr&) {}
+    void RecursiveConstVariantVisitor::visitAronVariantExit(const type::ObjectPtr&) {}
+    void RecursiveConstVariantVisitor::visitAronVariantEnter(const type::DictPtr&) {}
+    void RecursiveConstVariantVisitor::visitAronVariantExit(const type::DictPtr&) {}
+    void RecursiveConstVariantVisitor::visitAronVariantEnter(const type::PairPtr&) {}
+    void RecursiveConstVariantVisitor::visitAronVariantExit(const type::PairPtr&) {}
+    void RecursiveConstVariantVisitor::visitAronVariantEnter(const type::TuplePtr&) {}
+    void RecursiveConstVariantVisitor::visitAronVariantExit(const type::TuplePtr&) {}
+    void RecursiveConstVariantVisitor::visitAronVariantEnter(const type::ListPtr&) {}
+    void RecursiveConstVariantVisitor::visitAronVariantExit(const type::ListPtr&) {}
+    void RecursiveConstVariantVisitor::visitAronVariant(const type::NDArrayPtr&) {}
+    void RecursiveConstVariantVisitor::visitAronVariant(const type::MatrixPtr&) {}
+    void RecursiveConstVariantVisitor::visitAronVariant(const type::QuaternionPtr&) {}
+    void RecursiveConstVariantVisitor::visitAronVariant(const type::ImagePtr&) {}
+    void RecursiveConstVariantVisitor::visitAronVariant(const type::PointCloudPtr&) {}
+    void RecursiveConstVariantVisitor::visitAronVariant(const type::IntEnumPtr&) {}
+    void RecursiveConstVariantVisitor::visitAronVariant(const type::IntPtr&) {}
+    void RecursiveConstVariantVisitor::visitAronVariant(const type::LongPtr&) {}
+    void RecursiveConstVariantVisitor::visitAronVariant(const type::FloatPtr&) {}
+    void RecursiveConstVariantVisitor::visitAronVariant(const type::DoublePtr&) {}
+    void RecursiveConstVariantVisitor::visitAronVariant(const type::BoolPtr&) {}
+    void RecursiveConstVariantVisitor::visitAronVariant(const type::StringPtr&) {}
+    void RecursiveConstVariantVisitor::visitAronVariant(const type::AnyObjectPtr&) {}
 }
diff --git a/source/RobotAPI/libraries/aron/core/type/visitor/variant/VariantVisitor.h b/source/RobotAPI/libraries/aron/core/type/visitor/variant/VariantVisitor.h
index e7e87fa45974a37ded813f3bfc156417238e5a02..fccfae04aff6b10bca173d3b096001af51dd6782 100644
--- a/source/RobotAPI/libraries/aron/core/type/visitor/variant/VariantVisitor.h
+++ b/source/RobotAPI/libraries/aron/core/type/visitor/variant/VariantVisitor.h
@@ -60,6 +60,7 @@ namespace armarx::aron::type
         void visitDouble(Input&) override;
         void visitBool(Input&) override;
         void visitString(Input&) override;
+        void visitAnyObject(Input&) override;
 
         // Use these if you do not want to cast manually
         virtual void visitAronVariant(const type::ObjectPtr&);
@@ -79,6 +80,7 @@ namespace armarx::aron::type
         virtual void visitAronVariant(const type::DoublePtr&);
         virtual void visitAronVariant(const type::BoolPtr&);
         virtual void visitAronVariant(const type::StringPtr&);
+        virtual void visitAronVariant(const type::AnyObjectPtr&);
     };
 
     /**
@@ -98,6 +100,57 @@ namespace armarx::aron::type
         static TupleElements GetTupleAcceptedTypes(Input& t);
         TupleElements getTupleAcceptedTypes(Input& t) override;
 
+        void visitObjectOnEnter(Input&) override;
+        void visitObjectOnExit(Input&) override;
+        void visitDictOnEnter(Input&) override;
+        void visitDictOnExit(Input&) override;
+        void visitPairOnEnter(Input&) override;
+        void visitPairOnExit(Input&) override;
+        void visitTupleOnEnter(Input&) override;
+        void visitTupleOnExit(Input&) override;
+        void visitListOnEnter(Input&) override;
+        void visitListOnExit(Input&) override;
+
+        void visitMatrix(Input&) override;
+        void visitNDArray(Input&) override;
+        void visitQuaternion(Input&) override;
+        void visitImage(Input&) override;
+        void visitPointCloud(Input&) override;
+        void visitIntEnum(Input&) override;
+        void visitInt(Input&) override;
+        void visitLong(Input&) override;
+        void visitFloat(Input&) override;
+        void visitDouble(Input&) override;
+        void visitBool(Input&) override;
+        void visitString(Input&) override;
+        void visitAnyObject(Input&) override;
+
+
+        // Use these if you do not want to cast manually
+        virtual void visitAronVariantEnter(const type::ObjectPtr&);
+        virtual void visitAronVariantExit(const type::ObjectPtr&);
+        virtual void visitAronVariantEnter(const type::DictPtr&);
+        virtual void visitAronVariantExit(const type::DictPtr&);
+        virtual void visitAronVariantEnter(const type::ListPtr&);
+        virtual void visitAronVariantExit(const type::ListPtr&);
+        virtual void visitAronVariantEnter(const type::PairPtr&);
+        virtual void visitAronVariantExit(const type::PairPtr&);
+        virtual void visitAronVariantEnter(const type::TuplePtr&);
+        virtual void visitAronVariantExit(const type::TuplePtr&);
+        virtual void visitAronVariant(const type::MatrixPtr&);
+        virtual void visitAronVariant(const type::NDArrayPtr&);
+        virtual void visitAronVariant(const type::QuaternionPtr&);
+        virtual void visitAronVariant(const type::PointCloudPtr&);
+        virtual void visitAronVariant(const type::ImagePtr&);
+        virtual void visitAronVariant(const type::IntEnumPtr&);
+        virtual void visitAronVariant(const type::IntPtr&);
+        virtual void visitAronVariant(const type::LongPtr&);
+        virtual void visitAronVariant(const type::FloatPtr&);
+        virtual void visitAronVariant(const type::DoublePtr&);
+        virtual void visitAronVariant(const type::BoolPtr&);
+        virtual void visitAronVariant(const type::StringPtr&);
+        virtual void visitAronVariant(const type::AnyObjectPtr&);
+
         virtual ~RecursiveConstVariantVisitor() = default;
     };
 }