feat(user-prefs): IUserPreferences

Signed-off-by: Maxence Lange <maxence@artificial-owl.com>

16 files changed, 4429 insertions, 195 deletions

diff --git a/build/psalm-baseline.xml b/build/psalm-baseline.xml
index 437be7441f8..ed96e4391f9 100644
--- a/build/psalm-baseline.xml
+++ b/build/psalm-baseline.xml
@@ -1328,9 +1328,6 @@
     <MoreSpecificImplementedParamType>
       <code><![CDATA[$key]]></code>
     </MoreSpecificImplementedParamType>
-    <TypeDoesNotContainType>
-      <code><![CDATA[!is_array($userIds)]]></code>
-    </TypeDoesNotContainType>
   </file>
   <file src="lib/private/App/AppStore/Fetcher/Fetcher.php">
     <TooManyArguments>
diff --git a/core/Migrations/Version31000Date20240814184402.php b/core/Migrations/Version31000Date20240814184402.php
new file mode 100644
index 00000000000..20804b1b19e
--- /dev/null
+++ b/core/Migrations/Version31000Date20240814184402.php
@@ -0,0 +1,39 @@
+<?php
+
+declare(strict_types=1);
+/**
+ * SPDX-FileCopyrightText: 2024 Nextcloud GmbH and Nextcloud contributors
+ * SPDX-License-Identifier: AGPL-3.0-or-later
+ */
+
+namespace OC\Core\Migrations;
+
+use Closure;
+use OCP\DB\ISchemaWrapper;
+use OCP\DB\Types;
+use OCP\Migration\Attributes\AddColumn;
+use OCP\Migration\Attributes\AddIndex;
+use OCP\Migration\Attributes\ColumnType;
+use OCP\Migration\Attributes\IndexType;
+use OCP\Migration\IOutput;
+use OCP\Migration\SimpleMigrationStep;
+
+/**
+ * Create new column and index for lazy loading in preferences for the new IUserPreferences API.
+ */
+#[AddColumn(table: 'preferences', name: 'lazy', type: ColumnType::SMALLINT, description: 'lazy loading to user preferences')]
+#[AddColumn(table: 'preferences', name: 'type', type: ColumnType::SMALLINT, description: 'typed values to user preferences')]
+#[AddIndex(table: 'preferences', type: IndexType::INDEX, description: 'new index including lazy flag')]
+class Version31000Date20240814184402 extends SimpleMigrationStep {
+	public function changeSchema(IOutput $output, Closure $schemaClosure, array $options): ?ISchemaWrapper {
+		/** @var ISchemaWrapper $schema */
+		$schema = $schemaClosure();
+
+		$table = $schema->getTable('preferences');
+		$table->addColumn('lazy', Types::SMALLINT, ['notnull' => true, 'default' => 0, 'length' => 1, 'unsigned' => true]);
+		$table->addColumn('type', Types::INTEGER, ['notnull' => true, 'default' => 2, 'unsigned' => true]);
+		$table->addIndex(['userid', 'lazy'], 'prefs_uid_lazy_i');
+
+		return $schema;
+	}
+}
diff --git a/lib/composer/composer/autoload_classmap.php b/lib/composer/composer/autoload_classmap.php
index 13fb25ab303..3e65291819b 100644
--- a/lib/composer/composer/autoload_classmap.php
+++ b/lib/composer/composer/autoload_classmap.php
@@ -839,6 +839,13 @@ return array(
     'OCP\\UserMigration\\ISizeEstimationMigrator' => $baseDir . '/lib/public/UserMigration/ISizeEstimationMigrator.php',
     'OCP\\UserMigration\\TMigratorBasicVersionHandling' => $baseDir . '/lib/public/UserMigration/TMigratorBasicVersionHandling.php',
     'OCP\\UserMigration\\UserMigrationException' => $baseDir . '/lib/public/UserMigration/UserMigrationException.php',
+    'OCP\\UserPreferences\\Exceptions\\IncorrectTypeException' => $baseDir . '/lib/public/UserPreferences/Exceptions/IncorrectTypeException.php',
+    'OCP\\UserPreferences\\Exceptions\\TypeConflictException' => $baseDir . '/lib/public/UserPreferences/Exceptions/TypeConflictException.php',
+    'OCP\\UserPreferences\\Exceptions\\UnknownKeyException' => $baseDir . '/lib/public/UserPreferences/Exceptions/UnknownKeyException.php',
+    'OCP\\UserPreferences\\Exceptions\\UserPreferencesException' => $baseDir . '/lib/public/UserPreferences/Exceptions/UserPreferencesException.php',
+    'OCP\\UserPreferences\\IUserPreferences' => $baseDir . '/lib/public/UserPreferences/IUserPreferences.php',
+    'OCP\\UserPreferences\\ValueType' => $baseDir . '/lib/public/UserPreferences/ValueType.php',
+    'OCP\\UserPreferences\\ValueTypeDefinition' => $baseDir . '/lib/public/UserPreferences/ValueTypeDefinition.php',
     'OCP\\UserStatus\\IManager' => $baseDir . '/lib/public/UserStatus/IManager.php',
     'OCP\\UserStatus\\IProvider' => $baseDir . '/lib/public/UserStatus/IProvider.php',
     'OCP\\UserStatus\\IUserStatus' => $baseDir . '/lib/public/UserStatus/IUserStatus.php',
@@ -1386,6 +1393,7 @@ return array(
     'OC\\Core\\Migrations\\Version30000Date20240814180800' => $baseDir . '/core/Migrations/Version30000Date20240814180800.php',
     'OC\\Core\\Migrations\\Version30000Date20240815080800' => $baseDir . '/core/Migrations/Version30000Date20240815080800.php',
     'OC\\Core\\Migrations\\Version30000Date20240906095113' => $baseDir . '/core/Migrations/Version30000Date20240906095113.php',
+    'OC\\Core\\Migrations\\Version31000Date20240814184402' => $baseDir . '/core/Migrations/Version31000Date20240814184402.php',
     'OC\\Core\\Migrations\\Version31000Date20241018063111' => $baseDir . '/core/Migrations/Version31000Date20241018063111.php',
     'OC\\Core\\Notification\\CoreNotifier' => $baseDir . '/core/Notification/CoreNotifier.php',
     'OC\\Core\\ResponseDefinitions' => $baseDir . '/core/ResponseDefinitions.php',
@@ -1997,6 +2005,7 @@ return array(
     'OC\\Updater\\Exceptions\\ReleaseMetadataException' => $baseDir . '/lib/private/Updater/Exceptions/ReleaseMetadataException.php',
     'OC\\Updater\\ReleaseMetadata' => $baseDir . '/lib/private/Updater/ReleaseMetadata.php',
     'OC\\Updater\\VersionCheck' => $baseDir . '/lib/private/Updater/VersionCheck.php',
+    'OC\\UserPreferences' => $baseDir . '/lib/private/UserPreferences.php',
     'OC\\UserStatus\\ISettableProvider' => $baseDir . '/lib/private/UserStatus/ISettableProvider.php',
     'OC\\UserStatus\\Manager' => $baseDir . '/lib/private/UserStatus/Manager.php',
     'OC\\User\\AvailabilityCoordinator' => $baseDir . '/lib/private/User/AvailabilityCoordinator.php',
diff --git a/lib/composer/composer/autoload_static.php b/lib/composer/composer/autoload_static.php
index 526782636fb..46e59b25846 100644
--- a/lib/composer/composer/autoload_static.php
+++ b/lib/composer/composer/autoload_static.php
@@ -880,6 +880,13 @@ class ComposerStaticInit749170dad3f5e7f9ca158f5a9f04f6a2
         'OCP\\UserMigration\\ISizeEstimationMigrator' => __DIR__ . '/../../..' . '/lib/public/UserMigration/ISizeEstimationMigrator.php',
         'OCP\\UserMigration\\TMigratorBasicVersionHandling' => __DIR__ . '/../../..' . '/lib/public/UserMigration/TMigratorBasicVersionHandling.php',
         'OCP\\UserMigration\\UserMigrationException' => __DIR__ . '/../../..' . '/lib/public/UserMigration/UserMigrationException.php',
+        'OCP\\UserPreferences\\Exceptions\\IncorrectTypeException' => __DIR__ . '/../../..' . '/lib/public/UserPreferences/Exceptions/IncorrectTypeException.php',
+        'OCP\\UserPreferences\\Exceptions\\TypeConflictException' => __DIR__ . '/../../..' . '/lib/public/UserPreferences/Exceptions/TypeConflictException.php',
+        'OCP\\UserPreferences\\Exceptions\\UnknownKeyException' => __DIR__ . '/../../..' . '/lib/public/UserPreferences/Exceptions/UnknownKeyException.php',
+        'OCP\\UserPreferences\\Exceptions\\UserPreferencesException' => __DIR__ . '/../../..' . '/lib/public/UserPreferences/Exceptions/UserPreferencesException.php',
+        'OCP\\UserPreferences\\IUserPreferences' => __DIR__ . '/../../..' . '/lib/public/UserPreferences/IUserPreferences.php',
+        'OCP\\UserPreferences\\ValueType' => __DIR__ . '/../../..' . '/lib/public/UserPreferences/ValueType.php',
+        'OCP\\UserPreferences\\ValueTypeDefinition' => __DIR__ . '/../../..' . '/lib/public/UserPreferences/ValueTypeDefinition.php',
         'OCP\\UserStatus\\IManager' => __DIR__ . '/../../..' . '/lib/public/UserStatus/IManager.php',
         'OCP\\UserStatus\\IProvider' => __DIR__ . '/../../..' . '/lib/public/UserStatus/IProvider.php',
         'OCP\\UserStatus\\IUserStatus' => __DIR__ . '/../../..' . '/lib/public/UserStatus/IUserStatus.php',
@@ -1427,6 +1434,7 @@ class ComposerStaticInit749170dad3f5e7f9ca158f5a9f04f6a2
         'OC\\Core\\Migrations\\Version30000Date20240814180800' => __DIR__ . '/../../..' . '/core/Migrations/Version30000Date20240814180800.php',
         'OC\\Core\\Migrations\\Version30000Date20240815080800' => __DIR__ . '/../../..' . '/core/Migrations/Version30000Date20240815080800.php',
         'OC\\Core\\Migrations\\Version30000Date20240906095113' => __DIR__ . '/../../..' . '/core/Migrations/Version30000Date20240906095113.php',
+        'OC\\Core\\Migrations\\Version31000Date20240814184402' => __DIR__ . '/../../..' . '/core/Migrations/Version31000Date20240814184402.php',
         'OC\\Core\\Migrations\\Version31000Date20241018063111' => __DIR__ . '/../../..' . '/core/Migrations/Version31000Date20241018063111.php',
         'OC\\Core\\Notification\\CoreNotifier' => __DIR__ . '/../../..' . '/core/Notification/CoreNotifier.php',
         'OC\\Core\\ResponseDefinitions' => __DIR__ . '/../../..' . '/core/ResponseDefinitions.php',
@@ -2038,6 +2046,7 @@ class ComposerStaticInit749170dad3f5e7f9ca158f5a9f04f6a2
         'OC\\Updater\\Exceptions\\ReleaseMetadataException' => __DIR__ . '/../../..' . '/lib/private/Updater/Exceptions/ReleaseMetadataException.php',
         'OC\\Updater\\ReleaseMetadata' => __DIR__ . '/../../..' . '/lib/private/Updater/ReleaseMetadata.php',
         'OC\\Updater\\VersionCheck' => __DIR__ . '/../../..' . '/lib/private/Updater/VersionCheck.php',
+        'OC\\UserPreferences' => __DIR__ . '/../../..' . '/lib/private/UserPreferences.php',
         'OC\\UserStatus\\ISettableProvider' => __DIR__ . '/../../..' . '/lib/private/UserStatus/ISettableProvider.php',
         'OC\\UserStatus\\Manager' => __DIR__ . '/../../..' . '/lib/private/UserStatus/Manager.php',
         'OC\\User\\AvailabilityCoordinator' => __DIR__ . '/../../..' . '/lib/private/User/AvailabilityCoordinator.php',
diff --git a/lib/private/AllConfig.php b/lib/private/AllConfig.php
index 46b53e3c1b2..bc54ea1e6af 100644
--- a/lib/private/AllConfig.php
+++ b/lib/private/AllConfig.php
@@ -7,10 +7,12 @@
 namespace OC;
 
 use OCP\Cache\CappedMemoryCache;
-use OCP\DB\QueryBuilder\IQueryBuilder;
 use OCP\IConfig;
 use OCP\IDBConnection;
 use OCP\PreConditionNotMetException;
+use OCP\UserPreferences\Exceptions\TypeConflictException;
+use OCP\UserPreferences\IUserPreferences;
+use OCP\UserPreferences\ValueType;
 
 /**
  * Class to combine all the configuration options ownCloud offers
@@ -226,62 +228,25 @@ class AllConfig implements IConfig {
 	 * @param string $preCondition only update if the config value was previously the value passed as $preCondition
 	 * @throws \OCP\PreConditionNotMetException if a precondition is specified and is not met
 	 * @throws \UnexpectedValueException when trying to store an unexpected value
+	 * @deprecated 31.0.0 - use {@see IUserPreferences} directly
 	 */
 	public function setUserValue($userId, $appName, $key, $value, $preCondition = null) {
 		if (!is_int($value) && !is_float($value) && !is_string($value)) {
 			throw new \UnexpectedValueException('Only integers, floats and strings are allowed as value');
 		}
 
-		// TODO - FIXME
-		$this->fixDIInit();
-
-		if ($appName === 'settings' && $key === 'email') {
-			$value = strtolower((string)$value);
-		}
-
-		$prevValue = $this->getUserValue($userId, $appName, $key, null);
-
-		if ($prevValue !== null) {
-			if ($preCondition !== null && $prevValue !== (string)$preCondition) {
-				throw new PreConditionNotMetException();
-			} elseif ($prevValue === (string)$value) {
-				return;
-			} else {
-				$qb = $this->connection->getQueryBuilder();
-				$qb->update('preferences')
-					->set('configvalue', $qb->createNamedParameter($value))
-					->where($qb->expr()->eq('userid', $qb->createNamedParameter($userId)))
-					->andWhere($qb->expr()->eq('appid', $qb->createNamedParameter($appName)))
-					->andWhere($qb->expr()->eq('configkey', $qb->createNamedParameter($key)));
-				$qb->executeStatement();
-
-				$this->userCache[$userId][$appName][$key] = (string)$value;
-				return;
+		/** @var UserPreferences $userPreferences */
+		$userPreferences = \OC::$server->get(IUserPreferences::class);
+		if ($preCondition !== null) {
+			try {
+				if ($userPreferences->getValueMixed($userId, $appName, $key) !== (string)$preCondition) {
+					throw new PreConditionNotMetException();
+				}
+			} catch (TypeConflictException) {
 			}
 		}
 
-		$preconditionArray = [];
-		if (isset($preCondition)) {
-			$preconditionArray = [
-				'configvalue' => $preCondition,
-			];
-		}
-
-		$this->connection->setValues('preferences', [
-			'userid' => $userId,
-			'appid' => $appName,
-			'configkey' => $key,
-		], [
-			'configvalue' => $value,
-		], $preconditionArray);
-
-		// only add to the cache if we already loaded data for the user
-		if (isset($this->userCache[$userId])) {
-			if (!isset($this->userCache[$userId][$appName])) {
-				$this->userCache[$userId][$appName] = [];
-			}
-			$this->userCache[$userId][$appName][$key] = (string)$value;
-		}
+		$userPreferences->setValueMixed($userId, $appName, $key, (string)$value);
 	}
 
 	/**
@@ -292,14 +257,19 @@ class AllConfig implements IConfig {
 	 * @param string $key the key under which the value is being stored
 	 * @param mixed $default the default value to be returned if the value isn't set
 	 * @return string
+	 * @deprecated 31.0.0 - use {@see IUserPreferences} directly
 	 */
 	public function getUserValue($userId, $appName, $key, $default = '') {
-		$data = $this->getAllUserValues($userId);
-		if (isset($data[$appName][$key])) {
-			return $data[$appName][$key];
-		} else {
+		if ($userId === null || $userId === '') {
 			return $default;
 		}
+		/** @var UserPreferences $userPreferences */
+		$userPreferences = \OC::$server->get(IUserPreferences::class);
+		// because $default can be null ...
+		if (!$userPreferences->hasKey($userId, $appName, $key)) {
+			return $default;
+		}
+		return $userPreferences->getValueMixed($userId, $appName, $key, $default ?? '');
 	}
 
 	/**
@@ -308,14 +278,10 @@ class AllConfig implements IConfig {
 	 * @param string $userId the userId of the user that we want to store the value under
 	 * @param string $appName the appName that we stored the value under
 	 * @return string[]
+	 * @deprecated 31.0.0 - use {@see IUserPreferences} directly
 	 */
 	public function getUserKeys($userId, $appName) {
-		$data = $this->getAllUserValues($userId);
-		if (isset($data[$appName])) {
-			return array_map('strval', array_keys($data[$appName]));
-		} else {
-			return [];
-		}
+		return \OC::$server->get(IUserPreferences::class)->getKeys($userId, $appName);
 	}
 
 	/**
@@ -324,56 +290,33 @@ class AllConfig implements IConfig {
 	 * @param string $userId the userId of the user that we want to store the value under
 	 * @param string $appName the appName that we stored the value under
 	 * @param string $key the key under which the value is being stored
+	 * @deprecated 31.0.0 - use {@see IUserPreferences} directly
 	 */
 	public function deleteUserValue($userId, $appName, $key) {
-		// TODO - FIXME
-		$this->fixDIInit();
-
-		$qb = $this->connection->getQueryBuilder();
-		$qb->delete('preferences')
-			->where($qb->expr()->eq('userid', $qb->createNamedParameter($userId, IQueryBuilder::PARAM_STR)))
-			->andWhere($qb->expr()->eq('appid', $qb->createNamedParameter($appName, IQueryBuilder::PARAM_STR)))
-			->andWhere($qb->expr()->eq('configkey', $qb->createNamedParameter($key, IQueryBuilder::PARAM_STR)))
-			->executeStatement();
-
-		if (isset($this->userCache[$userId][$appName])) {
-			unset($this->userCache[$userId][$appName][$key]);
-		}
+		\OC::$server->get(IUserPreferences::class)->deletePreference($userId, $appName, $key);
 	}
 
 	/**
 	 * Delete all user values
 	 *
 	 * @param string $userId the userId of the user that we want to remove all values from
+	 * @deprecated 31.0.0 - use {@see IUserPreferences} directly
 	 */
 	public function deleteAllUserValues($userId) {
-		// TODO - FIXME
-		$this->fixDIInit();
-		$qb = $this->connection->getQueryBuilder();
-		$qb->delete('preferences')
-			->where($qb->expr()->eq('userid', $qb->createNamedParameter($userId, IQueryBuilder::PARAM_STR)))
-			->executeStatement();
-
-		unset($this->userCache[$userId]);
+		if ($userId === null) {
+			return;
+		}
+		\OC::$server->get(IUserPreferences::class)->deleteAllPreferences($userId);
 	}
 
 	/**
 	 * Delete all user related values of one app
 	 *
 	 * @param string $appName the appName of the app that we want to remove all values from
+	 * @deprecated 31.0.0 - use {@see IUserPreferences} directly
 	 */
 	public function deleteAppFromAllUsers($appName) {
-		// TODO - FIXME
-		$this->fixDIInit();
-
-		$qb = $this->connection->getQueryBuilder();
-		$qb->delete('preferences')
-			->where($qb->expr()->eq('appid', $qb->createNamedParameter($appName, IQueryBuilder::PARAM_STR)))
-			->executeStatement();
-
-		foreach ($this->userCache as &$userCache) {
-			unset($userCache[$appName]);
-		}
+		\OC::$server->get(IUserPreferences::class)->deleteApp($appName);
 	}
 
 	/**
@@ -385,35 +328,21 @@ class AllConfig implements IConfig {
 	 *                 [ $appId =>
 	 *                 [ $key => $value ]
 	 *                 ]
+	 * @deprecated 31.0.0 - use {@see IUserPreferences} directly
 	 */
 	public function getAllUserValues(?string $userId): array {
-		if (isset($this->userCache[$userId])) {
-			return $this->userCache[$userId];
-		}
 		if ($userId === null || $userId === '') {
-			$this->userCache[''] = [];
-			return $this->userCache[''];
+			return [];
 		}
 
-		// TODO - FIXME
-		$this->fixDIInit();
-
-		$data = [];
-
-		$qb = $this->connection->getQueryBuilder();
-		$result = $qb->select('appid', 'configkey', 'configvalue')
-			->from('preferences')
-			->where($qb->expr()->eq('userid', $qb->createNamedParameter($userId, IQueryBuilder::PARAM_STR)))
-			->executeQuery();
-		while ($row = $result->fetch()) {
-			$appId = $row['appid'];
-			if (!isset($data[$appId])) {
-				$data[$appId] = [];
+		$values = \OC::$server->get(IUserPreferences::class)->getAllValues($userId);
+		$result = [];
+		foreach ($values as $app => $list) {
+			foreach ($list as $key => $value) {
+				$result[$app][$key] = (string)$value;
 			}
-			$data[$appId][$row['configkey']] = $row['configvalue'];
 		}
-		$this->userCache[$userId] = $data;
-		return $data;
+		return $result;
 	}
 
 	/**
@@ -423,37 +352,10 @@ class AllConfig implements IConfig {
 	 * @param string $key the key to get the value for
 	 * @param array $userIds the user IDs to fetch the values for
 	 * @return array Mapped values: userId => value
+	 * @deprecated 31.0.0 - use {@see IUserPreferences} directly
 	 */
 	public function getUserValueForUsers($appName, $key, $userIds) {
-		// TODO - FIXME
-		$this->fixDIInit();
-
-		if (empty($userIds) || !is_array($userIds)) {
-			return [];
-		}
-
-		$chunkedUsers = array_chunk($userIds, 50, true);
-
-		$qb = $this->connection->getQueryBuilder();
-		$qb->select('userid', 'configvalue')
-			->from('preferences')
-			->where($qb->expr()->eq('appid', $qb->createParameter('appName')))
-			->andWhere($qb->expr()->eq('configkey', $qb->createParameter('configKey')))
-			->andWhere($qb->expr()->in('userid', $qb->createParameter('userIds')));
-
-		$userValues = [];
-		foreach ($chunkedUsers as $chunk) {
-			$qb->setParameter('appName', $appName, IQueryBuilder::PARAM_STR);
-			$qb->setParameter('configKey', $key, IQueryBuilder::PARAM_STR);
-			$qb->setParameter('userIds', $chunk, IQueryBuilder::PARAM_STR_ARRAY);
-			$result = $qb->executeQuery();
-
-			while ($row = $result->fetch()) {
-				$userValues[$row['userid']] = $row['configvalue'];
-			}
-		}
-
-		return $userValues;
+		return \OC::$server->get(IUserPreferences::class)->searchValuesByUsers($appName, $key, ValueType::MIXED, $userIds);
 	}
 
 	/**
@@ -463,31 +365,10 @@ class AllConfig implements IConfig {
 	 * @param string $key the key to get the user for
 	 * @param string $value the value to get the user for
 	 * @return list<string> of user IDs
+	 * @deprecated 31.0.0 - use {@see IUserPreferences} directly
 	 */
 	public function getUsersForUserValue($appName, $key, $value) {
-		// TODO - FIXME
-		$this->fixDIInit();
-
-		$qb = $this->connection->getQueryBuilder();
-		$configValueColumn = ($this->connection->getDatabaseProvider() === IDBConnection::PLATFORM_ORACLE)
-			? $qb->expr()->castColumn('configvalue', IQueryBuilder::PARAM_STR)
-			: 'configvalue';
-		$result = $qb->select('userid')
-			->from('preferences')
-			->where($qb->expr()->eq('appid', $qb->createNamedParameter($appName, IQueryBuilder::PARAM_STR)))
-			->andWhere($qb->expr()->eq('configkey', $qb->createNamedParameter($key, IQueryBuilder::PARAM_STR)))
-			->andWhere($qb->expr()->eq(
-				$configValueColumn,
-				$qb->createNamedParameter($value, IQueryBuilder::PARAM_STR))
-			)->orderBy('userid')
-			->executeQuery();
-
-		$userIDs = [];
-		while ($row = $result->fetch()) {
-			$userIDs[] = $row['userid'];
-		}
-
-		return $userIDs;
+		return \OC::$server->get(IUserPreferences::class)->searchUsersByValueString($appName, $key, $value);
 	}
 
 	/**
@@ -497,37 +378,14 @@ class AllConfig implements IConfig {
 	 * @param string $key the key to get the user for
 	 * @param string $value the value to get the user for
 	 * @return list<string> of user IDs
+	 * @deprecated 31.0.0 - use {@see IUserPreferences} directly
 	 */
 	public function getUsersForUserValueCaseInsensitive($appName, $key, $value) {
-		// TODO - FIXME
-		$this->fixDIInit();
-
 		if ($appName === 'settings' && $key === 'email') {
-			// Email address is always stored lowercase in the database
 			return $this->getUsersForUserValue($appName, $key, strtolower($value));
 		}
 
-		$qb = $this->connection->getQueryBuilder();
-		$configValueColumn = ($this->connection->getDatabaseProvider() === IDBConnection::PLATFORM_ORACLE)
-			? $qb->expr()->castColumn('configvalue', IQueryBuilder::PARAM_STR)
-			: 'configvalue';
-
-		$result = $qb->select('userid')
-			->from('preferences')
-			->where($qb->expr()->eq('appid', $qb->createNamedParameter($appName, IQueryBuilder::PARAM_STR)))
-			->andWhere($qb->expr()->eq('configkey', $qb->createNamedParameter($key, IQueryBuilder::PARAM_STR)))
-			->andWhere($qb->expr()->eq(
-				$qb->func()->lower($configValueColumn),
-				$qb->createNamedParameter(strtolower($value), IQueryBuilder::PARAM_STR))
-			)->orderBy('userid')
-			->executeQuery();
-
-		$userIDs = [];
-		while ($row = $result->fetch()) {
-			$userIDs[] = $row['userid'];
-		}
-
-		return $userIDs;
+		return \OC::$server->get(IUserPreferences::class)->searchUsersByValueString($appName, $key, $value, true);
 	}
 
 	public function getSystemConfig() {
diff --git a/lib/private/Server.php b/lib/private/Server.php
index 27a5f2662f8..10d6dee9d07 100644
--- a/lib/private/Server.php
+++ b/lib/private/Server.php
@@ -237,6 +237,7 @@ use OCP\User\Events\UserLoggedInEvent;
 use OCP\User\Events\UserLoggedInWithCookieEvent;
 use OCP\User\Events\UserLoggedOutEvent;
 use OCP\User\IAvailabilityCoordinator;
+use OCP\UserPreferences\IUserPreferences;
 use Psr\Container\ContainerExceptionInterface;
 use Psr\Container\ContainerInterface;
 use Psr\Log\LoggerInterface;
@@ -567,6 +568,7 @@ class Server extends ServerContainer implements IServerContainer {
 		});
 
 		$this->registerAlias(IAppConfig::class, \OC\AppConfig::class);
+		$this->registerAlias(IUserPreferences::class, \OC\UserPreferences::class);
 
 		$this->registerService(IFactory::class, function (Server $c) {
 			return new \OC\L10N\Factory(
diff --git a/lib/private/UserPreferences.php b/lib/private/UserPreferences.php
new file mode 100644
index 00000000000..a5426e5d247
--- /dev/null
+++ b/lib/private/UserPreferences.php
@@ -0,0 +1,1675 @@
+<?php
+
+declare(strict_types=1);
+/**
+ * SPDX-FileCopyrightText: 2024 Nextcloud GmbH and Nextcloud contributors
+ * SPDX-License-Identifier: AGPL-3.0-or-later
+ */
+
+namespace OC;
+
+use InvalidArgumentException;
+use JsonException;
+use OCP\DB\Exception as DBException;
+use OCP\DB\IResult;
+use OCP\DB\QueryBuilder\IQueryBuilder;
+use OCP\IConfig;
+use OCP\IDBConnection;
+use OCP\Security\ICrypto;
+use OCP\UserPreferences\Exceptions\IncorrectTypeException;
+use OCP\UserPreferences\Exceptions\TypeConflictException;
+use OCP\UserPreferences\Exceptions\UnknownKeyException;
+use OCP\UserPreferences\IUserPreferences;
+use OCP\UserPreferences\ValueType;
+use Psr\Log\LoggerInterface;
+use ValueError;
+
+/**
+ * This class provides an easy way for apps to store user preferences in the
+ * database.
+ * Supports **lazy loading**
+ *
+ * ### What is lazy loading ?
+ * In order to avoid loading useless user preferences into memory for each request,
+ * only non-lazy values are now loaded.
+ *
+ * Once a value that is lazy is requested, all lazy values will be loaded.
+ *
+ * Similarly, some methods from this class are marked with a warning about ignoring
+ * lazy loading. Use them wisely and only on parts of the code that are called
+ * during specific requests or actions to avoid loading the lazy values all the time.
+ *
+ * @since 31.0.0
+ */
+class UserPreferences implements IUserPreferences {
+	private const USER_MAX_LENGTH = 64;
+	private const APP_MAX_LENGTH = 32;
+	private const KEY_MAX_LENGTH = 64;
+	private const ENCRYPTION_PREFIX = '$UserPreferencesEncryption$';
+	private const ENCRYPTION_PREFIX_LENGTH = 27; // strlen(self::ENCRYPTION_PREFIX)
+
+	/** @var array<string, array<string, array<string, mixed>>> ['user_id' => ['app_id' => ['key' => 'value']]] */
+	private array $fastCache = [];   // cache for normal preference keys
+	/** @var array<string, array<string, array<string, mixed>>> ['user_id' => ['app_id' => ['key' => 'value']]] */
+	private array $lazyCache = [];   // cache for lazy preference keys
+	/** @var array<string, array<string, array<string, int>>> ['user_id' => ['app_id' => ['key' => bitflag]]] */
+	private array $valueTypes = [];  // type for all preference values
+	/** @var array<string, boolean> ['user_id' => bool] */
+	private array $fastLoaded = [];
+	/** @var array<string, boolean> ['user_id' => bool] */
+	private array $lazyLoaded = [];
+
+	public function __construct(
+		protected IDBConnection $connection,
+		protected LoggerInterface $logger,
+		protected ICrypto $crypto,
+	) {
+	}
+
+	/**
+	 * @inheritDoc
+	 *
+	 * @param string $appId optional id of app
+	 *
+	 * @return list<string> list of userIds
+	 * @since 31.0.0
+	 */
+	public function getUserIds(string $appId = ''): array {
+		$this->assertParams(app: $appId, allowEmptyUser: true, allowEmptyApp: true);
+
+		$qb = $this->connection->getQueryBuilder();
+		$qb->from('preferences');
+		$qb->select('userid');
+		$qb->groupBy('userid');
+		if ($appId !== '') {
+			$qb->where($qb->expr()->eq('appid', $qb->createNamedParameter($appId)));
+		}
+
+		$result = $qb->executeQuery();
+		$rows = $result->fetchAll();
+		$userIds = [];
+		foreach ($rows as $row) {
+			$userIds[] = $row['userid'];
+		}
+
+		return $userIds;
+	}
+
+	/**
+	 * @inheritDoc
+	 *
+	 * @return list<string> list of app ids
+	 * @since 31.0.0
+	 */
+	public function getApps(string $userId): array {
+		$this->assertParams($userId, allowEmptyApp: true);
+		$this->loadPreferencesAll($userId);
+		$apps = array_merge(array_keys($this->fastCache[$userId] ?? []), array_keys($this->lazyCache[$userId] ?? []));
+		sort($apps);
+
+		return array_values(array_unique($apps));
+	}
+
+	/**
+	 * @inheritDoc
+	 *
+	 * @param string $userId id of the user
+	 * @param string $app id of the app
+	 *
+	 * @return list<string> list of stored preference keys
+	 * @since 31.0.0
+	 */
+	public function getKeys(string $userId, string $app): array {
+		$this->assertParams($userId, $app);
+		$this->loadPreferencesAll($userId);
+		// array_merge() will remove numeric keys (here preference keys), so addition arrays instead
+		$keys = array_map('strval', array_keys(($this->fastCache[$userId][$app] ?? []) + ($this->lazyCache[$userId][$app] ?? [])));
+		sort($keys);
+
+		return array_values(array_unique($keys));
+	}
+
+	/**
+	 * @inheritDoc
+	 *
+	 * @param string $userId id of the user
+	 * @param string $app id of the app
+	 * @param string $key preference key
+	 * @param bool|null $lazy TRUE to search within lazy loaded preferences, NULL to search within all preferences
+	 *
+	 * @return bool TRUE if key exists
+	 * @since 31.0.0
+	 */
+	public function hasKey(string $userId, string $app, string $key, ?bool $lazy = false): bool {
+		$this->assertParams($userId, $app, $key);
+		$this->loadPreferences($userId, $lazy);
+
+		if ($lazy === null) {
+			$appCache = $this->getValues($userId, $app);
+			return isset($appCache[$key]);
+		}
+
+		if ($lazy) {
+			return isset($this->lazyCache[$userId][$app][$key]);
+		}
+
+		return isset($this->fastCache[$userId][$app][$key]);
+	}
+
+	/**
+	 * @param string $userId id of the user
+	 * @param string $app id of the app
+	 * @param string $key preference key
+	 * @param bool|null $lazy TRUE to search within lazy loaded preferences, NULL to search within all preferences
+	 *
+	 * @return bool
+	 * @throws UnknownKeyException if preference key is not known
+	 * @since 29.0.0
+	 */
+	public function isSensitive(string $userId, string $app, string $key, ?bool $lazy = false): bool {
+		$this->assertParams($userId, $app, $key);
+		$this->loadPreferences($userId, $lazy);
+
+		if (!isset($this->valueTypes[$userId][$app][$key])) {
+			throw new UnknownKeyException('unknown preference key');
+		}
+
+		return $this->isTyped(ValueType::SENSITIVE, $this->valueTypes[$userId][$app][$key]);
+	}
+
+	/**
+	 * @inheritDoc
+	 *
+	 * @param string $userId id of the user
+	 * @param string $app if of the app
+	 * @param string $key preference key
+	 *
+	 * @return bool TRUE if preference is lazy loaded
+	 * @throws UnknownKeyException if preference key is not known
+	 * @see IUserPreferences for details about lazy loading
+	 * @since 29.0.0
+	 */
+	public function isLazy(string $userId, string $app, string $key): bool {
+		// there is a huge probability the non-lazy preferences are already loaded
+		if ($this->hasKey($userId, $app, $key, false)) {
+			return false;
+		}
+
+		// key not found, we search in the lazy preferences
+		if ($this->hasKey($userId, $app, $key, true)) {
+			return true;
+		}
+
+		throw new UnknownKeyException('unknown preference key');
+	}
+
+	/**
+	 * @inheritDoc
+	 *
+	 * @param string $userId id of the user
+	 * @param string $app id of the app
+	 * @param string $prefix preference keys prefix to search
+	 * @param bool $filtered TRUE to hide sensitive preference values. Value are replaced by {@see IConfig::SENSITIVE_VALUE}
+	 *
+	 * @return array<string, string|int|float|bool|array> [key => value]
+	 * @since 31.0.0
+	 */
+	public function getValues(
+		string $userId,
+		string $app,
+		string $prefix = '',
+		bool $filtered = false,
+	): array {
+		$this->assertParams($userId, $app, $prefix);
+		// if we want to filter values, we need to get sensitivity
+		$this->loadPreferencesAll($userId);
+		// array_merge() will remove numeric keys (here preference keys), so addition arrays instead
+		$values = array_filter(
+			$this->formatAppValues($userId, $app, ($this->fastCache[$userId][$app] ?? []) + ($this->lazyCache[$userId][$app] ?? []), $filtered),
+			function (string $key) use ($prefix): bool {
+				return str_starts_with($key, $prefix); // filter values based on $prefix
+			}, ARRAY_FILTER_USE_KEY
+		);
+
+		return $values;
+	}
+
+	/**
+	 * @inheritDoc
+	 *
+	 * @param string $userId id of the user
+	 * @param bool $filtered TRUE to hide sensitive preference values. Value are replaced by {@see IConfig::SENSITIVE_VALUE}
+	 *
+	 * @return array<string, array<string, string|int|float|bool|array>> [appId => [key => value]]
+	 * @since 31.0.0
+	 */
+	public function getAllValues(string $userId, bool $filtered = false): array {
+		$this->assertParams($userId, allowEmptyApp: true);
+		$this->loadPreferencesAll($userId);
+
+		$result = [];
+		foreach ($this->getApps($userId) as $app) {
+			// array_merge() will remove numeric keys (here preference keys), so addition arrays instead
+			$cached = ($this->fastCache[$userId][$app] ?? []) + ($this->lazyCache[$userId][$app] ?? []);
+			$result[$app] = $this->formatAppValues($userId, $app, $cached, $filtered);
+		}
+
+		return $result;
+	}
+
+	/**
+	 * @inheritDoc
+	 *
+	 * @param string $userId id of the user
+	 * @param string $key preference key
+	 * @param bool $lazy search within lazy loaded preferences
+	 * @param ValueType|null $typedAs enforce type for the returned values
+	 *
+	 * @return array<string, string|int|float|bool|array> [appId => value]
+	 * @since 31.0.0
+	 */
+	public function searchValuesByApps(string $userId, string $key, bool $lazy = false, ?ValueType $typedAs = null): array {
+		$this->assertParams($userId, '', $key, allowEmptyApp: true);
+		$this->loadPreferences($userId, $lazy);
+
+		/** @var array<array-key, array<array-key, mixed>> $cache */
+		if ($lazy) {
+			$cache = $this->lazyCache[$userId];
+		} else {
+			$cache = $this->fastCache[$userId];
+		}
+
+		$values = [];
+		foreach (array_keys($cache) as $app) {
+			if (isset($cache[$app][$key])) {
+				$value = $cache[$app][$key];
+				try {
+					$this->decryptSensitiveValue($userId, $app, $key, $value);
+					$value = $this->convertTypedValue($value, $typedAs ?? $this->getValueType($userId, $app, $key, $lazy));
+				} catch (IncorrectTypeException|UnknownKeyException) {
+				}
+				$values[$app] = $value;
+			}
+		}
+
+		return $values;
+	}
+
+
+	/**
+	 * @inheritDoc
+	 *
+	 * @param string $app id of the app
+	 * @param string $key preference key
+	 * @param ValueType|null $typedAs enforce type for the returned values
+	 * @param array|null $userIds limit to a list of user ids
+	 *
+	 * @return array<string, string|int|float|bool|array> [userId => value]
+	 * @since 31.0.0
+	 */
+	public function searchValuesByUsers(
+		string $app,
+		string $key,
+		?ValueType $typedAs = null,
+		?array $userIds = null,
+	): array {
+		$this->assertParams('', $app, $key, allowEmptyUser: true);
+
+		$qb = $this->connection->getQueryBuilder();
+		$qb->select('userid', 'configvalue', 'type')
+			->from('preferences')
+			->where($qb->expr()->eq('appid', $qb->createNamedParameter($app)))
+			->andWhere($qb->expr()->eq('configkey', $qb->createNamedParameter($key)));
+
+		$values = [];
+		// this nested function will execute current Query and store result within $values.
+		$executeAndStoreValue = function (IQueryBuilder $qb) use (&$values, $typedAs): IResult {
+			$result = $qb->executeQuery();
+			while ($row = $result->fetch()) {
+				$value = $row['configvalue'];
+				try {
+					$value = $this->convertTypedValue($value, $typedAs ?? $this->extractValueType($row['type']));
+				} catch (IncorrectTypeException) {
+				}
+				$values[$row['userid']] = $value;
+			}
+			return $result;
+		};
+
+		// if no userIds to filter, we execute query as it is and returns all values ...
+		if ($userIds === null) {
+			$result = $executeAndStoreValue($qb);
+			$result->closeCursor();
+			return $values;
+		}
+
+		// if userIds to filter, we chunk the list and execute the same query multiple times until we get all values
+		$result = null;
+		$qb->andWhere($qb->expr()->in('userid', $qb->createParameter('userIds')));
+		foreach (array_chunk($userIds, 50, true) as $chunk) {
+			$qb->setParameter('userIds', $chunk, IQueryBuilder::PARAM_STR_ARRAY);
+			$result = $executeAndStoreValue($qb);
+		}
+		$result?->closeCursor();
+
+		return $values;
+	}
+
+	/**
+	 * @inheritDoc
+	 *
+	 * @param string $app id of the app
+	 * @param string $key preference key
+	 * @param string $value preference value
+	 * @param bool $caseInsensitive non-case-sensitive search, only works if $value is a string
+	 *
+	 * @return list<string>
+	 * @since 31.0.0
+	 */
+	public function searchUsersByValueString(string $app, string $key, string $value, bool $caseInsensitive = false): array {
+		return $this->searchUsersByTypedValue($app, $key, $value, $caseInsensitive);
+	}
+
+	/**
+	 * @inheritDoc
+	 *
+	 * @param string $app id of the app
+	 * @param string $key preference key
+	 * @param int $value preference value
+	 *
+	 * @return list<string>
+	 * @since 31.0.0
+	 */
+	public function searchUsersByValueInt(string $app, string $key, int $value): array {
+		return $this->searchUsersByValueString($app, $key, (string)$value);
+	}
+
+	/**
+	 * @inheritDoc
+	 *
+	 * @param string $app id of the app
+	 * @param string $key preference key
+	 * @param array $values list of preference values
+	 *
+	 * @return list<string>
+	 * @since 31.0.0
+	 */
+	public function searchUsersByValues(string $app, string $key, array $values): array {
+		return $this->searchUsersByTypedValue($app, $key, $values);
+	}
+
+	/**
+	 * @inheritDoc
+	 *
+	 * @param string $app id of the app
+	 * @param string $key preference key
+	 * @param bool $value preference value
+	 *
+	 * @return list<string>
+	 * @since 31.0.0
+	 */
+	public function searchUsersByValueBool(string $app, string $key, bool $value): array {
+		$values = ['0', 'off', 'false', 'no'];
+		if ($value) {
+			$values = ['1', 'on', 'true', 'yes'];
+		}
+		return $this->searchUsersByValues($app, $key, $values);
+	}
+
+	/**
+	 * returns a list of users with preference key set to a specific value, or within the list of
+	 * possible values
+	 *
+	 * @param string $app
+	 * @param string $key
+	 * @param string|array $value
+	 * @param bool $caseInsensitive
+	 *
+	 * @return list<string>
+	 */
+	private function searchUsersByTypedValue(string $app, string $key, string|array $value, bool $caseInsensitive = false): array {
+		$this->assertParams('', $app, $key, allowEmptyUser: true);
+
+		$qb = $this->connection->getQueryBuilder();
+		$qb->from('preferences');
+		$qb->select('userid');
+		$qb->where($qb->expr()->eq('appid', $qb->createNamedParameter($app)));
+		$qb->andWhere($qb->expr()->eq('configkey', $qb->createNamedParameter($key)));
+
+		$configValueColumn = ($this->connection->getDatabaseProvider() === IDBConnection::PLATFORM_ORACLE) ? $qb->expr()->castColumn('configvalue', IQueryBuilder::PARAM_STR) : 'configvalue';
+		if (is_array($value)) {
+			$qb->andWhere($qb->expr()->in($configValueColumn, $qb->createNamedParameter($value, IQueryBuilder::PARAM_STR_ARRAY)));
+		} else {
+			if ($caseInsensitive) {
+				$qb->andWhere($qb->expr()->eq(
+					$qb->func()->lower($configValueColumn),
+					$qb->createNamedParameter(strtolower($value)))
+				);
+			} else {
+				$qb->andWhere($qb->expr()->eq($configValueColumn, $qb->createNamedParameter($value)));
+			}
+		}
+
+		$userIds = [];
+		$result = $qb->executeQuery();
+		$rows = $result->fetchAll();
+		foreach ($rows as $row) {
+			$userIds[] = $row['userid'];
+		}
+
+		return $userIds;
+	}
+
+	/**
+	 * Get the preference value as string.
+	 * If the value does not exist the given default will be returned.
+	 *
+	 * Set lazy to `null` to ignore it and get the value from either source.
+	 *
+	 * **WARNING:** Method is internal and **SHOULD** not be used, as it is better to get the value with a type.
+	 *
+	 * @param string $userId id of the user
+	 * @param string $app id of the app
+	 * @param string $key preference key
+	 * @param string $default preference value
+	 * @param null|bool $lazy get preference as lazy loaded or not. can be NULL
+	 *
+	 * @return string the value or $default
+	 * @throws TypeConflictException
+	 * @internal
+	 * @since 31.0.0
+	 * @see IUserPreferences for explanation about lazy loading
+	 * @see getValueString()
+	 * @see getValueInt()
+	 * @see getValueFloat()
+	 * @see getValueBool()
+	 * @see getValueArray()
+	 */
+	public function getValueMixed(
+		string $userId,
+		string $app,
+		string $key,
+		string $default = '',
+		?bool $lazy = false,
+	): string {
+		try {
+			$lazy = ($lazy === null) ? $this->isLazy($userId, $app, $key) : $lazy;
+		} catch (UnknownKeyException) {
+			return $default;
+		}
+
+		return $this->getTypedValue(
+			$userId,
+			$app,
+			$key,
+			$default,
+			$lazy,
+			ValueType::MIXED
+		);
+	}
+
+	/**
+	 * @inheritDoc
+	 *
+	 * @param string $userId id of the user
+	 * @param string $app id of the app
+	 * @param string $key preference key
+	 * @param string $default default value
+	 * @param bool $lazy search within lazy loaded preferences
+	 *
+	 * @return string stored preference value or $default if not set in database
+	 * @throws InvalidArgumentException if one of the argument format is invalid
+	 * @throws TypeConflictException in case of conflict with the value type set in database
+	 * @since 31.0.0
+	 * @see IUserPreferences for explanation about lazy loading
+	 */
+	public function getValueString(
+		string $userId,
+		string $app,
+		string $key,
+		string $default = '',
+		bool $lazy = false,
+	): string {
+		return $this->getTypedValue($userId, $app, $key, $default, $lazy, ValueType::STRING);
+	}
+
+	/**
+	 * @inheritDoc
+	 *
+	 * @param string $userId id of the user
+	 * @param string $app id of the app
+	 * @param string $key preference key
+	 * @param int $default default value
+	 * @param bool $lazy search within lazy loaded preferences
+	 *
+	 * @return int stored preference value or $default if not set in database
+	 * @throws InvalidArgumentException if one of the argument format is invalid
+	 * @throws TypeConflictException in case of conflict with the value type set in database
+	 * @since 31.0.0
+	 * @see IUserPreferences for explanation about lazy loading
+	 */
+	public function getValueInt(
+		string $userId,
+		string $app,
+		string $key,
+		int $default = 0,
+		bool $lazy = false,
+	): int {
+		return (int)$this->getTypedValue($userId, $app, $key, (string)$default, $lazy, ValueType::INT);
+	}
+
+	/**
+	 * @inheritDoc
+	 *
+	 * @param string $userId id of the user
+	 * @param string $app id of the app
+	 * @param string $key preference key
+	 * @param float $default default value
+	 * @param bool $lazy search within lazy loaded preferences
+	 *
+	 * @return float stored preference value or $default if not set in database
+	 * @throws InvalidArgumentException if one of the argument format is invalid
+	 * @throws TypeConflictException in case of conflict with the value type set in database
+	 * @since 29.0.0
+	 * @see IUserPreferences for explanation about lazy loading
+	 */
+	public function getValueFloat(
+		string $userId,
+		string $app,
+		string $key,
+		float $default = 0,
+		bool $lazy = false,
+	): float {
+		return (float)$this->getTypedValue($userId, $app, $key, (string)$default, $lazy, ValueType::FLOAT);
+	}
+
+	/**
+	 * @inheritDoc
+	 *
+	 * @param string $userId id of the user
+	 * @param string $app id of the app
+	 * @param string $key preference key
+	 * @param bool $default default value
+	 * @param bool $lazy search within lazy loaded preferences
+	 *
+	 * @return bool stored preference value or $default if not set in database
+	 * @throws InvalidArgumentException if one of the argument format is invalid
+	 * @throws TypeConflictException in case of conflict with the value type set in database
+	 * @since 29.0.0
+	 * @see IUserPreferences for explanation about lazy loading
+	 */
+	public function getValueBool(
+		string $userId,
+		string $app,
+		string $key,
+		bool $default = false,
+		bool $lazy = false,
+	): bool {
+		$b = strtolower($this->getTypedValue($userId, $app, $key, $default ? 'true' : 'false', $lazy, ValueType::BOOL));
+		return in_array($b, ['1', 'true', 'yes', 'on']);
+	}
+
+	/**
+	 * @inheritDoc
+	 *
+	 * @param string $userId id of the user
+	 * @param string $app id of the app
+	 * @param string $key preference key
+	 * @param array $default default value
+	 * @param bool $lazy search within lazy loaded preferences
+	 *
+	 * @return array stored preference value or $default if not set in database
+	 * @throws InvalidArgumentException if one of the argument format is invalid
+	 * @throws TypeConflictException in case of conflict with the value type set in database
+	 * @since 29.0.0
+	 * @see IUserPreferences for explanation about lazy loading
+	 */
+	public function getValueArray(
+		string $userId,
+		string $app,
+		string $key,
+		array $default = [],
+		bool $lazy = false,
+	): array {
+		try {
+			$defaultJson = json_encode($default, JSON_THROW_ON_ERROR);
+			$value = json_decode($this->getTypedValue($userId, $app, $key, $defaultJson, $lazy, ValueType::ARRAY), true, flags: JSON_THROW_ON_ERROR);
+
+			return is_array($value) ? $value : [];
+		} catch (JsonException) {
+			return [];
+		}
+	}
+
+	/**
+	 * @param string $userId
+	 * @param string $app id of the app
+	 * @param string $key preference key
+	 * @param string $default default value
+	 * @param bool $lazy search within lazy loaded preferences
+	 * @param ValueType $type value type
+	 *
+	 * @return string
+	 * @throws TypeConflictException if type from database is not VALUE_MIXED and different from the requested one
+	 */
+	private function getTypedValue(
+		string $userId,
+		string $app,
+		string $key,
+		string $default,
+		bool $lazy,
+		ValueType $type,
+	): string {
+		$this->assertParams($userId, $app, $key, valueType: $type);
+		$this->loadPreferences($userId, $lazy);
+
+		/**
+		 * We ignore check if mixed type is requested.
+		 * If type of stored value is set as mixed, we don't filter.
+		 * If type of stored value is defined, we compare with the one requested.
+		 */
+		$knownType = $this->valueTypes[$userId][$app][$key] ?? 0;
+		if (!$this->isTyped(ValueType::MIXED, $type->value)
+			&& $knownType > 0
+			&& !$this->isTyped(ValueType::MIXED, $knownType)
+			&& !$this->isTyped($type, $knownType)) {
+			$this->logger->warning('conflict with value type from database', ['app' => $app, 'key' => $key, 'type' => $type, 'knownType' => $knownType]);
+			throw new TypeConflictException('conflict with value type from database');
+		}
+
+		/**
+		 * - the pair $app/$key cannot exist in both array,
+		 * - we should still return an existing non-lazy value even if current method
+		 *   is called with $lazy is true
+		 *
+		 * This way, lazyCache will be empty until the load for lazy preferences value is requested.
+		 */
+		if (isset($this->lazyCache[$userId][$app][$key])) {
+			$value = $this->lazyCache[$userId][$app][$key];
+		} elseif (isset($this->fastCache[$userId][$app][$key])) {
+			$value = $this->fastCache[$userId][$app][$key];
+		} else {
+			return $default;
+		}
+
+		$this->decryptSensitiveValue($userId, $app, $key, $value);
+		return $value;
+	}
+
+	/**
+	 * @inheritDoc
+	 *
+	 * @param string $userId id of the user
+	 * @param string $app id of the app
+	 * @param string $key preference key
+	 *
+	 * @return ValueType type of the value
+	 * @throws UnknownKeyException if preference key is not known
+	 * @throws IncorrectTypeException if preferences value type is not known
+	 * @since 31.0.0
+	 */
+	public function getValueType(string $userId, string $app, string $key, ?bool $lazy = null): ValueType {
+		$this->assertParams($userId, $app, $key);
+		$this->loadPreferences($userId, $lazy);
+
+		if (!isset($this->valueTypes[$userId][$app][$key])) {
+			throw new UnknownKeyException('unknown preference key');
+		}
+
+		return $this->extractValueType($this->valueTypes[$userId][$app][$key]);
+	}
+
+	/**
+	 * convert bitflag from value type to ValueType
+	 *
+	 * @param int $type
+	 *
+	 * @return ValueType
+	 * @throws IncorrectTypeException
+	 */
+	private function extractValueType(int $type): ValueType {
+		$type &= ~ValueType::SENSITIVE->value;
+
+		try {
+			return ValueType::from($type);
+		} catch (ValueError) {
+			throw new IncorrectTypeException('invalid value type');
+		}
+	}
+
+	/**
+	 * Store a preference key and its value in database as VALUE_MIXED
+	 *
+	 * **WARNING:** Method is internal and **MUST** not be used as it is best to set a real value type
+	 *
+	 * @param string $userId id of the user
+	 * @param string $app id of the app
+	 * @param string $key preference key
+	 * @param string $value preference value
+	 * @param bool $lazy set preference as lazy loaded
+	 * @param bool $sensitive if TRUE value will be hidden when listing preference values.
+	 *
+	 * @return bool TRUE if value was different, therefor updated in database
+	 * @throws TypeConflictException if type from database is not VALUE_MIXED
+	 * @internal
+	 * @since 29.0.0
+	 * @see IUserPreferences for explanation about lazy loading
+	 * @see setValueString()
+	 * @see setValueInt()
+	 * @see setValueFloat()
+	 * @see setValueBool()
+	 * @see setValueArray()
+	 */
+	public function setValueMixed(
+		string $userId,
+		string $app,
+		string $key,
+		string $value,
+		bool $lazy = false,
+		bool $sensitive = false,
+	): bool {
+		return $this->setTypedValue(
+			$userId,
+			$app,
+			$key,
+			$value,
+			$lazy,
+			$sensitive,
+			ValueType::MIXED
+		);
+	}
+
+
+	/**
+	 * @inheritDoc
+	 *
+	 * @param string $userId id of the user
+	 * @param string $app id of the app
+	 * @param string $key preference key
+	 * @param string $value preference value
+	 * @param bool $lazy set preference as lazy loaded
+	 * @param bool $sensitive if TRUE value will be hidden when listing preference values.
+	 *
+	 * @return bool TRUE if value was different, therefor updated in database
+	 * @throws TypeConflictException if type from database is not VALUE_MIXED and different from the requested one
+	 * @since 29.0.0
+	 * @see IUserPreferences for explanation about lazy loading
+	 */
+	public function setValueString(
+		string $userId,
+		string $app,
+		string $key,
+		string $value,
+		bool $lazy = false,
+		bool $sensitive = false,
+	): bool {
+		return $this->setTypedValue(
+			$userId,
+			$app,
+			$key,
+			$value,
+			$lazy,
+			$sensitive,
+			ValueType::STRING
+		);
+	}
+
+	/**
+	 * @inheritDoc
+	 *
+	 * @param string $userId id of the user
+	 * @param string $app id of the app
+	 * @param string $key preference key
+	 * @param int $value preference value
+	 * @param bool $lazy set preference as lazy loaded
+	 * @param bool $sensitive if TRUE value will be hidden when listing preference values.
+	 *
+	 * @return bool TRUE if value was different, therefor updated in database
+	 * @throws TypeConflictException if type from database is not VALUE_MIXED and different from the requested one
+	 * @since 29.0.0
+	 * @see IUserPreferences for explanation about lazy loading
+	 */
+	public function setValueInt(
+		string $userId,
+		string $app,
+		string $key,
+		int $value,
+		bool $lazy = false,
+		bool $sensitive = false,
+	): bool {
+		if ($value > 2000000000) {
+			$this->logger->debug('You are trying to store an integer value around/above 2,147,483,647. This is a reminder that reaching this theoretical limit on 32 bits system will throw an exception.');
+		}
+
+		return $this->setTypedValue(
+			$userId,
+			$app,
+			$key,
+			(string)$value,
+			$lazy,
+			$sensitive,
+			ValueType::INT
+		);
+	}
+
+	/**
+	 * @inheritDoc
+	 *
+	 * @param string $userId id of the user
+	 * @param string $app id of the app
+	 * @param string $key preference key
+	 * @param float $value preference value
+	 * @param bool $lazy set preference as lazy loaded
+	 * @param bool $sensitive if TRUE value will be hidden when listing preference values.
+	 *
+	 * @return bool TRUE if value was different, therefor updated in database
+	 * @throws TypeConflictException if type from database is not VALUE_MIXED and different from the requested one
+	 * @since 29.0.0
+	 * @see IUserPreferences for explanation about lazy loading
+	 */
+	public function setValueFloat(
+		string $userId,
+		string $app,
+		string $key,
+		float $value,
+		bool $lazy = false,
+		bool $sensitive = false,
+	): bool {
+		return $this->setTypedValue(
+			$userId,
+			$app,
+			$key,
+			(string)$value,
+			$lazy,
+			$sensitive,
+			ValueType::FLOAT
+		);
+	}
+
+	/**
+	 * @inheritDoc
+	 *
+	 * @param string $userId id of the user
+	 * @param string $app id of the app
+	 * @param string $key preference key
+	 * @param bool $value preference value
+	 * @param bool $lazy set preference as lazy loaded
+	 *
+	 * @return bool TRUE if value was different, therefor updated in database
+	 * @throws TypeConflictException if type from database is not VALUE_MIXED and different from the requested one
+	 * @since 29.0.0
+	 * @see IUserPreferences for explanation about lazy loading
+	 */
+	public function setValueBool(
+		string $userId,
+		string $app,
+		string $key,
+		bool $value,
+		bool $lazy = false,
+	): bool {
+		return $this->setTypedValue(
+			$userId,
+			$app,
+			$key,
+			($value) ? '1' : '0',
+			$lazy,
+			false,
+			ValueType::BOOL
+		);
+	}
+
+	/**
+	 * @inheritDoc
+	 *
+	 * @param string $userId id of the user
+	 * @param string $app id of the app
+	 * @param string $key preference key
+	 * @param array $value preference value
+	 * @param bool $lazy set preference as lazy loaded
+	 * @param bool $sensitive if TRUE value will be hidden when listing preference values.
+	 *
+	 * @return bool TRUE if value was different, therefor updated in database
+	 * @throws TypeConflictException if type from database is not VALUE_MIXED and different from the requested one
+	 * @throws JsonException
+	 * @since 29.0.0
+	 * @see IUserPreferences for explanation about lazy loading
+	 */
+	public function setValueArray(
+		string $userId,
+		string $app,
+		string $key,
+		array $value,
+		bool $lazy = false,
+		bool $sensitive = false,
+	): bool {
+		try {
+			return $this->setTypedValue(
+				$userId,
+				$app,
+				$key,
+				json_encode($value, JSON_THROW_ON_ERROR),
+				$lazy,
+				$sensitive,
+				ValueType::ARRAY
+			);
+		} catch (JsonException $e) {
+			$this->logger->warning('could not setValueArray', ['app' => $app, 'key' => $key, 'exception' => $e]);
+			throw $e;
+		}
+	}
+
+	/**
+	 * Store a preference key and its value in database
+	 *
+	 * If preference key is already known with the exact same preference value and same sensitive/lazy status, the
+	 * database is not updated. If preference value was previously stored as sensitive, status will not be
+	 * altered.
+	 *
+	 * @param string $userId id of the user
+	 * @param string $app id of the app
+	 * @param string $key preference key
+	 * @param string $value preference value
+	 * @param bool $lazy preferences set as lazy loaded
+	 * @param ValueType $type value type
+	 *
+	 * @return bool TRUE if value was updated in database
+	 * @throws TypeConflictException if type from database is not VALUE_MIXED and different from the requested one
+	 * @see IUserPreferences for explanation about lazy loading
+	 */
+	private function setTypedValue(
+		string $userId,
+		string $app,
+		string $key,
+		string $value,
+		bool $lazy,
+		bool $sensitive,
+		ValueType $type,
+	): bool {
+		$this->assertParams($userId, $app, $key, valueType: $type);
+		$this->loadPreferences($userId, $lazy);
+
+		$inserted = $refreshCache = false;
+		$origValue = $value;
+		$typeValue = $type->value;
+		if ($sensitive || ($this->hasKey($userId, $app, $key, $lazy) && $this->isSensitive($userId, $app, $key, $lazy))) {
+			$value = self::ENCRYPTION_PREFIX . $this->crypto->encrypt($value);
+			$typeValue = $typeValue | ValueType::SENSITIVE->value;
+		}
+
+		if ($this->hasKey($userId, $app, $key, $lazy)) {
+			/**
+			 * no update if key is already known with set lazy status and value is
+			 * not different, unless sensitivity is switched from false to true.
+			 */
+			if ($origValue === $this->getTypedValue($userId, $app, $key, $value, $lazy, $type)
+				&& (!$sensitive || $this->isSensitive($userId, $app, $key, $lazy))) {
+				return false;
+			}
+		} else {
+			/**
+			 * if key is not known yet, we try to insert.
+			 * It might fail if the key exists with a different lazy flag.
+			 */
+			try {
+				$insert = $this->connection->getQueryBuilder();
+				$insert->insert('preferences')
+					->setValue('userid', $insert->createNamedParameter($userId))
+					->setValue('appid', $insert->createNamedParameter($app))
+					->setValue('lazy', $insert->createNamedParameter(($lazy) ? 1 : 0, IQueryBuilder::PARAM_INT))
+					->setValue('type', $insert->createNamedParameter($typeValue, IQueryBuilder::PARAM_INT))
+					->setValue('configkey', $insert->createNamedParameter($key))
+					->setValue('configvalue', $insert->createNamedParameter($value));
+				$insert->executeStatement();
+				$inserted = true;
+			} catch (DBException $e) {
+				if ($e->getReason() !== DBException::REASON_UNIQUE_CONSTRAINT_VIOLATION) {
+					throw $e; // TODO: throw exception or just log and returns false !?
+				}
+			}
+		}
+
+		/**
+		 * We cannot insert a new row, meaning we need to update an already existing one
+		 */
+		if (!$inserted) {
+			$currType = $this->valueTypes[$userId][$app][$key] ?? 0;
+			if ($currType === 0) { // this might happen when switching lazy loading status
+				$this->loadPreferencesAll($userId);
+				$currType = $this->valueTypes[$userId][$app][$key] ?? 0;
+			}
+
+			/**
+			 * This should only happen during the upgrade process from 28 to 29.
+			 * We only log a warning and set it to VALUE_MIXED.
+			 */
+			if ($currType === 0) {
+				$this->logger->warning('Value type is set to zero (0) in database. This is fine only during the upgrade process from 28 to 29.', ['app' => $app, 'key' => $key]);
+				$currType = ValueType::MIXED->value;
+			}
+
+			//			if ($type->isSensitive()) {}
+
+			/**
+			 * we only accept a different type from the one stored in database
+			 * if the one stored in database is not-defined (VALUE_MIXED)
+			 */
+			if (!$this->isTyped(ValueType::MIXED, $currType) &&
+				($type->value | ValueType::SENSITIVE->value) !== ($currType | ValueType::SENSITIVE->value)) {
+				try {
+					$currType = $this->extractValueType($currType)->getDefinition();
+					$type = $type->getDefinition();
+				} catch (IncorrectTypeException) {
+					$type = $type->value;
+				}
+				throw new TypeConflictException('conflict between new type (' . $type . ') and old type (' . $currType . ')');
+			}
+
+			if ($lazy !== $this->isLazy($userId, $app, $key)) {
+				$refreshCache = true;
+			}
+
+			$update = $this->connection->getQueryBuilder();
+			$update->update('preferences')
+				->set('configvalue', $update->createNamedParameter($value))
+				->set('lazy', $update->createNamedParameter(($lazy) ? 1 : 0, IQueryBuilder::PARAM_INT))
+				->set('type', $update->createNamedParameter($typeValue, IQueryBuilder::PARAM_INT))
+				->where($update->expr()->eq('userid', $update->createNamedParameter($userId)))
+				->andWhere($update->expr()->eq('appid', $update->createNamedParameter($app)))
+				->andWhere($update->expr()->eq('configkey', $update->createNamedParameter($key)));
+
+			$update->executeStatement();
+		}
+
+		if ($refreshCache) {
+			$this->clearCache($userId);
+			return true;
+		}
+
+		// update local cache
+		if ($lazy) {
+			$this->lazyCache[$userId][$app][$key] = $value;
+		} else {
+			$this->fastCache[$userId][$app][$key] = $value;
+		}
+		$this->valueTypes[$userId][$app][$key] = $typeValue;
+
+		return true;
+	}
+
+	/**
+	 * Change the type of preference value.
+	 *
+	 * **WARNING:** Method is internal and **MUST** not be used as it may break things.
+	 *
+	 * @param string $userId id of the user
+	 * @param string $app id of the app
+	 * @param string $key preference key
+	 * @param ValueType $type value type
+	 *
+	 * @return bool TRUE if database update were necessary
+	 * @throws UnknownKeyException if $key is now known in database
+	 * @throws IncorrectTypeException if $type is not valid
+	 * @internal
+	 * @since 31.0.0
+	 */
+	public function updateType(string $userId, string $app, string $key, ValueType $type = ValueType::MIXED): bool {
+		$this->assertParams($userId, $app, $key, valueType: $type);
+		$this->loadPreferencesAll($userId);
+		$this->isLazy($userId, $app, $key); // confirm key exists
+		$typeValue = $type->value;
+
+		$currType = $this->valueTypes[$userId][$app][$key];
+		if (($typeValue | ValueType::SENSITIVE->value) === ($currType | ValueType::SENSITIVE->value)) {
+			return false;
+		}
+
+		// we complete with sensitive flag if the stored value is set as sensitive
+		if ($this->isTyped(ValueType::SENSITIVE, $currType)) {
+			$typeValue = $typeValue | ValueType::SENSITIVE->value;
+		}
+
+		$update = $this->connection->getQueryBuilder();
+		$update->update('preferences')
+			->set('type', $update->createNamedParameter($typeValue, IQueryBuilder::PARAM_INT))
+			->where($update->expr()->eq('userid', $update->createNamedParameter($userId)))
+			->andWhere($update->expr()->eq('appid', $update->createNamedParameter($app)))
+			->andWhere($update->expr()->eq('configkey', $update->createNamedParameter($key)));
+		$update->executeStatement();
+		$this->valueTypes[$userId][$app][$key] = $typeValue;
+
+		return true;
+	}
+
+	/**
+	 * @inheritDoc
+	 *
+	 * @param string $userId id of the user
+	 * @param string $app id of the app
+	 * @param string $key preference key
+	 * @param bool $sensitive TRUE to set as sensitive, FALSE to unset
+	 *
+	 * @return bool TRUE if entry was found in database and an update was necessary
+	 * @since 31.0.0
+	 */
+	public function updateSensitive(string $userId, string $app, string $key, bool $sensitive): bool {
+		$this->assertParams($userId, $app, $key);
+		$this->loadPreferencesAll($userId);
+
+		try {
+			if ($sensitive === $this->isSensitive($userId, $app, $key, null)) {
+				return false;
+			}
+		} catch (UnknownKeyException) {
+			return false;
+		}
+
+		$lazy = $this->isLazy($userId, $app, $key);
+		if ($lazy) {
+			$cache = $this->lazyCache;
+		} else {
+			$cache = $this->fastCache;
+		}
+
+		if (!isset($cache[$userId][$app][$key])) {
+			throw new UnknownKeyException('unknown preference key');
+		}
+
+		/**
+		 * type returned by getValueType() is already cleaned from sensitive flag
+		 * we just need to update it based on $sensitive and store it in database
+		 */
+		$typeValue = $this->getValueType($userId, $app, $key)->value;
+		$value = $cache[$userId][$app][$key];
+		if ($sensitive) {
+			$typeValue |= ValueType::SENSITIVE->value;
+			$value = self::ENCRYPTION_PREFIX . $this->crypto->encrypt($value);
+		} else {
+			$this->decryptSensitiveValue($userId, $app, $key, $value);
+		}
+
+		$update = $this->connection->getQueryBuilder();
+		$update->update('preferences')
+			->set('type', $update->createNamedParameter($typeValue, IQueryBuilder::PARAM_INT))
+			->set('configvalue', $update->createNamedParameter($value))
+			->where($update->expr()->eq('userid', $update->createNamedParameter($userId)))
+			->andWhere($update->expr()->eq('appid', $update->createNamedParameter($app)))
+			->andWhere($update->expr()->eq('configkey', $update->createNamedParameter($key)));
+		$update->executeStatement();
+
+		$this->valueTypes[$userId][$app][$key] = $typeValue;
+
+		return true;
+	}
+
+	/**
+	 * @inheritDoc
+	 *
+	 * @param string $app
+	 * @param string $key
+	 * @param bool $sensitive
+	 *
+	 * @since 31.0.0
+	 */
+	public function updateGlobalSensitive(string $app, string $key, bool $sensitive): void {
+		$this->assertParams('', $app, $key, allowEmptyUser: true);
+		foreach (array_keys($this->searchValuesByUsers($app, $key)) as $userId) {
+			try {
+				$this->updateSensitive($userId, $app, $key, $sensitive);
+			} catch (UnknownKeyException) {
+				// should not happen and can be ignored
+			}
+		}
+
+		$this->clearCacheAll(); // we clear all cache
+	}
+
+	/**
+	 * @inheritDoc
+	 *
+	 * @param string $userId id of the user
+	 * @param string $app id of the app
+	 * @param string $key preference key
+	 * @param bool $lazy TRUE to set as lazy loaded, FALSE to unset
+	 *
+	 * @return bool TRUE if entry was found in database and an update was necessary
+	 * @since 31.0.0
+	 */
+	public function updateLazy(string $userId, string $app, string $key, bool $lazy): bool {
+		$this->assertParams($userId, $app, $key);
+		$this->loadPreferencesAll($userId);
+
+		try {
+			if ($lazy === $this->isLazy($userId, $app, $key)) {
+				return false;
+			}
+		} catch (UnknownKeyException) {
+			return false;
+		}
+
+		$update = $this->connection->getQueryBuilder();
+		$update->update('preferences')
+			->set('lazy', $update->createNamedParameter($lazy ? 1 : 0, IQueryBuilder::PARAM_INT))
+			->where($update->expr()->eq('userid', $update->createNamedParameter($userId)))
+			->andWhere($update->expr()->eq('appid', $update->createNamedParameter($app)))
+			->andWhere($update->expr()->eq('configkey', $update->createNamedParameter($key)));
+		$update->executeStatement();
+
+		// At this point, it is a lot safer to clean cache
+		$this->clearCache($userId);
+
+		return true;
+	}
+
+	/**
+	 * @inheritDoc
+	 *
+	 * @param string $app id of the app
+	 * @param string $key preference key
+	 * @param bool $lazy TRUE to set as lazy loaded, FALSE to unset
+	 *
+	 * @since 31.0.0
+	 */
+	public function updateGlobalLazy(string $app, string $key, bool $lazy): void {
+		$this->assertParams('', $app, $key, allowEmptyUser: true);
+
+		$update = $this->connection->getQueryBuilder();
+		$update->update('preferences')
+			->set('lazy', $update->createNamedParameter($lazy ? 1 : 0, IQueryBuilder::PARAM_INT))
+			->where($update->expr()->eq('appid', $update->createNamedParameter($app)))
+			->andWhere($update->expr()->eq('configkey', $update->createNamedParameter($key)));
+		$update->executeStatement();
+
+		$this->clearCacheAll();
+	}
+
+	/**
+	 * @inheritDoc
+	 *
+	 * @param string $userId id of the user
+	 * @param string $app id of the app
+	 * @param string $key preference key
+	 *
+	 * @return array
+	 * @throws UnknownKeyException if preference key is not known in database
+	 * @since 31.0.0
+	 */
+	public function getDetails(string $userId, string $app, string $key): array {
+		$this->assertParams($userId, $app, $key);
+		$this->loadPreferencesAll($userId);
+		$lazy = $this->isLazy($userId, $app, $key);
+
+		if ($lazy) {
+			$cache = $this->lazyCache[$userId];
+		} else {
+			$cache = $this->fastCache[$userId];
+		}
+
+		$type = $this->getValueType($userId, $app, $key);
+		try {
+			$typeString = $type->getDefinition();
+		} catch (IncorrectTypeException $e) {
+			$this->logger->warning('type stored in database is not correct', ['exception' => $e, 'type' => $type]);
+			$typeString = (string)$type->value;
+		}
+
+		if (!isset($cache[$app][$key])) {
+			throw new UnknownKeyException('unknown preference key');
+		}
+
+		$value = $cache[$app][$key];
+		$sensitive = $this->isSensitive($userId, $app, $key, null);
+		$this->decryptSensitiveValue($userId, $app, $key, $value);
+
+		return [
+			'userId' => $userId,
+			'app' => $app,
+			'key' => $key,
+			'value' => $value,
+			'type' => $type->value,
+			'lazy' => $lazy,
+			'typeString' => $typeString,
+			'sensitive' => $sensitive
+		];
+	}
+
+	/**
+	 * @inheritDoc
+	 *
+	 * @param string $userId id of the user
+	 * @param string $app id of the app
+	 * @param string $key preference key
+	 *
+	 * @since 31.0.0
+	 */
+	public function deletePreference(string $userId, string $app, string $key): void {
+		$this->assertParams($userId, $app, $key);
+		$qb = $this->connection->getQueryBuilder();
+		$qb->delete('preferences')
+			->where($qb->expr()->eq('userid', $qb->createNamedParameter($userId)))
+			->andWhere($qb->expr()->eq('appid', $qb->createNamedParameter($app)))
+			->andWhere($qb->expr()->eq('configkey', $qb->createNamedParameter($key)));
+		$qb->executeStatement();
+
+		unset($this->lazyCache[$userId][$app][$key]);
+		unset($this->fastCache[$userId][$app][$key]);
+	}
+
+	/**
+	 * @inheritDoc
+	 *
+	 * @param string $app id of the app
+	 * @param string $key preference key
+	 *
+	 * @since 31.0.0
+	 */
+	public function deleteKey(string $app, string $key): void {
+		$this->assertParams('', $app, $key, allowEmptyUser: true);
+		$qb = $this->connection->getQueryBuilder();
+		$qb->delete('preferences')
+			->where($qb->expr()->eq('appid', $qb->createNamedParameter($app)))
+			->andWhere($qb->expr()->eq('configkey', $qb->createNamedParameter($key)));
+		$qb->executeStatement();
+
+		$this->clearCacheAll();
+	}
+
+	/**
+	 * @inheritDoc
+	 *
+	 * @param string $app id of the app
+	 *
+	 * @since 31.0.0
+	 */
+	public function deleteApp(string $app): void {
+		$this->assertParams('', $app, allowEmptyUser: true);
+		$qb = $this->connection->getQueryBuilder();
+		$qb->delete('preferences')
+			->where($qb->expr()->eq('appid', $qb->createNamedParameter($app)));
+		$qb->executeStatement();
+
+		$this->clearCacheAll();
+	}
+
+	public function deleteAllPreferences(string $userId): void {
+		$this->assertParams($userId, '', allowEmptyApp: true);
+		$qb = $this->connection->getQueryBuilder();
+		$qb->delete('preferences')
+			->where($qb->expr()->eq('userid', $qb->createNamedParameter($userId)));
+		$qb->executeStatement();
+
+		$this->clearCache($userId);
+	}
+
+	/**
+	 * @inheritDoc
+	 *
+	 * @param string $userId id of the user
+	 * @param bool $reload set to TRUE to refill cache instantly after clearing it.
+	 *
+	 * @since 31.0.0
+	 */
+	public function clearCache(string $userId, bool $reload = false): void {
+		$this->assertParams($userId, allowEmptyApp: true);
+		$this->lazyLoaded[$userId] = $this->fastLoaded[$userId] = false;
+		$this->lazyCache[$userId] = $this->fastCache[$userId] = $this->valueTypes[$userId] = [];
+
+		if (!$reload) {
+			return;
+		}
+
+		$this->loadPreferencesAll($userId);
+	}
+
+	/**
+	 * @inheritDoc
+	 *
+	 * @since 31.0.0
+	 */
+	public function clearCacheAll(): void {
+		$this->lazyLoaded = $this->fastLoaded = [];
+		$this->lazyCache = $this->fastCache = $this->valueTypes = [];
+	}
+
+	/**
+	 * For debug purpose.
+	 * Returns the cached data.
+	 *
+	 * @return array
+	 * @since 31.0.0
+	 * @internal
+	 */
+	public function statusCache(): array {
+		return [
+			'fastLoaded' => $this->fastLoaded,
+			'fastCache' => $this->fastCache,
+			'lazyLoaded' => $this->lazyLoaded,
+			'lazyCache' => $this->lazyCache,
+			'valueTypes' => $this->valueTypes,
+		];
+	}
+
+	/**
+	 * @param ValueType $needle bitflag to search
+	 * @param int $type known value
+	 *
+	 * @return bool TRUE if bitflag $needle is set in $type
+	 */
+	private function isTyped(ValueType $needle, int $type): bool {
+		return (($needle->value & $type) !== 0);
+	}
+
+	/**
+	 * Confirm the string set for app and key fit the database description
+	 *
+	 * @param string $userId
+	 * @param string $app assert $app fit in database
+	 * @param string $prefKey assert preference key fit in database
+	 * @param bool $allowEmptyUser
+	 * @param bool $allowEmptyApp $app can be empty string
+	 * @param ValueType|null $valueType assert value type is only one type
+	 */
+	private function assertParams(
+		string $userId = '',
+		string $app = '',
+		string $prefKey = '',
+		bool $allowEmptyUser = false,
+		bool $allowEmptyApp = false,
+		?ValueType $valueType = null,
+	): void {
+		if (!$allowEmptyUser && $userId === '') {
+			throw new InvalidArgumentException('userId cannot be an empty string');
+		}
+		if (!$allowEmptyApp && $app === '') {
+			throw new InvalidArgumentException('app cannot be an empty string');
+		}
+		if (strlen($userId) > self::USER_MAX_LENGTH) {
+			throw new InvalidArgumentException('Value (' . $userId . ') for userId is too long (' . self::USER_MAX_LENGTH . ')');
+		}
+		if (strlen($app) > self::APP_MAX_LENGTH) {
+			throw new InvalidArgumentException('Value (' . $app . ') for app is too long (' . self::APP_MAX_LENGTH . ')');
+		}
+		if (strlen($prefKey) > self::KEY_MAX_LENGTH) {
+			throw new InvalidArgumentException('Value (' . $prefKey . ') for key is too long (' . self::KEY_MAX_LENGTH . ')');
+		}
+		if ($valueType !== null) {
+			$valueFlag = $valueType->value;
+			$valueFlag &= ~ValueType::SENSITIVE->value;
+			if (ValueType::tryFrom($valueFlag) === null) {
+				throw new InvalidArgumentException('Unknown value type');
+			}
+		}
+	}
+
+	private function loadPreferencesAll(string $userId): void {
+		$this->loadPreferences($userId, null);
+	}
+
+	/**
+	 * Load normal preferences or preferences set as lazy loaded
+	 *
+	 * @param bool|null $lazy set to TRUE to load preferences set as lazy loaded, set to NULL to load all preferences
+	 */
+	private function loadPreferences(string $userId, ?bool $lazy = false): void {
+		if ($this->isLoaded($userId, $lazy)) {
+			return;
+		}
+
+		if (($lazy ?? true) !== false) { // if lazy is null or true, we debug log
+			$this->logger->debug('The loading of lazy UserPreferences values have been requested', ['exception' => new \RuntimeException('ignorable exception')]);
+		}
+
+		$qb = $this->connection->getQueryBuilder();
+		$qb->from('preferences');
+		$qb->select('userid', 'appid', 'configkey', 'configvalue', 'type');
+		$qb->where($qb->expr()->eq('userid', $qb->createNamedParameter($userId)));
+
+		// we only need value from lazy when loadPreferences does not specify it
+		if ($lazy !== null) {
+			$qb->andWhere($qb->expr()->eq('lazy', $qb->createNamedParameter($lazy ? 1 : 0, IQueryBuilder::PARAM_INT)));
+		} else {
+			$qb->addSelect('lazy');
+		}
+
+		$result = $qb->executeQuery();
+		$rows = $result->fetchAll();
+		foreach ($rows as $row) {
+			if (($row['lazy'] ?? ($lazy ?? 0) ? 1 : 0) === 1) {
+				$this->lazyCache[$row['userid']][$row['appid']][$row['configkey']] = $row['configvalue'] ?? '';
+			} else {
+				$this->fastCache[$row['userid']][$row['appid']][$row['configkey']] = $row['configvalue'] ?? '';
+			}
+			$this->valueTypes[$row['userid']][$row['appid']][$row['configkey']] = (int)($row['type'] ?? 0);
+		}
+		$result->closeCursor();
+		$this->setAsLoaded($userId, $lazy);
+	}
+
+	/**
+	 * if $lazy is:
+	 *  - false: will returns true if fast preferences are loaded
+	 *  - true : will returns true if lazy preferences are loaded
+	 *  - null : will returns true if both preferences are loaded
+	 *
+	 * @param string $userId
+	 * @param bool $lazy
+	 *
+	 * @return bool
+	 */
+	private function isLoaded(string $userId, ?bool $lazy): bool {
+		if ($lazy === null) {
+			return ($this->lazyLoaded[$userId] ?? false) && ($this->fastLoaded[$userId] ?? false);
+		}
+
+		return $lazy ? $this->lazyLoaded[$userId] ?? false : $this->fastLoaded[$userId] ?? false;
+	}
+
+	/**
+	 * if $lazy is:
+	 * - false: set fast preferences as loaded
+	 * - true : set lazy preferences as loaded
+	 * - null : set both preferences as loaded
+	 *
+	 * @param string $userId
+	 * @param bool $lazy
+	 */
+	private function setAsLoaded(string $userId, ?bool $lazy): void {
+		if ($lazy === null) {
+			$this->fastLoaded[$userId] = $this->lazyLoaded[$userId] = true;
+			return;
+		}
+
+		// We also create empty entry to keep both fastLoaded/lazyLoaded synced
+		if ($lazy) {
+			$this->lazyLoaded[$userId] = true;
+			$this->fastLoaded[$userId] = $this->fastLoaded[$userId] ?? false;
+			$this->fastCache[$userId] = $this->fastCache[$userId] ?? [];
+		} else {
+			$this->fastLoaded[$userId] = true;
+			$this->lazyLoaded[$userId] = $this->lazyLoaded[$userId] ?? false;
+			$this->lazyCache[$userId] = $this->lazyCache[$userId] ?? [];
+		}
+	}
+
+	/**
+	 * **Warning:** this will load all lazy values from the database
+	 *
+	 * @param string $userId id of the user
+	 * @param string $app id of the app
+	 * @param bool $filtered TRUE to hide sensitive preference values. Value are replaced by {@see IConfig::SENSITIVE_VALUE}
+	 *
+	 * @return array<string, string|int|float|bool|array>
+	 */
+	private function formatAppValues(string $userId, string $app, array $values, bool $filtered = false): array {
+		foreach ($values as $key => $value) {
+			//$key = (string)$key;
+			try {
+				$type = $this->getValueType($userId, $app, (string)$key);
+			} catch (UnknownKeyException) {
+				continue;
+			}
+
+			if ($this->isTyped(ValueType::SENSITIVE, $this->valueTypes[$userId][$app][$key] ?? 0)) {
+				if ($filtered) {
+					$value = IConfig::SENSITIVE_VALUE;
+					$type = ValueType::STRING;
+				} else {
+					$this->decryptSensitiveValue($userId, $app, (string)$key, $value);
+				}
+			}
+
+			$values[$key] = $this->convertTypedValue($value, $type);
+		}
+
+		return $values;
+	}
+
+	/**
+	 * convert string value to the expected type
+	 *
+	 * @param string $value
+	 * @param ValueType $type
+	 *
+	 * @return string|int|float|bool|array
+	 */
+	private function convertTypedValue(string $value, ValueType $type): string|int|float|bool|array {
+		switch ($type) {
+			case ValueType::INT:
+				return (int)$value;
+			case ValueType::FLOAT:
+				return (float)$value;
+			case ValueType::BOOL:
+				return in_array(strtolower($value), ['1', 'true', 'yes', 'on']);
+			case ValueType::ARRAY:
+				try {
+					return json_decode($value, true, flags: JSON_THROW_ON_ERROR);
+				} catch (JsonException) {
+					// ignoreable
+				}
+				break;
+		}
+		return $value;
+	}
+
+
+	private function decryptSensitiveValue(string $userId, string $app, string $key, string &$value): void {
+		if (!$this->isTyped(ValueType::SENSITIVE, $this->valueTypes[$userId][$app][$key] ?? 0)) {
+			return;
+		}
+
+		if (!str_starts_with($value, self::ENCRYPTION_PREFIX)) {
+			return;
+		}
+
+		try {
+			$value = $this->crypto->decrypt(substr($value, self::ENCRYPTION_PREFIX_LENGTH));
+		} catch (\Exception $e) {
+			$this->logger->warning('could not decrypt sensitive value', [
+				'userId' => $userId,
+				'app' => $app,
+				'key' => $key,
+				'value' => $value,
+				'exception' => $e
+			]);
+		}
+	}
+}
diff --git a/lib/public/UserPreferences/Exceptions/IncorrectTypeException.php b/lib/public/UserPreferences/Exceptions/IncorrectTypeException.php
new file mode 100644
index 00000000000..5c8f83dee5e
--- /dev/null
+++ b/lib/public/UserPreferences/Exceptions/IncorrectTypeException.php
@@ -0,0 +1,15 @@
+<?php
+
+declare(strict_types=1);
+/**
+ * SPDX-FileCopyrightText: 2024 Nextcloud GmbH and Nextcloud contributors
+ * SPDX-License-Identifier: AGPL-3.0-or-later
+ */
+
+namespace OCP\UserPreferences\Exceptions;
+
+/**
+ * @since 31.0.0
+ */
+class IncorrectTypeException extends UserPreferencesException {
+}
diff --git a/lib/public/UserPreferences/Exceptions/TypeConflictException.php b/lib/public/UserPreferences/Exceptions/TypeConflictException.php
new file mode 100644
index 00000000000..b67113fbba7
--- /dev/null
+++ b/lib/public/UserPreferences/Exceptions/TypeConflictException.php
@@ -0,0 +1,15 @@
+<?php
+
+declare(strict_types=1);
+/**
+ * SPDX-FileCopyrightText: 2024 Nextcloud GmbH and Nextcloud contributors
+ * SPDX-License-Identifier: AGPL-3.0-or-later
+ */
+
+namespace OCP\UserPreferences\Exceptions;
+
+/**
+ * @since 31.0.0
+ */
+class TypeConflictException extends UserPreferencesException {
+}
diff --git a/lib/public/UserPreferences/Exceptions/UnknownKeyException.php b/lib/public/UserPreferences/Exceptions/UnknownKeyException.php
new file mode 100644
index 00000000000..3df66689964
--- /dev/null
+++ b/lib/public/UserPreferences/Exceptions/UnknownKeyException.php
@@ -0,0 +1,15 @@
+<?php
+
+declare(strict_types=1);
+/**
+ * SPDX-FileCopyrightText: 2024 Nextcloud GmbH and Nextcloud contributors
+ * SPDX-License-Identifier: AGPL-3.0-or-later
+ */
+
+namespace OCP\UserPreferences\Exceptions;
+
+/**
+ * @since 31.0.0
+ */
+class UnknownKeyException extends UserPreferencesException {
+}
diff --git a/lib/public/UserPreferences/Exceptions/UserPreferencesException.php b/lib/public/UserPreferences/Exceptions/UserPreferencesException.php
new file mode 100644
index 00000000000..664181d420b
--- /dev/null
+++ b/lib/public/UserPreferences/Exceptions/UserPreferencesException.php
@@ -0,0 +1,17 @@
+<?php
+
+declare(strict_types=1);
+/**
+ * SPDX-FileCopyrightText: 2024 Nextcloud GmbH and Nextcloud contributors
+ * SPDX-License-Identifier: AGPL-3.0-or-later
+ */
+
+namespace OCP\UserPreferences\Exceptions;
+
+use Exception;
+
+/**
+ * @since 31.0.0
+ */
+class UserPreferencesException extends Exception {
+}
diff --git a/lib/public/UserPreferences/IUserPreferences.php b/lib/public/UserPreferences/IUserPreferences.php
new file mode 100644
index 00000000000..e050f2ea6af
--- /dev/null
+++ b/lib/public/UserPreferences/IUserPreferences.php
@@ -0,0 +1,609 @@
+<?php
+
+declare(strict_types=1);
+/**
+ * SPDX-FileCopyrightText: 2024 Nextcloud GmbH and Nextcloud contributors
+ * SPDX-License-Identifier: AGPL-3.0-or-later
+ */
+
+namespace OCP\UserPreferences;
+
+use OCP\UserPreferences\Exceptions\IncorrectTypeException;
+use OCP\UserPreferences\Exceptions\UnknownKeyException;
+
+/**
+ * @since 31.0.0
+ */
+interface IUserPreferences {
+	/**
+	 * Get list of all userIds with preferences stored in database.
+	 * If $appId is specified, will only limit the search to this value
+	 *
+	 * **WARNING:** ignore any cache and get data directly from database.
+	 *
+	 * @param string $appId optional id of app
+	 *
+	 * @return list<string> list of userIds
+	 * @since 31.0.0
+	 */
+	public function getUserIds(string $appId = ''): array;
+
+	/**
+	 * Get list of all apps that have at least one preference
+	 * value related to $userId stored in database
+	 *
+	 * **WARNING:** ignore lazy filtering, all user preferences are loaded from database
+	 *
+	 * @param string $userId id of the user
+	 *
+	 * @return list<string> list of app ids
+	 * @since 31.0.0
+	 */
+	public function getApps(string $userId): array;
+
+	/**
+	 * Returns all keys stored in database, related to user+app.
+	 * Please note that the values are not returned.
+	 *
+	 * **WARNING:** ignore lazy filtering, all user preferences are loaded from database
+	 *
+	 * @param string $userId id of the user
+	 * @param string $app id of the app
+	 *
+	 * @return list<string> list of stored preference keys
+	 * @since 31.0.0
+	 */
+	public function getKeys(string $userId, string $app): array;
+
+	/**
+	 * Check if a key exists in the list of stored preference values.
+	 *
+	 * @param string $userId id of the user
+	 * @param string $app id of the app
+	 * @param string $key preference key
+	 * @param bool $lazy search within lazy loaded preferences
+	 *
+	 * @return bool TRUE if key exists
+	 * @since 31.0.0
+	 */
+	public function hasKey(string $userId, string $app, string $key, ?bool $lazy = false): bool;
+
+	/**
+	 * best way to see if a value is set as sensitive (not displayed in report)
+	 *
+	 * @param string $userId id of the user
+	 * @param string $app id of the app
+	 * @param string $key preference key
+	 * @param bool|null $lazy search within lazy loaded preferences
+	 *
+	 * @return bool TRUE if value is sensitive
+	 * @throws UnknownKeyException if preference key is not known
+	 * @since 31.0.0
+	 */
+	public function isSensitive(string $userId, string $app, string $key, ?bool $lazy = false): bool;
+
+	/**
+	 * Returns if the preference key stored in database is lazy loaded
+	 *
+	 * **WARNING:** ignore lazy filtering, all preference values are loaded from database
+	 *
+	 * @param string $userId id of the user
+	 * @param string $app id of the app
+	 * @param string $key preference key
+	 *
+	 * @return bool TRUE if preference is lazy loaded
+	 * @throws UnknownKeyException if preference key is not known
+	 * @see IUserPreferences for details about lazy loading
+	 * @since 31.0.0
+	 */
+	public function isLazy(string $userId, string $app, string $key): bool;
+
+	/**
+	 * List all preference values from an app with preference key starting with $key.
+	 * Returns an array with preference key as key, stored value as value.
+	 *
+	 * **WARNING:** ignore lazy filtering, all preference values are loaded from database
+	 *
+	 * @param string $userId id of the user
+	 * @param string $app id of the app
+	 * @param string $prefix preference keys prefix to search, can be empty.
+	 * @param bool $filtered filter sensitive preference values
+	 *
+	 * @return array<string, string|int|float|bool|array> [key => value]
+	 * @since 31.0.0
+	 */
+	public function getValues(string $userId, string $app, string $prefix = '', bool $filtered = false): array;
+
+	/**
+	 * List all preference values of a user.
+	 * Returns an array with preference key as key, stored value as value.
+	 *
+	 * **WARNING:** ignore lazy filtering, all preference values are loaded from database
+	 *
+	 * @param string $userId id of the user
+	 * @param bool $filtered filter sensitive preference values
+	 *
+	 * @return array<string, string|int|float|bool|array> [key => value]
+	 * @since 31.0.0
+	 */
+	public function getAllValues(string $userId, bool $filtered = false): array;
+
+	/**
+	 * List all apps storing a specific preference key and its stored value.
+	 * Returns an array with appId as key, stored value as value.
+	 *
+	 * @param string $userId id of the user
+	 * @param string $key preference key
+	 * @param bool $lazy search within lazy loaded preferences
+	 * @param ValueType|null $typedAs enforce type for the returned values
+	 *
+	 * @return array<string, string|int|float|bool|array> [appId => value]
+	 * @since 31.0.0
+	 */
+	public function searchValuesByApps(string $userId, string $key, bool $lazy = false, ?ValueType $typedAs = null): array;
+
+	/**
+	 * List all users storing a specific preference key and its stored value.
+	 * Returns an array with userId as key, stored value as value.
+	 *
+	 * **WARNING:** no caching, generate a fresh request
+	 *
+	 * @param string $app id of the app
+	 * @param string $key preference key
+	 * @param ValueType|null $typedAs enforce type for the returned values
+	 * @param array|null $userIds limit the search to a list of user ids
+	 *
+	 * @return array<string, string|int|float|bool|array> [userId => value]
+	 * @since 31.0.0
+	 */
+	public function searchValuesByUsers(string $app, string $key, ?ValueType $typedAs = null, ?array $userIds = null): array;
+
+	/**
+	 * List all users storing a specific preference key/value pair.
+	 * Returns a list of user ids.
+	 *
+	 * **WARNING:** no caching, generate a fresh request
+	 *
+	 * @param string $app id of the app
+	 * @param string $key preference key
+	 * @param string $value preference value
+	 * @param bool $caseInsensitive non-case-sensitive search, only works if $value is a string
+	 *
+	 * @return list<string>
+	 * @since 31.0.0
+	 */
+	public function searchUsersByValueString(string $app, string $key, string $value, bool $caseInsensitive = false): array;
+
+	/**
+	 * List all users storing a specific preference key/value pair.
+	 * Returns a list of user ids.
+	 *
+	 * **WARNING:** no caching, generate a fresh request
+	 *
+	 * @param string $app id of the app
+	 * @param string $key preference key
+	 * @param int $value preference value
+	 *
+	 * @return list<string>
+	 * @since 31.0.0
+	 */
+	public function searchUsersByValueInt(string $app, string $key, int $value): array;
+
+	/**
+	 * List all users storing a specific preference key/value pair.
+	 * Returns a list of user ids.
+	 *
+	 * **WARNING:** no caching, generate a fresh request
+	 *
+	 * @param string $app id of the app
+	 * @param string $key preference key
+	 * @param array $values list of possible preference values
+	 *
+	 * @return list<string>
+	 * @since 31.0.0
+	 */
+	public function searchUsersByValues(string $app, string $key, array $values): array;
+
+	/**
+	 * List all users storing a specific preference key/value pair.
+	 * Returns a list of user ids.
+	 *
+	 * **WARNING:** no caching, generate a fresh request
+	 *
+	 * @param string $app id of the app
+	 * @param string $key preference key
+	 * @param bool $value preference value
+	 *
+	 * @return list<string>
+	 * @since 31.0.0
+	 */
+	public function searchUsersByValueBool(string $app, string $key, bool $value): array;
+
+	/**
+	 * Get user preference assigned to a preference key.
+	 * If preference key is not found in database, default value is returned.
+	 * If preference key is set as lazy loaded, the $lazy argument needs to be set to TRUE.
+	 *
+	 * @param string $userId id of the user
+	 * @param string $app id of the app
+	 * @param string $key preference key
+	 * @param string $default default value
+	 * @param bool $lazy search within lazy loaded preferences
+	 *
+	 * @return string stored preference value or $default if not set in database
+	 * @since 31.0.0
+	 * @see IUserPreferences for explanation about lazy loading
+	 * @see getValueInt()
+	 * @see getValueFloat()
+	 * @see getValueBool()
+	 * @see getValueArray()
+	 */
+	public function getValueString(string $userId, string $app, string $key, string $default = '', bool $lazy = false): string;
+
+	/**
+	 * Get preference value assigned to a preference key.
+	 * If preference key is not found in database, default value is returned.
+	 * If preference key is set as lazy loaded, the $lazy argument needs to be set to TRUE.
+	 *
+	 * @param string $userId id of the user
+	 * @param string $app id of the app
+	 * @param string $key preference key
+	 * @param int $default default value
+	 * @param bool $lazy search within lazy loaded preferences
+	 *
+	 * @return int stored preference value or $default if not set in database
+	 * @since 31.0.0
+	 * @see IUserPreferences for explanation about lazy loading
+	 * @see getValueString()
+	 * @see getValueFloat()
+	 * @see getValueBool()
+	 * @see getValueArray()
+	 */
+	public function getValueInt(string $userId, string $app, string $key, int $default = 0, bool $lazy = false): int;
+
+	/**
+	 * Get preference value assigned to a preference key.
+	 * If preference key is not found in database, default value is returned.
+	 * If preference key is set as lazy loaded, the $lazy argument needs to be set to TRUE.
+	 *
+	 * @param string $userId id of the user
+	 * @param string $app id of the app
+	 * @param string $key preference key
+	 * @param float $default default value
+	 * @param bool $lazy search within lazy loaded preferences
+	 *
+	 * @return float stored preference value or $default if not set in database
+	 * @since 31.0.0
+	 * @see IUserPreferences for explanation about lazy loading
+	 * @see getValueString()
+	 * @see getValueInt()
+	 * @see getValueBool()
+	 * @see getValueArray()
+	 */
+	public function getValueFloat(string $userId, string $app, string $key, float $default = 0, bool $lazy = false): float;
+
+	/**
+	 * Get preference value assigned to a preference key.
+	 * If preference key is not found in database, default value is returned.
+	 * If preference key is set as lazy loaded, the $lazy argument needs to be set to TRUE.
+	 *
+	 * @param string $userId id of the user
+	 * @param string $app id of the app
+	 * @param string $key preference key
+	 * @param bool $default default value
+	 * @param bool $lazy search within lazy loaded preferences
+	 *
+	 * @return bool stored preference value or $default if not set in database
+	 * @since 31.0.0
+	 * @see IUserPrefences for explanation about lazy loading
+	 * @see getValueString()
+	 * @see getValueInt()
+	 * @see getValueFloat()
+	 * @see getValueArray()
+	 */
+	public function getValueBool(string $userId, string $app, string $key, bool $default = false, bool $lazy = false): bool;
+
+	/**
+	 * Get preference value assigned to a preference key.
+	 * If preference key is not found in database, default value is returned.
+	 * If preference key is set as lazy loaded, the $lazy argument needs to be set to TRUE.
+	 *
+	 * @param string $userId id of the user
+	 * @param string $app id of the app
+	 * @param string $key preference key
+	 * @param array $default default value`
+	 * @param bool $lazy search within lazy loaded preferences
+	 *
+	 * @return array stored preference value or $default if not set in database
+	 * @since 31.0.0
+	 * @see IUserPreferences for explanation about lazy loading
+	 * @see getValueString()
+	 * @see getValueInt()
+	 * @see getValueFloat()
+	 * @see getValueBool()
+	 */
+	public function getValueArray(string $userId, string $app, string $key, array $default = [], bool $lazy = false): array;
+
+	/**
+	 * returns the type of preference value
+	 *
+	 * **WARNING:** ignore lazy filtering, all preference values are loaded from database
+	 *              unless lazy is set to false
+	 *
+	 * @param string $userId id of the user
+	 * @param string $app id of the app
+	 * @param string $key preference key
+	 * @param bool|null $lazy
+	 *
+	 * @return ValueType type of the value
+	 * @throws UnknownKeyException if preference key is not known
+	 * @throws IncorrectTypeException if preferences value type is not known
+	 * @since 31.0.0
+	 */
+	public function getValueType(string $userId, string $app, string $key, ?bool $lazy = null): ValueType;
+
+	/**
+	 * Store a preference key and its value in database
+	 *
+	 * If preference key is already known with the exact same preference value, the database is not updated.
+	 * If preference key is not supposed to be read during the boot of the cloud, it is advised to set it as lazy loaded.
+	 *
+	 * If preference value was previously stored as sensitive or lazy loaded, status cannot be altered without using {@see deleteKey()} first
+	 *
+	 * @param string $userId id of the user
+	 * @param string $app id of the app
+	 * @param string $key preference key
+	 * @param string $value preference value
+	 * @param bool $sensitive if TRUE value will be hidden when listing preference values.
+	 * @param bool $lazy set preference as lazy loaded
+	 *
+	 * @return bool TRUE if value was different, therefor updated in database
+	 * @since 31.0.0
+	 * @see IUserPreferences for explanation about lazy loading
+	 * @see setValueInt()
+	 * @see setValueFloat()
+	 * @see setValueBool()
+	 * @see setValueArray()
+	 */
+	public function setValueString(string $userId, string $app, string $key, string $value, bool $lazy = false, bool $sensitive = false): bool;
+
+	/**
+	 * Store a preference key and its value in database
+	 *
+	 * When handling huge value around and/or above 2,147,483,647, a debug log will be generated
+	 * on 64bits system, as php int type reach its limit (and throw an exception) on 32bits when using huge numbers.
+	 *
+	 * When using huge numbers, it is advised to use {@see \OCP\Util::numericToNumber()} and {@see setValueString()}
+	 *
+	 * If preference key is already known with the exact same preference value, the database is not updated.
+	 * If preference key is not supposed to be read during the boot of the cloud, it is advised to set it as lazy loaded.
+	 *
+	 * If preference value was previously stored as sensitive or lazy loaded, status cannot be altered without using {@see deleteKey()} first
+	 *
+	 * @param string $userId id of the user
+	 * @param string $app id of the app
+	 * @param string $key preference key
+	 * @param int $value preference value
+	 * @param bool $sensitive if TRUE value will be hidden when listing preference values.
+	 * @param bool $lazy set preference as lazy loaded
+	 *
+	 * @return bool TRUE if value was different, therefor updated in database
+	 * @since 31.0.0
+	 * @see IUserPreferences for explanation about lazy loading
+	 * @see setValueString()
+	 * @see setValueFloat()
+	 * @see setValueBool()
+	 * @see setValueArray()
+	 */
+	public function setValueInt(string $userId, string $app, string $key, int $value, bool $lazy = false, bool $sensitive = false): bool;
+
+	/**
+	 * Store a preference key and its value in database.
+	 *
+	 * If preference key is already known with the exact same preference value, the database is not updated.
+	 * If preference key is not supposed to be read during the boot of the cloud, it is advised to set it as lazy loaded.
+	 *
+	 * If preference value was previously stored as sensitive or lazy loaded, status cannot be altered without using {@see deleteKey()} first
+	 *
+	 * @param string $userId id of the user
+	 * @param string $app id of the app
+	 * @param string $key preference key
+	 * @param float $value preference value
+	 * @param bool $sensitive if TRUE value will be hidden when listing preference values.
+	 * @param bool $lazy set preference as lazy loaded
+	 *
+	 * @return bool TRUE if value was different, therefor updated in database
+	 * @since 31.0.0
+	 * @see IUserPreferences for explanation about lazy loading
+	 * @see setValueString()
+	 * @see setValueInt()
+	 * @see setValueBool()
+	 * @see setValueArray()
+	 */
+	public function setValueFloat(string $userId, string $app, string $key, float $value, bool $lazy = false, bool $sensitive = false): bool;
+
+	/**
+	 * Store a preference key and its value in database
+	 *
+	 * If preference key is already known with the exact same preference value, the database is not updated.
+	 * If preference key is not supposed to be read during the boot of the cloud, it is advised to set it as lazy loaded.
+	 *
+	 * If preference value was previously stored as lazy loaded, status cannot be altered without using {@see deleteKey()} first
+	 *
+	 * @param string $userId id of the user
+	 * @param string $app id of the app
+	 * @param string $key preference key
+	 * @param bool $value preference value
+	 * @param bool $lazy set preference as lazy loaded
+	 *
+	 * @return bool TRUE if value was different, therefor updated in database
+	 * @since 31.0.0
+	 * @see IUserPreferences for explanation about lazy loading
+	 * @see setValueString()
+	 * @see setValueInt()
+	 * @see setValueFloat()
+	 * @see setValueArray()
+	 */
+	public function setValueBool(string $userId, string $app, string $key, bool $value, bool $lazy = false): bool;
+
+	/**
+	 * Store a preference key and its value in database
+	 *
+	 * If preference key is already known with the exact same preference value, the database is not updated.
+	 * If preference key is not supposed to be read during the boot of the cloud, it is advised to set it as lazy loaded.
+	 *
+	 * If preference value was previously stored as sensitive or lazy loaded, status cannot be altered without using {@see deleteKey()} first
+	 *
+	 * @param string $userId id of the user
+	 * @param string $app id of the app
+	 * @param string $key preference key
+	 * @param array $value preference value
+	 * @param bool $sensitive if TRUE value will be hidden when listing preference values.
+	 * @param bool $lazy set preference as lazy loaded
+	 *
+	 * @return bool TRUE if value was different, therefor updated in database
+	 * @since 31.0.0
+	 * @see IUserPreferences for explanation about lazy loading
+	 * @see setValueString()
+	 * @see setValueInt()
+	 * @see setValueFloat()
+	 * @see setValueBool()
+	 */
+	public function setValueArray(string $userId, string $app, string $key, array $value, bool $lazy = false, bool $sensitive = false): bool;
+
+	/**
+	 * switch sensitive status of a preference value
+	 *
+	 * **WARNING:** ignore lazy filtering, all preference values are loaded from database
+	 *
+	 * @param string $userId id of the user
+	 * @param string $app id of the app
+	 * @param string $key preference key
+	 * @param bool $sensitive TRUE to set as sensitive, FALSE to unset
+	 *
+	 * @return bool TRUE if database update were necessary
+	 * @since 31.0.0
+	 */
+	public function updateSensitive(string $userId, string $app, string $key, bool $sensitive): bool;
+
+	/**
+	 * switch sensitive loading status of a preference key for all users
+	 *
+	 * **Warning:** heavy on resources, MUST only be used on occ command or migrations
+	 *
+	 *
+	 * @param string $app id of the app
+	 * @param string $key preference key
+	 * @param bool $sensitive TRUE to set as sensitive, FALSE to unset
+	 *
+	 * @since 31.0.0
+	 */
+	public function updateGlobalSensitive(string $app, string $key, bool $sensitive): void;
+
+	/**
+	 * switch lazy loading status of a preference value
+	 *
+	 * @param string $userId id of the user
+	 * @param string $app id of the app
+	 * @param string $key preference key
+	 * @param bool $lazy TRUE to set as lazy loaded, FALSE to unset
+	 *
+	 * @return bool TRUE if database update was necessary
+	 * @since 31.0.0
+	 */
+	public function updateLazy(string $userId, string $app, string $key, bool $lazy): bool;
+
+	/**
+	 * switch lazy loading status of a preference key for all users
+	 *
+	 * **Warning:** heavy on resources, MUST only be used on occ command or migrations
+	 *
+	 * @param string $app id of the app
+	 * @param string $key preference key
+	 * @param bool $lazy TRUE to set as lazy loaded, FALSE to unset
+	 * @since 31.0.0
+	 */
+	public function updateGlobalLazy(string $app, string $key, bool $lazy): void;
+
+	/**
+	 * returns an array contains details about a preference value
+	 *
+	 * ```
+	 * [
+	 *   "app" => "myapp",
+	 *   "key" => "mykey",
+	 *   "value" => "its_value",
+	 *   "lazy" => false,
+	 *   "type" => 4,
+	 *   "typeString" => "string",
+	 *   'sensitive' => true
+	 * ]
+	 * ```
+	 *
+	 * @param string $userId id of the user
+	 * @param string $app id of the app
+	 * @param string $key preference key
+	 *
+	 * @return array
+	 * @throws UnknownKeyException if preference key is not known in database
+	 * @since 31.0.0
+	 */
+	public function getDetails(string $userId, string $app, string $key): array;
+
+	/**
+	 * Delete single preference key from database.
+	 *
+	 * @param string $userId id of the user
+	 * @param string $app id of the app
+	 * @param string $key preference key
+	 *
+	 * @since 31.0.0
+	 */
+	public function deletePreference(string $userId, string $app, string $key): void;
+
+	/**
+	 * Delete preference values from all users linked to a specific preference keys
+	 *
+	 * @param string $app id of the app
+	 * @param string $key preference key
+	 *
+	 * @since 31.0.0
+	 */
+	public function deleteKey(string $app, string $key): void;
+
+	/**
+	 * delete all preference keys linked to an app
+	 *
+	 * @param string $app id of the app
+	 * @since 31.0.0
+	 */
+	public function deleteApp(string $app): void;
+
+	/**
+	 * delete all preference keys linked to a user
+	 *
+	 * @param string $userId id of the user
+	 * @since 31.0.0
+	 */
+	public function deleteAllPreferences(string $userId): void;
+
+	/**
+	 * Clear the cache for a single user
+	 *
+	 * The cache will be rebuilt only the next time a user preference is requested.
+	 *
+	 * @param string $userId id of the user
+	 * @param bool $reload set to TRUE to refill cache instantly after clearing it
+	 *
+	 * @since 31.0.0
+	 */
+	public function clearCache(string $userId, bool $reload = false): void;
+
+	/**
+	 * Clear the cache for all users.
+	 * The cache will be rebuilt only the next time a user preference is requested.
+	 *
+	 * @since 31.0.0
+	 */
+	public function clearCacheAll(): void;
+}
diff --git a/lib/public/UserPreferences/ValueType.php b/lib/public/UserPreferences/ValueType.php
new file mode 100644
index 00000000000..57f65b504c7
--- /dev/null
+++ b/lib/public/UserPreferences/ValueType.php
@@ -0,0 +1,111 @@
+<?php
+
+declare(strict_types=1);
+/**
+ * SPDX-FileCopyrightText: 2024 Nextcloud GmbH and Nextcloud contributors
+ * SPDX-License-Identifier: AGPL-3.0-or-later
+ */
+
+namespace OCP\UserPreferences;
+
+use OCP\UserPreferences\Exceptions\IncorrectTypeException;
+use UnhandledMatchError;
+use ValueError;
+
+/**
+ * Listing of available value type for user preferences
+ *
+ * @see IUserPreferences
+ * @since 31.0.0
+ */
+enum ValueType: int {
+	/** @since 31.0.0 */
+	case SENSITIVE = 1;
+	/** @since 31.0.0 */
+	case MIXED = 2;
+	/** @since 31.0.0 */
+	case STRING = 4;
+	/** @since 31.0.0 */
+	case INT = 8;
+	/** @since 31.0.0 */
+	case FLOAT = 16;
+	/** @since 31.0.0 */
+	case BOOL = 32;
+	/** @since 31.0.0 */
+	case ARRAY = 64;
+
+	/**
+	 * get ValueType from string based on ValueTypeDefinition
+	 *
+	 * @param string $definition
+	 *
+	 * @return self
+	 * @throws IncorrectTypeException
+	 * @since 31.0.0
+	 */
+	public function fromStringDefinition(string $definition): self {
+		try {
+			return $this->fromValueDefinition(ValueTypeDefinition::from($definition));
+		} catch (ValueError) {
+			throw new IncorrectTypeException('unknown string definition');
+		}
+	}
+
+	/**
+	 * get ValueType from ValueTypeDefinition
+	 *
+	 * @param ValueTypeDefinition $definition
+	 *
+	 * @return self
+	 * @throws IncorrectTypeException
+	 * @since 31.0.0
+	 */
+	public function fromValueDefinition(ValueTypeDefinition $definition): self {
+		try {
+			return match ($definition) {
+				ValueTypeDefinition::MIXED => self::MIXED,
+				ValueTypeDefinition::STRING => self::STRING,
+				ValueTypeDefinition::INT => self::INT,
+				ValueTypeDefinition::FLOAT => self::FLOAT,
+				ValueTypeDefinition::BOOL => self::BOOL,
+				ValueTypeDefinition::ARRAY => self::ARRAY
+			};
+		} catch (UnhandledMatchError) {
+			throw new IncorrectTypeException('unknown definition ' . $definition->value);
+		}
+	}
+
+	/**
+	 * get string definition for current enum value
+	 *
+	 * @return string
+	 * @throws IncorrectTypeException
+	 * @since 31.0.0
+	 */
+	public function getDefinition(): string {
+		return $this->getValueTypeDefinition()->value;
+	}
+
+	/**
+	 * get ValueTypeDefinition for current enum value
+	 *
+	 * @return ValueTypeDefinition
+	 * @throws IncorrectTypeException
+	 * @since 31.0.0
+	 */
+	public function getValueTypeDefinition(): ValueTypeDefinition {
+		try {
+			/** @psalm-suppress UnhandledMatchCondition */
+			return match ($this) {
+				self::MIXED => ValueTypeDefinition::MIXED,
+				self::STRING => ValueTypeDefinition::STRING,
+				self::INT => ValueTypeDefinition::INT,
+				self::FLOAT => ValueTypeDefinition::FLOAT,
+				self::BOOL => ValueTypeDefinition::BOOL,
+				self::ARRAY => ValueTypeDefinition::ARRAY,
+			};
+		} catch (UnhandledMatchError) {
+			throw new IncorrectTypeException('unknown type definition ' . $this->value);
+		}
+	}
+}
diff --git a/lib/public/UserPreferences/ValueTypeDefinition.php b/lib/public/UserPreferences/ValueTypeDefinition.php
new file mode 100644
index 00000000000..116c20b3baf
--- /dev/null
+++ b/lib/public/UserPreferences/ValueTypeDefinition.php
@@ -0,0 +1,30 @@
+<?php
+
+declare(strict_types=1);
+/**
+ * SPDX-FileCopyrightText: 2024 Nextcloud GmbH and Nextcloud contributors
+ * SPDX-License-Identifier: AGPL-3.0-or-later
+ */
+
+namespace OCP\UserPreferences;
+
+/**
+ * Listing of value type definition for user preferences
+ *
+ * @see IUserPreferences
+ * @since 31.0.0
+ */
+enum ValueTypeDefinition: string {
+	/** @since 30.0.0 */
+	case MIXED = 'mixed';
+	/** @since 30.0.0 */
+	case STRING = 'string';
+	/** @since 30.0.0 */
+	case INT = 'int';
+	/** @since 30.0.0 */
+	case FLOAT = 'float';
+	/** @since 30.0.0 */
+	case BOOL = 'bool';
+	/** @since 30.0.0 */
+	case ARRAY = 'array';
+}
diff --git a/tests/lib/AllConfigTest.php b/tests/lib/AllConfigTest.php
index 5d2091780a0..e892e441ecf 100644
--- a/tests/lib/AllConfigTest.php
+++ b/tests/lib/AllConfigTest.php
@@ -317,8 +317,8 @@ class AllConfigTest extends \Test\TestCase {
 
 		// preparation - add something to the database
 		$data = [
-			['userFetch', 'appFetch1', '123', 'value'],
-			['userFetch', 'appFetch1', '456', 'value'],
+			['userFetch8', 'appFetch1', '123', 'value'],
+			['userFetch8', 'appFetch1', '456', 'value'],
 		];
 		foreach ($data as $entry) {
 			$this->connection->executeUpdate(
@@ -328,7 +328,7 @@ class AllConfigTest extends \Test\TestCase {
 			);
 		}
 
-		$value = $config->getUserKeys('userFetch', 'appFetch1');
+		$value = $config->getUserKeys('userFetch8', 'appFetch1');
 		$this->assertEquals(['123', '456'], $value);
 		$this->assertIsString($value[0]);
 		$this->assertIsString($value[1]);
diff --git a/tests/lib/UserPreferencesTest.php b/tests/lib/UserPreferencesTest.php
new file mode 100644
index 00000000000..b7e1c229bcb
--- /dev/null
+++ b/tests/lib/UserPreferencesTest.php
@@ -0,0 +1,1833 @@
+<?php
+
+declare(strict_types=1);
+/**
+ * SPDX-FileCopyrightText: 2024 Nextcloud GmbH and Nextcloud contributors
+ * SPDX-License-Identifier: AGPL-3.0-only
+ */
+namespace lib;
+
+use OC\UserPreferences;
+use OCP\IDBConnection;
+use OCP\Security\ICrypto;
+use OCP\UserPreferences\Exceptions\TypeConflictException;
+use OCP\UserPreferences\Exceptions\UnknownKeyException;
+use OCP\UserPreferences\IUserPreferences;
+use OCP\UserPreferences\ValueType;
+use Psr\Log\LoggerInterface;
+use Test\TestCase;
+
+/**
+ * Class UserPreferencesTest
+ *
+ * @group DB
+ *
+ * @package Test
+ */
+class UserPreferencesTest extends TestCase {
+	protected IDBConnection $connection;
+	private LoggerInterface $logger;
+	private ICrypto $crypto;
+	private array $originalPreferences;
+
+	/**
+	 * @var array<string, array<string, array<array<string, string, int, bool, bool>>> [userId => [appId => prefKey, prefValue, valueType, lazy, sensitive]]]
+	 */
+	private array $basePreferences =
+		[
+			'user1' =>
+				[
+					'app1' => [
+						'key1' => ['key1', 'value1'],
+						'key22' => ['key22', '31'],
+						'fast_string' => ['fast_string', 'f_value', ValueType::STRING],
+						'lazy_string' => ['lazy_string', 'l_value', ValueType::STRING, true],
+						'fast_string_sensitive' => [
+							'fast_string_sensitive', 'fs_value', ValueType::STRING, false, true
+						],
+						'lazy_string_sensitive' => [
+							'lazy_string_sensitive', 'ls_value', ValueType::STRING, true, true
+						],
+						'fast_int' => ['fast_int', 11, ValueType::INT],
+						'lazy_int' => ['lazy_int', 12, ValueType::INT, true],
+						'fast_int_sensitive' => ['fast_int_sensitive', 2024, ValueType::INT, false, true],
+						'lazy_int_sensitive' => ['lazy_int_sensitive', 2048, ValueType::INT, true, true],
+						'fast_float' => ['fast_float', 3.14, ValueType::FLOAT],
+						'lazy_float' => ['lazy_float', 3.14159, ValueType::FLOAT, true],
+						'fast_float_sensitive' => [
+							'fast_float_sensitive', 1.41, ValueType::FLOAT, false, true
+						],
+						'lazy_float_sensitive' => [
+							'lazy_float_sensitive', 1.4142, ValueType::FLOAT, true, true
+						],
+						'fast_array' => ['fast_array', ['year' => 2024], ValueType::ARRAY],
+						'lazy_array' => ['lazy_array', ['month' => 'October'], ValueType::ARRAY, true],
+						'fast_array_sensitive' => [
+							'fast_array_sensitive', ['password' => 'pwd'], ValueType::ARRAY, false, true
+						],
+						'lazy_array_sensitive' => [
+							'lazy_array_sensitive', ['password' => 'qwerty'], ValueType::ARRAY, true, true
+						],
+						'fast_boolean' => ['fast_boolean', true, ValueType::BOOL],
+						'fast_boolean_0' => ['fast_boolean_0', false, ValueType::BOOL],
+						'lazy_boolean' => ['lazy_boolean', true, ValueType::BOOL, true],
+						'lazy_boolean_0' => ['lazy_boolean_0', false, ValueType::BOOL, true],
+					],
+					'app2' => [
+						'key2' => ['key2', 'value2a', ValueType::STRING],
+						'key3' => ['key3', 'value3', ValueType::STRING, true, false],
+						'key4' => ['key4', 'value4', ValueType::STRING, false, true],
+						'key8' => ['key8', 11, ValueType::INT],
+						'key9' => ['key9', 'value9a', ValueType::STRING],
+					],
+					'app3' => [
+						'key1' => ['key1', 'value123'],
+						'key3' => ['key3', 'value3'],
+						'key8' => ['key8', 12, ValueType::INT, false, true],
+						'key9' => ['key9', 'value9b', ValueType::STRING, false, true],
+						'key10' => ['key10', true, ValueType::BOOL],
+					],
+					'only-lazy' => [
+						'key1' => ['key1', 'value456', ValueType::STRING, true],
+						'key2' => ['key2', 'value2c', ValueType::STRING, true, true],
+						'key3' => ['key3', 42, ValueType::INT, true],
+						'key4' => ['key4', 17.42, ValueType::FLOAT, true],
+						'key5' => ['key5', true, ValueType::BOOL, true],
+					]
+				],
+			'user2' =>
+				[
+					'app1' => [
+						'1' => ['1', 'value1'],
+						'2' => ['2', 'value2', ValueType::STRING, true, true],
+						'3' => ['3', 17, ValueType::INT, true],
+						'4' => ['4', 42, ValueType::INT, false, true],
+						'5' => ['5', 17.42, ValueType::FLOAT, false],
+						'6' => ['6', true, ValueType::BOOL, false],
+					],
+					'app2' => [
+						'key2' => ['key2', 'value2b', ValueType::STRING],
+						'key3' => ['key3', 'value3', ValueType::STRING, true, false],
+						'key4' => ['key4', 'value4', ValueType::STRING, false, true],
+						'key8' => ['key8', 12, ValueType::INT],
+					],
+					'app3' => [
+						'key10' => ['key10', false, ValueType::BOOL],
+					],
+					'only-lazy' => [
+						'key1' => ['key1', 'value1', ValueType::STRING, true]
+					]
+				],
+			'user3' =>
+				[
+					'app2' => [
+						'key2' => ['key2', 'value2c'],
+						'key3' => ['key3', 'value3', ValueType::STRING, true, false],
+						'key4' => ['key4', 'value4', ValueType::STRING, false, true],
+						'fast_string_sensitive' => [
+							'fast_string_sensitive', 'fs_value', ValueType::STRING, false, true
+						],
+						'lazy_string_sensitive' => [
+							'lazy_string_sensitive', 'ls_value', ValueType::STRING, true, true
+						],
+					],
+					'only-lazy' => [
+						'key3' => ['key3', 'value3', ValueType::STRING, true]
+					]
+				],
+			'user4' =>
+				[
+					'app2' => [
+						'key1' => ['key1', 'value1'],
+						'key2' => ['key2', 'value2A'],
+						'key3' => ['key3', 'value3', ValueType::STRING, true, false],
+						'key4' => ['key4', 'value4', ValueType::STRING, false, true],
+					],
+					'app3' => [
+						'key10' => ['key10', true, ValueType::BOOL],
+					],
+					'only-lazy' => [
+						'key1' => ['key1', 123, ValueType::INT, true]
+					]
+				],
+			'user5' =>
+				[
+					'app1' => [
+						'key1' => ['key1', 'value1']
+					],
+					'app2' => [
+						'key8' => ['key8', 12, ValueType::INT]
+					],
+					'only-lazy' => [
+						'key1' => ['key1', 'value1', ValueType::STRING, true]
+					]
+				],
+
+		];
+
+	protected function setUp(): void {
+		parent::setUp();
+
+		$this->connection = \OCP\Server::get(IDBConnection::class);
+		$this->logger = \OCP\Server::get(LoggerInterface::class);
+		$this->crypto = \OCP\Server::get(ICrypto::class);
+
+		// storing current preferences and emptying the data table
+		$sql = $this->connection->getQueryBuilder();
+		$sql->select('*')
+			->from('preferences');
+		$result = $sql->executeQuery();
+		$this->originalPreferences = $result->fetchAll();
+		$result->closeCursor();
+
+		$sql = $this->connection->getQueryBuilder();
+		$sql->delete('preferences');
+		$sql->executeStatement();
+
+		$sql = $this->connection->getQueryBuilder();
+		$sql->insert('preferences')
+			->values(
+				[
+					'userid' => $sql->createParameter('userid'),
+					'appid' => $sql->createParameter('appid'),
+					'configkey' => $sql->createParameter('configkey'),
+					'configvalue' => $sql->createParameter('configvalue'),
+					'type' => $sql->createParameter('type'),
+					'lazy' => $sql->createParameter('lazy')
+				]
+			);
+
+		foreach ($this->basePreferences as $userId => $userData) {
+			foreach ($userData as $appId => $appData) {
+				foreach ($appData as $key => $row) {
+					$value = $row[1];
+					$type = ($row[2] ?? ValueType::MIXED)->value;
+
+					if ($type === ValueType::ARRAY->value) {
+						$value = json_encode($value);
+					}
+
+					if (($row[4] ?? false) === true) {
+						$type |= ValueType::SENSITIVE->value;
+						$value = self::invokePrivate(UserPreferences::class, 'ENCRYPTION_PREFIX')
+								 . $this->crypto->encrypt((string)$value);
+						$this->basePreferences[$userId][$appId][$key]['encrypted'] = $value;
+					}
+
+					if ($type === ValueType::BOOL->value && $value === false) {
+						$value = '0';
+					}
+
+					$sql->setParameters(
+						[
+							'userid' => $userId,
+							'appid' => $appId,
+							'configkey' => $row[0],
+							'configvalue' => $value,
+							'type' => $type,
+							'lazy' => (($row[3] ?? false) === true) ? 1 : 0
+						]
+					)->executeStatement();
+				}
+			}
+		}
+	}
+
+	protected function tearDown(): void {
+		$sql = $this->connection->getQueryBuilder();
+		$sql->delete('preferences');
+		$sql->executeStatement();
+
+		$sql = $this->connection->getQueryBuilder();
+		$sql->insert('preferences')
+			->values(
+				[
+					'userid' => $sql->createParameter('userid'),
+					'appid' => $sql->createParameter('appid'),
+					'configkey' => $sql->createParameter('configkey'),
+					'configvalue' => $sql->createParameter('configvalue'),
+					'lazy' => $sql->createParameter('lazy'),
+					'type' => $sql->createParameter('type'),
+				]
+			);
+
+		foreach ($this->originalPreferences as $key => $configs) {
+			$sql->setParameter('userid', $configs['userid'])
+				->setParameter('appid', $configs['appid'])
+				->setParameter('configkey', $configs['configkey'])
+				->setParameter('configvalue', $configs['configvalue'])
+				->setParameter('lazy', ($configs['lazy'] === '1') ? '1' : '0')
+				->setParameter('type', $configs['type']);
+			$sql->executeStatement();
+		}
+
+		parent::tearDown();
+	}
+
+	/**
+	 * @param array $preLoading preload the 'fast' cache for a list of users)
+	 *
+	 * @return IUserPreferences
+	 */
+	private function generateUserPreferences(array $preLoading = []): IUserPreferences {
+		$preferences = new \OC\UserPreferences(
+			$this->connection,
+			$this->logger,
+			$this->crypto,
+		);
+		$msg = ' generateUserPreferences() failed to confirm cache status';
+
+		// confirm cache status
+		$status = $preferences->statusCache();
+		$this->assertSame([], $status['fastLoaded'], $msg);
+		$this->assertSame([], $status['lazyLoaded'], $msg);
+		$this->assertSame([], $status['fastCache'], $msg);
+		$this->assertSame([], $status['lazyCache'], $msg);
+		foreach ($preLoading as $preLoadUser) {
+			// simple way to initiate the load of non-lazy preferences values in cache
+			$preferences->getValueString($preLoadUser, 'core', 'preload');
+
+			// confirm cache status
+			$status = $preferences->statusCache();
+			$this->assertSame(true, $status['fastLoaded'][$preLoadUser], $msg);
+			$this->assertSame(false, $status['lazyLoaded'][$preLoadUser], $msg);
+
+			$apps = array_values(array_diff(array_keys($this->basePreferences[$preLoadUser]), ['only-lazy']));
+			$this->assertEqualsCanonicalizing($apps, array_keys($status['fastCache'][$preLoadUser]), $msg);
+			$this->assertSame([], array_keys($status['lazyCache'][$preLoadUser]), $msg);
+		}
+
+		return $preferences;
+	}
+
+	public function testGetUserIdsEmpty(): void {
+		$preferences = $this->generateUserPreferences();
+		$this->assertEqualsCanonicalizing(array_keys($this->basePreferences), $preferences->getUserIds());
+	}
+
+	public function testGetUserIds(): void {
+		$preferences = $this->generateUserPreferences();
+		$this->assertEqualsCanonicalizing(['user1', 'user2', 'user5'], $preferences->getUserIds('app1'));
+	}
+
+	public function testGetApps(): void {
+		$preferences = $this->generateUserPreferences();
+		$this->assertEqualsCanonicalizing(
+			array_keys($this->basePreferences['user1']), $preferences->getApps('user1')
+		);
+	}
+
+	public function testGetKeys(): void {
+		$preferences = $this->generateUserPreferences(['user1']);
+		$this->assertEqualsCanonicalizing(
+			array_keys($this->basePreferences['user1']['app1']), $preferences->getKeys('user1', 'app1')
+		);
+	}
+
+	/**
+	 * @return array[]
+	 */
+	public function providerHasKey(): array {
+		return [
+			['user1', 'app1', 'key1', false, true],
+			['user0', 'app1', 'key1', false, false],
+			['user1', 'app1', 'key1', true, false],
+			['user1', 'app1', 'key0', false, false],
+			['user1', 'app1', 'key0', true, false],
+			['user1', 'app1', 'fast_string_sensitive', false, true],
+			['user1', 'app1', 'lazy_string_sensitive', true, true],
+			['user2', 'only-lazy', 'key1', false, false],
+			['user2', 'only-lazy', 'key1', true, true],
+		];
+	}
+
+	/**
+	 * @dataProvider providerHasKey
+	 */
+	public function testHasKey(string $userId, string $appId, string $key, ?bool $lazy, bool $result): void {
+		$preferences = $this->generateUserPreferences();
+		$this->assertEquals($result, $preferences->hasKey($userId, $appId, $key, $lazy));
+	}
+
+	/**
+	 * @return array[]
+	 */
+	public function providerIsSensitive(): array {
+		return [
+			['user1', 'app1', 'key1', false, false, false],
+			['user0', 'app1', 'key1', false, false, true],
+			['user1', 'app1', 'key1', true, false, true],
+			['user1', 'app1', 'key1', null, false, false],
+			['user1', 'app1', 'key0', false, false, true],
+			['user1', 'app1', 'key0', true, false, true],
+			['user1', 'app1', 'fast_string_sensitive', false, true, false],
+			['user1', 'app1', 'lazy_string_sensitive', true, true, false],
+			['user1', 'app1', 'fast_string_sensitive', true, true, true],
+			['user1', 'app1', 'lazy_string_sensitive', false, true, true],
+			['user1', 'app1', 'lazy_string_sensitive', null, true, false],
+			['user2', 'only-lazy', 'key1', false, false, true],
+			['user2', 'only-lazy', 'key1', true, false, false],
+			['user2', 'only-lazy', 'key1', null, false, false],
+		];
+	}
+
+	/**
+	 * @dataProvider providerIsSensitive
+	 */
+	public function testIsSensitive(
+		string $userId,
+		string $appId,
+		string $key,
+		?bool $lazy,
+		bool $result,
+		bool $exception,
+	): void {
+		$preferences = $this->generateUserPreferences();
+		if ($exception) {
+			$this->expectException(UnknownKeyException::class);
+		}
+
+		$this->assertEquals($result, $preferences->isSensitive($userId, $appId, $key, $lazy));
+	}
+
+	/**
+	 * @return array[]
+	 */
+	public function providerIsLazy(): array {
+		return [
+			['user1', 'app1', 'key1', false, false],
+			['user0', 'app1', 'key1', false, true],
+			['user1', 'app1', 'key0', false, true],
+			['user1', 'app1', 'key0', false, true],
+			['user1', 'app1', 'fast_string_sensitive', false, false],
+			['user1', 'app1', 'lazy_string_sensitive', true, false],
+			['user2', 'only-lazy', 'key1', true, false],
+		];
+	}
+
+	/**
+	 * @dataProvider providerIsLazy
+	 */
+	public function testIsLazy(
+		string $userId,
+		string $appId,
+		string $key,
+		bool $result,
+		bool $exception,
+	): void {
+		$preferences = $this->generateUserPreferences();
+		if ($exception) {
+			$this->expectException(UnknownKeyException::class);
+		}
+
+		$this->assertEquals($result, $preferences->isLazy($userId, $appId, $key));
+	}
+
+	public function providerGetValues(): array {
+		return [
+			[
+				'user1', 'app1', '', true,
+				[
+					'fast_array' => ['year' => 2024],
+					'fast_array_sensitive' => '***REMOVED SENSITIVE VALUE***',
+					'fast_boolean' => true,
+					'fast_boolean_0' => false,
+					'fast_float' => 3.14,
+					'fast_float_sensitive' => '***REMOVED SENSITIVE VALUE***',
+					'fast_int' => 11,
+					'fast_int_sensitive' => '***REMOVED SENSITIVE VALUE***',
+					'fast_string' => 'f_value',
+					'fast_string_sensitive' => '***REMOVED SENSITIVE VALUE***',
+					'key1' => 'value1',
+					'key22' => '31',
+					'lazy_array' => ['month' => 'October'],
+					'lazy_array_sensitive' => '***REMOVED SENSITIVE VALUE***',
+					'lazy_boolean' => true,
+					'lazy_boolean_0' => false,
+					'lazy_float' => 3.14159,
+					'lazy_float_sensitive' => '***REMOVED SENSITIVE VALUE***',
+					'lazy_int' => 12,
+					'lazy_int_sensitive' => '***REMOVED SENSITIVE VALUE***',
+					'lazy_string' => 'l_value',
+					'lazy_string_sensitive' => '***REMOVED SENSITIVE VALUE***',
+				]
+			],
+			[
+				'user1', 'app1', '', false,
+				[
+					'fast_array' => ['year' => 2024],
+					'fast_array_sensitive' => ['password' => 'pwd'],
+					'fast_boolean' => true,
+					'fast_boolean_0' => false,
+					'fast_float' => 3.14,
+					'fast_float_sensitive' => 1.41,
+					'fast_int' => 11,
+					'fast_int_sensitive' => 2024,
+					'fast_string' => 'f_value',
+					'fast_string_sensitive' => 'fs_value',
+					'key1' => 'value1',
+					'key22' => '31',
+					'lazy_array' => ['month' => 'October'],
+					'lazy_array_sensitive' => ['password' => 'qwerty'],
+					'lazy_boolean' => true,
+					'lazy_boolean_0' => false,
+					'lazy_float' => 3.14159,
+					'lazy_float_sensitive' => 1.4142,
+					'lazy_int' => 12,
+					'lazy_int_sensitive' => 2048,
+					'lazy_string' => 'l_value',
+					'lazy_string_sensitive' => 'ls_value'
+				]
+			],
+			[
+				'user1', 'app1', 'fast_', true,
+				[
+					'fast_array' => ['year' => 2024],
+					'fast_array_sensitive' => '***REMOVED SENSITIVE VALUE***',
+					'fast_boolean' => true,
+					'fast_boolean_0' => false,
+					'fast_float' => 3.14,
+					'fast_float_sensitive' => '***REMOVED SENSITIVE VALUE***',
+					'fast_int' => 11,
+					'fast_int_sensitive' => '***REMOVED SENSITIVE VALUE***',
+					'fast_string' => 'f_value',
+					'fast_string_sensitive' => '***REMOVED SENSITIVE VALUE***',
+				]
+			],
+			[
+				'user1', 'app1', 'fast_', false,
+				[
+					'fast_array' => ['year' => 2024],
+					'fast_array_sensitive' => ['password' => 'pwd'],
+					'fast_boolean' => true,
+					'fast_boolean_0' => false,
+					'fast_float' => 3.14,
+					'fast_float_sensitive' => 1.41,
+					'fast_int' => 11,
+					'fast_int_sensitive' => 2024,
+					'fast_string' => 'f_value',
+					'fast_string_sensitive' => 'fs_value',
+				]
+			],
+			[
+				'user1', 'app1', 'key1', true,
+				[
+					'key1' => 'value1',
+				]
+			],
+			[
+				'user2', 'app1', '', false,
+				[
+					'1' => 'value1',
+					'4' => 42,
+					'5' => 17.42,
+					'6' => true,
+					'2' => 'value2',
+					'3' => 17,
+				]
+			],
+			[
+				'user2', 'app1', '', true,
+				[
+					'1' => 'value1',
+					'4' => '***REMOVED SENSITIVE VALUE***',
+					'5' => 17.42,
+					'6' => true,
+					'2' => '***REMOVED SENSITIVE VALUE***',
+					'3' => 17,
+				]
+			],
+		];
+	}
+
+	/**
+	 * @dataProvider providerGetValues
+	 */
+	public function testGetValues(
+		string $userId,
+		string $appId,
+		string $prefix,
+		bool $filtered,
+		array $result,
+	): void {
+		$preferences = $this->generateUserPreferences();
+		$this->assertJsonStringEqualsJsonString(
+			json_encode($result), json_encode($preferences->getValues($userId, $appId, $prefix, $filtered))
+		);
+	}
+
+	public function providerGetAllValues(): array {
+		return [
+			[
+				'user2', false,
+				[
+					'app1' => [
+						'1' => 'value1',
+						'4' => 42,
+						'5' => 17.42,
+						'6' => true,
+						'2' => 'value2',
+						'3' => 17,
+					],
+					'app2' => [
+						'key2' => 'value2b',
+						'key3' => 'value3',
+						'key4' => 'value4',
+						'key8' => 12,
+					],
+					'app3' => [
+						'key10' => false,
+					],
+					'only-lazy' => [
+						'key1' => 'value1',
+					]
+				],
+			],
+			[
+				'user2', true,
+				[
+					'app1' => [
+						'1' => 'value1',
+						'4' => '***REMOVED SENSITIVE VALUE***',
+						'5' => 17.42,
+						'6' => true,
+						'2' => '***REMOVED SENSITIVE VALUE***',
+						'3' => 17,
+					],
+					'app2' => [
+						'key2' => 'value2b',
+						'key3' => 'value3',
+						'key4' => '***REMOVED SENSITIVE VALUE***',
+						'key8' => 12,
+					],
+					'app3' => [
+						'key10' => false,
+					],
+					'only-lazy' => [
+						'key1' => 'value1',
+					]
+				],
+			],
+			[
+				'user3', true,
+				[
+					'app2' => [
+						'key2' => 'value2c',
+						'key3' => 'value3',
+						'key4' => '***REMOVED SENSITIVE VALUE***',
+						'fast_string_sensitive' => '***REMOVED SENSITIVE VALUE***',
+						'lazy_string_sensitive' => '***REMOVED SENSITIVE VALUE***',
+					],
+					'only-lazy' => [
+						'key3' => 'value3',
+					]
+				],
+			],
+			[
+				'user3', false,
+				[
+					'app2' => [
+						'key2' => 'value2c',
+						'key3' => 'value3',
+						'key4' => 'value4',
+						'fast_string_sensitive' => 'fs_value',
+						'lazy_string_sensitive' => 'ls_value',
+					],
+					'only-lazy' => [
+						'key3' => 'value3',
+					]
+				],
+			],
+		];
+	}
+
+	/**
+	 * @dataProvider providerGetAllValues
+	 */
+	public function testGetAllValues(
+		string $userId,
+		bool $filtered,
+		array $result,
+	): void {
+		$preferences = $this->generateUserPreferences();
+		$this->assertEqualsCanonicalizing($result, $preferences->getAllValues($userId, $filtered));
+	}
+
+	public function providerSearchValuesByApps(): array {
+		return [
+			[
+				'user1', 'key1', false, null,
+				[
+					'app1' => 'value1',
+					'app3' => 'value123'
+				]
+			],
+			[
+				'user1', 'key1', true, null,
+				[
+					'only-lazy' => 'value456'
+				]
+			],
+			[
+				'user1', 'key8', false, null,
+				[
+					'app2' => 11,
+					'app3' => 12,
+				]
+			],
+			[
+				'user1', 'key9', false, ValueType::INT,
+				[
+					'app2' => 0,
+					'app3' => 0,
+				]
+			]
+		];
+	}
+
+	/**
+	 * @dataProvider providerSearchValuesByApps
+	 */
+	public function testSearchValuesByApps(
+		string $userId,
+		string $key,
+		bool $lazy,
+		?ValueType $typedAs,
+		array $result,
+	): void {
+		$preferences = $this->generateUserPreferences();
+		$this->assertEquals($result, $preferences->searchValuesByApps($userId, $key, $lazy, $typedAs));
+	}
+
+	public function providerSearchValuesByUsers(): array {
+		return [
+			[
+				'app2', 'key2', null, null,
+				[
+					'user1' => 'value2a',
+					'user2' => 'value2b',
+					'user3' => 'value2c',
+					'user4' => 'value2A'
+				]
+			],
+			[
+				'app2', 'key2', null, ['user1', 'user3'],
+				[
+					'user1' => 'value2a',
+					'user3' => 'value2c',
+				]
+			],
+			[
+				'app2', 'key2', ValueType::INT, ['user1', 'user3'],
+				[
+					'user1' => 0,
+					'user3' => 0,
+				]
+			],
+			[
+				'app2', 'key8', ValueType::INT, null,
+				[
+					'user1' => 11,
+					'user2' => 12,
+					'user5' => 12,
+				]
+			],
+		];
+	}
+
+	/**
+	 * @dataProvider providerSearchValuesByUsers
+	 */
+	public function testSearchValuesByUsers(
+		string $app,
+		string $key,
+		?ValueType $typedAs = null,
+		?array $userIds = null,
+		array $result,
+	): void {
+		$preferences = $this->generateUserPreferences();
+		$this->assertEqualsCanonicalizing(
+			$result, $preferences->searchValuesByUsers($app, $key, $typedAs, $userIds)
+		);
+	}
+
+	public function providerSearchValuesByValueString(): array {
+		return [
+			['app2', 'key2', 'value2a', false, ['user1']],
+			['app2', 'key2', 'value2A', false, ['user4']],
+			['app2', 'key2', 'value2A', true, ['user1', 'user4']]
+		];
+	}
+
+	/**
+	 * @dataProvider providerSearchValuesByValueString
+	 */
+	public function testSearchUsersByValueString(
+		string $app,
+		string $key,
+		string|array $value,
+		bool $ci,
+		array $result,
+	): void {
+		$preferences = $this->generateUserPreferences();
+		$this->assertEqualsCanonicalizing(
+			$result, $preferences->searchUsersByValueString($app, $key, $value, $ci)
+		);
+	}
+
+	public function providerSearchValuesByValueInt(): array {
+		return [
+			['app3', 'key8', 12, []], // sensitive value, cannot search
+			['app2', 'key8', 12, ['user2', 'user5']], // sensitive value, cannot search
+			['only-lazy', 'key1', 123, ['user4']],
+		];
+	}
+
+	/**
+	 * @dataProvider providerSearchValuesByValueInt
+	 */
+	public function testSearchUsersByValueInt(
+		string $app,
+		string $key,
+		int $value,
+		array $result,
+	): void {
+		$preferences = $this->generateUserPreferences();
+		$this->assertEqualsCanonicalizing($result, $preferences->searchUsersByValueInt($app, $key, $value));
+	}
+
+	public function providerSearchValuesByValues(): array {
+		return [
+			['app2', 'key2', ['value2a', 'value2b'], ['user1', 'user2']],
+			['app2', 'key2', ['value2a', 'value2c'], ['user1', 'user3']],
+		];
+	}
+
+	/**
+	 * @dataProvider providerSearchValuesByValues
+	 */
+	public function testSearchUsersByValues(
+		string $app,
+		string $key,
+		array $values,
+		array $result,
+	): void {
+		$preferences = $this->generateUserPreferences();
+		$this->assertEqualsCanonicalizing($result, $preferences->searchUsersByValues($app, $key, $values));
+	}
+
+	public function providerSearchValuesByValueBool(): array {
+		return [
+			['app3', 'key10', true, ['user1', 'user4']],
+			['app3', 'key10', false, ['user2']],
+		];
+	}
+
+	/**
+	 * @dataProvider providerSearchValuesByValueBool
+	 */
+	public function testSearchUsersByValueBool(
+		string $app,
+		string $key,
+		bool $value,
+		array $result,
+	): void {
+		$preferences = $this->generateUserPreferences();
+		$this->assertEqualsCanonicalizing($result, $preferences->searchUsersByValueBool($app, $key, $value));
+	}
+
+	public function providerGetValueMixed(): array {
+		return [
+			[
+				['user1'], 'user1', 'app1', 'key0', 'default_because_unknown_key', true,
+				'default_because_unknown_key'
+			],
+			[
+				null, 'user1', 'app1', 'key0', 'default_because_unknown_key', true,
+				'default_because_unknown_key'
+			],
+			[
+				['user1'], 'user1', 'app1', 'key0', 'default_because_unknown_key', false,
+				'default_because_unknown_key'
+			],
+			[
+				null, 'user1', 'app1', 'key0', 'default_because_unknown_key', false,
+				'default_because_unknown_key'
+			],
+			[['user1'], 'user1', 'app1', 'fast_string', 'default_because_unknown_key', false, 'f_value'],
+			[null, 'user1', 'app1', 'fast_string', 'default_because_unknown_key', false, 'f_value'],
+			[['user1'], 'user1', 'app1', 'fast_string', 'default_because_unknown_key', true, 'f_value'],
+			// because non-lazy are already loaded
+			[
+				null, 'user1', 'app1', 'fast_string', 'default_because_unknown_key', true,
+				'default_because_unknown_key'
+			],
+			[
+				['user1'], 'user1', 'app1', 'lazy_string', 'default_because_unknown_key', false,
+				'default_because_unknown_key'
+			],
+			[
+				null, 'user1', 'app1', 'lazy_string', 'default_because_unknown_key', false,
+				'default_because_unknown_key'
+			],
+			[['user1'], 'user1', 'app1', 'lazy_string', 'default_because_unknown_key', true, 'l_value'],
+			[null, 'user1', 'app1', 'lazy_string', 'default_because_unknown_key', true, 'l_value'],
+			[
+				['user1'], 'user1', 'app1', 'fast_string_sensitive', 'default_because_unknown_key', false,
+				'fs_value'
+			],
+			[
+				null, 'user1', 'app1', 'fast_string_sensitive', 'default_because_unknown_key', false,
+				'fs_value'
+			],
+			[
+				['user1'], 'user1', 'app1', 'fast_string_sensitive', 'default_because_unknown_key', true,
+				'fs_value'
+			],
+			[
+				null, 'user1', 'app1', 'fast_string_sensitive', 'default_because_unknown_key', true,
+				'default_because_unknown_key'
+			],
+			[
+				['user1'], 'user1', 'app1', 'lazy_string_sensitive', 'default_because_unknown_key', false,
+				'default_because_unknown_key'
+			],
+			[
+				null, 'user1', 'app1', 'lazy_string_sensitive', 'default_because_unknown_key', false,
+				'default_because_unknown_key'
+			],
+			[
+				['user1'], 'user1', 'app1', 'lazy_string_sensitive', 'default_because_unknown_key', true,
+				'ls_value'
+			],
+			[null, 'user1', 'app1', 'lazy_string_sensitive', 'default_because_unknown_key', true, 'ls_value'],
+		];
+	}
+
+	/**
+	 * @dataProvider providerGetValueMixed
+	 */
+	public function testGetValueMixed(
+		?array $preload,
+		string $userId,
+		string $app,
+		string $key,
+		string $default,
+		bool $lazy,
+		string $result,
+	): void {
+		$preferences = $this->generateUserPreferences($preload ?? []);
+		$this->assertEquals($result, $preferences->getValueMixed($userId, $app, $key, $default, $lazy));
+	}
+
+	/**
+	 * @dataProvider providerGetValueMixed
+	 */
+	public function testGetValueString(
+		?array $preload,
+		string $userId,
+		string $app,
+		string $key,
+		string $default,
+		bool $lazy,
+		string $result,
+	): void {
+		$preferences = $this->generateUserPreferences($preload ?? []);
+		$this->assertEquals($result, $preferences->getValueString($userId, $app, $key, $default, $lazy));
+	}
+
+	public function providerGetValueInt(): array {
+		return [
+			[['user1'], 'user1', 'app1', 'key0', 54321, true, 54321],
+			[null, 'user1', 'app1', 'key0', 54321, true, 54321],
+			[['user1'], 'user1', 'app1', 'key0', 54321, false, 54321],
+			[null, 'user1', 'app1', 'key0', 54321, false, 54321],
+			[null, 'user1', 'app1', 'key22', 54321, false, 31],
+			[['user1'], 'user1', 'app1', 'fast_int', 54321, false, 11],
+			[null, 'user1', 'app1', 'fast_int', 54321, false, 11],
+			[['user1'], 'user1', 'app1', 'fast_int', 54321, true, 11],
+			[null, 'user1', 'app1', 'fast_int', 54321, true, 54321],
+			[['user1'], 'user1', 'app1', 'fast_int_sensitive', 54321, false, 2024],
+			[null, 'user1', 'app1', 'fast_int_sensitive', 54321, false, 2024],
+			[['user1'], 'user1', 'app1', 'fast_int_sensitive', 54321, true, 2024],
+			[null, 'user1', 'app1', 'fast_int_sensitive', 54321, true, 54321],
+			[['user1'], 'user1', 'app1', 'lazy_int', 54321, false, 54321],
+			[null, 'user1', 'app1', 'lazy_int', 54321, false, 54321],
+			[['user1'], 'user1', 'app1', 'lazy_int', 54321, true, 12],
+			[null, 'user1', 'app1', 'lazy_int', 54321, true, 12],
+			[['user1'], 'user1', 'app1', 'lazy_int_sensitive', 54321, false, 54321],
+			[null, 'user1', 'app1', 'lazy_int_sensitive', 54321, false, 54321],
+			[['user1'], 'user1', 'app1', 'lazy_int_sensitive', 54321, true, 2048],
+			[null, 'user1', 'app1', 'lazy_int_sensitive', 54321, true, 2048],
+		];
+	}
+
+	/**
+	 * @dataProvider providerGetValueInt
+	 */
+	public function testGetValueInt(
+		?array $preload,
+		string $userId,
+		string $app,
+		string $key,
+		int $default,
+		bool $lazy,
+		int $result,
+	): void {
+		$preferences = $this->generateUserPreferences($preload ?? []);
+		$this->assertEquals($result, $preferences->getValueInt($userId, $app, $key, $default, $lazy));
+	}
+
+	public function providerGetValueFloat(): array {
+		return [
+			[['user1'], 'user1', 'app1', 'key0', 54.321, true, 54.321],
+			[null, 'user1', 'app1', 'key0', 54.321, true, 54.321],
+			[['user1'], 'user1', 'app1', 'key0', 54.321, false, 54.321],
+			[null, 'user1', 'app1', 'key0', 54.321, false, 54.321],
+			[['user1'], 'user1', 'app1', 'fast_float', 54.321, false, 3.14],
+			[null, 'user1', 'app1', 'fast_float', 54.321, false, 3.14],
+			[['user1'], 'user1', 'app1', 'fast_float', 54.321, true, 3.14],
+			[null, 'user1', 'app1', 'fast_float', 54.321, true, 54.321],
+			[['user1'], 'user1', 'app1', 'fast_float_sensitive', 54.321, false, 1.41],
+			[null, 'user1', 'app1', 'fast_float_sensitive', 54.321, false, 1.41],
+			[['user1'], 'user1', 'app1', 'fast_float_sensitive', 54.321, true, 1.41],
+			[null, 'user1', 'app1', 'fast_float_sensitive', 54.321, true, 54.321],
+			[['user1'], 'user1', 'app1', 'lazy_float', 54.321, false, 54.321],
+			[null, 'user1', 'app1', 'lazy_float', 54.321, false, 54.321],
+			[['user1'], 'user1', 'app1', 'lazy_float', 54.321, true, 3.14159],
+			[null, 'user1', 'app1', 'lazy_float', 54.321, true, 3.14159],
+			[['user1'], 'user1', 'app1', 'lazy_float_sensitive', 54.321, false, 54.321],
+			[null, 'user1', 'app1', 'lazy_float_sensitive', 54.321, false, 54.321],
+			[['user1'], 'user1', 'app1', 'lazy_float_sensitive', 54.321, true, 1.4142],
+			[null, 'user1', 'app1', 'lazy_float_sensitive', 54.321, true, 1.4142],
+		];
+	}
+
+	/**
+	 * @dataProvider providerGetValueFloat
+	 */
+	public function testGetValueFloat(
+		?array $preload,
+		string $userId,
+		string $app,
+		string $key,
+		float $default,
+		bool $lazy,
+		float $result,
+	): void {
+		$preferences = $this->generateUserPreferences($preload ?? []);
+		$this->assertEquals($result, $preferences->getValueFloat($userId, $app, $key, $default, $lazy));
+	}
+
+	public function providerGetValueBool(): array {
+		return [
+			[['user1'], 'user1', 'app1', 'key0', false, true, false],
+			[null, 'user1', 'app1', 'key0', false, true, false],
+			[['user1'], 'user1', 'app1', 'key0', true, true, true],
+			[null, 'user1', 'app1', 'key0', true, true, true],
+			[['user1'], 'user1', 'app1', 'key0', false, false, false],
+			[null, 'user1', 'app1', 'key0', false, false, false],
+			[['user1'], 'user1', 'app1', 'key0', true, false, true],
+			[null, 'user1', 'app1', 'key0', true, false, true],
+			[['user1'], 'user1', 'app1', 'fast_boolean', false, false, true],
+			[null, 'user1', 'app1', 'fast_boolean', false, false, true],
+			[['user1'], 'user1', 'app1', 'fast_boolean_0', false, false, false],
+			[null, 'user1', 'app1', 'fast_boolean_0', false, false, false],
+			[['user1'], 'user1', 'app1', 'fast_boolean', true, false, true],
+			[null, 'user1', 'app1', 'fast_boolean', true, false, true],
+			[['user1'], 'user1', 'app1', 'fast_boolean_0', true, false, false],
+			[null, 'user1', 'app1', 'fast_boolean_0', true, false, false],
+			[['user1'], 'user1', 'app1', 'fast_boolean', false, true, true],
+			[null, 'user1', 'app1', 'fast_boolean', false, true, false],
+			[['user1'], 'user1', 'app1', 'fast_boolean_0', false, true, false],
+			[null, 'user1', 'app1', 'fast_boolean_0', false, true, false],
+			[['user1'], 'user1', 'app1', 'fast_boolean', true, true, true],
+			[null, 'user1', 'app1', 'fast_boolean', true, true, true],
+			[['user1'], 'user1', 'app1', 'fast_boolean_0', true, true, false],
+			[null, 'user1', 'app1', 'fast_boolean_0', true, true, true],
+			[['user1'], 'user1', 'app1', 'lazy_boolean', false, false, false],
+			[null, 'user1', 'app1', 'lazy_boolean', false, false, false],
+			[['user1'], 'user1', 'app1', 'lazy_boolean_0', false, false, false],
+			[null, 'user1', 'app1', 'lazy_boolean_0', false, false, false],
+			[['user1'], 'user1', 'app1', 'lazy_boolean', true, false, true],
+			[null, 'user1', 'app1', 'lazy_boolean', true, false, true],
+			[['user1'], 'user1', 'app1', 'lazy_boolean_0', true, false, true],
+			[null, 'user1', 'app1', 'lazy_boolean_0', true, false, true],
+			[['user1'], 'user1', 'app1', 'lazy_boolean', false, true, true],
+			[null, 'user1', 'app1', 'lazy_boolean', false, true, true],
+			[['user1'], 'user1', 'app1', 'lazy_boolean_0', false, true, false],
+			[null, 'user1', 'app1', 'lazy_boolean_0', false, true, false],
+			[['user1'], 'user1', 'app1', 'lazy_boolean', true, true, true],
+			[null, 'user1', 'app1', 'lazy_boolean', true, true, true],
+			[['user1'], 'user1', 'app1', 'lazy_boolean_0', true, true, false],
+			[null, 'user1', 'app1', 'lazy_boolean_0', true, true, false],
+		];
+	}
+
+	/**
+	 * @dataProvider providerGetValueBool
+	 */
+	public function testGetValueBool(
+		?array $preload,
+		string $userId,
+		string $app,
+		string $key,
+		bool $default,
+		bool $lazy,
+		bool $result,
+	): void {
+		$preferences = $this->generateUserPreferences($preload ?? []);
+		$this->assertEquals($result, $preferences->getValueBool($userId, $app, $key, $default, $lazy));
+	}
+
+	public function providerGetValueArray(): array {
+		return [
+			[
+				['user1'], 'user1', 'app1', 'key0', ['default_because_unknown_key'], true,
+				['default_because_unknown_key']
+			],
+			[
+				null, 'user1', 'app1', 'key0', ['default_because_unknown_key'], true,
+				['default_because_unknown_key']
+			],
+			[
+				['user1'], 'user1', 'app1', 'key0', ['default_because_unknown_key'], false,
+				['default_because_unknown_key']
+			],
+			[
+				null, 'user1', 'app1', 'key0', ['default_because_unknown_key'], false,
+				['default_because_unknown_key']
+			],
+		];
+	}
+
+	/**
+	 * @dataProvider providerGetValueArray
+	 */
+	public function testGetValueArray(
+		?array $preload,
+		string $userId,
+		string $app,
+		string $key,
+		array $default,
+		bool $lazy,
+		array $result,
+	): void {
+		$preferences = $this->generateUserPreferences($preload ?? []);
+		$this->assertEqualsCanonicalizing(
+			$result, $preferences->getValueArray($userId, $app, $key, $default, $lazy)
+		);
+	}
+
+	public function providerGetValueType(): array {
+		return [
+			[null, 'user1', 'app1', 'key1', false, ValueType::MIXED],
+			[null, 'user1', 'app1', 'key1', true, null, UnknownKeyException::class],
+			[null, 'user1', 'app1', 'fast_string', true, ValueType::STRING, UnknownKeyException::class],
+			[['user1'], 'user1', 'app1', 'fast_string', true, ValueType::STRING],
+			[null, 'user1', 'app1', 'fast_string', false, ValueType::STRING],
+			[null, 'user1', 'app1', 'lazy_string', true, ValueType::STRING],
+			[null, 'user1', 'app1', 'lazy_string', false, ValueType::STRING, UnknownKeyException::class],
+			[
+				null, 'user1', 'app1', 'fast_string_sensitive', true, ValueType::STRING,
+				UnknownKeyException::class
+			],
+			[['user1'], 'user1', 'app1', 'fast_string_sensitive', true, ValueType::STRING],
+			[null, 'user1', 'app1', 'fast_string_sensitive', false, ValueType::STRING],
+			[null, 'user1', 'app1', 'lazy_string_sensitive', true, ValueType::STRING],
+			[
+				null, 'user1', 'app1', 'lazy_string_sensitive', false, ValueType::STRING,
+				UnknownKeyException::class
+			],
+			[null, 'user1', 'app1', 'fast_int', true, ValueType::INT, UnknownKeyException::class],
+			[['user1'], 'user1', 'app1', 'fast_int', true, ValueType::INT],
+			[null, 'user1', 'app1', 'fast_int', false, ValueType::INT],
+			[null, 'user1', 'app1', 'lazy_int', true, ValueType::INT],
+			[null, 'user1', 'app1', 'lazy_int', false, ValueType::INT, UnknownKeyException::class],
+			[null, 'user1', 'app1', 'fast_float', true, ValueType::FLOAT, UnknownKeyException::class],
+			[['user1'], 'user1', 'app1', 'fast_float', true, ValueType::FLOAT],
+			[null, 'user1', 'app1', 'fast_float', false, ValueType::FLOAT],
+			[null, 'user1', 'app1', 'lazy_float', true, ValueType::FLOAT],
+			[null, 'user1', 'app1', 'lazy_float', false, ValueType::FLOAT, UnknownKeyException::class],
+			[null, 'user1', 'app1', 'fast_boolean', true, ValueType::BOOL, UnknownKeyException::class],
+			[['user1'], 'user1', 'app1', 'fast_boolean', true, ValueType::BOOL],
+			[null, 'user1', 'app1', 'fast_boolean', false, ValueType::BOOL],
+			[null, 'user1', 'app1', 'lazy_boolean', true, ValueType::BOOL],
+			[null, 'user1', 'app1', 'lazy_boolean', false, ValueType::BOOL, UnknownKeyException::class],
+		];
+	}
+
+	/**
+	 * @dataProvider providerGetValueType
+	 */
+	public function testGetValueType(
+		?array $preload,
+		string $userId,
+		string $app,
+		string $key,
+		?bool $lazy,
+		?ValueType $result,
+		?string $exception = null,
+	): void {
+		$preferences = $this->generateUserPreferences($preload ?? []);
+		if ($exception !== null) {
+			$this->expectException($exception);
+		}
+
+		$type = $preferences->getValueType($userId, $app, $key, $lazy);
+		if ($exception === null) {
+			$this->assertEquals($result->value, $type->value);
+		}
+	}
+
+	public function providerSetValueMixed(): array {
+		return [
+			[null, 'user1', 'app1', 'key1', 'value', false, false, true],
+			[null, 'user1', 'app1', 'key1', '12345', true, false, true],
+			[null, 'user1', 'app1', 'key1', '12345', true, true, true],
+			[null, 'user1', 'app1', 'key1', 'value1', false, false, false],
+			[null, 'user1', 'app1', 'key1', 'value1', true, false, true],
+			[null, 'user1', 'app1', 'key1', 'value1', false, true, true],
+			[
+				null, 'user1', 'app1', 'fast_string', 'f_value_2', false, false, true,
+				TypeConflictException::class
+			],
+			[
+				null, 'user1', 'app1', 'fast_string', 'f_value', true, false, true,
+				TypeConflictException::class
+			],
+			[null, 'user1', 'app1', 'fast_string', 'f_value', true, true, true, TypeConflictException::class],
+			[null, 'user1', 'app1', 'fast_int', 'n_value', false, false, true, TypeConflictException::class],
+			[
+				null, 'user1', 'app1', 'fast_float', 'n_value', false, false, true,
+				TypeConflictException::class
+			],
+			[
+				null, 'user1', 'app1', 'lazy_string', 'l_value_2', false, false, true,
+				TypeConflictException::class
+			],
+			[null, 'user1', 'app1', 'lazy_string', 'l_value', true, false, false],
+			[null, 'user1', 'app1', 'lazy_string', 'l_value', true, true, true, TypeConflictException::class],
+			[null, 'user1', 'app1', 'lazy_int', 'l_value', false, false, true, TypeConflictException::class],
+			[
+				null, 'user1', 'app1', 'lazy_float', 'l_value', false, false, true,
+				TypeConflictException::class
+			],
+		];
+	}
+
+	/**
+	 * @dataProvider providerSetValueMixed
+	 */
+	public function testSetValueMixed(
+		?array $preload,
+		string $userId,
+		string $app,
+		string $key,
+		string $value,
+		bool $lazy,
+		bool $sensitive,
+		bool $result,
+		?string $exception = null,
+	): void {
+		$preferences = $this->generateUserPreferences($preload ?? []);
+		if ($exception !== null) {
+			$this->expectException($exception);
+		}
+
+		$edited = $preferences->setValueMixed($userId, $app, $key, $value, $lazy, $sensitive);
+
+		if ($exception === null) {
+			$this->assertEquals($result, $edited);
+		}
+	}
+
+
+	public function providerSetValueString(): array {
+		return [
+			[null, 'user1', 'app1', 'key1', 'value', false, false, true],
+			[null, 'user1', 'app1', 'key1', '12345', true, false, true],
+			[null, 'user1', 'app1', 'key1', '12345', true, true, true],
+			[null, 'user1', 'app1', 'key1', 'value1', false, false, false],
+			[null, 'user1', 'app1', 'key1', 'value1', true, false, true],
+			[null, 'user1', 'app1', 'key1', 'value1', false, true, true],
+			[null, 'user1', 'app1', 'fast_string', 'f_value_2', false, false, true],
+			[null, 'user1', 'app1', 'fast_string', 'f_value', false, false, false],
+			[null, 'user1', 'app1', 'fast_string', 'f_value', true, false, true],
+			[null, 'user1', 'app1', 'fast_string', 'f_value', true, true, true],
+			[null, 'user1', 'app1', 'lazy_string', 'l_value_2', false, false, true],
+			[null, 'user1', 'app1', 'lazy_string', 'l_value', true, false, false],
+			[null, 'user1', 'app1', 'lazy_string', 'l_value', true, true, true],
+			[null, 'user1', 'app1', 'fast_string_sensitive', 'fs_value', false, true, false],
+			[null, 'user1', 'app1', 'fast_string_sensitive', 'fs_value', true, true, true],
+			[null, 'user1', 'app1', 'fast_string_sensitive', 'fs_value', true, false, true],
+			[null, 'user1', 'app1', 'lazy_string_sensitive', 'ls_value', false, true, true],
+			[null, 'user1', 'app1', 'lazy_string_sensitive', 'ls_value', true, true, false],
+			[null, 'user1', 'app1', 'lazy_string_sensitive', 'ls_value', true, false, false],
+			[null, 'user1', 'app1', 'lazy_string_sensitive', 'ls_value_2', true, false, true],
+			[null, 'user1', 'app1', 'fast_int', 'n_value', false, false, true, TypeConflictException::class],
+			[
+				null, 'user1', 'app1', 'fast_float', 'n_value', false, false, true,
+				TypeConflictException::class
+			],
+			[
+				null, 'user1', 'app1', 'fast_float', 'n_value', false, false, true,
+				TypeConflictException::class
+			],
+			[null, 'user1', 'app1', 'lazy_int', 'n_value', false, false, true, TypeConflictException::class],
+			[
+				null, 'user1', 'app1', 'lazy_boolean', 'n_value', false, false, true,
+				TypeConflictException::class
+			],
+			[
+				null, 'user1', 'app1', 'lazy_float', 'n_value', false, false, true,
+				TypeConflictException::class
+			],
+		];
+	}
+
+	/**
+	 * @dataProvider providerSetValueString
+	 */
+	public function testSetValueString(
+		?array $preload,
+		string $userId,
+		string $app,
+		string $key,
+		string $value,
+		bool $lazy,
+		bool $sensitive,
+		bool $result,
+		?string $exception = null,
+	): void {
+		$preferences = $this->generateUserPreferences($preload ?? []);
+		if ($exception !== null) {
+			$this->expectException($exception);
+		}
+
+		$edited = $preferences->setValueString($userId, $app, $key, $value, $lazy, $sensitive);
+		if ($exception !== null) {
+			return;
+		}
+
+		$this->assertEquals($result, $edited);
+		if ($result) {
+			$this->assertEquals($value, $preferences->getValueString($userId, $app, $key, $value, $lazy));
+			$preferences = $this->generateUserPreferences($preload ?? []);
+			$this->assertEquals($value, $preferences->getValueString($userId, $app, $key, $value, $lazy));
+		}
+	}
+
+	public function providerSetValueInt(): array {
+		return [
+			[null, 'user1', 'app1', 'key1', 12345, false, false, true],
+			[null, 'user1', 'app1', 'key1', 12345, true, false, true],
+			[null, 'user1', 'app1', 'key1', 12345, true, true, true],
+			[null, 'user1', 'app1', 'fast_int', 11, false, false, false],
+			[null, 'user1', 'app1', 'fast_int', 111, false, false, true],
+			[null, 'user1', 'app1', 'fast_int', 111, true, false, true],
+			[null, 'user1', 'app1', 'fast_int', 111, false, true, true],
+			[null, 'user1', 'app1', 'fast_int', 11, true, false, true],
+			[null, 'user1', 'app1', 'fast_int', 11, false, true, true],
+			[null, 'user1', 'app1', 'lazy_int', 12, false, false, true],
+			[null, 'user1', 'app1', 'lazy_int', 121, false, false, true],
+			[null, 'user1', 'app1', 'lazy_int', 121, true, false, true],
+			[null, 'user1', 'app1', 'lazy_int', 121, false, true, true],
+			[null, 'user1', 'app1', 'lazy_int', 12, true, false, false],
+			[null, 'user1', 'app1', 'lazy_int', 12, false, true, true],
+			[null, 'user1', 'app1', 'fast_string', 12345, false, false, true, TypeConflictException::class],
+			[null, 'user1', 'app1', 'fast_string', 12345, false, false, false, TypeConflictException::class],
+			[null, 'user1', 'app1', 'fast_string', 12345, true, false, true, TypeConflictException::class],
+			[null, 'user1', 'app1', 'fast_string', 12345, true, true, true, TypeConflictException::class],
+			[null, 'user1', 'app1', 'lazy_string', 12345, false, false, true, TypeConflictException::class],
+			[null, 'user1', 'app1', 'lazy_string', 12345, true, false, false, TypeConflictException::class],
+			[null, 'user1', 'app1', 'lazy_string', 12345, true, true, true, TypeConflictException::class],
+			[null, 'user1', 'app1', 'fast_float', 12345, false, false, true, TypeConflictException::class],
+			[null, 'user1', 'app1', 'fast_float', 12345, false, false, true, TypeConflictException::class],
+			[null, 'user1', 'app1', 'lazy_boolean', 12345, false, false, true, TypeConflictException::class],
+			[null, 'user1', 'app1', 'lazy_float', 12345, false, false, true, TypeConflictException::class],
+		];
+	}
+
+	/**
+	 * @dataProvider providerSetValueInt
+	 */
+	public function testSetValueInt(
+		?array $preload,
+		string $userId,
+		string $app,
+		string $key,
+		int $value,
+		bool $lazy,
+		bool $sensitive,
+		bool $result,
+		?string $exception = null,
+	): void {
+		$preferences = $this->generateUserPreferences($preload ?? []);
+		if ($exception !== null) {
+			$this->expectException($exception);
+		}
+
+		$edited = $preferences->setValueInt($userId, $app, $key, $value, $lazy, $sensitive);
+
+		if ($exception !== null) {
+			return;
+		}
+
+		$this->assertEquals($result, $edited);
+		if ($result) {
+			$this->assertEquals($value, $preferences->getValueInt($userId, $app, $key, $value, $lazy));
+			$preferences = $this->generateUserPreferences($preload ?? []);
+			$this->assertEquals($value, $preferences->getValueInt($userId, $app, $key, $value, $lazy));
+		}
+	}
+
+	public function providerSetValueFloat(): array {
+		return [
+			[null, 'user1', 'app1', 'key1', 12.345, false, false, true],
+			[null, 'user1', 'app1', 'key1', 12.345, true, false, true],
+			[null, 'user1', 'app1', 'key1', 12.345, true, true, true],
+			[null, 'user1', 'app1', 'fast_float', 3.14, false, false, false],
+			[null, 'user1', 'app1', 'fast_float', 3.15, false, false, true],
+			[null, 'user1', 'app1', 'fast_float', 3.15, true, false, true],
+			[null, 'user1', 'app1', 'fast_float', 3.15, false, true, true],
+			[null, 'user1', 'app1', 'fast_float', 3.14, true, false, true],
+			[null, 'user1', 'app1', 'fast_float', 3.14, false, true, true],
+			[null, 'user1', 'app1', 'lazy_float', 3.14159, false, false, true],
+			[null, 'user1', 'app1', 'lazy_float', 3.14158, false, false, true],
+			[null, 'user1', 'app1', 'lazy_float', 3.14158, true, false, true],
+			[null, 'user1', 'app1', 'lazy_float', 3.14158, false, true, true],
+			[null, 'user1', 'app1', 'lazy_float', 3.14159, true, false, false],
+			[null, 'user1', 'app1', 'lazy_float', 3.14159, false, true, true],
+			[null, 'user1', 'app1', 'fast_string', 12.345, false, false, true, TypeConflictException::class],
+			[null, 'user1', 'app1', 'fast_string', 12.345, false, false, false, TypeConflictException::class],
+			[null, 'user1', 'app1', 'fast_string', 12.345, true, false, true, TypeConflictException::class],
+			[null, 'user1', 'app1', 'fast_string', 12.345, true, true, true, TypeConflictException::class],
+			[null, 'user1', 'app1', 'lazy_string', 12.345, false, false, true, TypeConflictException::class],
+			[null, 'user1', 'app1', 'lazy_string', 12.345, true, false, false, TypeConflictException::class],
+			[null, 'user1', 'app1', 'fast_array', 12.345, true, true, true, TypeConflictException::class],
+			[null, 'user1', 'app1', 'fast_int', 12.345, false, false, true, TypeConflictException::class],
+			[null, 'user1', 'app1', 'fast_int', 12.345, false, false, true, TypeConflictException::class],
+			[null, 'user1', 'app1', 'lazy_boolean', 12.345, false, false, true, TypeConflictException::class],
+		];
+	}
+
+	/**
+	 * @dataProvider providerSetValueFloat
+	 */
+	public function testSetValueFloat(
+		?array $preload,
+		string $userId,
+		string $app,
+		string $key,
+		float $value,
+		bool $lazy,
+		bool $sensitive,
+		bool $result,
+		?string $exception = null,
+	): void {
+		$preferences = $this->generateUserPreferences($preload ?? []);
+		if ($exception !== null) {
+			$this->expectException($exception);
+		}
+
+		$edited = $preferences->setValueFloat($userId, $app, $key, $value, $lazy, $sensitive);
+
+		if ($exception !== null) {
+			return;
+		}
+
+		$this->assertEquals($result, $edited);
+		if ($result) {
+			$this->assertEquals($value, $preferences->getValueFloat($userId, $app, $key, $value, $lazy));
+			$preferences = $this->generateUserPreferences($preload ?? []);
+			$this->assertEquals($value, $preferences->getValueFloat($userId, $app, $key, $value, $lazy));
+		}
+	}
+
+
+	public function providerSetValueArray(): array {
+		return [
+			[null, 'user1', 'app1', 'key1', [], false, false, true],
+			[null, 'user1', 'app1', 'key1', [], true, false, true],
+			[null, 'user1', 'app1', 'key1', [], true, true, true],
+			[null, 'user1', 'app1', 'fast_array', ['year' => 2024], false, false, false],
+			[null, 'user1', 'app1', 'fast_array', [], false, false, true],
+			[null, 'user1', 'app1', 'fast_array', [], true, false, true],
+			[null, 'user1', 'app1', 'fast_array', [], false, true, true],
+			[null, 'user1', 'app1', 'fast_array', ['year' => 2024], true, false, true],
+			[null, 'user1', 'app1', 'fast_array', ['year' => 2024], false, true, true],
+			[null, 'user1', 'app1', 'lazy_array', ['month' => 'October'], false, false, true],
+			[null, 'user1', 'app1', 'lazy_array', ['month' => 'September'], false, false, true],
+			[null, 'user1', 'app1', 'lazy_array', ['month' => 'September'], true, false, true],
+			[null, 'user1', 'app1', 'lazy_array', ['month' => 'September'], false, true, true],
+			[null, 'user1', 'app1', 'lazy_array', ['month' => 'October'], true, false, false],
+			[null, 'user1', 'app1', 'lazy_array', ['month' => 'October'], false, true, true],
+			[null, 'user1', 'app1', 'fast_string', [], false, false, true, TypeConflictException::class],
+			[null, 'user1', 'app1', 'fast_string', [], false, false, false, TypeConflictException::class],
+			[null, 'user1', 'app1', 'fast_string', [], true, false, true, TypeConflictException::class],
+			[null, 'user1', 'app1', 'fast_string', [], true, true, true, TypeConflictException::class],
+			[null, 'user1', 'app1', 'lazy_string', [], false, false, true, TypeConflictException::class],
+			[null, 'user1', 'app1', 'lazy_string', [], true, false, false, TypeConflictException::class],
+			[null, 'user1', 'app1', 'lazy_string', [], true, true, true, TypeConflictException::class],
+			[null, 'user1', 'app1', 'fast_int', [], false, false, true, TypeConflictException::class],
+			[null, 'user1', 'app1', 'fast_int', [], false, false, true, TypeConflictException::class],
+			[null, 'user1', 'app1', 'lazy_boolean', [], false, false, true, TypeConflictException::class],
+		];
+	}
+
+	/**
+	 * @dataProvider providerSetValueArray
+	 */
+	public function testSetValueArray(
+		?array $preload,
+		string $userId,
+		string $app,
+		string $key,
+		array $value,
+		bool $lazy,
+		bool $sensitive,
+		bool $result,
+		?string $exception = null,
+	): void {
+		$preferences = $this->generateUserPreferences($preload ?? []);
+		if ($exception !== null) {
+			$this->expectException($exception);
+		}
+
+		$edited = $preferences->setValueArray($userId, $app, $key, $value, $lazy, $sensitive);
+
+		if ($exception !== null) {
+			return;
+		}
+
+		$this->assertEquals($result, $edited);
+		if ($result) {
+			$this->assertEqualsCanonicalizing(
+				$value, $preferences->getValueArray($userId, $app, $key, $value, $lazy)
+			);
+			$preferences = $this->generateUserPreferences($preload ?? []);
+			$this->assertEqualsCanonicalizing(
+				$value, $preferences->getValueArray($userId, $app, $key, $value, $lazy)
+			);
+		}
+	}
+
+	public function providerUpdateSensitive(): array {
+		return [
+			[null, 'user1', 'app1', 'key1', false, false],
+			[['user1'], 'user1', 'app1', 'key1', false, false],
+			[null, 'user1', 'app1', 'key1', true, true],
+			[['user1'], 'user1', 'app1', 'key1', true, true],
+		];
+	}
+
+	/**
+	 * @dataProvider providerUpdateSensitive
+	 */
+	public function testUpdateSensitive(
+		?array $preload,
+		string $userId,
+		string $app,
+		string $key,
+		bool $sensitive,
+		bool $result,
+		?string $exception = null,
+	): void {
+		$preferences = $this->generateUserPreferences($preload ?? []);
+		if ($exception !== null) {
+			$this->expectException($exception);
+		}
+
+		$edited = $preferences->updateSensitive($userId, $app, $key, $sensitive);
+		if ($exception !== null) {
+			return;
+		}
+
+		$this->assertEquals($result, $edited);
+		if ($result) {
+			$this->assertEquals($sensitive, $preferences->isSensitive($userId, $app, $key));
+			$preferences = $this->generateUserPreferences($preload ?? []);
+			$this->assertEquals($sensitive, $preferences->isSensitive($userId, $app, $key));
+			if ($sensitive) {
+				$this->assertEquals(true, str_starts_with(
+					$preferences->statusCache()['fastCache'][$userId][$app][$key] ??
+					$preferences->statusCache()['lazyCache'][$userId][$app][$key],
+					'$UserPreferencesEncryption$')
+				);
+			}
+		}
+	}
+
+	public function providerUpdateGlobalSensitive(): array {
+		return [[true], [false]];
+	}
+
+	/**
+	 * @dataProvider providerUpdateGlobalSensitive
+	 */
+	public function testUpdateGlobalSensitive(bool $sensitive): void {
+		$preferences = $this->generateUserPreferences($preload ?? []);
+		$app = 'app2';
+		if ($sensitive) {
+			$key = 'key2';
+			$value = 'value2a';
+		} else {
+			$key = 'key4';
+			$value = 'value4';
+		}
+
+		$this->assertEquals($value, $preferences->getValueString('user1', $app, $key));
+		foreach (['user1', 'user2', 'user3', 'user4'] as $userId) {
+			$preferences->getValueString($userId, $app, $key); // cache loading for userId
+			$this->assertEquals(
+				!$sensitive, str_starts_with(
+					$preferences->statusCache()['fastCache'][$userId][$app][$key] ??
+					$preferences->statusCache()['lazyCache'][$userId][$app][$key],
+					'$UserPreferencesEncryption$'
+				)
+			);
+		}
+
+		$preferences->updateGlobalSensitive($app, $key, $sensitive);
+
+		$this->assertEquals($value, $preferences->getValueString('user1', $app, $key));
+		foreach (['user1', 'user2', 'user3', 'user4'] as $userId) {
+			$this->assertEquals($sensitive, $preferences->isSensitive($userId, $app, $key));
+			// should only work if updateGlobalSensitive drop cache
+			$this->assertEquals($sensitive, str_starts_with(
+				$preferences->statusCache()['fastCache'][$userId][$app][$key] ??
+				$preferences->statusCache()['lazyCache'][$userId][$app][$key],
+				'$UserPreferencesEncryption$')
+			);
+		}
+	}
+
+	public function providerUpdateLazy(): array {
+		return [
+			[null, 'user1', 'app1', 'key1', false, false],
+			[['user1'], 'user1', 'app1', 'key1', false, false],
+			[null, 'user1', 'app1', 'key1', true, true],
+			[['user1'], 'user1', 'app1', 'key1', true, true],
+		];
+	}
+
+	/**
+	 * @dataProvider providerUpdateLazy
+	 */
+	public function testUpdateLazy(
+		?array $preload,
+		string $userId,
+		string $app,
+		string $key,
+		bool $lazy,
+		bool $result,
+		?string $exception = null,
+	): void {
+		$preferences = $this->generateUserPreferences($preload ?? []);
+		if ($exception !== null) {
+			$this->expectException($exception);
+		}
+
+		$edited = $preferences->updateLazy($userId, $app, $key, $lazy);
+		if ($exception !== null) {
+			return;
+		}
+
+		$this->assertEquals($result, $edited);
+		if ($result) {
+			$this->assertEquals($lazy, $preferences->isLazy($userId, $app, $key));
+			$preferences = $this->generateUserPreferences($preload ?? []);
+			$this->assertEquals($lazy, $preferences->isLazy($userId, $app, $key));
+		}
+	}
+
+	public function providerUpdateGlobalLazy(): array {
+		return [[true], [false]];
+	}
+
+	/**
+	 * @dataProvider providerUpdateGlobalLazy
+	 */
+	public function testUpdateGlobalLazy(bool $lazy): void {
+		$preferences = $this->generateUserPreferences($preload ?? []);
+		$app = 'app2';
+		if ($lazy) {
+			$key = 'key4';
+			$value = 'value4';
+		} else {
+			$key = 'key3';
+			$value = 'value3';
+		}
+
+		$this->assertEquals($value, $preferences->getValueString('user1', $app, $key, '', !$lazy));
+		foreach (['user1', 'user2', 'user3', 'user4'] as $userId) {
+			$this->assertEquals(!$lazy, $preferences->isLazy($userId, $app, $key));
+		}
+
+		$preferences->updateGlobalLazy($app, $key, $lazy);
+		$this->assertEquals($value, $preferences->getValueString('user1', $app, $key, '', $lazy));
+		foreach (['user1', 'user2', 'user3', 'user4'] as $userId) {
+			$this->assertEquals($lazy, $preferences->isLazy($userId, $app, $key));
+		}
+	}
+
+	public function providerGetDetails(): array {
+		return [
+			[
+				'user3', 'app2', 'key2',
+				[
+					'userId' => 'user3',
+					'app' => 'app2',
+					'key' => 'key2',
+					'value' => 'value2c',
+					'type' => 2,
+					'lazy' => false,
+					'typeString' => 'mixed',
+					'sensitive' => false
+				]
+			],
+			[
+				'user1', 'app1', 'lazy_int',
+				[
+					'userId' => 'user1',
+					'app' => 'app1',
+					'key' => 'lazy_int',
+					'value' => 12,
+					'type' => 8,
+					'lazy' => true,
+					'typeString' => 'int',
+					'sensitive' => false
+				]
+			],
+			[
+				'user1', 'app1', 'fast_float_sensitive',
+				[
+					'userId' => 'user1',
+					'app' => 'app1',
+					'key' => 'fast_float_sensitive',
+					'value' => 1.41,
+					'type' => 16,
+					'lazy' => false,
+					'typeString' => 'float',
+					'sensitive' => true
+				]
+			],
+		];
+	}
+
+	/**
+	 * @dataProvider providerGetDetails
+	 */
+	public function testGetDetails(string $userId, string $app, string $key, array $result): void {
+		$preferences = $this->generateUserPreferences($preload ?? []);
+		$this->assertEqualsCanonicalizing($result, $preferences->getDetails($userId, $app, $key));
+	}
+
+
+	public function providerDeletePreference(): array {
+		return [
+			[null, 'user1', 'app1', 'key22'],
+			[['user1'], 'user1', 'app1', 'fast_string_sensitive'],
+			[null, 'user1', 'app1', 'lazy_array_sensitive'],
+			[['user2'], 'user1', 'app1', 'lazy_array_sensitive'],
+			[null, 'user2', 'only-lazy', 'key1'],
+			[['user2'], 'user2', 'only-lazy', 'key1'],
+		];
+	}
+
+	/**
+	 * @dataProvider providerDeletePreference
+	 */
+	public function testDeletePreference(
+		?array $preload,
+		string $userId,
+		string $app,
+		string $key,
+	): void {
+		$preferences = $this->generateUserPreferences($preload ?? []);
+		$lazy = $preferences->isLazy($userId, $app, $key);
+
+		$preferences = $this->generateUserPreferences($preload ?? []);
+		$this->assertEquals(true, $preferences->hasKey($userId, $app, $key, $lazy));
+		$preferences->deletePreference($userId, $app, $key);
+		$this->assertEquals(false, $preferences->hasKey($userId, $app, $key, $lazy));
+		$preferences = $this->generateUserPreferences($preload ?? []);
+		$this->assertEquals(false, $preferences->hasKey($userId, $app, $key, $lazy));
+	}
+
+	public function providerDeleteKey(): array {
+		return [
+			[null, 'app2', 'key3'],
+			[['user1'], 'app2', 'key3'],
+			[null, 'only-lazy', 'key1'],
+			[['user2'], 'only-lazy', 'key1'],
+			[null, 'app2', 'lazy_string_sensitive'],
+			[['user3', 'user1'], 'app2', 'lazy_string_sensitive'],
+		];
+	}
+
+	/**
+	 * @dataProvider providerDeleteKey
+	 */
+	public function testDeleteKey(
+		?array $preload,
+		string $app,
+		string $key,
+	): void {
+		$preferences = $this->generateUserPreferences($preload ?? []);
+		$preferences->deleteKey($app, $key);
+
+		foreach (['user1', 'user2', 'user3', 'user4'] as $userId) {
+			$this->assertEquals(false, $preferences->hasKey($userId, $app, $key, null));
+			$preferencesTemp = $this->generateUserPreferences($preload ?? []);
+			$this->assertEquals(false, $preferencesTemp->hasKey($userId, $app, $key, null));
+		}
+	}
+
+	public function testDeleteApp(): void {
+		$preferences = $this->generateUserPreferences();
+		$preferences->deleteApp('only-lazy');
+
+		foreach (['user1', 'user2', 'user3', 'user4'] as $userId) {
+			$this->assertEquals(false, in_array('only-lazy', $preferences->getApps($userId)));
+			$preferencesTemp = $this->generateUserPreferences();
+			$this->assertEquals(false, in_array('only-lazy', $preferencesTemp->getApps($userId)));
+		}
+	}
+
+	public function testDeleteAllPreferences(): void {
+		$preferences = $this->generateUserPreferences();
+		$preferences->deleteAllPreferences('user1');
+
+		$this->assertEqualsCanonicalizing([], $preferences->getApps('user1'));
+		$preferences = $this->generateUserPreferences();
+		$this->assertEqualsCanonicalizing([], $preferences->getApps('user1'));
+	}
+
+	public function testClearCache(): void {
+		$preferences = $this->generateUserPreferences(['user1', 'user2']);
+		$preferences->clearCache('user1');
+
+		$this->assertEquals(true, $preferences->statusCache()['fastLoaded']['user2']);
+		$this->assertEquals(false, $preferences->statusCache()['fastLoaded']['user1']);
+		$this->assertEquals('value2a', $preferences->getValueString('user1', 'app2', 'key2'));
+		$this->assertEquals(false, $preferences->statusCache()['lazyLoaded']['user1']);
+		$this->assertEquals(true, $preferences->statusCache()['fastLoaded']['user1']);
+	}
+
+	public function testClearCacheAll(): void {
+		$preferences = $this->generateUserPreferences(['user1', 'user2']);
+		$preferences->clearCacheAll();
+		$this->assertEqualsCanonicalizing(
+			[
+				'fastLoaded' => [],
+				'fastCache' => [],
+				'lazyLoaded' => [],
+				'lazyCache' => [],
+				'valueTypes' => [],
+			],
+			$preferences->statusCache()
+		);
+	}
+}