react-native-nitro-storage 0.5.9 → 0.7.0

package/android/src/main/java/com/nitrostorage/AndroidStorageAdapter.kt

@@ -3,7 +3,10 @@
 package com.nitrostorage
 
 import android.content.Context
+import android.os.Build
+import android.security.keystore.KeyGenParameterSpec
 import android.security.keystore.KeyPermanentlyInvalidatedException
+import android.security.keystore.KeyProperties
 import android.security.keystore.UserNotAuthenticatedException
 import android.content.SharedPreferences
 import androidx.security.crypto.EncryptedSharedPreferences
@@ -60,33 +63,113 @@ class AndroidStorageAdapter private constructor(private val context: Context) {
         throw RuntimeException("NitroStorage: Cannot create encryption key. Device may not support AES256-GCM.", e)
     }
 
-    private val encryptedPreferences: SharedPreferences = initializeEncryptedPreferences("NitroStorageSecure", masterKey)
+    private val encryptedPreferences: SharedPreferences = initializeEncryptedPreferences(
+        "NitroStorageSecure",
+        masterKey,
+        masterKeyAlias,
+        ::createDefaultMasterKey,
+    )
 
     private val biometricMasterKeyAlias = "${context.packageName}.nitro_storage.biometric_key"
+    private val biometricOrPasscodeMasterKeyAlias =
+        "${context.packageName}.nitro_storage.biometric_or_passcode_key"
+    private val biometricOnlyMasterKeyAlias =
+        "${context.packageName}.nitro_storage.biometric_only_key"
+
+    private val legacyBiometricPreferences: SharedPreferences by lazy {
+        createBiometricPreferences(
+            "NitroStorageBiometric",
+            biometricMasterKeyAlias,
+            1,
+        )
+    }
 
-    private val biometricPreferences: SharedPreferences by lazy {
-        try {
-            val bioKey = MasterKey.Builder(context, biometricMasterKeyAlias)
-                .setKeyScheme(MasterKey.KeyScheme.AES256_GCM)
-                .setUserAuthenticationRequired(true, 30)
+    private val biometricOrPasscodePreferences: SharedPreferences by lazy {
+        createBiometricPreferences(
+            "NitroStorageBiometricOrPasscode",
+            biometricOrPasscodeMasterKeyAlias,
+            1,
+        )
+    }
+
+    private val biometricOnlyPreferences: SharedPreferences by lazy {
+        createBiometricPreferences(
+            "NitroStorageBiometricOnly",
+            biometricOnlyMasterKeyAlias,
+            2,
+        )
+    }
+
+    @Volatile
+    private var secureWritesAsync = false
+
+    @Volatile
+    private var secureKeysCache: Array<String>? = null
+
+    private fun createDefaultMasterKey(): MasterKey {
+        return MasterKey.Builder(context, masterKeyAlias)
+            .setKeyScheme(MasterKey.KeyScheme.AES256_GCM)
+            .build()
+    }
+
+    private fun createBiometricMasterKey(alias: String, level: Int): MasterKey {
+        if (level == 2 && Build.VERSION.SDK_INT < Build.VERSION_CODES.R) {
+            throw RuntimeException(
+                "[nitro-error:biometric_unavailable] NitroStorage: BiometryOnly requires Android 11 or newer.",
+            )
+        }
+
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.R) {
+            val authenticationTypes = if (level == 1) {
+                KeyProperties.AUTH_BIOMETRIC_STRONG or KeyProperties.AUTH_DEVICE_CREDENTIAL
+            } else {
+                KeyProperties.AUTH_BIOMETRIC_STRONG
+            }
+            val keySpec = KeyGenParameterSpec.Builder(
+                alias,
+                KeyProperties.PURPOSE_ENCRYPT or KeyProperties.PURPOSE_DECRYPT,
+            )
+                .setBlockModes(KeyProperties.BLOCK_MODE_GCM)
+                .setEncryptionPaddings(KeyProperties.ENCRYPTION_PADDING_NONE)
+                .setKeySize(256)
+                .setUserAuthenticationRequired(true)
+                .setUserAuthenticationParameters(30, authenticationTypes)
+                .setInvalidatedByBiometricEnrollment(level == 2)
+                .build()
+            return MasterKey.Builder(context, alias)
+                .setKeyGenParameterSpec(keySpec)
                 .build()
-            initializeEncryptedPreferences("NitroStorageBiometric", bioKey)
+        }
+
+        return MasterKey.Builder(context, alias)
+            .setKeyScheme(MasterKey.KeyScheme.AES256_GCM)
+            .setUserAuthenticationRequired(true, 30)
+            .build()
+    }
+
+    private fun createBiometricPreferences(
+        name: String,
+        alias: String,
+        level: Int,
+    ): SharedPreferences {
+        return try {
+            val keyFactory = { createBiometricMasterKey(alias, level) }
+            initializeEncryptedPreferences(name, keyFactory(), alias, keyFactory)
         } catch (e: Exception) {
             throw e.wrapStorageException(
                 "NitroStorage: Biometric storage is not available on this device. " +
-                    "Ensure biometric hardware is present and credentials are enrolled.",
+                    "Ensure supported authentication is enrolled.",
                 defaultCode = "biometric_unavailable",
             )
         }
     }
 
-    @Volatile
-    private var secureWritesAsync = false
-
-    @Volatile
-    private var secureKeysCache: Array<String>? = null
-
-    private fun initializeEncryptedPreferences(name: String, key: MasterKey): SharedPreferences {
+    private fun initializeEncryptedPreferences(
+        name: String,
+        key: MasterKey,
+        alias: String,
+        keyFactory: () -> MasterKey,
+    ): SharedPreferences {
         return try {
             EncryptedSharedPreferences.create(
                 context, name, key,
@@ -96,16 +179,8 @@ class AndroidStorageAdapter private constructor(private val context: Context) {
         } catch (e: Exception) {
             when {
                 e.hasCause(AEADBadTagException::class.java) -> {
-                    clearCorruptedStorage(name, key)
-                    val freshAlias = if (name == "NitroStorageBiometric") biometricMasterKeyAlias else masterKeyAlias
-                    val freshKey = MasterKey.Builder(context, freshAlias)
-                        .setKeyScheme(MasterKey.KeyScheme.AES256_GCM)
-                        .apply {
-                            if (name == "NitroStorageBiometric") {
-                                setUserAuthenticationRequired(true, 30)
-                            }
-                        }
-                        .build()
+                    clearCorruptedStorage(name, alias)
+                    val freshKey = keyFactory()
                     try {
                         EncryptedSharedPreferences.create(
                             context, name, freshKey,
@@ -120,7 +195,6 @@ class AndroidStorageAdapter private constructor(private val context: Context) {
                     }
                 }
                 else -> {
-                    // Don't wipe on non-corruption failures (e.g., locked keystore)
                     throw e.wrapStorageException(
                         "NitroStorage: Failed to initialize $name (${e::class.simpleName}). " +
                             "This may be a temporary keystore issue. If it persists, clear app data.",
@@ -130,18 +204,58 @@ class AndroidStorageAdapter private constructor(private val context: Context) {
         }
     }
 
-    private fun clearCorruptedStorage(name: String, key: MasterKey) {
-        try {
-            context.deleteSharedPreferences(name)
-            val keyStore = KeyStore.getInstance("AndroidKeyStore")
-            keyStore.load(null)
-            val alias = when {
-                name == "NitroStorageSecure" -> masterKeyAlias
-                name == "NitroStorageBiometric" -> biometricMasterKeyAlias
-                else -> masterKeyAlias
-            }
-            keyStore.deleteEntry(alias)
-        } catch (_: Exception) {
+    private fun clearCorruptedStorage(name: String, alias: String) {
+        context.deleteSharedPreferences(name)
+        val keyStore = KeyStore.getInstance("AndroidKeyStore")
+        keyStore.load(null)
+        keyStore.deleteEntry(alias)
+    }
+
+    private fun preferencesFileExists(name: String): Boolean {
+        return context.getSharedPreferences(name, Context.MODE_PRIVATE).all.isNotEmpty()
+    }
+
+    private fun existingBiometricPreferences(): List<SharedPreferences> {
+        val stores = mutableListOf<SharedPreferences>()
+        if (preferencesFileExists("NitroStorageBiometricOnly")) {
+            stores.add(biometricOnlyPreferences)
+        }
+        if (preferencesFileExists("NitroStorageBiometricOrPasscode")) {
+            stores.add(biometricOrPasscodePreferences)
+        }
+        if (preferencesFileExists("NitroStorageBiometric")) {
+            stores.add(legacyBiometricPreferences)
+        }
+        for (preferences in stores) {
+            preferences.all
+        }
+        return stores
+    }
+
+    private fun biometricPreferencesForLevel(level: Int): SharedPreferences {
+        return when (level) {
+            1 -> biometricOrPasscodePreferences
+            2 -> biometricOnlyPreferences
+            else -> throw IllegalArgumentException(
+                "NitroStorage: Invalid biometric level. Expected 0, 1, or 2.",
+            )
+        }
+    }
+
+    private fun removeBiometricKey(
+        key: String,
+        preferencesList: List<SharedPreferences> = existingBiometricPreferences(),
+    ) {
+        for (preferences in preferencesList) {
+            applySecureEditor(preferences.edit().remove(key))
+        }
+    }
+
+    private fun clearBiometricStores(
+        preferencesList: List<SharedPreferences> = existingBiometricPreferences(),
+    ) {
+        for (preferences in preferencesList) {
+            applySecureEditor(preferences.edit().clear())
         }
     }
 
@@ -162,8 +276,8 @@ class AndroidStorageAdapter private constructor(private val context: Context) {
         try {
             if (secureWritesAsync) {
                 editor.apply()
-            } else {
-                editor.commit()
+            } else if (!editor.commit()) {
+                throw IllegalStateException("SharedPreferences commit returned false")
             }
         } catch (e: Exception) {
             throw e.wrapStorageException(
@@ -192,9 +306,8 @@ class AndroidStorageAdapter private constructor(private val context: Context) {
             val INTERNAL_PREFIX = "__androidx_security_crypto_encrypted_prefs_"
             val keys = linkedSetOf<String>()
             keys.addAll(encryptedPreferences.all.keys.filter { !it.startsWith(INTERNAL_PREFIX) })
-            try {
-                keys.addAll(biometricPreferences.all.keys.filter { !it.startsWith(INTERNAL_PREFIX) })
-            } catch (_: Exception) {
+            for (preferences in existingBiometricPreferences()) {
+                keys.addAll(preferences.all.keys.filter { !it.startsWith(INTERNAL_PREFIX) })
             }
             val built = keys.toTypedArray()
             secureKeysCache = built
@@ -361,11 +474,9 @@ class AndroidStorageAdapter private constructor(private val context: Context) {
         fun deleteSecure(key: String) {
             val inst = getInstanceOrThrow()
             synchronized(inst) {
+                val biometricPreferences = inst.existingBiometricPreferences()
                 inst.applySecureEditor(inst.encryptedPreferences.edit().remove(key))
-                try {
-                    inst.applySecureEditor(inst.biometricPreferences.edit().remove(key))
-                } catch (_: Exception) {
-                }
+                inst.removeBiometricKey(key, biometricPreferences)
                 inst.invalidateSecureKeysCache()
             }
         }
@@ -374,18 +485,18 @@ class AndroidStorageAdapter private constructor(private val context: Context) {
         fun deleteSecureBatch(keys: Array<String>) {
             val inst = getInstanceOrThrow()
             synchronized(inst) {
+                val biometricPreferences = inst.existingBiometricPreferences()
                 val editor = inst.encryptedPreferences.edit()
                 for (key in keys) {
                     editor.remove(key)
                 }
                 inst.applySecureEditor(editor)
-                try {
-                    val biometricEditor = inst.biometricPreferences.edit()
+                for (preferences in biometricPreferences) {
+                    val biometricEditor = preferences.edit()
                     for (key in keys) {
                         biometricEditor.remove(key)
                     }
                     inst.applySecureEditor(biometricEditor)
-                } catch (_: Exception) {
                 }
                 inst.invalidateSecureKeysCache()
             }
@@ -394,13 +505,10 @@ class AndroidStorageAdapter private constructor(private val context: Context) {
         @JvmStatic
         fun hasSecure(key: String): Boolean {
             val inst = getInstanceOrThrow()
-            val hasInEncrypted = inst.encryptedPreferences.contains(key)
-            val hasInBiometric = try {
-                inst.biometricPreferences.contains(key)
-            } catch (_: Exception) {
-                false
+            if (inst.encryptedPreferences.contains(key)) {
+                return true
             }
-            return hasInEncrypted || hasInBiometric
+            return inst.existingBiometricPreferences().any { it.contains(key) }
         }
 
         @JvmStatic
@@ -422,12 +530,12 @@ class AndroidStorageAdapter private constructor(private val context: Context) {
         @JvmStatic
         fun clearSecure() {
             val inst = getInstanceOrThrow()
-            inst.applySecureEditor(inst.encryptedPreferences.edit().clear())
-            try {
-                inst.applySecureEditor(inst.biometricPreferences.edit().clear())
-            } catch (_: Exception) {
+            synchronized(inst) {
+                val biometricPreferences = inst.existingBiometricPreferences()
+                inst.applySecureEditor(inst.encryptedPreferences.edit().clear())
+                inst.clearBiometricStores(biometricPreferences)
+                inst.invalidateSecureKeysCache()
             }
-            inst.invalidateSecureKeysCache()
         }
 
         // --- Biometric (separate encrypted store, requires recent biometric auth on Android) ---
@@ -438,12 +546,32 @@ class AndroidStorageAdapter private constructor(private val context: Context) {
         }
 
         @JvmStatic
-        fun setSecureBiometricWithLevel(key: String, value: String, @Suppress("UNUSED_PARAMETER") level: Int) {
+        fun setSecureBiometricWithLevel(key: String, value: String, level: Int) {
             val inst = getInstanceOrThrow()
             try {
-                val editor = inst.biometricPreferences.edit().putString(key, value)
-                inst.applySecureEditor(editor)
-                inst.invalidateSecureKeysCache()
+                synchronized(inst) {
+                    val biometricPreferences = inst.existingBiometricPreferences()
+                    if (level == 0) {
+                        inst.removeBiometricKey(key, biometricPreferences)
+                        inst.applySecureEditor(
+                            inst.encryptedPreferences.edit().putString(key, value),
+                        )
+                    } else {
+                        val targetPreferences = inst.biometricPreferencesForLevel(level)
+                        inst.applySecureEditor(
+                            targetPreferences.edit().putString(key, value),
+                        )
+                        inst.applySecureEditor(
+                            inst.encryptedPreferences.edit().remove(key),
+                        )
+                        for (preferences in biometricPreferences) {
+                            if (preferences !== targetPreferences) {
+                                inst.applySecureEditor(preferences.edit().remove(key))
+                            }
+                        }
+                    }
+                    inst.invalidateSecureKeysCache()
+                }
             } catch (e: Exception) {
                 throw e.wrapStorageException(
                     "NitroStorage: Biometric storage unavailable on this device",
@@ -456,9 +584,17 @@ class AndroidStorageAdapter private constructor(private val context: Context) {
         fun getSecureBiometric(key: String): String? {
             val inst = getInstanceOrThrow()
             return try {
-                inst.getSecureSafe(inst.biometricPreferences, key)
-            } catch (_: Exception) {
+                for (preferences in inst.existingBiometricPreferences()) {
+                    val value = inst.getSecureSafe(preferences, key)
+                    if (value != null) {
+                        return value
+                    }
+                }
                 null
+            } catch (e: Exception) {
+                throw e.wrapStorageException(
+                    "NitroStorage: Failed to read biometric storage: ${e.message}",
+                )
             }
         }
 
@@ -466,18 +602,26 @@ class AndroidStorageAdapter private constructor(private val context: Context) {
         fun deleteSecureBiometric(key: String) {
             val inst = getInstanceOrThrow()
             try {
-                inst.applySecureEditor(inst.biometricPreferences.edit().remove(key))
-                inst.invalidateSecureKeysCache()
-            } catch (_: Exception) {
+                synchronized(inst) {
+                    inst.removeBiometricKey(key)
+                    inst.invalidateSecureKeysCache()
+                }
+            } catch (e: Exception) {
+                throw e.wrapStorageException(
+                    "NitroStorage: Failed to delete biometric storage: ${e.message}",
+                )
             }
         }
 
         @JvmStatic
         fun hasSecureBiometric(key: String): Boolean {
+            val inst = getInstanceOrThrow()
             return try {
-                getInstanceOrThrow().biometricPreferences.contains(key)
-            } catch (_: Exception) {
-                false
+                inst.existingBiometricPreferences().any { it.contains(key) }
+            } catch (e: Exception) {
+                throw e.wrapStorageException(
+                    "NitroStorage: Failed to inspect biometric storage: ${e.message}",
+                )
             }
         }
 
@@ -485,9 +629,14 @@ class AndroidStorageAdapter private constructor(private val context: Context) {
         fun clearSecureBiometric() {
             val inst = getInstanceOrThrow()
             try {
-                inst.applySecureEditor(inst.biometricPreferences.edit().clear())
-                inst.invalidateSecureKeysCache()
-            } catch (_: Exception) {
+                synchronized(inst) {
+                    inst.clearBiometricStores()
+                    inst.invalidateSecureKeysCache()
+                }
+            } catch (e: Exception) {
+                throw e.wrapStorageException(
+                    "NitroStorage: Failed to clear biometric storage: ${e.message}",
+                )
             }
         }
     }

package/app.plugin.js

@@ -15,6 +15,8 @@ const FULL_BACKUP_CONTENT_RESOURCE = "@xml/nitro_storage_full_backup_content";
 const secureSharedPrefs = [
   "NitroStorageSecure.xml",
   "NitroStorageBiometric.xml",
+  "NitroStorageBiometricOrPasscode.xml",
+  "NitroStorageBiometricOnly.xml",
 ];
 
 function sharedPrefsExcludes(indent = "    ") {

package/cpp/bindings/HybridStorage.cpp

@@ -277,23 +277,32 @@ std::function<void()> HybridStorage::addOnChange(
         listenerId = nextListenerId_++;
         listeners_[intScope].push_back({listenerId, callback});
     }
-    
+    // Publish the count after the vector mutation so a zero count seen by the
+    // lock-free reader always means "vector has no listeners for this scope".
+    if (intScope >= 0 && intScope < 3) {
+        listenerScopeCounts_[static_cast<size_t>(intScope)].fetch_add(1, std::memory_order_release);
+    }
+
     std::weak_ptr<HybridStorage> weakSelf = std::dynamic_pointer_cast<HybridStorage>(shared_from_this());
     return [weakSelf, intScope, listenerId]() {
         auto self = weakSelf.lock();
         if (!self) return;  // HybridStorage was destroyed — safe no-op
-        std::lock_guard<std::mutex> lock(self->listenersMutex_);
-        auto& scopeListeners = self->listeners_[intScope];
         bool found = false;
-        for (auto it = scopeListeners.begin(); it != scopeListeners.end(); ++it) {
-            if (it->id == listenerId) {
-                scopeListeners.erase(it);
-                found = true;
-                break;
+        {
+            std::lock_guard<std::mutex> lock(self->listenersMutex_);
+            auto& scopeListeners = self->listeners_[intScope];
+            for (auto it = scopeListeners.begin(); it != scopeListeners.end(); ++it) {
+                if (it->id == listenerId) {
+                    scopeListeners.erase(it);
+                    found = true;
+                    break;
+                }
             }
         }
         // Silently ignore double-unsubscribe (listener already removed)
-        (void)found;
+        if (found && intScope >= 0 && intScope < 3) {
+            self->listenerScopeCounts_[static_cast<size_t>(intScope)].fetch_sub(1, std::memory_order_release);
+        }
     };
 }
 
@@ -608,6 +617,13 @@ void HybridStorage::clearSecureBiometric() {
 // --- Internal ---
 
 std::vector<HybridStorage::Listener> HybridStorage::copyListenersForScope(int scope) {
+    // Lock-free fast path: when no listeners are registered for this scope,
+    // avoid taking the mutex and copying the (empty) vector on every write.
+    if (scope >= 0 && scope < 3 &&
+        listenerScopeCounts_[static_cast<size_t>(scope)].load(std::memory_order_acquire) == 0) {
+        return {};
+    }
+
     std::vector<Listener> listenersCopy;
     {
         std::lock_guard<std::mutex> lock(listenersMutex_);
@@ -656,12 +672,10 @@ void HybridStorage::ensureKeyIndexHydrated(int scope) {
         return;
     }
 
-    {
-        std::lock_guard<std::mutex> lock(keyIndexMutex_);
-        auto hydratedIt = keyIndexHydrated_.find(scope);
-        if (hydratedIt != keyIndexHydrated_.end() && hydratedIt->second) {
-            return;
-        }
+    std::lock_guard<std::mutex> lock(keyIndexMutex_);
+    auto hydratedIt = keyIndexHydrated_.find(scope);
+    if (hydratedIt != keyIndexHydrated_.end() && hydratedIt->second) {
+        return;
     }
 
     ensureAdapter();
@@ -678,12 +692,6 @@ void HybridStorage::ensureKeyIndexHydrated(int scope) {
         throw std::runtime_error("NitroStorage: Key index hydration failed (unknown error)");
     }
 
-    std::lock_guard<std::mutex> lock(keyIndexMutex_);
-    // Double-check: another thread may have hydrated while we fetched
-    auto hydratedIt = keyIndexHydrated_.find(scope);
-    if (hydratedIt != keyIndexHydrated_.end() && hydratedIt->second) {
-        return; // discard our results
-    }
     auto& index = keyIndex_[scope];
     index.clear();
     for (const auto& key : keys) {

package/cpp/bindings/HybridStorage.hpp

@@ -11,6 +11,8 @@
 #include <memory>
 #include <vector>
 #include <unordered_set>
+#include <atomic>
+#include <array>
 
 namespace margelo::nitro::NitroStorage {
 
@@ -74,6 +76,9 @@ private:
     HybridStorageMap<int, std::vector<Listener>> listeners_;
     std::mutex listenersMutex_;
     size_t nextListenerId_ = 0;
+    // Lock-free fast path: skip locking/copying the listener vector on the
+    // write/notify path when no listeners are registered for a scope.
+    std::array<std::atomic<size_t>, 3> listenerScopeCounts_{};
     HybridStorageMap<int, std::unordered_set<std::string>> keyIndex_;
     HybridStorageMap<int, bool> keyIndexHydrated_;
     std::mutex keyIndexMutex_;

package/docs/secure-storage.md

@@ -47,6 +47,8 @@ export const recoveryCodeItem = createStorageItem<string>({
 
 `BiometricLevel.BiometryOnly` does not allow passcode fallback. Use `BiometricLevel.BiometryOrPasscode` when passcode fallback is acceptable.
 
+On Android 11 and newer, the two levels use separate Android Keystore keys with distinct allowed authenticators. Android 10 and older support `BiometryOrPasscode`; `BiometryOnly` reports `biometric_unavailable` because the older Keystore API cannot enforce that distinction safely for this storage backend. Android authorization remains valid for a 30-second window after successful authentication.
+
 ## Access Control
 
 `accessControl` maps to platform accessibility rules where available.
@@ -141,6 +143,8 @@ Android secure storage uses encrypted SharedPreferences. Restored encrypted pref
 
 - `NitroStorageSecure.xml`
 - `NitroStorageBiometric.xml`
+- `NitroStorageBiometricOrPasscode.xml`
+- `NitroStorageBiometricOnly.xml`
 
 If you disable `configureAndroidBackup` or maintain custom Android backup XML, add equivalent exclusions for both cloud backup and device transfer.
 

package/lib/commonjs/index.js

@@ -27,7 +27,7 @@ Object.defineProperty(exports, "createIndexedDBBackend", {
     return _indexeddbBackend.createIndexedDBBackend;
   }
 });
-exports.createStorageItem = exports.createSecureAuthStorage = void 0;
+exports.diskItem = exports.createStorageItem = exports.createSetItem = exports.createSecureAuthStorage = void 0;
 exports.flushWebStorageBackends = flushWebStorageBackends;
 exports.getBatch = void 0;
 Object.defineProperty(exports, "getStorageErrorCode", {
@@ -44,13 +44,14 @@ Object.defineProperty(exports, "isKeychainLockedError", {
     return _shared.isKeychainLockedError;
   }
 });
+exports.memoryItem = void 0;
 Object.defineProperty(exports, "migrateFromMMKV", {
   enumerable: true,
   get: function () {
     return _migration.migrateFromMMKV;
   }
 });
-exports.setBatch = exports.runTransaction = exports.removeBatch = exports.registerMigration = exports.migrateToLatest = void 0;
+exports.setBatch = exports.secureItem = exports.runTransaction = exports.removeBatch = exports.registerMigration = exports.migrateToLatest = void 0;
 exports.setWebDiskStorageBackend = setWebDiskStorageBackend;
 exports.setWebSecureStorageBackend = setWebSecureStorageBackend;
 exports.storage = void 0;
@@ -66,12 +67,24 @@ Object.defineProperty(exports, "useStorage", {
     return _storageHooks.useStorage;
   }
 });
+Object.defineProperty(exports, "useStorageActions", {
+  enumerable: true,
+  get: function () {
+    return _storageHooks.useStorageActions;
+  }
+});
 Object.defineProperty(exports, "useStorageSelector", {
   enumerable: true,
   get: function () {
     return _storageHooks.useStorageSelector;
   }
 });
+Object.defineProperty(exports, "useStorageValue", {
+  enumerable: true,
+  get: function () {
+    return _storageHooks.useStorageValue;
+  }
+});
 var _shared = require("./shared");
 var _reactNativeNitroModules = require("react-native-nitro-modules");
 var _Storage = require("./Storage.types");
@@ -252,6 +265,10 @@ const storage = exports.storage = {
   })
 };
 const createStorageItem = exports.createStorageItem = core.createStorageItem;
+const memoryItem = exports.memoryItem = core.memoryItem;
+const diskItem = exports.diskItem = core.diskItem;
+const secureItem = exports.secureItem = core.secureItem;
+const createSetItem = exports.createSetItem = core.createSetItem;
 const getBatch = exports.getBatch = core.getBatch;
 const setBatch = exports.setBatch = core.setBatch;
 const removeBatch = exports.removeBatch = core.removeBatch;