diff --git a/app/src/main/kotlin/org/equeim/tremotesf/ui/Settings.kt b/app/src/main/kotlin/org/equeim/tremotesf/ui/Settings.kt
index 824f5236..d3124a4f 100644
--- a/app/src/main/kotlin/org/equeim/tremotesf/ui/Settings.kt
+++ b/app/src/main/kotlin/org/equeim/tremotesf/ui/Settings.kt
@@ -28,7 +28,6 @@ import kotlinx.coroutines.withContext
 import org.equeim.tremotesf.R
 import org.equeim.tremotesf.TremotesfApplication
 import org.equeim.tremotesf.torrentfile.rpc.requests.torrentproperties.TorrentLimits
-import org.equeim.tremotesf.ui.Settings.Property
 import org.equeim.tremotesf.ui.torrentslistfragment.TorrentsListFragmentViewModel
 import timber.log.Timber
 import kotlin.reflect.KClass
@@ -124,41 +123,6 @@ object Settings {
         }
     }
 
-    private class EnumPrefsMapper<T : Enum<T>>(
-        private val enumClass: Class<T>,
-        @StringRes private val keyResId: Int,
-        @StringRes private val defaultValueResId: Int,
-        val enumToPrefsValue: (T) -> String,
-    ) {
-        private val enumValues = requireNotNull(enumClass.enumConstants)
-
-        fun prefsValueToEnum(prefsValue: String): T {
-            enumValues.find { enumToPrefsValue(it) == prefsValue }?.let { return it }
-            val key = context.getString(keyResId)
-            Timber.e("Unknown prefs value $prefsValue for key $key and enum $enumClass")
-            val defaultPrefsValue = context.getString(defaultValueResId)
-            return enumValues.find { enumToPrefsValue(it) == defaultPrefsValue }
-                ?: throw IllegalStateException("Did not find value of enum $enumClass for default prefs value $defaultPrefsValue and key $key")
-        }
-    }
-
-    private inline fun <reified T : Enum<T>> EnumPrefsMapper(
-        @StringRes keyResId: Int,
-        @StringRes defaultValueResId: Int,
-        noinline enumToPrefsValue: (T) -> String,
-    ): EnumPrefsMapper<T> =
-        EnumPrefsMapper(T::class.java, keyResId, defaultValueResId, enumToPrefsValue)
-
-    private interface MappedPrefsEnum {
-        val prefsValue: String
-    }
-
-    private inline fun <reified T> EnumPrefsMapper(
-        @StringRes keyResId: Int,
-        @StringRes defaultValueResId: Int,
-    ): EnumPrefsMapper<T> where T : MappedPrefsEnum, T : Enum<T> =
-        EnumPrefsMapper(T::class.java, keyResId, defaultValueResId, MappedPrefsEnum::prefsValue)
-
     enum class ColorTheme(
         @StringRes prefsValueResId: Int,
         @StyleRes val activityThemeResId: Int = 0,
@@ -172,12 +136,12 @@ object Settings {
 
     private val colorThemeMapper =
         EnumPrefsMapper<ColorTheme>(R.string.prefs_color_theme_key, R.string.prefs_color_theme_default_value)
-    val colorTheme: MutableProperty<ColorTheme> = mutableProperty<String>(
+    val colorTheme: Property<ColorTheme> = PrefsProperty<String>(
         R.string.prefs_color_theme_key,
         R.string.prefs_color_theme_default_value
     ).map(
-        transformGetter = colorThemeMapper::prefsValueToEnum,
-        transformSetter = { it.prefsValue }
+        prefsToMapped = colorThemeMapper::prefsValueToEnum,
+        mappedToPrefs = ColorTheme::prefsValue
     )
 
     enum class DarkThemeMode(@StringRes prefsValueResId: Int, val nightMode: Int) :
@@ -201,74 +165,77 @@ object Settings {
         R.string.prefs_dark_theme_mode_default_value
     )
     val darkThemeMode: Property<DarkThemeMode> =
-        property<String>(
+        PrefsProperty<String>(
             R.string.prefs_dark_theme_mode_key,
             R.string.prefs_dark_theme_mode_default_value
-        ).map(darkThemeModeMapper::prefsValueToEnum)
+        ).map(prefsToMapped = darkThemeModeMapper::prefsValueToEnum, mappedToPrefs = DarkThemeMode::prefsValue)
 
-    val torrentCompactView: Property<Boolean> = property(
+    val torrentCompactView: Property<Boolean> = PrefsProperty(
         R.string.prefs_torrent_compact_view_key,
         R.bool.prefs_torrent_compact_view_default_value
     )
 
-    val torrentNameMultiline: Property<Boolean> = property(
+    val torrentNameMultiline: Property<Boolean> = PrefsProperty(
         R.string.prefs_torrent_name_multiline_key,
         R.bool.prefs_torrent_name_multiline_default_value
     )
 
     val quickReturn: Property<Boolean> =
-        property(R.string.prefs_quick_return, R.bool.prefs_quick_return_default_value)
+        PrefsProperty(R.string.prefs_quick_return, R.bool.prefs_quick_return_default_value)
 
-    val showPersistentNotification: Property<Boolean> = property(
+    val showPersistentNotification: Property<Boolean> = PrefsProperty(
         R.string.prefs_persistent_notification_key,
         R.bool.prefs_persistent_notification_default_value
     )
 
-    val notifyOnFinished: Property<Boolean> = property(
+    val notifyOnFinished: Property<Boolean> = PrefsProperty(
         R.string.prefs_notify_on_finished_key,
         R.bool.prefs_notify_on_finished_default_value
     )
 
     val notifyOnAdded: Property<Boolean> =
-        property(R.string.prefs_notify_on_added_key, R.bool.prefs_notify_on_added_default_value)
+        PrefsProperty(R.string.prefs_notify_on_added_key, R.bool.prefs_notify_on_added_default_value)
 
-    val backgroundUpdateInterval: Property<Long> = property<String>(
+    val backgroundUpdateInterval: Property<Long> = PrefsProperty<String>(
         R.string.prefs_background_update_interval_key,
         R.string.prefs_background_update_interval_default_value
-    ).map {
-        try {
-            it.toLong()
-        } catch (ignore: NumberFormatException) {
-            0
-        }
-    }
+    ).map(
+        prefsToMapped = {
+            try {
+                it.toLong()
+            } catch (ignore: NumberFormatException) {
+                0
+            }
+        },
+        mappedToPrefs = Long::toString
+    )
 
     val notifyOnFinishedSinceLastConnection: Property<Boolean> =
-        property(
+        PrefsProperty(
             R.string.prefs_notify_on_finished_since_last_key,
             R.bool.prefs_notify_on_finished_since_last_default_value
         )
 
     val notifyOnAddedSinceLastConnection: Property<Boolean> =
-        property(
+        PrefsProperty(
             R.string.prefs_notify_on_added_since_last_key,
             R.bool.prefs_notify_on_added_since_last_default_value
         )
 
-    val userDismissedNotificationPermissionRequest: MutableProperty<Boolean> =
-        mutableProperty(
+    val userDismissedNotificationPermissionRequest: Property<Boolean> =
+        PrefsProperty(
             R.string.prefs_user_dismissed_notification_permission_request_key,
             R.bool.prefs_user_dismissed_notification_permission_request_default_value
         )
 
     val deleteFiles: Property<Boolean> =
-        property(R.string.prefs_delete_files_key, R.bool.prefs_delete_files_default_value)
+        PrefsProperty(R.string.prefs_delete_files_key, R.bool.prefs_delete_files_default_value)
 
     val fillTorrentLinkFromKeyboard: Property<Boolean> =
-        property(R.string.prefs_link_from_clipboard_key, R.bool.prefs_link_from_clipboard_default_value)
+        PrefsProperty(R.string.prefs_link_from_clipboard_key, R.bool.prefs_link_from_clipboard_default_value)
 
     val rememberAddTorrentParameters: Property<Boolean> =
-        property(
+        PrefsProperty(
             R.string.prefs_remember_add_torrent_parameters_key,
             R.bool.prefs_remember_add_torrent_parameters_default_value
         )
@@ -283,12 +250,12 @@ object Settings {
         R.string.prefs_last_add_torrent_start_after_adding_key,
         R.string.prefs_last_add_torrent_start_after_adding_default_value
     )
-    val lastAddTorrentStartAfterAdding: MutableProperty<StartTorrentAfterAdding> = mutableProperty<String>(
+    val lastAddTorrentStartAfterAdding: Property<StartTorrentAfterAdding> = PrefsProperty<String>(
         R.string.prefs_last_add_torrent_start_after_adding_key,
         R.string.prefs_last_add_torrent_start_after_adding_default_value
     ).map(
-        transformGetter = startTorrentAfterAddingMapper::prefsValueToEnum,
-        transformSetter = startTorrentAfterAddingMapper.enumToPrefsValue
+        prefsToMapped = startTorrentAfterAddingMapper::prefsValueToEnum,
+        mappedToPrefs = startTorrentAfterAddingMapper.enumToPrefsValue
     )
 
     private val bandwidthPriorityMapper = EnumPrefsMapper<TorrentLimits.BandwidthPriority>(
@@ -301,180 +268,183 @@ object Settings {
             TorrentLimits.BandwidthPriority.High -> "high"
         }
     }
-    val lastAddTorrentPriority: MutableProperty<TorrentLimits.BandwidthPriority> = mutableProperty<String>(
+    val lastAddTorrentPriority: Property<TorrentLimits.BandwidthPriority> = PrefsProperty<String>(
         R.string.prefs_last_add_torrent_priority_key,
         R.string.prefs_last_add_torrent_priority_default_value
     ).map(
-        transformGetter = bandwidthPriorityMapper::prefsValueToEnum,
-        transformSetter = bandwidthPriorityMapper.enumToPrefsValue
+        prefsToMapped = bandwidthPriorityMapper::prefsValueToEnum,
+        mappedToPrefs = bandwidthPriorityMapper.enumToPrefsValue
     )
 
-    val torrentsSortMode: MutableProperty<TorrentsListFragmentViewModel.SortMode> =
-        mutableProperty<Int>(
+    val torrentsSortMode: Property<TorrentsListFragmentViewModel.SortMode> =
+        PrefsProperty<Int>(
             R.string.torrents_sort_mode_key,
             R.integer.torrents_sort_mode_default_value
         ).map(
-            transformGetter = { TorrentsListFragmentViewModel.SortMode.entries.getOrElse(it) { TorrentsListFragmentViewModel.SortMode.DEFAULT } },
-            transformSetter = { it.ordinal }
+            prefsToMapped = { TorrentsListFragmentViewModel.SortMode.entries.getOrElse(it) { TorrentsListFragmentViewModel.SortMode.DEFAULT } },
+            mappedToPrefs = { it.ordinal }
         )
 
-    val torrentsSortOrder: MutableProperty<TorrentsListFragmentViewModel.SortOrder> =
-        mutableProperty<Int>(
+    val torrentsSortOrder: Property<TorrentsListFragmentViewModel.SortOrder> =
+        PrefsProperty<Int>(
             R.string.torrents_sort_order_key,
             R.integer.torrents_sort_order_default_value
         ).map(
-            transformGetter = { TorrentsListFragmentViewModel.SortOrder.entries.getOrElse(it) { TorrentsListFragmentViewModel.SortOrder.DEFAULT } },
-            transformSetter = { it.ordinal }
+            prefsToMapped = { TorrentsListFragmentViewModel.SortOrder.entries.getOrElse(it) { TorrentsListFragmentViewModel.SortOrder.DEFAULT } },
+            mappedToPrefs = { it.ordinal }
         )
 
-    val torrentsStatusFilter: MutableProperty<TorrentsListFragmentViewModel.StatusFilterMode> =
-        mutableProperty<Int>(
+    val torrentsStatusFilter: Property<TorrentsListFragmentViewModel.StatusFilterMode> =
+        PrefsProperty<Int>(
             R.string.torrents_status_filter_key,
             R.integer.torrents_status_filter_default_value
         ).map(
-            transformGetter = { TorrentsListFragmentViewModel.StatusFilterMode.entries.getOrElse(it) { TorrentsListFragmentViewModel.StatusFilterMode.DEFAULT } },
-            transformSetter = { it.ordinal }
+            prefsToMapped = { TorrentsListFragmentViewModel.StatusFilterMode.entries.getOrElse(it) { TorrentsListFragmentViewModel.StatusFilterMode.DEFAULT } },
+            mappedToPrefs = { it.ordinal }
         )
 
-    val torrentsTrackerFilter: MutableProperty<String> = mutableProperty(
+    val torrentsTrackerFilter: Property<String> = PrefsProperty(
         R.string.torrents_tracker_filter_key,
         R.string.torrents_tracker_filter_default_value
     )
 
-    val torrentsDirectoryFilter: MutableProperty<String> = mutableProperty(
+    val torrentsDirectoryFilter: Property<String> = PrefsProperty(
         R.string.torrents_directory_filter_key,
         R.string.torrents_directory_filter_default_value
     )
 
-    private fun <T : Any> property(
-        kClass: KClass<T>,
-        @StringRes keyResId: Int,
-        @AnyRes defaultValueResId: Int,
-        key: String = context.getString(keyResId),
-    ): Property<T> {
-        @Suppress("IMPLICIT_CAST_TO_ANY", "UNCHECKED_CAST")
-        val defaultValue = when (kClass) {
-            Boolean::class -> context.resources.getBoolean(defaultValueResId)
-            Float::class -> context.resources.getDimension(defaultValueResId)
-            Int::class -> context.resources.getInteger(defaultValueResId)
-            Long::class -> context.resources.getInteger(defaultValueResId).toLong()
-            String::class -> context.getString(defaultValueResId)
-            Set::class -> context.resources.getStringArray(defaultValueResId).toSet()
-            else -> throw IllegalArgumentException("Unsupported property type $kClass")
-        } as T
-
-        val getter = getSharedPreferencesGetter(kClass)
-
-        return object : Property<T> {
-            override val key = key
-
-            override suspend fun get(): T {
-                migrate()
-                return preferences.getter(key, defaultValue)
-            }
-
-            override fun flow() = callbackFlow {
-                send(get())
-                val listener = SharedPreferences.OnSharedPreferenceChangeListener { _, changedKey ->
-                    if (changedKey == key) {
-                        launch { send(get()) }
-                    }
-                }
-                preferences.registerOnSharedPreferenceChangeListener(listener)
-                awaitClose { preferences.unregisterOnSharedPreferenceChangeListener(listener) }
-            }.flowOn(Dispatchers.IO)
-        }
+    interface Property<T : Any> {
+        val key: String
+        suspend fun get(): T
+        fun flow(): Flow<T>
+        suspend fun set(value: T)
     }
 
-    private inline fun <reified T : Any> property(
+    private inline fun <reified T : Any> PrefsProperty(
         @StringRes keyResId: Int,
         @AnyRes defaultValueResId: Int,
-    ): Property<T> = property(T::class, keyResId, defaultValueResId)
+    ) = PrefsProperty(T::class, keyResId, defaultValueResId)
 
-    private fun <T : Any> mutableProperty(
+    private class PrefsProperty<T : Any>(
         kClass: KClass<T>,
         @StringRes keyResId: Int,
         @AnyRes defaultValueResId: Int,
-    ): MutableProperty<T> {
-        val key = context.getString(keyResId)
-        val property = property(kClass, keyResId, defaultValueResId, key = key)
-        val setter = getSharedPreferencesSetter(kClass)
-        return object : MutableProperty<T>, Property<T> by property {
-            override suspend fun set(value: T) = withContext(Dispatchers.IO) {
-                migrate()
-                preferences.setter(key, value)
+    ) : Property<T> {
+        private val defaultValue = getDefaultValue(kClass, defaultValueResId)
+        private val getter = getSharedPreferencesGetter(kClass)
+        private val setter = getSharedPreferencesSetter(kClass)
+
+        override val key: String = context.getString(keyResId)
+
+        override suspend fun get(): T = withContext(Dispatchers.IO) {
+            migrate()
+            preferences.getter(key, defaultValue)
+        }
+
+        override fun flow(): Flow<T> = callbackFlow {
+            send(get())
+            val listener = SharedPreferences.OnSharedPreferenceChangeListener { _, changedKey ->
+                if (changedKey == key) {
+                    launch { send(get()) }
+                }
             }
+            preferences.registerOnSharedPreferenceChangeListener(listener)
+            awaitClose { preferences.unregisterOnSharedPreferenceChangeListener(listener) }
+        }.flowOn(Dispatchers.IO)
+
+        override suspend fun set(value: T) = withContext(Dispatchers.IO) {
+            migrate()
+            preferences.edit { setter(key, value) }
         }
-    }
 
-    private inline fun <reified T : Any> mutableProperty(
-        @StringRes keyResId: Int,
-        @AnyRes defaultValueResId: Int,
-    ): MutableProperty<T> = mutableProperty(T::class, keyResId, defaultValueResId)
+        private companion object {
+            private fun <T : Any> getDefaultValue(kClass: KClass<T>, @AnyRes defaultValueResId: Int): T {
+                @Suppress("IMPLICIT_CAST_TO_ANY", "UNCHECKED_CAST")
+                return when (kClass) {
+                    Boolean::class -> context.resources.getBoolean(defaultValueResId)
+                    Float::class -> context.resources.getDimension(defaultValueResId)
+                    Int::class -> context.resources.getInteger(defaultValueResId)
+                    Long::class -> context.resources.getInteger(defaultValueResId).toLong()
+                    String::class -> context.getString(defaultValueResId)
+                    Set::class -> context.resources.getStringArray(defaultValueResId).toSet()
+                    else -> throw IllegalArgumentException("Unsupported property type $kClass")
+                } as T
+            }
 
-    interface Property<T : Any> {
-        val key: String
-        suspend fun get(): T
-        fun flow(): Flow<T>
-    }
+            private fun <T : Any> getSharedPreferencesGetter(kClass: KClass<T>): SharedPreferences.(String, T) -> T {
+                @Suppress("UNCHECKED_CAST")
+                return when (kClass) {
+                    Boolean::class -> SharedPreferences::getBoolean
+                    Float::class -> SharedPreferences::getFloat
+                    Int::class -> SharedPreferences::getInt
+                    Long::class -> SharedPreferences::getLong
+                    String::class -> SharedPreferences::getString
+                    Set::class -> SharedPreferences::getStringSet
+                    else -> throw IllegalArgumentException("Unsupported property type $kClass")
+                } as SharedPreferences.(String, T) -> T
+            }
 
-    interface MutableProperty<T : Any> : Property<T> {
-        suspend fun set(value: T)
+            private fun <T : Any> getSharedPreferencesSetter(kClass: KClass<T>): SharedPreferences.Editor.(String, T) -> Unit {
+                @Suppress("UNCHECKED_CAST")
+                return when (kClass) {
+                    Boolean::class -> SharedPreferences.Editor::putBoolean
+                    Float::class -> SharedPreferences.Editor::putFloat
+                    Int::class -> SharedPreferences.Editor::putInt
+                    Long::class -> SharedPreferences.Editor::putLong
+                    String::class -> SharedPreferences.Editor::putString
+                    Set::class -> SharedPreferences.Editor::putStringSet
+                    else -> throw IllegalArgumentException("Unsupported property type $kClass")
+                } as SharedPreferences.Editor.(String, T) -> Unit
+            }
+        }
     }
-}
 
-private fun <T : Any> getSharedPreferencesGetter(kClass: KClass<T>): suspend SharedPreferences.(String, T) -> T {
-    @Suppress("UNCHECKED_CAST")
-    val baseGetter = when (kClass) {
-        Boolean::class -> SharedPreferences::getBoolean
-        Float::class -> SharedPreferences::getFloat
-        Int::class -> SharedPreferences::getInt
-        Long::class -> SharedPreferences::getLong
-        String::class -> SharedPreferences::getString
-        Set::class -> SharedPreferences::getStringSet
-        else -> throw IllegalArgumentException("Unsupported property type $kClass")
-    } as SharedPreferences.(String, T) -> T
-    return { key, defaultValue ->
-        withContext(Dispatchers.IO) {
-            baseGetter(key, defaultValue)
-        }
+    private fun <T : Any, R : Any> Property<T>.map(prefsToMapped: (T) -> R, mappedToPrefs: (R) -> T) =
+        MappedProperty(this, prefsToMapped, mappedToPrefs)
+
+    private class MappedProperty<T : Any, R : Any>(
+        private val prefsProperty: Property<T>,
+        private val prefsToMapped: (T) -> R,
+        private val mappedToPrefs: (R) -> T,
+    ) : Property<R> {
+        override val key: String get() = prefsProperty.key
+        override suspend fun get(): R = prefsToMapped(prefsProperty.get())
+        override fun flow(): Flow<R> = prefsProperty.flow().map(prefsToMapped)
+        override suspend fun set(value: R) = prefsProperty.set(mappedToPrefs(value))
     }
-}
 
-private fun <T : Any> getSharedPreferencesSetter(kClass: KClass<T>): suspend SharedPreferences.(String, T) -> Unit {
-    @Suppress("UNCHECKED_CAST")
-    val baseSetter = when (kClass) {
-        Boolean::class -> SharedPreferences.Editor::putBoolean
-        Float::class -> SharedPreferences.Editor::putFloat
-        Int::class -> SharedPreferences.Editor::putInt
-        Long::class -> SharedPreferences.Editor::putLong
-        String::class -> SharedPreferences.Editor::putString
-        Set::class -> SharedPreferences.Editor::putStringSet
-        else -> throw IllegalArgumentException("Unsupported property type $kClass")
-    } as SharedPreferences.Editor.(String, T) -> Unit
-    return { key, value ->
-        withContext(Dispatchers.IO) {
-            edit {
-                baseSetter(key, value)
-            }
+    private class EnumPrefsMapper<T : Enum<T>>(
+        private val enumClass: Class<T>,
+        @StringRes private val keyResId: Int,
+        @StringRes private val defaultValueResId: Int,
+        val enumToPrefsValue: (T) -> String,
+    ) {
+        private val enumValues = requireNotNull(enumClass.enumConstants)
+
+        fun prefsValueToEnum(prefsValue: String): T {
+            enumValues.find { enumToPrefsValue(it) == prefsValue }?.let { return it }
+            val key = context.getString(keyResId)
+            Timber.e("Unknown prefs value $prefsValue for key $key and enum $enumClass")
+            val defaultPrefsValue = context.getString(defaultValueResId)
+            return enumValues.find { enumToPrefsValue(it) == defaultPrefsValue }
+                ?: throw IllegalStateException("Did not find value of enum $enumClass for default prefs value $defaultPrefsValue and key $key")
         }
     }
-}
 
-private fun <T : Any, R : Any> Property<T>.map(transform: suspend (T) -> R) =
-    object : Property<R> {
-        override val key = this@map.key
-        override suspend fun get() = transform(this@map.get())
-        override fun flow() = this@map.flow().map(transform)
-    }
+    private inline fun <reified T : Enum<T>> EnumPrefsMapper(
+        @StringRes keyResId: Int,
+        @StringRes defaultValueResId: Int,
+        noinline enumToPrefsValue: (T) -> String,
+    ): EnumPrefsMapper<T> =
+        EnumPrefsMapper(T::class.java, keyResId, defaultValueResId, enumToPrefsValue)
 
-private fun <T : Any, R : Any> Settings.MutableProperty<T>.map(
-    transformGetter: suspend (T) -> R,
-    transformSetter: suspend (R) -> T,
-) =
-    object : Settings.MutableProperty<R> {
-        override val key = this@map.key
-        override suspend fun get() = transformGetter(this@map.get())
-        override fun flow(): Flow<R> = this@map.flow().map(transformGetter)
-        override suspend fun set(value: R) = this@map.set(transformSetter(value))
+    private interface MappedPrefsEnum {
+        val prefsValue: String
     }
+
+    private inline fun <reified T> EnumPrefsMapper(
+        @StringRes keyResId: Int,
+        @StringRes defaultValueResId: Int,
+    ): EnumPrefsMapper<T> where T : MappedPrefsEnum, T : Enum<T> =
+        EnumPrefsMapper(T::class.java, keyResId, defaultValueResId, MappedPrefsEnum::prefsValue)
+}
diff --git a/app/src/main/kotlin/org/equeim/tremotesf/ui/torrentslistfragment/TorrentsListFragmentViewModel.kt b/app/src/main/kotlin/org/equeim/tremotesf/ui/torrentslistfragment/TorrentsListFragmentViewModel.kt
index 6613ff9f..4cd3eeb9 100644
--- a/app/src/main/kotlin/org/equeim/tremotesf/ui/torrentslistfragment/TorrentsListFragmentViewModel.kt
+++ b/app/src/main/kotlin/org/equeim/tremotesf/ui/torrentslistfragment/TorrentsListFragmentViewModel.kt
@@ -139,7 +139,7 @@ class TorrentsListFragmentViewModel(application: Application, savedStateHandle:
     val directoryFilter: Flow<String> = Settings.torrentsDirectoryFilter.flow()
     fun setDirectoryFilter(filter: String) = Settings.torrentsDirectoryFilter.setAsync(filter)
 
-    private fun <T : Any> Settings.MutableProperty<T>.setAsync(value: T) {
+    private fun <T : Any> Settings.Property<T>.setAsync(value: T) {
         viewModelScope.launch { set(value) }
     }