diff --git a/components/nvs_flash/.build-test-rules.yml b/components/nvs_flash/.build-test-rules.yml
new file mode 100644
index 0000000000..93b76378a9
--- /dev/null
+++ b/components/nvs_flash/.build-test-rules.yml
@@ -0,0 +1,3 @@
+components/nvs_flash/host_test:
+  enable:
+    - if: IDF_TARGET == "linux"
diff --git a/components/nvs_flash/Kconfig b/components/nvs_flash/Kconfig
index c246d48f83..0acfcdeed1 100644
--- a/components/nvs_flash/Kconfig
+++ b/components/nvs_flash/Kconfig
@@ -25,4 +25,13 @@ menu "NVS"
         default n
         help
             This option switches error checking type between assertions (y) or return codes (n).
+
+    config NVS_LEGACY_DUP_KEYS_COMPATIBILITY
+        bool "Enable legacy nvs_set function behavior when same key is reused with different data types"
+        default n
+        help
+            Enabling this will switch the nvs_set family of functions to the legacy mode. When called with same
+            key and different data type, existing value stored in NVS remains active and as a side effect, the
+            new value is also stored into NVS, although not accessible using respective nvs_get function. Use only
+            if your application relies on this NVS API behaviour.
 endmenu
diff --git a/components/nvs_flash/host_test/nvs_host_test/sdkconfig.ci.default_set_key b/components/nvs_flash/host_test/nvs_host_test/sdkconfig.ci.default_set_key
new file mode 100644
index 0000000000..4ebf01d0f9
--- /dev/null
+++ b/components/nvs_flash/host_test/nvs_host_test/sdkconfig.ci.default_set_key
@@ -0,0 +1 @@
+# CONFIG_NVS_LEGACY_DUP_KEYS_COMPATIBILITY=n
diff --git a/components/nvs_flash/host_test/nvs_host_test/sdkconfig.ci.legacy_set_key b/components/nvs_flash/host_test/nvs_host_test/sdkconfig.ci.legacy_set_key
new file mode 100644
index 0000000000..226772f237
--- /dev/null
+++ b/components/nvs_flash/host_test/nvs_host_test/sdkconfig.ci.legacy_set_key
@@ -0,0 +1 @@
+CONFIG_NVS_LEGACY_DUP_KEYS_COMPATIBILITY=y
diff --git a/components/nvs_flash/include/nvs.h b/components/nvs_flash/include/nvs.h
index b57d982776..9f4f1b68f0 100644
--- a/components/nvs_flash/include/nvs.h
+++ b/components/nvs_flash/include/nvs.h
@@ -1,5 +1,5 @@
 /*
- * SPDX-FileCopyrightText: 2015-2022 Espressif Systems (Shanghai) CO LTD
+ * SPDX-FileCopyrightText: 2015-2025 Espressif Systems (Shanghai) CO LTD
  *
  * SPDX-License-Identifier: Apache-2.0
  */
@@ -464,6 +464,25 @@ esp_err_t nvs_get_str (nvs_handle_t handle, const char* key, char* out_value, si
 esp_err_t nvs_get_blob(nvs_handle_t handle, const char* key, void* out_value, size_t* length);
 /**@}*/
 
+/**
+ * @brief      Lookup key-value pair with given key name.
+ *
+ * Note that function may indicate both existence of the key as well as the data type of NVS entry if it is found.
+ *
+ * @param[in]  handle    Storage handle obtained with nvs_open.
+ * @param[in]  key       Key name. Maximum length is (NVS_KEY_NAME_MAX_SIZE-1) characters. Shouldn't be empty.
+ * @param[out] out_type  Pointer to the output variable populated with data type of NVS entry in case key was found.
+ *                       May be NULL, respective data type is then not provided.
+ * @return
+ *              - ESP_OK if NVS entry for key provided was found
+ *              - ESP_ERR_NVS_NOT_FOUND if the requested key doesn't exist
+ *              - ESP_ERR_NVS_INVALID_HANDLE if handle has been closed or is NULL
+ *              - ESP_FAIL if there is an internal error; most likely due to corrupted
+ *                NVS partition (only if NVS assertion checks are disabled)
+ *              - other error codes from the underlying storage driver
+ */
+esp_err_t nvs_find_key(nvs_handle_t handle, const char* key, nvs_type_t* out_type);
+
 /**
  * @brief      Erase key-value pair with given key name.
  *
diff --git a/components/nvs_flash/include/nvs_handle.hpp b/components/nvs_flash/include/nvs_handle.hpp
index b09d013d22..d4ba6d3481 100644
--- a/components/nvs_flash/include/nvs_handle.hpp
+++ b/components/nvs_flash/include/nvs_handle.hpp
@@ -164,6 +164,21 @@ public:
      */
     virtual esp_err_t get_item_size(ItemType datatype, const char *key, size_t &size) = 0;
 
+    /**
+     * @brief Checks whether key exists and optionally returns also data type of associated entry.
+     *
+     * @param[in]     key        Key name. Maximum length is (NVS_KEY_NAME_MAX_SIZE-1) characters. Shouldn't be empty.
+     * @param[out]    nvstype    Nvs data type to of entry, if it exists.
+     *
+     * @return      - ESP_OK if NVS entry for key provided was found. Data type will be returned via \c nvstype.
+     *              - ESP_ERR_NVS_NOT_FOUND if the requested key doesn't exist.
+     *              - ESP_ERR_NVS_INVALID_HANDLE if handle has been closed or is NULL.
+     *              - ESP_FAIL if there is an internal error; most likely due to corrupted
+     *                NVS partition (only if NVS assertion checks are disabled).
+     *              - other error codes from the underlying storage driver.
+     */
+    virtual esp_err_t find_key(const char* key, nvs_type_t &nvstype) = 0;
+
     /**
      * @brief Erases an entry.
      */
diff --git a/components/nvs_flash/src/nvs_api.cpp b/components/nvs_flash/src/nvs_api.cpp
index cf8226bec3..5b4f15532b 100644
--- a/components/nvs_flash/src/nvs_api.cpp
+++ b/components/nvs_flash/src/nvs_api.cpp
@@ -1,5 +1,5 @@
 /*
- * SPDX-FileCopyrightText: 2015-2024 Espressif Systems (Shanghai) CO LTD
+ * SPDX-FileCopyrightText: 2015-2025 Espressif Systems (Shanghai) CO LTD
  *
  * SPDX-License-Identifier: Apache-2.0
  */
@@ -310,6 +310,25 @@ extern "C" void nvs_close(nvs_handle_t handle)
     delete static_cast<NVSHandleEntry*>(it);
 }
 
+extern "C" esp_err_t nvs_find_key(nvs_handle_t c_handle, const char* key, nvs_type_t* out_type)
+{
+    Lock lock;
+    ESP_LOGD(TAG, "%s %s", __func__, key);
+    NVSHandleSimple *handle;
+    auto err = nvs_find_ns_handle(c_handle, &handle);
+    if (err != ESP_OK) {
+        return err;
+    }
+
+    nvs_type_t nvstype;
+    err = handle->find_key(key, nvstype);
+
+    if(err == ESP_OK && out_type != nullptr)
+        *out_type = nvstype;
+
+    return err;
+}
+
 extern "C" esp_err_t nvs_erase_key(nvs_handle_t c_handle, const char* key)
 {
     Lock lock;
diff --git a/components/nvs_flash/src/nvs_handle_locked.cpp b/components/nvs_flash/src/nvs_handle_locked.cpp
index 3921887448..ede347d899 100644
--- a/components/nvs_flash/src/nvs_handle_locked.cpp
+++ b/components/nvs_flash/src/nvs_handle_locked.cpp
@@ -1,16 +1,8 @@
-// Copyright 2015-2016 Espressif Systems (Shanghai) PTE LTD
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-
-//     http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
+/*
+ * SPDX-FileCopyrightText: 2015-2025 Espressif Systems (Shanghai) CO LTD
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ */
 #include "nvs_handle_locked.hpp"
 
 namespace nvs {
@@ -47,6 +39,12 @@ esp_err_t NVSHandleLocked::get_item_size(ItemType datatype, const char *key, siz
     return handle->get_item_size(datatype, key, size);
 }
 
+esp_err_t NVSHandleLocked::find_key(const char* key, nvs_type_t &nvstype)
+{
+    Lock lock;
+    return handle->find_key(key, nvstype);
+}
+
 esp_err_t NVSHandleLocked::erase_item(const char* key) {
     Lock lock;
     return handle->erase_item(key);
diff --git a/components/nvs_flash/src/nvs_handle_locked.hpp b/components/nvs_flash/src/nvs_handle_locked.hpp
index b9b0cb5620..368162485e 100644
--- a/components/nvs_flash/src/nvs_handle_locked.hpp
+++ b/components/nvs_flash/src/nvs_handle_locked.hpp
@@ -1,16 +1,8 @@
-// Copyright 2015-2016 Espressif Systems (Shanghai) PTE LTD
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-
-//     http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
+/*
+ * SPDX-FileCopyrightText: 2015-2025 Espressif Systems (Shanghai) CO LTD
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ */
 #ifndef NVS_HANDLE_LOCKED_HPP_
 #define NVS_HANDLE_LOCKED_HPP_
 
@@ -49,6 +41,8 @@ public:
 
     esp_err_t get_item_size(ItemType datatype, const char *key, size_t &size) override;
 
+    esp_err_t find_key(const char* key, nvs_type_t &nvstype) override;
+
     esp_err_t erase_item(const char* key) override;
 
     esp_err_t erase_all() override;
diff --git a/components/nvs_flash/src/nvs_handle_simple.cpp b/components/nvs_flash/src/nvs_handle_simple.cpp
index 348e197b7c..faaea7fedf 100644
--- a/components/nvs_flash/src/nvs_handle_simple.cpp
+++ b/components/nvs_flash/src/nvs_handle_simple.cpp
@@ -1,16 +1,8 @@
-// Copyright 2015-2016 Espressif Systems (Shanghai) PTE LTD
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-
-//     http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
+/*
+ * SPDX-FileCopyrightText: 2015-2025 Espressif Systems (Shanghai) CO LTD
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ */
 #include <cstdlib>
 #include "nvs_handle.hpp"
 #include "nvs_partition_manager.hpp"
@@ -73,6 +65,23 @@ esp_err_t NVSHandleSimple::get_item_size(ItemType datatype, const char *key, siz
     return mStoragePtr->getItemDataSize(mNsIndex, datatype, key, size);
 }
 
+esp_err_t NVSHandleSimple::find_key(const char* key, nvs_type_t &nvstype)
+{
+    if (!valid) return ESP_ERR_NVS_INVALID_HANDLE;
+
+    nvs::ItemType datatype;
+    esp_err_t err = mStoragePtr->findKey(mNsIndex, key, &datatype);
+    if(err != ESP_OK)
+        return err;
+
+    if(datatype == ItemType::BLOB_IDX || datatype == ItemType::BLOB)
+        datatype = ItemType::BLOB_DATA;
+
+    nvstype = (nvs_type_t) datatype;
+
+    return err;
+}
+
 esp_err_t NVSHandleSimple::erase_item(const char* key)
 {
     if (!valid) return ESP_ERR_NVS_INVALID_HANDLE;
diff --git a/components/nvs_flash/src/nvs_handle_simple.hpp b/components/nvs_flash/src/nvs_handle_simple.hpp
index ff0e93a3d6..7ddcc0a390 100644
--- a/components/nvs_flash/src/nvs_handle_simple.hpp
+++ b/components/nvs_flash/src/nvs_handle_simple.hpp
@@ -51,6 +51,8 @@ public:
 
     esp_err_t get_item_size(ItemType datatype, const char *key, size_t &size) override;
 
+    esp_err_t find_key(const char *key, nvs_type_t &nvstype) override;
+
     esp_err_t erase_item(const char *key) override;
 
     esp_err_t erase_all() override;
diff --git a/components/nvs_flash/src/nvs_storage.cpp b/components/nvs_flash/src/nvs_storage.cpp
index 4fd501094c..a4974563c1 100644
--- a/components/nvs_flash/src/nvs_storage.cpp
+++ b/components/nvs_flash/src/nvs_storage.cpp
@@ -38,7 +38,7 @@ void Storage::clearNamespaces()
 
 esp_err_t Storage::populateBlobIndices(TBlobIndexList& blobIdxList)
 {
-    for (auto it = mPageManager.begin(); it != mPageManager.end(); ++it) {
+    for(auto it = mPageManager.begin(); it != mPageManager.end(); ++it) {
         Page& p = *it;
         size_t itemIndex = 0;
         Item item;
@@ -47,10 +47,10 @@ esp_err_t Storage::populateBlobIndices(TBlobIndexList& blobIdxList)
          * logic in pagemanager will remove the earlier index. So we should never find a
          * duplicate index at this point */
 
-        while (p.findItem(Page::NS_ANY, ItemType::BLOB_IDX, nullptr, itemIndex, item) == ESP_OK) {
+        while(p.findItem(Page::NS_ANY, ItemType::BLOB_IDX, nullptr, itemIndex, item) == ESP_OK) {
             BlobIndexNode* entry = new (std::nothrow) BlobIndexNode;
 
-            if (!entry) return ESP_ERR_NO_MEM;
+            if(!entry) return ESP_ERR_NO_MEM;
 
             item.getKey(entry->key, sizeof(entry->key));
             entry->nsIndex = item.nsIndex;
@@ -76,7 +76,7 @@ esp_err_t Storage::populateBlobIndices(TBlobIndexList& blobIdxList)
 // later by the call to eraseOrphanDataBlobs().
 void Storage::eraseMismatchedBlobIndexes(TBlobIndexList& blobIdxList)
 {
-    for (auto it = mPageManager.begin(); it != mPageManager.end(); ++it) {
+    for(auto it = mPageManager.begin(); it != mPageManager.end(); ++it) {
         Page& p = *it;
         size_t itemIndex = 0;
         Item item;
@@ -85,7 +85,7 @@ void Storage::eraseMismatchedBlobIndexes(TBlobIndexList& blobIdxList)
          * 1) VER_0_OFFSET <= chunkIndex < VER_1_OFFSET-1 => Version0 chunks
          * 2) VER_1_OFFSET <= chunkIndex < VER_ANY => Version1 chunks
          */
-        while (p.findItem(Page::NS_ANY, ItemType::BLOB_DATA, nullptr, itemIndex, item) == ESP_OK) {
+        while(p.findItem(Page::NS_ANY, ItemType::BLOB_DATA, nullptr, itemIndex, item) == ESP_OK) {
 
             auto iter = std::find_if(blobIdxList.begin(),
                     blobIdxList.end(),
@@ -94,7 +94,7 @@ void Storage::eraseMismatchedBlobIndexes(TBlobIndexList& blobIdxList)
                             && (item.nsIndex == e.nsIndex)
                             && (item.chunkIndex >=  static_cast<uint8_t> (e.chunkStart))
                             && (item.chunkIndex < static_cast<uint8_t> ((e.chunkStart == nvs::VerOffset::VER_0_OFFSET) ? nvs::VerOffset::VER_1_OFFSET : nvs::VerOffset::VER_ANY));});
-            if (iter != std::end(blobIdxList)) {
+            if(iter != std::end(blobIdxList)) {
                 // accumulate the size
                 iter->observedDataSize += item.varLength.dataSize;
                 iter->observedChunkCount++;
@@ -104,15 +104,15 @@ void Storage::eraseMismatchedBlobIndexes(TBlobIndexList& blobIdxList)
     }
 
     auto iter = blobIdxList.begin();
-    while (iter != blobIdxList.end())
+    while(iter != blobIdxList.end())
     {
-        if ( (iter->observedDataSize != iter->dataSize) || (iter->observedChunkCount != iter->chunkCount) )
+        if( (iter->observedDataSize != iter->dataSize) || (iter->observedChunkCount != iter->chunkCount) )
         {
             // Delete blob_index from flash
             // This is very rare case, so we can loop over all pages
-            for (auto it = mPageManager.begin(); it != mPageManager.end(); ++it) {
+            for(auto it = mPageManager.begin(); it != mPageManager.end(); ++it) {
                 // skip pages in non eligible states
-                if (it->state() == nvs::Page::PageState::CORRUPT
+                if(it->state() == nvs::Page::PageState::CORRUPT
                     || it->state() == nvs::Page::PageState::INVALID
                     || it->state() == nvs::Page::PageState::UNINITIALIZED){
                     continue;
@@ -140,7 +140,7 @@ void Storage::eraseMismatchedBlobIndexes(TBlobIndexList& blobIdxList)
 
 void Storage::eraseOrphanDataBlobs(TBlobIndexList& blobIdxList)
 {
-    for (auto it = mPageManager.begin(); it != mPageManager.end(); ++it) {
+    for(auto it = mPageManager.begin(); it != mPageManager.end(); ++it) {
         Page& p = *it;
         size_t itemIndex = 0;
         Item item;
@@ -149,7 +149,7 @@ void Storage::eraseOrphanDataBlobs(TBlobIndexList& blobIdxList)
          * 1) VER_0_OFFSET <= chunkIndex < VER_1_OFFSET-1 => Version0 chunks
          * 2) VER_1_OFFSET <= chunkIndex < VER_ANY => Version1 chunks
          */
-        while (p.findItem(Page::NS_ANY, ItemType::BLOB_DATA, nullptr, itemIndex, item) == ESP_OK) {
+        while(p.findItem(Page::NS_ANY, ItemType::BLOB_DATA, nullptr, itemIndex, item) == ESP_OK) {
 
             auto iter = std::find_if(blobIdxList.begin(),
                     blobIdxList.end(),
@@ -158,7 +158,7 @@ void Storage::eraseOrphanDataBlobs(TBlobIndexList& blobIdxList)
                             && (item.nsIndex == e.nsIndex)
                             && (item.chunkIndex >=  static_cast<uint8_t> (e.chunkStart))
                             && (item.chunkIndex < static_cast<uint8_t> (e.chunkStart) + e.chunkCount);});
-            if (iter == std::end(blobIdxList)) {
+            if(iter == std::end(blobIdxList)) {
                 p.eraseItem(item.nsIndex, item.datatype, item.key, item.chunkIndex);
             }
 
@@ -170,7 +170,7 @@ void Storage::eraseOrphanDataBlobs(TBlobIndexList& blobIdxList)
 esp_err_t Storage::init(uint32_t baseSector, uint32_t sectorCount)
 {
     auto err = mPageManager.load(mPartition, baseSector, sectorCount);
-    if (err != ESP_OK) {
+    if(err != ESP_OK) {
         mState = StorageState::INVALID;
         return err;
     }
@@ -178,25 +178,25 @@ esp_err_t Storage::init(uint32_t baseSector, uint32_t sectorCount)
     // load namespaces list
     clearNamespaces();
     std::fill_n(mNamespaceUsage.data(), mNamespaceUsage.byteSize() / 4, 0);
-    for (auto it = mPageManager.begin(); it != mPageManager.end(); ++it) {
+    for(auto it = mPageManager.begin(); it != mPageManager.end(); ++it) {
         Page& p = *it;
         size_t itemIndex = 0;
         Item item;
-        while (p.findItem(Page::NS_INDEX, ItemType::U8, nullptr, itemIndex, item) == ESP_OK) {
+        while(p.findItem(Page::NS_INDEX, ItemType::U8, nullptr, itemIndex, item) == ESP_OK) {
             NamespaceEntry* entry = new (std::nothrow) NamespaceEntry;
 
-            if (!entry) {
+            if(!entry) {
                 mState = StorageState::INVALID;
                 return ESP_ERR_NO_MEM;
             }
 
             item.getKey(entry->mName, sizeof(entry->mName));
             err = item.getValue(entry->mIndex);
-            if (err != ESP_OK) {
+            if(err != ESP_OK) {
                 delete entry;
                 return err;
             }
-            if (mNamespaceUsage.set(entry->mIndex, true) != ESP_OK) {
+            if(mNamespaceUsage.set(entry->mIndex, true) != ESP_OK) {
                 delete entry;
                 return ESP_FAIL;
             }
@@ -204,17 +204,17 @@ esp_err_t Storage::init(uint32_t baseSector, uint32_t sectorCount)
             itemIndex += item.span;
         }
     }
-    if (mNamespaceUsage.set(0, true) != ESP_OK) {
+    if(mNamespaceUsage.set(0, true) != ESP_OK) {
         return ESP_FAIL;
     }
-    if (mNamespaceUsage.set(255, true) != ESP_OK) {
+    if(mNamespaceUsage.set(255, true) != ESP_OK) {
         return ESP_FAIL;
     }
 
     // Populate list of multi-page index entries.
     TBlobIndexList blobIdxList;
     err = populateBlobIndices(blobIdxList);
-    if (err != ESP_OK) {
+    if(err != ESP_OK) {
         mState = StorageState::INVALID;
         return ESP_ERR_NO_MEM;
     }
@@ -243,10 +243,10 @@ bool Storage::isValid() const
 
 esp_err_t Storage::findItem(uint8_t nsIndex, ItemType datatype, const char* key, Page* &page, Item& item, uint8_t chunkIdx, VerOffset chunkStart)
 {
-    for (auto it = std::begin(mPageManager); it != std::end(mPageManager); ++it) {
+    for(auto it = std::begin(mPageManager); it != std::end(mPageManager); ++it) {
         size_t itemIndex = 0;
         auto err = it->findItem(nsIndex, datatype, key, itemIndex, item, chunkIdx, chunkStart);
-        if (err == ESP_OK) {
+        if(err == ESP_OK) {
             page = it;
             return ESP_OK;
         }
@@ -269,7 +269,7 @@ esp_err_t Storage::writeMultiPageBlob(uint8_t nsIndex, const char* key, const vo
        max_pages = (Page::CHUNK_ANY-1)/2;
     }
 
-    if (dataSize > max_pages * Page::CHUNK_MAX_SIZE) {
+    if(dataSize > max_pages * Page::CHUNK_MAX_SIZE) {
         return ESP_ERR_NVS_VALUE_TOO_LONG;
     }
 
@@ -277,16 +277,16 @@ esp_err_t Storage::writeMultiPageBlob(uint8_t nsIndex, const char* key, const vo
         Page& page = getCurrentPage();
         size_t tailroom = page.getVarDataTailroom();
         size_t chunkSize = 0;
-        if (chunkCount == 0U && ((tailroom < dataSize) || (tailroom == 0 && dataSize == 0)) && tailroom < Page::CHUNK_MAX_SIZE/10) {
+        if(chunkCount == 0U && ((tailroom < dataSize) || (tailroom == 0 && dataSize == 0)) && tailroom < Page::CHUNK_MAX_SIZE/10) {
             /** This is the first chunk and tailroom is too small ***/
-            if (page.state() != Page::PageState::FULL) {
+            if(page.state() != Page::PageState::FULL) {
                 err = page.markFull();
-                if (err != ESP_OK) {
+                if(err != ESP_OK) {
                     return err;
                 }
             }
             err = mPageManager.requestNewPage();
-            if (err != ESP_OK) {
+            if(err != ESP_OK) {
                 return err;
             } else if(getCurrentPage().getVarDataTailroom() == tailroom) {
                 /* We got the same page or we are not improving.*/
@@ -294,7 +294,7 @@ esp_err_t Storage::writeMultiPageBlob(uint8_t nsIndex, const char* key, const vo
             } else {
                 continue;
             }
-        } else if (!tailroom) {
+        } else if(!tailroom) {
             err = ESP_ERR_NVS_NOT_ENOUGH_SPACE;
             break;
         }
@@ -309,32 +309,32 @@ esp_err_t Storage::writeMultiPageBlob(uint8_t nsIndex, const char* key, const vo
                 static_cast<const uint8_t*> (data) + offset, chunkSize, static_cast<uint8_t> (chunkStart) + chunkCount);
         chunkCount++;
 
-        if (err != ESP_OK) {
+        if(err != ESP_OK) {
             NVS_ASSERT_OR_RETURN(err != ESP_ERR_NVS_PAGE_FULL, err);
             break;
         } else {
             UsedPageNode* node = new (std::nothrow) UsedPageNode();
-            if (!node) {
+            if(!node) {
                 err = ESP_ERR_NO_MEM;
                 break;
             }
             node->mPage = &page;
             usedPages.push_back(node);
-            if (remainingSize || (tailroom - chunkSize) < Page::ENTRY_SIZE) {
-                if (page.state() != Page::PageState::FULL) {
+            if(remainingSize || (tailroom - chunkSize) < Page::ENTRY_SIZE) {
+                if(page.state() != Page::PageState::FULL) {
                     err = page.markFull();
-                    if (err != ESP_OK) {
+                    if(err != ESP_OK) {
                         break;
                     }
                 }
                 err = mPageManager.requestNewPage();
-                if (err != ESP_OK) {
+                if(err != ESP_OK) {
                     break;
                 }
             }
         }
         offset += chunkSize;
-        if (!remainingSize) {
+        if(!remainingSize) {
             /* All pages are stored. Now store the index.*/
             Item item;
             std::fill_n(item.data, sizeof(item.data), 0xff);
@@ -346,12 +346,12 @@ esp_err_t Storage::writeMultiPageBlob(uint8_t nsIndex, const char* key, const vo
             NVS_ASSERT_OR_RETURN(err != ESP_ERR_NVS_PAGE_FULL, err);
             break;
         }
-    } while (1);
+    } while(1);
 
-    if (err != ESP_OK) {
+    if(err != ESP_OK) {
         /* Anything failed, then we should erase all the written chunks*/
         int ii=0;
-        for (auto it = std::begin(usedPages); it != std::end(usedPages); it++) {
+        for(auto it = std::begin(usedPages); it != std::end(usedPages); it++) {
             it->mPage->eraseItem(nsIndex, ItemType::BLOB_DATA, key, ii++);
         }
     }
@@ -359,178 +359,264 @@ esp_err_t Storage::writeMultiPageBlob(uint8_t nsIndex, const char* key, const vo
     return err;
 }
 
+// datatype BLOB is written as BLOB_INDEX and BLOB_DATA and is searched for previous value as BLOB_INDEX and/or BLOB
+// datatype BLOB_IDX and BLOB_DATA are not supported as input parameters, the layer above should always use BLOB
 esp_err_t Storage::writeItem(uint8_t nsIndex, ItemType datatype, const char* key, const void* data, size_t dataSize)
 {
-    if (mState != StorageState::ACTIVE) {
+    if(mState != StorageState::ACTIVE) {
         return ESP_ERR_NVS_NOT_INITIALIZED;
     }
 
+    // pointer to the page where the existing item was found
     Page* findPage = nullptr;
+    // page sequence number helping to detect whether the page with old value was relocated during the new write
+    uint32_t findPageSeqNumber = UINT32_MAX;
+
+    // indicates the datatype representation match between the old value and the new one
+    bool matchedTypePageFound = false;
+
+    // contains the item with the old value, if found
     Item item;
 
-    esp_err_t err;
-    if (datatype == ItemType::BLOB) {
+    esp_err_t err = ESP_OK;
+
+    // Try to find existing item with the same key and namespace index
+    // We are performing the findItem with datatype specified (it is not ANY) to ensure the hash list lookup is done.
+    if(datatype == ItemType::BLOB) {
+        // Specific lookup if performed for input datatype BLOB. The searched datatype for exact match is BLOB_INDEX.
+        // The BLOB_INDEX is used to store the metadata of the (originally typed) BLOB data in current V2 implementation.
         err = findItem(nsIndex, ItemType::BLOB_IDX, key, findPage, item);
+        if(err == ESP_OK && findPage != nullptr) {
+            matchedTypePageFound = true;
+        }
     } else {
+        // Handle all other data types than BLOB
         err = findItem(nsIndex, datatype, key, findPage, item);
+        if(err == ESP_OK && findPage != nullptr) {
+            matchedTypePageFound = true;
+
+            // keep the sequence number of the page where the item was found for later check of relocation
+            err = findPage->getSeqNumber(findPageSeqNumber);
+            if(err != ESP_OK) {
+                return err;
+            }
+        }
     }
 
-    if (err != ESP_OK && err != ESP_ERR_NVS_NOT_FOUND) {
+#ifndef CONFIG_NVS_LEGACY_DUP_KEYS_COMPATIBILITY
+    // If the item was not found, try to find it with any other datatype. Omit the BLOB_DATA and handle BLOB with respect
+    // to the V1 and V2 representation.
+    const ItemType dataTypes[] = {
+        ItemType::U8,
+        ItemType::U16,
+        ItemType::U32,
+        ItemType::U64,
+        ItemType::I8,
+        ItemType::I16,
+        ItemType::I32,
+        ItemType::I64,
+        ItemType::SZ,
+        ItemType::BLOB_IDX,
+        ItemType::BLOB
+    };
+
+    if(findPage == nullptr) {
+        // Iterate over potential data types to allow findItem() search using the hash list instead of bruteforce search.
+        for(const auto& currType : dataTypes) {
+            // Skip search for BLOB_IDX if the requested datatype is BLOB. BLOB_IDX was already searched above.
+            if(datatype == ItemType::BLOB && currType == ItemType::BLOB_IDX) continue;
+
+            // Skip search if requested datatype is not BLOB and the current datatype is equal to the requested one. This was already searched above.
+            if(datatype != ItemType::BLOB && currType == datatype) continue;
+
+            err = findItem(nsIndex, currType, key, findPage, item);
+            if(err == ESP_OK && findPage != nullptr) {
+                // keep the sequence number of the page where the item was found for later check of relocation
+                err = findPage->getSeqNumber(findPageSeqNumber);
+                if(err != ESP_OK) {
+                    return err;
+                }
+                // item was found with the same key and namespace index but data type is different
+                matchedTypePageFound = false;
+                break;
+            }
+        }
+    }
+#endif
+
+    // Here the findPage is either nullptr or points to the page where the item was found.
+    // The matchedTypePageFound is true if the old value item was found and its datatype representation matches the new one.
+    // This flag is used to determine if the item should be checked for same value.
+    if(err != ESP_OK && err != ESP_ERR_NVS_NOT_FOUND) {
         return err;
     }
 
-    if (datatype == ItemType::BLOB) {
+    // Handle value update
+    if(datatype == ItemType::BLOB) {
         VerOffset prevStart,  nextStart;
         prevStart = nextStart = VerOffset::VER_0_OFFSET;
-        if (findPage) {
-            // Do a sanity check that the item in question is actually being modified.
+        if(matchedTypePageFound) {
+            // Do a check that the item in question is actually being modified.
             // If it isn't, it is cheaper to purposefully not write out new data.
             // since it may invoke an erasure of flash.
-            if (cmpMultiPageBlob(nsIndex, key, data, dataSize) == ESP_OK) {
+            if(cmpMultiPageBlob(nsIndex, key, data, dataSize) == ESP_OK) {
                 return ESP_OK;
             }
 
-            if (findPage->state() == Page::PageState::UNINITIALIZED ||
-                    findPage->state() == Page::PageState::INVALID) {
-                err = findItem(nsIndex, datatype, key, findPage, item);
-                if (err != ESP_OK) {
-                    return err;
-                }
-            }
-            /* Get the version of the previous index with same <ns,key> */
+            // Get the version of the previous index with same <ns,key>
             prevStart = item.blobIndex.chunkStart;
             NVS_ASSERT_OR_RETURN(prevStart == VerOffset::VER_0_OFFSET || prevStart == VerOffset::VER_1_OFFSET, ESP_FAIL);
 
-
-            /* Toggle the version by changing the offset */
+            // Toggle the version by changing the offset
             nextStart
                 = (prevStart == VerOffset::VER_1_OFFSET) ? VerOffset::VER_0_OFFSET : VerOffset::VER_1_OFFSET;
         }
-        /* Write the blob with new version*/
+        // Write the blob with new version
         err = writeMultiPageBlob(nsIndex, key, data, dataSize, nextStart);
 
-        if (err == ESP_ERR_NVS_PAGE_FULL) {
+        if(err == ESP_ERR_NVS_PAGE_FULL) {
             return ESP_ERR_NVS_NOT_ENOUGH_SPACE;
         }
-        if (err != ESP_OK) {
+
+        if(err != ESP_OK) {
             return err;
         }
-
-        if (findPage) {
-            /* Erase the blob with earlier version*/
-            err = eraseMultiPageBlob(nsIndex, key, prevStart);
-
-            if (err == ESP_ERR_FLASH_OP_FAIL) {
-                return ESP_ERR_NVS_REMOVE_FAILED;
-            }
-            if (err != ESP_OK) {
-                return err;
-            }
-
-            findPage = nullptr;
-        } else {
-            /* Support for earlier versions where BLOBS were stored without index */
-            err = findItem(nsIndex, datatype, key, findPage, item);
-            if (err != ESP_OK && err != ESP_ERR_NVS_NOT_FOUND) {
-                return err;
-            }
-        }
     } else {
-        // Do a sanity check that the item in question is actually being modified.
+        // Do a check that the item in question is actually being modified.
         // If it isn't, it is cheaper to purposefully not write out new data.
         // since it may invoke an erasure of flash.
-        if (findPage != nullptr &&
+        if(matchedTypePageFound &&
                 findPage->cmpItem(nsIndex, datatype, key, data, dataSize) == ESP_OK) {
             return ESP_OK;
         }
 
         Page& page = getCurrentPage();
         err = page.writeItem(nsIndex, datatype, key, data, dataSize);
-        if (err == ESP_ERR_NVS_PAGE_FULL) {
-            if (page.state() != Page::PageState::FULL) {
+        if(err == ESP_ERR_NVS_PAGE_FULL) {
+            if(page.state() != Page::PageState::FULL) {
                 err = page.markFull();
-                if (err != ESP_OK) {
+                if(err != ESP_OK) {
                     return err;
                 }
             }
             err = mPageManager.requestNewPage();
-            if (err != ESP_OK) {
+            if(err != ESP_OK) {
                 return err;
             }
 
             err = getCurrentPage().writeItem(nsIndex, datatype, key, data, dataSize);
-            if (err == ESP_ERR_NVS_PAGE_FULL) {
+            if(err == ESP_ERR_NVS_PAGE_FULL) {
                 return ESP_ERR_NVS_NOT_ENOUGH_SPACE;
             }
-            if (err != ESP_OK) {
-                return err;
-            }
-        } else if (err != ESP_OK) {
+        }
+
+        if(err != ESP_OK) {
             return err;
         }
     }
 
-    if (findPage) {
-        if (findPage->state() == Page::PageState::UNINITIALIZED ||
-                findPage->state() == Page::PageState::INVALID) {
-            err = findItem(nsIndex, datatype, key, findPage, item);
-            if (err != ESP_OK) {
+    // Delete previous value
+    // Note: The old entry won't be deleted if the new value is the same as the old value - code won't reach here in that case.
+
+    // If findPage is null then previous value was not present in NVS and nothig is to be deleted.
+    if(findPage == nullptr) {
+        return err;
+    }
+
+    if(item.datatype == ItemType::BLOB_IDX) {
+        // If the item found was BLOB_INDEX, the eraseMultiPageBlob is used to erase the whole multi-page blob.
+        // It is not necessary to check the potential page relocation as the function will find the blob again anyway.
+        VerOffset prevStart = item.blobIndex.chunkStart;
+        err = eraseMultiPageBlob(nsIndex, key, prevStart);
+
+        if(err == ESP_ERR_FLASH_OP_FAIL) {
+            return ESP_ERR_NVS_REMOVE_FAILED;
+        }
+    } else {
+        // For all other data types, we have to check the potential page relocation.
+
+        // The findPage might have been relocated as a part of space reclaiming.
+        // First indication is the page state. It might become the "spare" page thus changing the state from FULL or ACTIVE.
+        bool wasRelocated = false;
+
+        if( findPage->state() != Page::PageState::ACTIVE &&
+            findPage->state() != Page::PageState::FULL) {
+                wasRelocated = true;
+        }
+
+        // Other indication of the multi step relocation is the page sequence number. If the sequence number is different than page
+        // sequence number at the moment initial item was found, the page was relocated.
+        if(!wasRelocated) {
+            uint32_t newPageSeqNumber;
+            err = findPage->getSeqNumber(newPageSeqNumber);
+            if(err != ESP_OK) {
+                return err;
+            }
+            if(newPageSeqNumber != findPageSeqNumber) {
+                wasRelocated = true;
+            }
+        }
+
+        if(wasRelocated) {
+            // The page was relocated. We have to find the old value again from the beginning.
+            // As the item was already found before relocation, we can use the exact datatype from item.
+            err = findItem(nsIndex, item.datatype, key, findPage, item);
+            if(err != ESP_OK) {
                 return err;
             }
         }
-        err = findPage->eraseItem(nsIndex, datatype, key);
-        if (err == ESP_ERR_FLASH_OP_FAIL) {
+        // Page containing the old value is now refreshed. We can erase the old value.
+        err = findPage->eraseItem(nsIndex, item.datatype, key);
+        if(err == ESP_ERR_FLASH_OP_FAIL) {
             return ESP_ERR_NVS_REMOVE_FAILED;
         }
-        if (err != ESP_OK) {
-            return err;
-        }
     }
+
 #ifdef DEBUG_STORAGE
     debugCheck();
 #endif
-    return ESP_OK;
+    return err;
 }
 
 esp_err_t Storage::createOrOpenNamespace(const char* nsName, bool canCreate, uint8_t& nsIndex)
 {
-    if (mState != StorageState::ACTIVE) {
+    if(mState != StorageState::ACTIVE) {
         return ESP_ERR_NVS_NOT_INITIALIZED;
     }
     auto it = std::find_if(mNamespaces.begin(), mNamespaces.end(), [=] (const NamespaceEntry& e) -> bool {
         return strncmp(nsName, e.mName, sizeof(e.mName) - 1) == 0;
     });
-    if (it == std::end(mNamespaces)) {
-        if (!canCreate) {
+    if(it == std::end(mNamespaces)) {
+        if(!canCreate) {
             return ESP_ERR_NVS_NOT_FOUND;
         }
 
         uint8_t ns;
         bool ns_state;
-        for (ns = 1; ns < 255; ++ns) {
-            if (mNamespaceUsage.get(ns, &ns_state) != ESP_OK) {
+        for(ns = 1; ns < 255; ++ns) {
+            if(mNamespaceUsage.get(ns, &ns_state) != ESP_OK) {
                 return ESP_FAIL;
             }
-            if (!ns_state) {
+            if(!ns_state) {
                 break;
             }
         }
 
-        if (ns == 255) {
+        if(ns == 255) {
             return ESP_ERR_NVS_NOT_ENOUGH_SPACE;
         }
 
         auto err = writeItem(Page::NS_INDEX, ItemType::U8, nsName, &ns, sizeof(ns));
-        if (err != ESP_OK) {
+        if(err != ESP_OK) {
             return err;
         }
-        if (mNamespaceUsage.set(ns, true) != ESP_OK) {
+        if(mNamespaceUsage.set(ns, true) != ESP_OK) {
             return ESP_FAIL;
         }
         nsIndex = ns;
 
         NamespaceEntry* entry = new (std::nothrow) NamespaceEntry;
-        if (!entry) {
+        if(!entry) {
             return ESP_ERR_NO_MEM;
         }
 
@@ -552,7 +638,7 @@ esp_err_t Storage::readMultiPageBlob(uint8_t nsIndex, const char* key, void* dat
 
     /* First read the blob index */
     auto err = findItem(nsIndex, ItemType::BLOB_IDX, key, findPage, item);
-    if (err != ESP_OK) {
+    if(err != ESP_OK) {
         return err;
     }
 
@@ -563,21 +649,21 @@ esp_err_t Storage::readMultiPageBlob(uint8_t nsIndex, const char* key, void* dat
     NVS_ASSERT_OR_RETURN(dataSize == item.blobIndex.dataSize, ESP_FAIL);
 
     /* Now read corresponding chunks */
-    for (uint8_t chunkNum = 0; chunkNum < chunkCount; chunkNum++) {
+    for(uint8_t chunkNum = 0; chunkNum < chunkCount; chunkNum++) {
         err = findItem(nsIndex, ItemType::BLOB_DATA, key, findPage, item, static_cast<uint8_t> (chunkStart) + chunkNum);
-        if (err != ESP_OK) {
-            if (err == ESP_ERR_NVS_NOT_FOUND) {
+        if(err != ESP_OK) {
+            if(err == ESP_ERR_NVS_NOT_FOUND) {
                 break;
             }
             return err;
         }
-        if (item.varLength.dataSize > dataSize - offset) {
+        if(item.varLength.dataSize > dataSize - offset) {
             /* The size of the entry in the index is inconsistent with the sum of the sizes of chunks */
             err = ESP_ERR_NVS_INVALID_LENGTH;
             break;
         }
         err = findPage->readItem(nsIndex, ItemType::BLOB_DATA, key, static_cast<uint8_t*>(data) + offset, item.varLength.dataSize, static_cast<uint8_t> (chunkStart) + chunkNum);
-        if (err != ESP_OK) {
+        if(err != ESP_OK) {
             return err;
         }
         NVS_ASSERT_OR_RETURN(static_cast<uint8_t> (chunkStart) + chunkNum == item.chunkIndex, ESP_FAIL);
@@ -585,7 +671,7 @@ esp_err_t Storage::readMultiPageBlob(uint8_t nsIndex, const char* key, void* dat
         offset += item.varLength.dataSize;
     }
 
-    if (err == ESP_ERR_NVS_NOT_FOUND || err == ESP_ERR_NVS_INVALID_LENGTH) {
+    if(err == ESP_ERR_NVS_NOT_FOUND || err == ESP_ERR_NVS_INVALID_LENGTH) {
         // cleanup if a chunk is not found or the size is inconsistent
         eraseMultiPageBlob(nsIndex, key);
     }
@@ -602,7 +688,7 @@ esp_err_t Storage::cmpMultiPageBlob(uint8_t nsIndex, const char* key, const void
 
     /* First read the blob index */
     auto err = findItem(nsIndex, ItemType::BLOB_IDX, key, findPage, item);
-    if (err != ESP_OK) {
+    if(err != ESP_OK) {
         return err;
     }
 
@@ -611,21 +697,21 @@ esp_err_t Storage::cmpMultiPageBlob(uint8_t nsIndex, const char* key, const void
     size_t readSize = item.blobIndex.dataSize;
     size_t offset = 0;
 
-    if (dataSize != readSize) {
+    if(dataSize != readSize) {
         return ESP_ERR_NVS_CONTENT_DIFFERS;
     }
 
     /* Now read corresponding chunks */
-    for (uint8_t chunkNum = 0; chunkNum < chunkCount; chunkNum++) {
+    for(uint8_t chunkNum = 0; chunkNum < chunkCount; chunkNum++) {
         err = findItem(nsIndex, ItemType::BLOB_DATA, key, findPage, item, static_cast<uint8_t> (chunkStart) + chunkNum);
-        if (err != ESP_OK) {
-            if (err == ESP_ERR_NVS_NOT_FOUND) {
+        if(err != ESP_OK) {
+            if(err == ESP_ERR_NVS_NOT_FOUND) {
                 break;
             }
             return err;
         }
         err = findPage->cmpItem(nsIndex, ItemType::BLOB_DATA, key, static_cast<const uint8_t*>(data) + offset, item.varLength.dataSize, static_cast<uint8_t> (chunkStart) + chunkNum);
-        if (err != ESP_OK) {
+        if(err != ESP_OK) {
             return err;
         }
         NVS_ASSERT_OR_RETURN(static_cast<uint8_t> (chunkStart) + chunkNum == item.chunkIndex, ESP_FAIL);
@@ -639,21 +725,21 @@ esp_err_t Storage::cmpMultiPageBlob(uint8_t nsIndex, const char* key, const void
 
 esp_err_t Storage::readItem(uint8_t nsIndex, ItemType datatype, const char* key, void* data, size_t dataSize)
 {
-    if (mState != StorageState::ACTIVE) {
+    if(mState != StorageState::ACTIVE) {
         return ESP_ERR_NVS_NOT_INITIALIZED;
     }
 
     Item item;
     Page* findPage = nullptr;
-    if (datatype == ItemType::BLOB) {
+    if(datatype == ItemType::BLOB) {
         auto err = readMultiPageBlob(nsIndex, key, data, dataSize);
-        if (err != ESP_ERR_NVS_NOT_FOUND) {
+        if(err != ESP_ERR_NVS_NOT_FOUND) {
             return err;
         } // else check if the blob is stored with earlier version format without index
     }
 
     auto err = findItem(nsIndex, datatype, key, findPage, item);
-    if (err != ESP_OK) {
+    if(err != ESP_OK) {
         return err;
     }
     return findPage->readItem(nsIndex, datatype, key, data, dataSize);
@@ -662,19 +748,19 @@ esp_err_t Storage::readItem(uint8_t nsIndex, ItemType datatype, const char* key,
 
 esp_err_t Storage::eraseMultiPageBlob(uint8_t nsIndex, const char* key, VerOffset chunkStart)
 {
-    if (mState != StorageState::ACTIVE) {
+    if(mState != StorageState::ACTIVE) {
         return ESP_ERR_NVS_NOT_INITIALIZED;
     }
     Item item;
     Page* findPage = nullptr;
 
     auto err = findItem(nsIndex, ItemType::BLOB_IDX, key, findPage, item, Page::CHUNK_ANY, chunkStart);
-    if (err != ESP_OK) {
+    if(err != ESP_OK) {
         return err;
     }
     // Erase the index first and make children blobs orphan
     err = findPage->eraseItem(nsIndex, ItemType::BLOB_IDX, key, Page::CHUNK_ANY, chunkStart);
-    if (err != ESP_OK) {
+    if(err != ESP_OK) {
         return err;
     }
 
@@ -684,12 +770,12 @@ esp_err_t Storage::eraseMultiPageBlob(uint8_t nsIndex, const char* key, VerOffse
     if(chunkStart == VerOffset::VER_ANY)
     {
         err = findItem(nsIndex, ItemType::BLOB_IDX, key, findPage, item, Page::CHUNK_ANY, chunkStart);
-        if (err == ESP_OK) {
+        if(err == ESP_OK) {
             err = findPage->eraseItem(nsIndex, ItemType::BLOB_IDX, key, Page::CHUNK_ANY, chunkStart);
-            if (err != ESP_OK) {
+            if(err != ESP_OK) {
                 return err;
             }
-        } else if (err != ESP_ERR_NVS_NOT_FOUND) {
+        } else if(err != ESP_ERR_NVS_NOT_FOUND) {
             return err;
         }
     }
@@ -700,17 +786,17 @@ esp_err_t Storage::eraseMultiPageBlob(uint8_t nsIndex, const char* key, VerOffse
 
     if(chunkStart == VerOffset::VER_0_OFFSET) {
         maxChunkIndex = (uint8_t) VerOffset::VER_1_OFFSET;
-    } else if (chunkStart == VerOffset::VER_1_OFFSET) {
+    } else if(chunkStart == VerOffset::VER_1_OFFSET) {
         minChunkIndex = (uint8_t) VerOffset::VER_1_OFFSET;
     }
 
-    for (auto it = std::begin(mPageManager); it != std::end(mPageManager); ++it) {
+    for(auto it = std::begin(mPageManager); it != std::end(mPageManager); ++it) {
         size_t itemIndex = 0;
         do {
             err = it->findItem(nsIndex, ItemType::BLOB_DATA, key, itemIndex, item);
-            if (err == ESP_ERR_NVS_NOT_FOUND) {
+            if(err == ESP_ERR_NVS_NOT_FOUND) {
                 break;
-            } else if (err == ESP_OK) {
+            } else if(err == ESP_OK) {
                 // check if item.chunkIndex is within the version range indicated by chunkStart, if so, delete it
                 if((item.chunkIndex >= minChunkIndex) && (item.chunkIndex < maxChunkIndex)) {
                     err = it->eraseEntryAndSpan(itemIndex);
@@ -722,7 +808,7 @@ esp_err_t Storage::eraseMultiPageBlob(uint8_t nsIndex, const char* key, VerOffse
             if(err != ESP_OK) {
                 return err;
             }
-        } while (err == ESP_OK && itemIndex < Page::ENTRY_COUNT);
+        } while(err == ESP_OK && itemIndex < Page::ENTRY_COUNT);
     }
 
     return ESP_OK;
@@ -730,22 +816,22 @@ esp_err_t Storage::eraseMultiPageBlob(uint8_t nsIndex, const char* key, VerOffse
 
 esp_err_t Storage::eraseItem(uint8_t nsIndex, ItemType datatype, const char* key)
 {
-    if (mState != StorageState::ACTIVE) {
+    if(mState != StorageState::ACTIVE) {
         return ESP_ERR_NVS_NOT_INITIALIZED;
     }
 
-    if (datatype == ItemType::BLOB) {
+    if(datatype == ItemType::BLOB) {
         return eraseMultiPageBlob(nsIndex, key);
     }
 
     Item item;
     Page* findPage = nullptr;
     auto err = findItem(nsIndex, datatype, key, findPage, item);
-    if (err != ESP_OK) {
+    if(err != ESP_OK) {
         return err;
     }
 
-    if (item.datatype == ItemType::BLOB_DATA || item.datatype == ItemType::BLOB_IDX) {
+    if(item.datatype == ItemType::BLOB_DATA || item.datatype == ItemType::BLOB_IDX) {
         return eraseMultiPageBlob(nsIndex, key);
     }
 
@@ -754,17 +840,17 @@ esp_err_t Storage::eraseItem(uint8_t nsIndex, ItemType datatype, const char* key
 
 esp_err_t Storage::eraseNamespace(uint8_t nsIndex)
 {
-    if (mState != StorageState::ACTIVE) {
+    if(mState != StorageState::ACTIVE) {
         return ESP_ERR_NVS_NOT_INITIALIZED;
     }
 
-    for (auto it = std::begin(mPageManager); it != std::end(mPageManager); ++it) {
-        while (true) {
+    for(auto it = std::begin(mPageManager); it != std::end(mPageManager); ++it) {
+        while(true) {
             auto err = it->eraseItem(nsIndex, ItemType::ANY, nullptr);
-            if (err == ESP_ERR_NVS_NOT_FOUND) {
+            if(err == ESP_ERR_NVS_NOT_FOUND) {
                 break;
             }
-            else if (err != ESP_OK) {
+            else if(err != ESP_OK) {
                 return err;
             }
         }
@@ -773,7 +859,7 @@ esp_err_t Storage::eraseNamespace(uint8_t nsIndex)
 
 }
 
-esp_err_t Storage::getItemDataSize(uint8_t nsIndex, ItemType datatype, const char* key, size_t& dataSize)
+esp_err_t Storage::findKey(const uint8_t nsIndex, const char* key, ItemType* datatype)
 {
     if (mState != StorageState::ACTIVE) {
         return ESP_ERR_NVS_NOT_INITIALIZED;
@@ -781,13 +867,33 @@ esp_err_t Storage::getItemDataSize(uint8_t nsIndex, ItemType datatype, const cha
 
     Item item;
     Page* findPage = nullptr;
-    auto err = findItem(nsIndex, datatype, key, findPage, item);
+    auto err = findItem(nsIndex, ItemType::ANY, key, findPage, item);
     if (err != ESP_OK) {
-        if (datatype != ItemType::BLOB) {
+        return err;
+    }
+
+    if(datatype != nullptr) {
+        *datatype = item.datatype;
+    }
+
+    return err;
+}
+
+esp_err_t Storage::getItemDataSize(uint8_t nsIndex, ItemType datatype, const char* key, size_t& dataSize)
+{
+    if(mState != StorageState::ACTIVE) {
+        return ESP_ERR_NVS_NOT_INITIALIZED;
+    }
+
+    Item item;
+    Page* findPage = nullptr;
+    auto err = findItem(nsIndex, datatype, key, findPage, item);
+    if(err != ESP_OK) {
+        if(datatype != ItemType::BLOB) {
             return err;
         }
         err = findItem(nsIndex, ItemType::BLOB_IDX, key, findPage, item);
-        if (err != ESP_OK) {
+        if(err != ESP_OK) {
             return err;
         }
         dataSize = item.blobIndex.dataSize;
@@ -800,7 +906,7 @@ esp_err_t Storage::getItemDataSize(uint8_t nsIndex, ItemType datatype, const cha
 
 void Storage::debugDump()
 {
-    for (auto p = mPageManager.begin(); p != mPageManager.end(); ++p) {
+    for(auto p = mPageManager.begin(); p != mPageManager.end(); ++p) {
         p->debugDump();
     }
 }
@@ -810,15 +916,15 @@ void Storage::debugCheck()
 {
     std::map<std::string, Page*> keys;
 
-    for (auto p = mPageManager.begin(); p != mPageManager.end(); ++p) {
+    for(auto p = mPageManager.begin(); p != mPageManager.end(); ++p) {
         size_t itemIndex = 0;
         size_t usedCount = 0;
         Item item;
-        while (p->findItem(Page::NS_ANY, ItemType::ANY, nullptr, itemIndex, item) == ESP_OK) {
+        while(p->findItem(Page::NS_ANY, ItemType::ANY, nullptr, itemIndex, item) == ESP_OK) {
             std::stringstream keyrepr;
             keyrepr << static_cast<unsigned>(item.nsIndex) << "_" << static_cast<unsigned>(item.datatype) << "_" << item.key <<"_"<<static_cast<unsigned>(item.chunkIndex);
             std::string keystr = keyrepr.str();
-            if (keys.find(keystr) != std::end(keys)) {
+            if(keys.find(keystr) != std::end(keys)) {
                 printf("Duplicate key: %s\n", keystr.c_str());
                 debugDump();
                 assert(0);
@@ -842,24 +948,24 @@ esp_err_t Storage::calcEntriesInNamespace(uint8_t nsIndex, size_t& usedEntries)
 {
     usedEntries = 0;
 
-    if (mState != StorageState::ACTIVE) {
+    if(mState != StorageState::ACTIVE) {
         return ESP_ERR_NVS_NOT_INITIALIZED;
     }
 
-    for (auto it = std::begin(mPageManager); it != std::end(mPageManager); ++it) {
+    for(auto it = std::begin(mPageManager); it != std::end(mPageManager); ++it) {
         size_t itemIndex = 0;
         Item item;
-        while (true) {
+        while(true) {
             auto err = it->findItem(nsIndex, ItemType::ANY, nullptr, itemIndex, item);
-            if (err == ESP_ERR_NVS_NOT_FOUND) {
+            if(err == ESP_ERR_NVS_NOT_FOUND) {
                 break;
             }
-            else if (err != ESP_OK) {
+            else if(err != ESP_OK) {
                 return err;
             }
             usedEntries += item.span;
             itemIndex   += item.span;
-            if (itemIndex >= it->ENTRY_COUNT) break;
+            if(itemIndex >= it->ENTRY_COUNT) break;
         }
     }
     return ESP_OK;
@@ -871,7 +977,7 @@ void Storage::fillEntryInfo(Item &item, nvs_entry_info_t &info)
     strncpy(info.key, item.key, sizeof(info.key) - 1);
     info.key[sizeof(info.key) - 1] = '\0';
 
-    for (auto &name : mNamespaces) {
+    for(auto &name : mNamespaces) {
         if(item.nsIndex == name.mIndex) {
             strlcpy(info.namespace_name, name.mName, sizeof(info.namespace_name));
             break;
@@ -885,7 +991,7 @@ bool Storage::findEntry(nvs_opaque_iterator_t* it, const char* namespace_name)
     it->nsIndex = Page::NS_ANY;
     it->page = mPageManager.begin();
 
-    if (namespace_name != nullptr) {
+    if(namespace_name != nullptr) {
         if(createOrOpenNamespace(namespace_name, false, it->nsIndex) != ESP_OK) {
             return false;
         }
@@ -913,7 +1019,7 @@ bool Storage::nextEntry(nvs_opaque_iterator_t* it)
     Item item;
     esp_err_t err;
 
-    for (auto page = it->page; page != mPageManager.end(); ++page) {
+    for(auto page = it->page; page != mPageManager.end(); ++page) {
         do {
             err = page->findItem(it->nsIndex, (ItemType)it->type, nullptr, it->entryIndex, item);
             it->entryIndex += item.span;
@@ -922,7 +1028,7 @@ bool Storage::nextEntry(nvs_opaque_iterator_t* it)
                 it->page = page;
                 return true;
             }
-        } while (err != ESP_ERR_NVS_NOT_FOUND);
+        } while(err != ESP_ERR_NVS_NOT_FOUND);
 
         it->entryIndex = 0;
     }
diff --git a/components/nvs_flash/src/nvs_storage.hpp b/components/nvs_flash/src/nvs_storage.hpp
index 6dbb6b1007..eab1b9dfaf 100644
--- a/components/nvs_flash/src/nvs_storage.hpp
+++ b/components/nvs_flash/src/nvs_storage.hpp
@@ -74,6 +74,8 @@ public:
 
     esp_err_t readItem(uint8_t nsIndex, ItemType datatype, const char* key, void* data, size_t dataSize);
 
+    esp_err_t findKey(const uint8_t nsIndex, const char* key, ItemType* datatype);
+
     esp_err_t getItemDataSize(uint8_t nsIndex, ItemType datatype, const char* key, size_t& dataSize);
 
     esp_err_t eraseItem(uint8_t nsIndex, ItemType datatype, const char* key);
diff --git a/docs/en/api-reference/storage/nvs_flash.rst b/docs/en/api-reference/storage/nvs_flash.rst
index b54715d939..fbfd461044 100644
--- a/docs/en/api-reference/storage/nvs_flash.rst
+++ b/docs/en/api-reference/storage/nvs_flash.rst
@@ -35,12 +35,9 @@ NVS operates on key-value pairs. Keys are ASCII strings; the maximum key length
 
 Additional types, such as ``float`` and ``double`` might be added later.
 
-Keys are required to be unique. Assigning a new value to an existing key works as follows:
+Keys are required to be unique. Assigning a new value to an existing key replaces the old value and data type with the value and data type specified by a write operation.
 
--  If the new value is of the same type as the old one, value is updated.
--  If the new value has a different data type, an error is returned.
-
-Data type check is also performed when reading a value. An error is returned if the data type of the read operation does not match the data type of the value.
+A data type check is performed when reading a value. An error is returned if the data type expected by read operation does not match the data type of entry found for the key provided.
 
 
 Namespaces
diff --git a/docs/zh_CN/api-reference/storage/nvs_flash.rst b/docs/zh_CN/api-reference/storage/nvs_flash.rst
index d3d33002eb..49d3f690f8 100644
--- a/docs/zh_CN/api-reference/storage/nvs_flash.rst
+++ b/docs/zh_CN/api-reference/storage/nvs_flash.rst
@@ -35,12 +35,9 @@ NVS 的操作对象为键值对，其中键是 ASCII 字符串，当前支持的
 
 后续可能会增加对 ``float`` 和 ``double`` 等其他类型数据的支持。
 
-键必须唯一。为现有的键写入新的值可能产生如下结果：
+键必须唯一。为现有的键写入新值时，会将旧的值及数据类型更新为写入操作指定的值和数据类型。
 
--  如果新旧值数据类型相同，则更新值；
--  如果新旧值数据类型不同，则返回错误。
-
-读取值时也会执行数据类型检查。如果读取操作的数据类型与该值的数据类型不匹配，则返回错误。
+读取值时会执行数据类型检查。如果读取操作预期的数据类型与对应键的数据类型不匹配，则返回错误。
 
 
 命名空间
diff --git a/tools/ci/check_copyright_ignore.txt b/tools/ci/check_copyright_ignore.txt
index 9e68f680cb..2964fa50d6 100644
--- a/tools/ci/check_copyright_ignore.txt
+++ b/tools/ci/check_copyright_ignore.txt
@@ -700,9 +700,6 @@ components/nvs_flash/include/nvs_flash.h
 components/nvs_flash/include/nvs_handle.hpp
 components/nvs_flash/src/nvs_cxx_api.cpp
 components/nvs_flash/src/nvs_encrypted_partition.hpp
-components/nvs_flash/src/nvs_handle_locked.cpp
-components/nvs_flash/src/nvs_handle_locked.hpp
-components/nvs_flash/src/nvs_handle_simple.cpp
 components/nvs_flash/src/nvs_item_hash_list.cpp
 components/nvs_flash/src/nvs_pagemanager.hpp
 components/nvs_flash/src/nvs_partition.cpp