fixes and filling of cru.yml for swagger

repos/cache/src/commonMain/kotlin/dev/inmo/micro_utils/repos/cache/KeyValueCacheRepo.kt

@@ -4,8 +4,6 @@ import dev.inmo.micro_utils.repos.*
 import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.flow.*
-import kotlinx.coroutines.sync.Mutex
-import kotlinx.coroutines.sync.withLock
 
 open class ReadKeyValueCacheRepo<Key,Value>(
     protected val parentRepo: ReadKeyValueRepo<Key, Value>,

repos/cache/src/commonMain/kotlin/dev/inmo/micro_utils/repos/cache/KeyValuesCacheRepo.kt

@@ -8,8 +8,6 @@ import dev.inmo.micro_utils.repos.*
 import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.flow.*
-import kotlinx.coroutines.sync.Mutex
-import kotlinx.coroutines.sync.withLock
 
 open class ReadKeyValuesCacheRepo<Key,Value>(
     protected val parentRepo: ReadKeyValuesRepo<Key, Value>,

repos/common/src/commonMain/kotlin/dev/inmo/micro_utils/repos/KeyValuesRepo.kt

@@ -1,11 +1,10 @@
 package dev.inmo.micro_utils.repos
 
 import dev.inmo.micro_utils.pagination.*
-import dev.inmo.micro_utils.pagination.utils.doForAllWithCurrentPaging
 import dev.inmo.micro_utils.pagination.utils.getAllWithNextPaging
 import kotlinx.coroutines.flow.Flow
 
-interface ReadOneToManyKeyValueRepo<Key, Value> : Repo {
+interface ReadKeyValuesRepo<Key, Value> : Repo {
     suspend fun get(k: Key, pagination: Pagination, reversed: Boolean = false): PaginationResult<Value>
     suspend fun keys(pagination: Pagination, reversed: Boolean = false): PaginationResult<Key>
     suspend fun keys(v: Value, pagination: Pagination, reversed: Boolean = false): PaginationResult<Key>
@@ -36,9 +35,9 @@ interface ReadOneToManyKeyValueRepo<Key, Value> : Repo {
         }
     }
 }
-typealias ReadKeyValuesRepo<Key,Value> = ReadOneToManyKeyValueRepo<Key, Value>
+typealias ReadOneToManyKeyValueRepo<Key,Value> = ReadKeyValuesRepo<Key, Value>
 
-interface WriteOneToManyKeyValueRepo<Key, Value> : Repo {
+interface WriteKeyValuesRepo<Key, Value> : Repo {
     val onNewValue: Flow<Pair<Key, Value>>
     val onValueRemoved: Flow<Pair<Key, Value>>
     val onDataCleared: Flow<Key>
@@ -55,41 +54,41 @@ interface WriteOneToManyKeyValueRepo<Key, Value> : Repo {
         add(toSet)
     }
 }
-typealias WriteKeyValuesRepo<Key,Value> = WriteOneToManyKeyValueRepo<Key, Value>
+typealias WriteOneToManyKeyValueRepo<Key,Value> = WriteKeyValuesRepo<Key, Value>
 
-suspend inline fun <Key, Value, REPO : WriteOneToManyKeyValueRepo<Key, Value>> REPO.add(
+suspend inline fun <Key, Value, REPO : WriteKeyValuesRepo<Key, Value>> REPO.add(
     keysAndValues: List<Pair<Key, List<Value>>>
 ) = add(keysAndValues.toMap())
 
-suspend inline fun <Key, Value, REPO : WriteOneToManyKeyValueRepo<Key, Value>> REPO.add(
+suspend inline fun <Key, Value, REPO : WriteKeyValuesRepo<Key, Value>> REPO.add(
     vararg keysAndValues: Pair<Key, List<Value>>
 ) = add(keysAndValues.toMap())
 
-suspend inline fun <Key, Value> WriteOneToManyKeyValueRepo<Key, Value>.add(
+suspend inline fun <Key, Value> WriteKeyValuesRepo<Key, Value>.add(
     k: Key, v: List<Value>
 ) = add(mapOf(k to v))
 
-suspend inline fun <Key, Value> WriteOneToManyKeyValueRepo<Key, Value>.add(
+suspend inline fun <Key, Value> WriteKeyValuesRepo<Key, Value>.add(
     k: Key, vararg v: Value
 ) = add(k, v.toList())
 
-suspend inline fun <Key, Value, REPO : WriteOneToManyKeyValueRepo<Key, Value>> REPO.set(
+suspend inline fun <Key, Value, REPO : WriteKeyValuesRepo<Key, Value>> REPO.set(
     keysAndValues: List<Pair<Key, List<Value>>>
 ) = set(keysAndValues.toMap())
 
-suspend inline fun <Key, Value, REPO : WriteOneToManyKeyValueRepo<Key, Value>> REPO.set(
+suspend inline fun <Key, Value, REPO : WriteKeyValuesRepo<Key, Value>> REPO.set(
     vararg keysAndValues: Pair<Key, List<Value>>
 ) = set(keysAndValues.toMap())
 
-suspend inline fun <Key, Value> WriteOneToManyKeyValueRepo<Key, Value>.set(
+suspend inline fun <Key, Value> WriteKeyValuesRepo<Key, Value>.set(
     k: Key, v: List<Value>
 ) = set(mapOf(k to v))
 
-suspend inline fun <Key, Value> WriteOneToManyKeyValueRepo<Key, Value>.set(
+suspend inline fun <Key, Value> WriteKeyValuesRepo<Key, Value>.set(
     k: Key, vararg v: Value
 ) = set(k, v.toList())
 
-interface OneToManyKeyValueRepo<Key, Value> : ReadOneToManyKeyValueRepo<Key, Value>, WriteOneToManyKeyValueRepo<Key, Value> {
+interface KeyValuesRepo<Key, Value> : ReadKeyValuesRepo<Key, Value>, WriteKeyValuesRepo<Key, Value> {
     override suspend fun clearWithValue(v: Value) {
         doWithPagination {
             val keysResult = keys(v, it)
@@ -102,29 +101,29 @@ interface OneToManyKeyValueRepo<Key, Value> : ReadOneToManyKeyValueRepo<Key, Val
         }
     }
 }
-typealias KeyValuesRepo<Key,Value> = OneToManyKeyValueRepo<Key, Value>
+typealias OneToManyKeyValueRepo<Key,Value> = KeyValuesRepo<Key, Value>
 
-class DelegateBasedOneToManyKeyValueRepo<Key, Value>(
-    readDelegate: ReadOneToManyKeyValueRepo<Key, Value>,
-    writeDelegate: WriteOneToManyKeyValueRepo<Key, Value>
-) : OneToManyKeyValueRepo<Key, Value>,
-    ReadOneToManyKeyValueRepo<Key, Value> by readDelegate,
-    WriteOneToManyKeyValueRepo<Key, Value> by writeDelegate
+class DelegateBasedKeyValuesRepo<Key, Value>(
+    readDelegate: ReadKeyValuesRepo<Key, Value>,
+    writeDelegate: WriteKeyValuesRepo<Key, Value>
+) : KeyValuesRepo<Key, Value>,
+    ReadKeyValuesRepo<Key, Value> by readDelegate,
+    WriteKeyValuesRepo<Key, Value> by writeDelegate
 
-suspend inline fun <Key, Value> WriteOneToManyKeyValueRepo<Key, Value>.remove(
+suspend inline fun <Key, Value> WriteKeyValuesRepo<Key, Value>.remove(
     keysAndValues: List<Pair<Key, List<Value>>>
 ) = remove(keysAndValues.toMap())
 
-suspend inline fun <Key, Value> WriteOneToManyKeyValueRepo<Key, Value>.remove(
+suspend inline fun <Key, Value> WriteKeyValuesRepo<Key, Value>.remove(
     vararg keysAndValues: Pair<Key, List<Value>>
 ) = remove(keysAndValues.toMap())
 
-suspend inline fun <Key, Value> WriteOneToManyKeyValueRepo<Key, Value>.remove(
+suspend inline fun <Key, Value> WriteKeyValuesRepo<Key, Value>.remove(
     k: Key,
     v: List<Value>
 ) = remove(mapOf(k to v))
 
-suspend inline fun <Key, Value> WriteOneToManyKeyValueRepo<Key, Value>.remove(
+suspend inline fun <Key, Value> WriteKeyValuesRepo<Key, Value>.remove(
     k: Key,
     vararg v: Value
 ) = remove(k, v.toList())

repos/common/src/commonMain/kotlin/dev/inmo/micro_utils/repos/StandartCRUDRepo.kt

@@ -4,13 +4,13 @@ import dev.inmo.micro_utils.pagination.Pagination
 import dev.inmo.micro_utils.pagination.PaginationResult
 import kotlinx.coroutines.flow.Flow
 
-interface ReadStandardCRUDRepo<ObjectType, IdType> : Repo {
+interface ReadCRUDRepo<ObjectType, IdType> : Repo {
     suspend fun getByPagination(pagination: Pagination): PaginationResult<ObjectType>
     suspend fun getById(id: IdType): ObjectType?
     suspend fun contains(id: IdType): Boolean
     suspend fun count(): Long
 }
-typealias ReadCRUDRepo<ObjectType, IdType> = ReadStandardCRUDRepo<ObjectType, IdType>
+typealias ReadStandardCRUDRepo<ObjectType, IdType> = ReadCRUDRepo<ObjectType, IdType>
 
 typealias UpdatedValuePair<IdType, ValueType> = Pair<IdType, ValueType>
 val <IdType> UpdatedValuePair<IdType, *>.id
@@ -18,7 +18,7 @@ val <IdType> UpdatedValuePair<IdType, *>.id
 val <ValueType> UpdatedValuePair<*, ValueType>.value
     get() = second
 
-interface WriteStandardCRUDRepo<ObjectType, IdType, InputValueType> : Repo {
+interface WriteCRUDRepo<ObjectType, IdType, InputValueType> : Repo {
     val newObjectsFlow: Flow<ObjectType>
     val updatedObjectsFlow: Flow<ObjectType>
     val deletedObjectsIdsFlow: Flow<IdType>
@@ -28,25 +28,25 @@ interface WriteStandardCRUDRepo<ObjectType, IdType, InputValueType> : Repo {
     suspend fun update(values: List<UpdatedValuePair<IdType, InputValueType>>): List<ObjectType>
     suspend fun deleteById(ids: List<IdType>)
 }
-typealias WriteCRUDRepo<ObjectType, IdType, InputValueType> = WriteStandardCRUDRepo<ObjectType, IdType, InputValueType>
+typealias WriteStandardCRUDRepo<ObjectType, IdType, InputValueType> = WriteCRUDRepo<ObjectType, IdType, InputValueType>
 
-suspend fun <ObjectType, IdType, InputValueType> WriteStandardCRUDRepo<ObjectType, IdType, InputValueType>.create(
+suspend fun <ObjectType, IdType, InputValueType> WriteCRUDRepo<ObjectType, IdType, InputValueType>.create(
     vararg values: InputValueType
 ): List<ObjectType> = create(values.toList())
-suspend fun <ObjectType, IdType, InputValueType> WriteStandardCRUDRepo<ObjectType, IdType, InputValueType>.update(
+suspend fun <ObjectType, IdType, InputValueType> WriteCRUDRepo<ObjectType, IdType, InputValueType>.update(
     vararg values: UpdatedValuePair<IdType, InputValueType>
 ): List<ObjectType> = update(values.toList())
-suspend fun <ObjectType, IdType, InputValueType> WriteStandardCRUDRepo<ObjectType, IdType, InputValueType>.deleteById(
+suspend fun <ObjectType, IdType, InputValueType> WriteCRUDRepo<ObjectType, IdType, InputValueType>.deleteById(
     vararg ids: IdType
 ) = deleteById(ids.toList())
 
-interface StandardCRUDRepo<ObjectType, IdType, InputValueType> : ReadStandardCRUDRepo<ObjectType, IdType>,
-    WriteStandardCRUDRepo<ObjectType, IdType, InputValueType>
-typealias CRUDRepo<ObjectType, IdType, InputValueType> = StandardCRUDRepo<ObjectType, IdType, InputValueType>
+interface CRUDRepo<ObjectType, IdType, InputValueType> : ReadCRUDRepo<ObjectType, IdType>,
+    WriteCRUDRepo<ObjectType, IdType, InputValueType>
+typealias StandardCRUDRepo<ObjectType, IdType, InputValueType> = CRUDRepo<ObjectType, IdType, InputValueType>
 
-class DelegateBasedStandardCRUDRepo<ObjectType, IdType, InputValueType>(
-    readDelegate: ReadStandardCRUDRepo<ObjectType, IdType>,
-    writeDelegate: WriteStandardCRUDRepo<ObjectType, IdType, InputValueType>
-) : StandardCRUDRepo<ObjectType, IdType, InputValueType>,
-    ReadStandardCRUDRepo<ObjectType, IdType> by readDelegate,
-    WriteStandardCRUDRepo<ObjectType, IdType, InputValueType> by writeDelegate
+class DelegateBasedCRUDRepo<ObjectType, IdType, InputValueType>(
+    readDelegate: ReadCRUDRepo<ObjectType, IdType>,
+    writeDelegate: WriteCRUDRepo<ObjectType, IdType, InputValueType>
+) : CRUDRepo<ObjectType, IdType, InputValueType>,
+    ReadCRUDRepo<ObjectType, IdType> by readDelegate,
+    WriteCRUDRepo<ObjectType, IdType, InputValueType> by writeDelegate

repos/common/src/commonMain/kotlin/dev/inmo/micro_utils/repos/StandartKeyValueRepo.kt

@@ -4,7 +4,7 @@ import dev.inmo.micro_utils.pagination.*
 import dev.inmo.micro_utils.pagination.utils.doAllWithCurrentPaging
 import kotlinx.coroutines.flow.Flow
 
-interface ReadStandardKeyValueRepo<Key, Value> : Repo {
+interface ReadKeyValueRepo<Key, Value> : Repo {
     suspend fun get(k: Key): Value?
     suspend fun values(pagination: Pagination, reversed: Boolean = false): PaginationResult<Value>
     suspend fun keys(pagination: Pagination, reversed: Boolean = false): PaginationResult<Key>
@@ -12,9 +12,9 @@ interface ReadStandardKeyValueRepo<Key, Value> : Repo {
     suspend fun contains(key: Key): Boolean
     suspend fun count(): Long
 }
-typealias ReadKeyValueRepo<Key,Value> = ReadStandardKeyValueRepo<Key, Value>
+typealias ReadStandardKeyValueRepo<Key,Value> = ReadKeyValueRepo<Key, Value>
 
-interface WriteStandardKeyValueRepo<Key, Value> : Repo {
+interface WriteKeyValueRepo<Key, Value> : Repo {
     val onNewValue: Flow<Pair<Key, Value>>
     val onValueRemoved: Flow<Key>
 
@@ -22,25 +22,25 @@ interface WriteStandardKeyValueRepo<Key, Value> : Repo {
     suspend fun unset(toUnset: List<Key>)
     suspend fun unsetWithValues(toUnset: List<Value>)
 }
-typealias WriteKeyValueRepo<Key,Value> = WriteStandardKeyValueRepo<Key, Value>
+typealias WriteStandardKeyValueRepo<Key,Value> = WriteKeyValueRepo<Key, Value>
 
-suspend inline fun <Key, Value> WriteStandardKeyValueRepo<Key, Value>.set(
+suspend inline fun <Key, Value> WriteKeyValueRepo<Key, Value>.set(
     vararg toSet: Pair<Key, Value>
 ) = set(toSet.toMap())
 
-suspend inline fun <Key, Value> WriteStandardKeyValueRepo<Key, Value>.set(
+suspend inline fun <Key, Value> WriteKeyValueRepo<Key, Value>.set(
     k: Key, v: Value
 ) = set(k to v)
 
-suspend inline fun <Key, Value> WriteStandardKeyValueRepo<Key, Value>.unset(
+suspend inline fun <Key, Value> WriteKeyValueRepo<Key, Value>.unset(
     vararg k: Key
 ) = unset(k.toList())
 
-suspend inline fun <Key, Value> WriteStandardKeyValueRepo<Key, Value>.unsetWithValues(
+suspend inline fun <Key, Value> WriteKeyValueRepo<Key, Value>.unsetWithValues(
     vararg v: Value
 ) = unsetWithValues(v.toList())
 
-interface StandardKeyValueRepo<Key, Value> : ReadStandardKeyValueRepo<Key, Value>, WriteStandardKeyValueRepo<Key, Value> {
+interface KeyValueRepo<Key, Value> : ReadKeyValueRepo<Key, Value>, WriteKeyValueRepo<Key, Value> {
     override suspend fun unsetWithValues(toUnset: List<Value>) = toUnset.forEach { v ->
         doAllWithCurrentPaging {
             keys(v, it).also {
@@ -49,11 +49,11 @@ interface StandardKeyValueRepo<Key, Value> : ReadStandardKeyValueRepo<Key, Value
         }
     }
 }
-typealias KeyValueRepo<Key,Value> = StandardKeyValueRepo<Key, Value>
+typealias StandardKeyValueRepo<Key,Value> = KeyValueRepo<Key, Value>
 
-class DelegateBasedStandardKeyValueRepo<Key, Value>(
-    readDelegate: ReadStandardKeyValueRepo<Key, Value>,
-    writeDelegate: WriteStandardKeyValueRepo<Key, Value>
-) : StandardKeyValueRepo<Key, Value>,
-    ReadStandardKeyValueRepo<Key, Value> by readDelegate,
-    WriteStandardKeyValueRepo<Key, Value> by writeDelegate
+class DelegateBasedKeyValueRepo<Key, Value>(
+    readDelegate: ReadKeyValueRepo<Key, Value>,
+    writeDelegate: WriteKeyValueRepo<Key, Value>
+) : KeyValueRepo<Key, Value>,
+    ReadKeyValueRepo<Key, Value> by readDelegate,
+    WriteKeyValueRepo<Key, Value> by writeDelegate

repos/common/src/commonMain/kotlin/dev/inmo/micro_utils/repos/mappers/KeyValueMappers.kt

@@ -6,10 +6,12 @@ import dev.inmo.micro_utils.repos.*
 import kotlinx.coroutines.flow.Flow
 import kotlinx.coroutines.flow.map
 
-open class MapperReadStandardKeyValueRepo<FromKey, FromValue, ToKey, ToValue>(
-    private val to: ReadStandardKeyValueRepo<ToKey, ToValue>,
+@Deprecated("Renamed", ReplaceWith("MapperReadKeyValueRepo", "dev.inmo.micro_utils.repos.mappers.MapperReadKeyValueRepo"))
+typealias MapperReadStandardKeyValueRepo<FromKey, FromValue, ToKey, ToValue> = MapperReadKeyValueRepo<FromKey, FromValue, ToKey, ToValue>
+open class MapperReadKeyValueRepo<FromKey, FromValue, ToKey, ToValue>(
+    private val to: ReadKeyValueRepo<ToKey, ToValue>,
     mapper: MapperRepo<FromKey, FromValue, ToKey, ToValue>
-) : ReadStandardKeyValueRepo<FromKey, FromValue>, MapperRepo<FromKey, FromValue, ToKey, ToValue> by mapper {
+) : ReadKeyValueRepo<FromKey, FromValue>, MapperRepo<FromKey, FromValue, ToKey, ToValue> by mapper {
     override suspend fun get(k: FromKey): FromValue? = to.get(
         k.toOutKey()
     ) ?.toInnerValue()
@@ -69,24 +71,26 @@ open class MapperReadStandardKeyValueRepo<FromKey, FromValue, ToKey, ToValue>(
 }
 
 @Suppress("NOTHING_TO_INLINE")
-inline fun <FromKey, FromValue, ToKey, ToValue> ReadStandardKeyValueRepo<ToKey, ToValue>.withMapper(
+inline fun <FromKey, FromValue, ToKey, ToValue> ReadKeyValueRepo<ToKey, ToValue>.withMapper(
     mapper: MapperRepo<FromKey, FromValue, ToKey, ToValue>
-): ReadStandardKeyValueRepo<FromKey, FromValue> = MapperReadStandardKeyValueRepo(this, mapper)
+): ReadKeyValueRepo<FromKey, FromValue> = MapperReadKeyValueRepo(this, mapper)
 
 @Suppress("NOTHING_TO_INLINE")
-inline fun <reified FromKey, reified FromValue, reified ToKey, reified ToValue> ReadStandardKeyValueRepo<ToKey, ToValue>.withMapper(
+inline fun <reified FromKey, reified FromValue, reified ToKey, reified ToValue> ReadKeyValueRepo<ToKey, ToValue>.withMapper(
     crossinline keyFromToTo: suspend FromKey.() -> ToKey = { this as ToKey },
     crossinline valueFromToTo: suspend FromValue.() -> ToValue = { this as ToValue },
     crossinline keyToToFrom: suspend ToKey.() -> FromKey = { this as FromKey },
     crossinline valueToToFrom: suspend ToValue.() -> FromValue = { this as FromValue },
-): ReadStandardKeyValueRepo<FromKey, FromValue> = withMapper(
+): ReadKeyValueRepo<FromKey, FromValue> = withMapper(
     mapper(keyFromToTo, valueFromToTo, keyToToFrom, valueToToFrom)
 )
 
-open class MapperWriteStandardKeyValueRepo<FromKey, FromValue, ToKey, ToValue>(
-    private val to: WriteStandardKeyValueRepo<ToKey, ToValue>,
+@Deprecated("Renamed", ReplaceWith("MapperWriteKeyValueRepo", "dev.inmo.micro_utils.repos.mappers.MapperWriteKeyValueRepo"))
+typealias MapperWriteStandardKeyValueRepo<FromKey, FromValue, ToKey, ToValue> = MapperWriteKeyValueRepo<FromKey, FromValue, ToKey, ToValue>
+open class MapperWriteKeyValueRepo<FromKey, FromValue, ToKey, ToValue>(
+    private val to: WriteKeyValueRepo<ToKey, ToValue>,
     mapper: MapperRepo<FromKey, FromValue, ToKey, ToValue>
-) : WriteStandardKeyValueRepo<FromKey, FromValue>, MapperRepo<FromKey, FromValue, ToKey, ToValue> by mapper {
+) : WriteKeyValueRepo<FromKey, FromValue>, MapperRepo<FromKey, FromValue, ToKey, ToValue> by mapper {
     override val onNewValue: Flow<Pair<FromKey, FromValue>> = to.onNewValue.map { (k, v) ->
         k.toInnerKey() to v.toInnerValue()
     }
@@ -112,40 +116,42 @@ open class MapperWriteStandardKeyValueRepo<FromKey, FromValue, ToKey, ToValue>(
 }
 
 @Suppress("NOTHING_TO_INLINE")
-inline fun <FromKey, FromValue, ToKey, ToValue> WriteStandardKeyValueRepo<ToKey, ToValue>.withMapper(
+inline fun <FromKey, FromValue, ToKey, ToValue> WriteKeyValueRepo<ToKey, ToValue>.withMapper(
     mapper: MapperRepo<FromKey, FromValue, ToKey, ToValue>
-): WriteStandardKeyValueRepo<FromKey, FromValue> = MapperWriteStandardKeyValueRepo(this, mapper)
+): WriteKeyValueRepo<FromKey, FromValue> = MapperWriteKeyValueRepo(this, mapper)
 
 @Suppress("NOTHING_TO_INLINE")
-inline fun <reified FromKey, reified FromValue, reified ToKey, reified ToValue> WriteStandardKeyValueRepo<ToKey, ToValue>.withMapper(
+inline fun <reified FromKey, reified FromValue, reified ToKey, reified ToValue> WriteKeyValueRepo<ToKey, ToValue>.withMapper(
     crossinline keyFromToTo: suspend FromKey.() -> ToKey = { this as ToKey },
     crossinline valueFromToTo: suspend FromValue.() -> ToValue = { this as ToValue },
     crossinline keyToToFrom: suspend ToKey.() -> FromKey = { this as FromKey },
     crossinline valueToToFrom: suspend ToValue.() -> FromValue = { this as FromValue },
-): WriteStandardKeyValueRepo<FromKey, FromValue> = withMapper(
+): WriteKeyValueRepo<FromKey, FromValue> = withMapper(
     mapper(keyFromToTo, valueFromToTo, keyToToFrom, valueToToFrom)
 )
 
+@Deprecated("Renamed", ReplaceWith("MapperKeyValueRepo", "dev.inmo.micro_utils.repos.mappers.MapperKeyValueRepo"))
+typealias MapperStandardKeyValueRepo<FromKey, FromValue, ToKey, ToValue> = MapperKeyValueRepo<FromKey, FromValue, ToKey, ToValue>
 @Suppress("DELEGATED_MEMBER_HIDES_SUPERTYPE_OVERRIDE")
-open class MapperStandardKeyValueRepo<FromKey, FromValue, ToKey, ToValue>(
-    private val to: StandardKeyValueRepo<ToKey, ToValue>,
+open class MapperKeyValueRepo<FromKey, FromValue, ToKey, ToValue>(
+    private val to: KeyValueRepo<ToKey, ToValue>,
     private val mapper: MapperRepo<FromKey, FromValue, ToKey, ToValue>
-) : StandardKeyValueRepo<FromKey, FromValue>,
+) : KeyValueRepo<FromKey, FromValue>,
     MapperRepo<FromKey, FromValue, ToKey, ToValue> by mapper,
-    ReadStandardKeyValueRepo<FromKey, FromValue> by MapperReadStandardKeyValueRepo(to, mapper),
-    WriteStandardKeyValueRepo<FromKey, FromValue> by MapperWriteStandardKeyValueRepo(to, mapper)
+    ReadKeyValueRepo<FromKey, FromValue> by MapperReadKeyValueRepo(to, mapper),
+    WriteKeyValueRepo<FromKey, FromValue> by MapperWriteKeyValueRepo(to, mapper)
 
 @Suppress("NOTHING_TO_INLINE")
-inline fun <FromKey, FromValue, ToKey, ToValue> StandardKeyValueRepo<ToKey, ToValue>.withMapper(
+inline fun <FromKey, FromValue, ToKey, ToValue> KeyValueRepo<ToKey, ToValue>.withMapper(
     mapper: MapperRepo<FromKey, FromValue, ToKey, ToValue>
-): StandardKeyValueRepo<FromKey, FromValue> = MapperStandardKeyValueRepo(this, mapper)
+): KeyValueRepo<FromKey, FromValue> = MapperKeyValueRepo(this, mapper)
 
 @Suppress("NOTHING_TO_INLINE")
-inline fun <reified FromKey, reified FromValue, reified ToKey, reified ToValue> StandardKeyValueRepo<ToKey, ToValue>.withMapper(
+inline fun <reified FromKey, reified FromValue, reified ToKey, reified ToValue> KeyValueRepo<ToKey, ToValue>.withMapper(
     crossinline keyFromToTo: suspend FromKey.() -> ToKey = { this as ToKey },
     crossinline valueFromToTo: suspend FromValue.() -> ToValue = { this as ToValue },
     crossinline keyToToFrom: suspend ToKey.() -> FromKey = { this as FromKey },
     crossinline valueToToFrom: suspend ToValue.() -> FromValue = { this as FromValue },
-): StandardKeyValueRepo<FromKey, FromValue> = withMapper(
+): KeyValueRepo<FromKey, FromValue> = withMapper(
     mapper(keyFromToTo, valueFromToTo, keyToToFrom, valueToToFrom)
 )

repos/common/src/commonMain/kotlin/dev/inmo/micro_utils/repos/mappers/OneToManyKeyValueMappers.kt

@@ -6,10 +6,12 @@ import dev.inmo.micro_utils.repos.*
 import kotlinx.coroutines.flow.Flow
 import kotlinx.coroutines.flow.map
 
-open class MapperReadOneToManyKeyValueRepo<FromKey, FromValue, ToKey, ToValue>(
-    private val to: ReadOneToManyKeyValueRepo<ToKey, ToValue>,
+@Deprecated("Renamed", ReplaceWith("MapperReadKeyValuesRepo", "dev.inmo.micro_utils.repos.mappers.MapperReadKeyValuesRepo"))
+typealias MapperReadOneToManyKeyValueRepo<FromKey, FromValue, ToKey, ToValue> = MapperReadKeyValuesRepo<FromKey, FromValue, ToKey, ToValue>
+open class MapperReadKeyValuesRepo<FromKey, FromValue, ToKey, ToValue>(
+    private val to: ReadKeyValuesRepo<ToKey, ToValue>,
     mapper: MapperRepo<FromKey, FromValue, ToKey, ToValue>
-) : ReadOneToManyKeyValueRepo<FromKey, FromValue>, MapperRepo<FromKey, FromValue, ToKey, ToValue> by mapper {
+) : ReadKeyValuesRepo<FromKey, FromValue>, MapperRepo<FromKey, FromValue, ToKey, ToValue> by mapper {
     override suspend fun get(
         k: FromKey,
         pagination: Pagination,
@@ -67,24 +69,26 @@ open class MapperReadOneToManyKeyValueRepo<FromKey, FromValue, ToKey, ToValue>(
 }
 
 @Suppress("NOTHING_TO_INLINE")
-inline fun <FromKey, FromValue, ToKey, ToValue> ReadOneToManyKeyValueRepo<ToKey, ToValue>.withMapper(
+inline fun <FromKey, FromValue, ToKey, ToValue> ReadKeyValuesRepo<ToKey, ToValue>.withMapper(
     mapper: MapperRepo<FromKey, FromValue, ToKey, ToValue>
-): ReadOneToManyKeyValueRepo<FromKey, FromValue> = MapperReadOneToManyKeyValueRepo(this, mapper)
+): ReadKeyValuesRepo<FromKey, FromValue> = MapperReadKeyValuesRepo(this, mapper)
 
 @Suppress("NOTHING_TO_INLINE")
-inline fun <reified FromKey, reified FromValue, reified ToKey, reified ToValue> ReadOneToManyKeyValueRepo<ToKey, ToValue>.withMapper(
+inline fun <reified FromKey, reified FromValue, reified ToKey, reified ToValue> ReadKeyValuesRepo<ToKey, ToValue>.withMapper(
     crossinline keyFromToTo: suspend FromKey.() -> ToKey = { this as ToKey },
     crossinline valueFromToTo: suspend FromValue.() -> ToValue = { this as ToValue },
     crossinline keyToToFrom: suspend ToKey.() -> FromKey = { this as FromKey },
     crossinline valueToToFrom: suspend ToValue.() -> FromValue = { this as FromValue },
-): ReadOneToManyKeyValueRepo<FromKey, FromValue> = withMapper(
+): ReadKeyValuesRepo<FromKey, FromValue> = withMapper(
     mapper(keyFromToTo, valueFromToTo, keyToToFrom, valueToToFrom)
 )
 
-open class MapperWriteOneToManyKeyValueRepo<FromKey, FromValue, ToKey, ToValue>(
-    private val to: WriteOneToManyKeyValueRepo<ToKey, ToValue>,
+@Deprecated("Renamed", ReplaceWith("MapperWriteKeyValuesRepo", "dev.inmo.micro_utils.repos.mappers.MapperWriteKeyValuesRepo"))
+typealias MapperWriteOneToManyKeyValueRepo<FromKey, FromValue, ToKey, ToValue> = MapperWriteKeyValuesRepo<FromKey, FromValue, ToKey, ToValue>
+open class MapperWriteKeyValuesRepo<FromKey, FromValue, ToKey, ToValue>(
+    private val to: WriteKeyValuesRepo<ToKey, ToValue>,
     mapper: MapperRepo<FromKey, FromValue, ToKey, ToValue>
-) : WriteOneToManyKeyValueRepo<FromKey, FromValue>, MapperRepo<FromKey, FromValue, ToKey, ToValue> by mapper {
+) : WriteKeyValuesRepo<FromKey, FromValue>, MapperRepo<FromKey, FromValue, ToKey, ToValue> by mapper {
     override val onNewValue: Flow<Pair<FromKey, FromValue>> = to.onNewValue.map { (k, v) ->
         k.toInnerKey() to v.toInnerValue()
     }
@@ -118,40 +122,42 @@ open class MapperWriteOneToManyKeyValueRepo<FromKey, FromValue, ToKey, ToValue>(
 }
 
 @Suppress("NOTHING_TO_INLINE")
-inline fun <FromKey, FromValue, ToKey, ToValue> WriteOneToManyKeyValueRepo<ToKey, ToValue>.withMapper(
+inline fun <FromKey, FromValue, ToKey, ToValue> WriteKeyValuesRepo<ToKey, ToValue>.withMapper(
     mapper: MapperRepo<FromKey, FromValue, ToKey, ToValue>
-): WriteOneToManyKeyValueRepo<FromKey, FromValue> = MapperWriteOneToManyKeyValueRepo(this, mapper)
+): WriteKeyValuesRepo<FromKey, FromValue> = MapperWriteKeyValuesRepo(this, mapper)
 
 @Suppress("NOTHING_TO_INLINE")
-inline fun <reified FromKey, reified FromValue, reified ToKey, reified ToValue> WriteOneToManyKeyValueRepo<ToKey, ToValue>.withMapper(
+inline fun <reified FromKey, reified FromValue, reified ToKey, reified ToValue> WriteKeyValuesRepo<ToKey, ToValue>.withMapper(
     crossinline keyFromToTo: suspend FromKey.() -> ToKey = { this as ToKey },
     crossinline valueFromToTo: suspend FromValue.() -> ToValue = { this as ToValue },
     crossinline keyToToFrom: suspend ToKey.() -> FromKey = { this as FromKey },
     crossinline valueToToFrom: suspend ToValue.() -> FromValue = { this as FromValue },
-): WriteOneToManyKeyValueRepo<FromKey, FromValue> = withMapper(
+): WriteKeyValuesRepo<FromKey, FromValue> = withMapper(
     mapper(keyFromToTo, valueFromToTo, keyToToFrom, valueToToFrom)
 )
 
+@Deprecated("Renamed", ReplaceWith("MapperKeyValuesRepo", "dev.inmo.micro_utils.repos.mappers.MapperKeyValuesRepo"))
+typealias MapperOneToManyKeyValueRepo<FromKey, FromValue, ToKey, ToValue> = MapperKeyValuesRepo<FromKey, FromValue, ToKey, ToValue>
 @Suppress("DELEGATED_MEMBER_HIDES_SUPERTYPE_OVERRIDE")
-open class MapperOneToManyKeyValueRepo<FromKey, FromValue, ToKey, ToValue>(
-    private val to: OneToManyKeyValueRepo<ToKey, ToValue>,
+open class MapperKeyValuesRepo<FromKey, FromValue, ToKey, ToValue>(
+    private val to: KeyValuesRepo<ToKey, ToValue>,
     mapper: MapperRepo<FromKey, FromValue, ToKey, ToValue>
-) : OneToManyKeyValueRepo<FromKey, FromValue>,
+) : KeyValuesRepo<FromKey, FromValue>,
     MapperRepo<FromKey, FromValue, ToKey, ToValue> by mapper,
-    ReadOneToManyKeyValueRepo<FromKey, FromValue> by MapperReadOneToManyKeyValueRepo(to, mapper),
-    WriteOneToManyKeyValueRepo<FromKey, FromValue> by MapperWriteOneToManyKeyValueRepo(to, mapper)
+    ReadKeyValuesRepo<FromKey, FromValue> by MapperReadKeyValuesRepo(to, mapper),
+    WriteKeyValuesRepo<FromKey, FromValue> by MapperWriteKeyValuesRepo(to, mapper)
 
 @Suppress("NOTHING_TO_INLINE")
-inline fun <FromKey, FromValue, ToKey, ToValue> OneToManyKeyValueRepo<ToKey, ToValue>.withMapper(
+inline fun <FromKey, FromValue, ToKey, ToValue> KeyValuesRepo<ToKey, ToValue>.withMapper(
     mapper: MapperRepo<FromKey, FromValue, ToKey, ToValue>
-): OneToManyKeyValueRepo<FromKey, FromValue> = MapperOneToManyKeyValueRepo(this, mapper)
+): KeyValuesRepo<FromKey, FromValue> = MapperKeyValuesRepo(this, mapper)
 
 @Suppress("NOTHING_TO_INLINE")
-inline fun <reified FromKey, reified FromValue, reified ToKey, reified ToValue> OneToManyKeyValueRepo<ToKey, ToValue>.withMapper(
+inline fun <reified FromKey, reified FromValue, reified ToKey, reified ToValue> KeyValuesRepo<ToKey, ToValue>.withMapper(
     crossinline keyFromToTo: suspend FromKey.() -> ToKey = { this as ToKey },
     crossinline valueFromToTo: suspend FromValue.() -> ToValue = { this as ToValue },
     crossinline keyToToFrom: suspend ToKey.() -> FromKey = { this as FromKey },
     crossinline valueToToFrom: suspend ToValue.() -> FromValue = { this as FromValue },
-): OneToManyKeyValueRepo<FromKey, FromValue> = withMapper(
+): KeyValuesRepo<FromKey, FromValue> = withMapper(
     mapper(keyFromToTo, valueFromToTo, keyToToFrom, valueToToFrom)
 )

repos/common/src/commonMain/kotlin/dev/inmo/micro_utils/repos/pagination/CRUDPaginationExtensions.kt

@@ -1,11 +1,10 @@
 package dev.inmo.micro_utils.repos.pagination
 
 import dev.inmo.micro_utils.pagination.*
-import dev.inmo.micro_utils.pagination.utils.doForAllWithNextPaging
 import dev.inmo.micro_utils.pagination.utils.getAllWithNextPaging
-import dev.inmo.micro_utils.repos.ReadStandardCRUDRepo
+import dev.inmo.micro_utils.repos.ReadCRUDRepo
 
-suspend inline fun <T, ID, REPO : ReadStandardCRUDRepo<T, ID>> REPO.getAll(
+suspend inline fun <T, ID, REPO : ReadCRUDRepo<T, ID>> REPO.getAll(
     @Suppress("REDUNDANT_INLINE_SUSPEND_FUNCTION_TYPE")
     crossinline methodCaller: suspend REPO.(Pagination) -> PaginationResult<T>
 ): List<T> = getAllWithNextPaging {

repos/common/src/commonMain/kotlin/dev/inmo/micro_utils/repos/pagination/KeyValuePaginationExtensions.kt

@@ -2,9 +2,9 @@ package dev.inmo.micro_utils.repos.pagination
 
 import dev.inmo.micro_utils.pagination.*
 import dev.inmo.micro_utils.pagination.utils.getAllWithNextPaging
-import dev.inmo.micro_utils.repos.ReadStandardKeyValueRepo
+import dev.inmo.micro_utils.repos.ReadKeyValueRepo
 
-suspend inline fun <Key, Value, REPO : ReadStandardKeyValueRepo<Key, Value>> REPO.getAll(
+suspend inline fun <Key, Value, REPO : ReadKeyValueRepo<Key, Value>> REPO.getAll(
     @Suppress("REDUNDANT_INLINE_SUSPEND_FUNCTION_TYPE")
     crossinline methodCaller: suspend REPO.(Pagination) -> PaginationResult<Key>
 ): List<Pair<Key, Value>> = getAllWithNextPaging {

repos/common/src/commonMain/kotlin/dev/inmo/micro_utils/repos/pagination/OneToManyPaginationExtensions.kt

@@ -2,9 +2,9 @@ package dev.inmo.micro_utils.repos.pagination
 
 import dev.inmo.micro_utils.pagination.*
 import dev.inmo.micro_utils.pagination.utils.getAllWithNextPaging
-import dev.inmo.micro_utils.repos.ReadOneToManyKeyValueRepo
+import dev.inmo.micro_utils.repos.ReadKeyValuesRepo
 
-suspend inline fun <Key, Value, REPO : ReadOneToManyKeyValueRepo<Key, Value>> REPO.getAll(
+suspend inline fun <Key, Value, REPO : ReadKeyValuesRepo<Key, Value>> REPO.getAll(
     @Suppress("REDUNDANT_INLINE_SUSPEND_FUNCTION_TYPE")
     crossinline methodCaller: suspend REPO.(Pagination) -> PaginationResult<Key>
 ): List<Pair<Key, List<Value>>> = getAllWithNextPaging {

repos/common/src/commonMain/kotlin/dev/inmo/micro_utils/repos/versions/KeyValueBasedVersionsRepoProxy.kt

@@ -1,10 +1,10 @@
 package dev.inmo.micro_utils.repos.versions
 
-import dev.inmo.micro_utils.repos.StandardKeyValueRepo
+import dev.inmo.micro_utils.repos.KeyValueRepo
 import dev.inmo.micro_utils.repos.set
 
 class KeyValueBasedVersionsRepoProxy<T>(
-    private val keyValueStore: StandardKeyValueRepo<String, Int>,
+    private val keyValueStore: KeyValueRepo<String, Int>,
     override val database: T
 ) : StandardVersionsRepoProxy<T> {
     override suspend fun getTableVersion(tableName: String): Int? = keyValueStore.get(tableName)

repos/common/src/jvmMain/kotlin/dev/inmo/micro_utils/repos/FileKeyValueRepo.kt

@@ -13,9 +13,12 @@ import java.nio.file.StandardWatchEventKinds.*
 private inline val String.isAbsolute
     get() = startsWith(File.separator)
 
-class FileReadStandardKeyValueRepo(
+@Deprecated("Renamed", ReplaceWith("FileReadKeyValueRepo", "dev.inmo.micro_utils.repos.FileReadKeyValueRepo"))
+typealias FileReadStandardKeyValueRepo = FileReadKeyValueRepo
+
+class FileReadKeyValueRepo(
     private val folder: File
-) : ReadStandardKeyValueRepo<String, File> {
+) : ReadKeyValueRepo<String, File> {
     init {
         folder.mkdirs()
     }
@@ -79,14 +82,17 @@ class FileReadStandardKeyValueRepo(
     override suspend fun count(): Long = folder.list() ?.size ?.toLong() ?: 0L
 }
 
+@Deprecated("Renamed", ReplaceWith("FileWriteKeyValueRepo", "dev.inmo.micro_utils.repos.FileWriteKeyValueRepo"))
+typealias FileWriteStandardKeyValueRepo = FileWriteKeyValueRepo
+
 /**
  * Files watching will not correctly works on Android with version of API lower than API 26
  */
 @Warning("Files watching will not correctly works on Android Platform with version of API lower than API 26")
-class FileWriteStandardKeyValueRepo(
+class FileWriteKeyValueRepo(
     private val folder: File,
     filesChangedProcessingScope: CoroutineScope? = null
-) : WriteStandardKeyValueRepo<String, File> {
+) : WriteKeyValueRepo<String, File> {
     private val _onNewValue = MutableSharedFlow<Pair<String, File>>()
     override val onNewValue: Flow<Pair<String, File>> = _onNewValue.asSharedFlow()
     private val _onValueRemoved = MutableSharedFlow<String>()
@@ -174,12 +180,15 @@ class FileWriteStandardKeyValueRepo(
     }
 }
 
+@Deprecated("Renamed", ReplaceWith("FileKeyValueRepo", "dev.inmo.micro_utils.repos.FileKeyValueRepo"))
+typealias FileStandardKeyValueRepo = FileKeyValueRepo
+
 @Warning("Files watching will not correctly works on Android Platform with version of API lower than API 26")
 @Suppress("DELEGATED_MEMBER_HIDES_SUPERTYPE_OVERRIDE")
-class FileStandardKeyValueRepo(
+class FileKeyValueRepo(
     folder: File,
     filesChangedProcessingScope: CoroutineScope? = null
-) : StandardKeyValueRepo<String, File>,
-    WriteStandardKeyValueRepo<String, File> by FileWriteStandardKeyValueRepo(folder, filesChangedProcessingScope),
-    ReadStandardKeyValueRepo<String, File> by FileReadStandardKeyValueRepo(folder) {
+) : KeyValueRepo<String, File>,
+    WriteKeyValueRepo<String, File> by FileWriteKeyValueRepo(folder, filesChangedProcessingScope),
+    ReadKeyValueRepo<String, File> by FileReadKeyValueRepo(folder) {
 }

repos/common/src/main/kotlin/dev/inmo/micro_utils/repos/crud/AbstractAndroidCRUDRepo.kt

@@ -12,7 +12,7 @@ val <T> T.asId: String
 
 abstract class AbstractAndroidCRUDRepo<ObjectType, IdType>(
     protected val helper: StandardSQLHelper
-) : ReadStandardCRUDRepo<ObjectType, IdType> {
+) : ReadCRUDRepo<ObjectType, IdType> {
     protected abstract val tableName: String
     protected abstract val idColumnName: String
     protected abstract suspend fun Cursor.toObject(): ObjectType
@@ -64,4 +64,4 @@ abstract class AbstractAndroidCRUDRepo<ObjectType, IdType>(
             }
         }
     }
-}
+}

repos/common/src/main/kotlin/dev/inmo/micro_utils/repos/crud/AbstractMutableAndroidCRUDRepo.kt

@@ -9,9 +9,9 @@ abstract class AbstractMutableAndroidCRUDRepo<ObjectType, IdType, InputValueType
     helper: StandardSQLHelper,
     replyInFlows: Int = 0,
     extraBufferCapacityInFlows: Int = 64
-) : WriteStandardCRUDRepo<ObjectType, IdType, InputValueType>,
+) : WriteCRUDRepo<ObjectType, IdType, InputValueType>,
     AbstractAndroidCRUDRepo<ObjectType, IdType>(helper),
-    StandardCRUDRepo<ObjectType, IdType, InputValueType> {
+    CRUDRepo<ObjectType, IdType, InputValueType> {
     protected val newObjectsChannel = MutableSharedFlow<ObjectType>(replyInFlows, extraBufferCapacityInFlows)
     protected val updateObjectsChannel = MutableSharedFlow<ObjectType>(replyInFlows, extraBufferCapacityInFlows)
     protected val deleteObjectsIdsChannel = MutableSharedFlow<IdType>(replyInFlows, extraBufferCapacityInFlows)

repos/common/src/main/kotlin/dev/inmo/micro_utils/repos/keyvalue/KeyValueStore.kt

@@ -7,7 +7,7 @@ import dev.inmo.micro_utils.pagination.Pagination
 import dev.inmo.micro_utils.pagination.PaginationResult
 import dev.inmo.micro_utils.pagination.utils.paginate
 import dev.inmo.micro_utils.pagination.utils.reverse
-import dev.inmo.micro_utils.repos.StandardKeyValueRepo
+import dev.inmo.micro_utils.repos.KeyValueRepo
 import kotlinx.coroutines.flow.*
 
 private val cache = HashMap<String, KeyValueStore<*>>()
@@ -15,7 +15,7 @@ private val cache = HashMap<String, KeyValueStore<*>>()
 fun <T : Any> Context.keyValueStore(
     name: String = "default",
     cacheValues: Boolean = false
-): StandardKeyValueRepo<String, T> {
+): KeyValueRepo<String, T> {
     @Suppress("UNCHECKED_CAST")
     return cache.getOrPut(name) {
         KeyValueStore<T>(this, name, cacheValues)
@@ -26,7 +26,7 @@ class KeyValueStore<T : Any> internal constructor (
     c: Context,
     preferencesName: String,
     useCache: Boolean = false
-) : SharedPreferences.OnSharedPreferenceChangeListener, StandardKeyValueRepo<String, T> {
+) : SharedPreferences.OnSharedPreferenceChangeListener, KeyValueRepo<String, T> {
     private val sharedPreferences = c.getSharedPreferences(preferencesName, Context.MODE_PRIVATE)
 
     private val cachedData = if (useCache) {

repos/common/src/main/kotlin/dev/inmo/micro_utils/repos/onetomany/OneToManyAndroidRepo.kt

@@ -9,7 +9,6 @@ import dev.inmo.micro_utils.repos.*
 import kotlinx.coroutines.flow.Flow
 import kotlinx.coroutines.flow.MutableSharedFlow
 import kotlinx.coroutines.flow.asSharedFlow
-import kotlinx.coroutines.runBlocking
 import kotlinx.serialization.KSerializer
 import kotlinx.serialization.json.Json
 
@@ -26,7 +25,7 @@ class OneToManyAndroidRepo<Key, Value>(
     private val keyFromString: String.() -> Key,
     private val valueFromString: String.() -> Value,
     private val helper: SQLiteOpenHelper
-) : OneToManyKeyValueRepo<Key, Value> {
+) : KeyValuesRepo<Key, Value> {
     private val _onNewValue: MutableSharedFlow<Pair<Key, Value>> = MutableSharedFlow()
     override val onNewValue: Flow<Pair<Key, Value>> = _onNewValue.asSharedFlow()
     private val _onValueRemoved: MutableSharedFlow<Pair<Key, Value>> = MutableSharedFlow()

repos/common/src/main/kotlin/dev/inmo/micro_utils/repos/versions/AndroidSharedPreferencesStandardVersionsRepoProxy.kt

@@ -4,13 +4,11 @@ package dev.inmo.micro_utils.repos.versions
 
 import android.content.Context
 import android.database.sqlite.SQLiteOpenHelper
-import androidx.core.content.contentValuesOf
 import dev.inmo.micro_utils.repos.*
 import dev.inmo.micro_utils.repos.keyvalue.keyValueStore
-import kotlinx.coroutines.runBlocking
 
 /**
- * Will create [VersionsRepo] based on [T], but versions will be stored in [StandardKeyValueRepo]
+ * Will create [VersionsRepo] based on [T], but versions will be stored in [KeyValueRepo]
  *
  * @receiver Will be used to create [KeyValueBasedVersionsRepoProxy] via [keyValueStore] and pass it to [StandardVersionsRepo]
  *
@@ -26,9 +24,9 @@ inline fun <T> Context.versionsKeyValueRepo(
     )
 )
 /**
- * Will create [VersionsRepo] based on [SQLiteOpenHelper], but versions will be stored in [StandardKeyValueRepo]
+ * Will create [VersionsRepo] based on [SQLiteOpenHelper], but versions will be stored in [KeyValueRepo]
  *
- * @receiver Will be used to create [StandardKeyValueRepo] via [keyValueStore] and pass it to [StandardVersionsRepo]
+ * @receiver Will be used to create [KeyValueRepo] via [keyValueStore] and pass it to [StandardVersionsRepo]
  *
  * @see [keyValueStore]
  */
@@ -37,9 +35,9 @@ inline fun Context.versionsKeyValueRepoForSQL(
 ) = versionsKeyValueRepo(database)
 
 /**
- * Will create [VersionsRepo] based on [SQLiteOpenHelper], but versions will be stored in [StandardKeyValueRepo]
+ * Will create [VersionsRepo] based on [SQLiteOpenHelper], but versions will be stored in [KeyValueRepo]
  *
- * @param context Will be used to create [StandardKeyValueRepo] via [keyValueStore] and pass it to [StandardVersionsRepo]
+ * @param context Will be used to create [KeyValueRepo] via [keyValueStore] and pass it to [StandardVersionsRepo]
  *
  * @see [keyValueStore]
  */

repos/exposed/src/jvmMain/kotlin/dev/inmo/micro_utils/repos/exposed/AbstractExposedCRUDRepo.kt

@@ -1,6 +1,6 @@
 package dev.inmo.micro_utils.repos.exposed
 
-import dev.inmo.micro_utils.repos.StandardCRUDRepo
+import dev.inmo.micro_utils.repos.CRUDRepo
 
 abstract class AbstractExposedCRUDRepo<ObjectType, IdType, InputValueType>(
     flowsChannelsSize: Int = 0,
@@ -11,4 +11,4 @@ abstract class AbstractExposedCRUDRepo<ObjectType, IdType, InputValueType>(
         tableName
     ),
     ExposedCRUDRepo<ObjectType, IdType>,
-    StandardCRUDRepo<ObjectType, IdType, InputValueType>
+    CRUDRepo<ObjectType, IdType, InputValueType>

repos/exposed/src/jvmMain/kotlin/dev/inmo/micro_utils/repos/exposed/AbstractExposedReadCRUDRepo.kt

@@ -1,14 +1,14 @@
 package dev.inmo.micro_utils.repos.exposed
 
 import dev.inmo.micro_utils.pagination.*
-import dev.inmo.micro_utils.repos.ReadStandardCRUDRepo
+import dev.inmo.micro_utils.repos.ReadCRUDRepo
 import org.jetbrains.exposed.sql.*
 import org.jetbrains.exposed.sql.transactions.transaction
 
 abstract class AbstractExposedReadCRUDRepo<ObjectType, IdType>(
     tableName: String
 ) :
-    ReadStandardCRUDRepo<ObjectType, IdType>,
+    ReadCRUDRepo<ObjectType, IdType>,
     ExposedCRUDRepo<ObjectType, IdType>,
     Table(tableName)
 {

repos/exposed/src/jvmMain/kotlin/dev/inmo/micro_utils/repos/exposed/AbstractExposedWriteCRUDRepo.kt

@@ -1,7 +1,7 @@
 package dev.inmo.micro_utils.repos.exposed
 
 import dev.inmo.micro_utils.repos.UpdatedValuePair
-import dev.inmo.micro_utils.repos.WriteStandardCRUDRepo
+import dev.inmo.micro_utils.repos.WriteCRUDRepo
 import kotlinx.coroutines.flow.*
 import org.jetbrains.exposed.sql.*
 import org.jetbrains.exposed.sql.statements.InsertStatement
@@ -15,7 +15,7 @@ abstract class AbstractExposedWriteCRUDRepo<ObjectType, IdType, InputValueType>(
 ) :
     AbstractExposedReadCRUDRepo<ObjectType, IdType>(tableName),
     ExposedCRUDRepo<ObjectType, IdType>,
-    WriteStandardCRUDRepo<ObjectType, IdType, InputValueType>
+    WriteCRUDRepo<ObjectType, IdType, InputValueType>
 {
     protected val _newObjectsFlow = MutableSharedFlow<ObjectType>(replyCacheInFlows, flowsChannelsSize)
     protected val _updatedObjectsFlow = MutableSharedFlow<ObjectType>(replyCacheInFlows, flowsChannelsSize)

repos/exposed/src/jvmMain/kotlin/dev/inmo/micro_utils/repos/exposed/keyvalue/ExposedKeyValueRepo.kt

@@ -1,9 +1,7 @@
 package dev.inmo.micro_utils.repos.exposed.keyvalue
 
-import dev.inmo.micro_utils.repos.StandardKeyValueRepo
+import dev.inmo.micro_utils.repos.KeyValueRepo
 import dev.inmo.micro_utils.repos.exposed.ColumnAllocator
-import dev.inmo.micro_utils.repos.exposed.initTable
-import kotlinx.coroutines.channels.Channel
 import kotlinx.coroutines.flow.*
 import org.jetbrains.exposed.sql.*
 import org.jetbrains.exposed.sql.transactions.transaction
@@ -13,7 +11,7 @@ open class ExposedKeyValueRepo<Key, Value>(
     keyColumnAllocator: ColumnAllocator<Key>,
     valueColumnAllocator: ColumnAllocator<Value>,
     tableName: String? = null
-) : StandardKeyValueRepo<Key, Value>, ExposedReadKeyValueRepo<Key, Value>(
+) : KeyValueRepo<Key, Value>, ExposedReadKeyValueRepo<Key, Value>(
     database,
     keyColumnAllocator,
     valueColumnAllocator,

repos/exposed/src/jvmMain/kotlin/dev/inmo/micro_utils/repos/exposed/keyvalue/ExposedReadKeyValueRepo.kt

@@ -1,7 +1,7 @@
 package dev.inmo.micro_utils.repos.exposed.keyvalue
 
 import dev.inmo.micro_utils.pagination.*
-import dev.inmo.micro_utils.repos.ReadStandardKeyValueRepo
+import dev.inmo.micro_utils.repos.ReadKeyValueRepo
 import dev.inmo.micro_utils.repos.exposed.*
 import org.jetbrains.exposed.sql.*
 import org.jetbrains.exposed.sql.transactions.transaction
@@ -11,7 +11,7 @@ open class ExposedReadKeyValueRepo<Key, Value>(
     keyColumnAllocator: ColumnAllocator<Key>,
     valueColumnAllocator: ColumnAllocator<Value>,
     tableName: String? = null
-) : ReadStandardKeyValueRepo<Key, Value>, ExposedRepo, Table(tableName ?: "") {
+) : ReadKeyValueRepo<Key, Value>, ExposedRepo, Table(tableName ?: "") {
     val keyColumn: Column<Key> = keyColumnAllocator()
     val valueColumn: Column<Value> = valueColumnAllocator()
     override val primaryKey: PrimaryKey = PrimaryKey(keyColumn, valueColumn)

repos/exposed/src/jvmMain/kotlin/dev/inmo/micro_utils/repos/exposed/onetomany/ExposedKeyValuesRepo.kt

@@ -1,18 +1,18 @@
 package dev.inmo.micro_utils.repos.exposed.onetomany
 
-import dev.inmo.micro_utils.repos.OneToManyKeyValueRepo
+import dev.inmo.micro_utils.repos.KeyValuesRepo
 import dev.inmo.micro_utils.repos.exposed.ColumnAllocator
 import kotlinx.coroutines.flow.*
 import org.jetbrains.exposed.sql.*
 import org.jetbrains.exposed.sql.transactions.transaction
 
-typealias ExposedKeyValuesRepo<Key, Value> = ExposedOneToManyKeyValueRepo<Key, Value>
-open class ExposedOneToManyKeyValueRepo<Key, Value>(
+typealias ExposedOneToManyKeyValueRepo1<Key, Value> = ExposedKeyValuesRepo<Key, Value>
+open class ExposedKeyValuesRepo<Key, Value>(
     database: Database,
     keyColumnAllocator: ColumnAllocator<Key>,
     valueColumnAllocator: ColumnAllocator<Value>,
     tableName: String? = null
-) : OneToManyKeyValueRepo<Key, Value>, ExposedReadOneToManyKeyValueRepo<Key, Value>(
+) : KeyValuesRepo<Key, Value>, ExposedReadKeyValuesRepo<Key, Value>(
     database,
     keyColumnAllocator,
     valueColumnAllocator,

repos/exposed/src/jvmMain/kotlin/dev/inmo/micro_utils/repos/exposed/onetomany/ExposedReadKeyValuesRepo.kt

@@ -1,20 +1,19 @@
 package dev.inmo.micro_utils.repos.exposed.onetomany
 
 import dev.inmo.micro_utils.pagination.*
-import dev.inmo.micro_utils.repos.ReadOneToManyKeyValueRepo
+import dev.inmo.micro_utils.repos.ReadKeyValuesRepo
 import dev.inmo.micro_utils.repos.exposed.*
-import dev.inmo.micro_utils.repos.exposed.keyvalue.ExposedReadKeyValueRepo
 import org.jetbrains.exposed.sql.*
 import org.jetbrains.exposed.sql.transactions.transaction
 
-typealias ExposedReadKeyValuesRepo<Key, Value> = ExposedReadOneToManyKeyValueRepo<Key, Value>
+typealias ExposedReadOneToManyKeyValueRepo<Key, Value> = ExposedReadKeyValuesRepo<Key, Value>
 
-open class ExposedReadOneToManyKeyValueRepo<Key, Value>(
+open class ExposedReadKeyValuesRepo<Key, Value>(
     override val database: Database,
     keyColumnAllocator: ColumnAllocator<Key>,
     valueColumnAllocator: ColumnAllocator<Value>,
     tableName: String? = null
-) : ReadOneToManyKeyValueRepo<Key, Value>, ExposedRepo, Table(tableName ?: "") {
+) : ReadKeyValuesRepo<Key, Value>, ExposedRepo, Table(tableName ?: "") {
     val keyColumn: Column<Key> = keyColumnAllocator()
     val valueColumn: Column<Value> = valueColumnAllocator()
 

repos/inmemory/src/commonMain/kotlin/dev/inmo/micro_utils/repos/MapCRUDRepo.kt

@@ -5,7 +5,7 @@ import kotlinx.coroutines.flow.*
 
 class ReadMapCRUDRepo<ObjectType, IdType>(
     private val map: Map<IdType, ObjectType> = emptyMap()
-) : ReadStandardCRUDRepo<ObjectType, IdType> {
+) : ReadCRUDRepo<ObjectType, IdType> {
     override suspend fun getByPagination(pagination: Pagination): PaginationResult<ObjectType> {
         return map.keys.drop(pagination.firstIndex).take(pagination.size).mapNotNull {
             map[it]
@@ -24,7 +24,7 @@ class ReadMapCRUDRepo<ObjectType, IdType>(
 
 abstract class WriteMapCRUDRepo<ObjectType, IdType, InputValueType>(
     protected val map: MutableMap<IdType, ObjectType> = mutableMapOf()
-) : WriteStandardCRUDRepo<ObjectType, IdType, InputValueType> {
+) : WriteCRUDRepo<ObjectType, IdType, InputValueType> {
     protected val _newObjectsFlow: MutableSharedFlow<ObjectType> = MutableSharedFlow()
     override val newObjectsFlow: Flow<ObjectType> = _newObjectsFlow.asSharedFlow()
     protected val _updatedObjectsFlow: MutableSharedFlow<ObjectType> = MutableSharedFlow()
@@ -68,8 +68,8 @@ abstract class WriteMapCRUDRepo<ObjectType, IdType, InputValueType>(
 
 abstract class MapCRUDRepo<ObjectType, IdType, InputValueType>(
     map: MutableMap<IdType, ObjectType>
-) : StandardCRUDRepo<ObjectType, IdType, InputValueType>,
-    ReadStandardCRUDRepo<ObjectType, IdType> by ReadMapCRUDRepo(map),
+) : CRUDRepo<ObjectType, IdType, InputValueType>,
+    ReadCRUDRepo<ObjectType, IdType> by ReadMapCRUDRepo(map),
     WriteMapCRUDRepo<ObjectType, IdType, InputValueType>(map)
 
 fun <ObjectType, IdType, InputValueType> MapCRUDRepo(

repos/inmemory/src/commonMain/kotlin/dev/inmo/micro_utils/repos/MapKeyValueRepo.kt

@@ -9,7 +9,7 @@ import kotlinx.coroutines.flow.MutableSharedFlow
 
 class ReadMapKeyValueRepo<Key, Value>(
     protected val map: Map<Key, Value> = emptyMap()
-) : ReadStandardKeyValueRepo<Key, Value> {
+) : ReadKeyValueRepo<Key, Value> {
     override suspend fun get(k: Key): Value? = map[k]
 
     override suspend fun values(
@@ -58,7 +58,7 @@ class ReadMapKeyValueRepo<Key, Value>(
 
 class WriteMapKeyValueRepo<Key, Value>(
     private val map: MutableMap<Key, Value> = mutableMapOf()
-) : WriteStandardKeyValueRepo<Key, Value> {
+) : WriteKeyValueRepo<Key, Value> {
     private val _onNewValue: MutableSharedFlow<Pair<Key, Value>> = MutableSharedFlow()
     override val onNewValue: Flow<Pair<Key, Value>>
         get() = _onNewValue
@@ -89,8 +89,8 @@ class WriteMapKeyValueRepo<Key, Value>(
 
 class MapKeyValueRepo<Key, Value>(
     private val map: MutableMap<Key, Value> = mutableMapOf()
-) : StandardKeyValueRepo<Key, Value>,
-    ReadStandardKeyValueRepo<Key, Value> by ReadMapKeyValueRepo(map),
-    WriteStandardKeyValueRepo<Key, Value> by WriteMapKeyValueRepo(map)
+) : KeyValueRepo<Key, Value>,
+    ReadKeyValueRepo<Key, Value> by ReadMapKeyValueRepo(map),
+    WriteKeyValueRepo<Key, Value> by WriteMapKeyValueRepo(map)
 
-fun <K, V> MutableMap<K, V>.asKeyValueRepo(): StandardKeyValueRepo<K, V> = MapKeyValueRepo(this)
+fun <K, V> MutableMap<K, V>.asKeyValueRepo(): KeyValueRepo<K, V> = MapKeyValueRepo(this)

repos/inmemory/src/commonMain/kotlin/dev/inmo/micro_utils/repos/MapKeyValuesRepo.kt

@@ -5,9 +5,11 @@ import dev.inmo.micro_utils.pagination.utils.paginate
 import dev.inmo.micro_utils.pagination.utils.reverse
 import kotlinx.coroutines.flow.*
 
-class MapReadOneToManyKeyValueRepo<Key, Value>(
+@Deprecated("Renamed", ReplaceWith("MapReadKeyValuesRepo", "dev.inmo.micro_utils.repos.MapReadKeyValuesRepo"))
+typealias MapReadOneToManyKeyValueRepo<Key, Value> = MapReadKeyValuesRepo<Key, Value>
+class MapReadKeyValuesRepo<Key, Value>(
     private val map: Map<Key, List<Value>> = emptyMap()
-) : ReadOneToManyKeyValueRepo<Key, Value> {
+) : ReadKeyValuesRepo<Key, Value> {
     override suspend fun get(k: Key, pagination: Pagination, reversed: Boolean): PaginationResult<Value> {
         val list = map[k] ?: return emptyPaginationResult()
 
@@ -53,9 +55,11 @@ class MapReadOneToManyKeyValueRepo<Key, Value>(
     override suspend fun count(): Long = map.size.toLong()
 }
 
-class MapWriteOneToManyKeyValueRepo<Key, Value>(
+@Deprecated("Renamed", ReplaceWith("MapWriteKeyValuesRepo", "dev.inmo.micro_utils.repos.MapWriteKeyValuesRepo"))
+typealias MapWriteOneToManyKeyValueRepo<Key, Value> = MapWriteKeyValuesRepo<Key, Value>
+class MapWriteKeyValuesRepo<Key, Value>(
     private val map: MutableMap<Key, MutableList<Value>> = mutableMapOf()
-) : WriteOneToManyKeyValueRepo<Key, Value> {
+) : WriteKeyValuesRepo<Key, Value> {
     private val _onNewValue: MutableSharedFlow<Pair<Key, Value>> = MutableSharedFlow()
     override val onNewValue: Flow<Pair<Key, Value>> = _onNewValue.asSharedFlow()
     private val _onValueRemoved: MutableSharedFlow<Pair<Key, Value>> = MutableSharedFlow()
@@ -98,12 +102,17 @@ class MapWriteOneToManyKeyValueRepo<Key, Value>(
     }
 }
 
-class MapOneToManyKeyValueRepo<Key, Value>(
+@Deprecated("Renamed", ReplaceWith("MapKeyValuesRepo", "dev.inmo.micro_utils.repos.MapKeyValuesRepo"))
+typealias MapOneToManyKeyValueRepo1<Key, Value> = MapKeyValuesRepo<Key, Value>
+class MapKeyValuesRepo<Key, Value>(
     private val map: MutableMap<Key, MutableList<Value>> = mutableMapOf()
-) : OneToManyKeyValueRepo<Key, Value>,
-    ReadOneToManyKeyValueRepo<Key, Value> by MapReadOneToManyKeyValueRepo(map),
-    WriteOneToManyKeyValueRepo<Key, Value> by MapWriteOneToManyKeyValueRepo(map)
+) : KeyValuesRepo<Key, Value>,
+    ReadKeyValuesRepo<Key, Value> by MapReadKeyValuesRepo(map),
+    WriteKeyValuesRepo<Key, Value> by MapWriteKeyValuesRepo(map)
 
-fun <K, V> MutableMap<K, List<V>>.asOneToManyKeyValueRepo(): OneToManyKeyValueRepo<K, V> = MapOneToManyKeyValueRepo(
+fun <K, V> MutableMap<K, List<V>>.asKeyValuesRepo(): KeyValuesRepo<K, V> = MapKeyValuesRepo(
     map { (k, v) -> k to v.toMutableList() }.toMap().toMutableMap()
 )
+
+@Deprecated("Renamed", ReplaceWith("asKeyValuesRepo", "dev.inmo.micro_utils.repos.asKeyValuesRepo"))
+fun <K, V> MutableMap<K, List<V>>.asOneToManyKeyValueRepo(): KeyValuesRepo<K, V> = asKeyValuesRepo()

repos/ktor/client/src/commonMain/kotlin/dev/inmo/micro_utils/repos/ktor/client/crud/KtorCRUDRepoClient.kt

@@ -3,16 +3,15 @@ package dev.inmo.micro_utils.repos.ktor.client.crud
 import dev.inmo.micro_utils.ktor.common.*
 import dev.inmo.micro_utils.repos.*
 import io.ktor.client.HttpClient
-import io.ktor.client.utils.EmptyContent.contentType
 import io.ktor.http.ContentType
 import io.ktor.util.reflect.TypeInfo
 import io.ktor.util.reflect.typeInfo
 import kotlinx.serialization.*
 
-class KtorStandardCrudRepoClient<ObjectType, IdType, InputValue> (
-    readDelegate: ReadStandardCRUDRepo<ObjectType, IdType>,
-    writeDelegate: WriteStandardCRUDRepo<ObjectType, IdType, InputValue>
-) : StandardCRUDRepo<ObjectType, IdType, InputValue> by DelegateBasedStandardCRUDRepo(
+class KtorCRUDRepoClient<ObjectType, IdType, InputValue> (
+    readDelegate: ReadCRUDRepo<ObjectType, IdType>,
+    writeDelegate: WriteCRUDRepo<ObjectType, IdType, InputValue>
+) : CRUDRepo<ObjectType, IdType, InputValue> by DelegateBasedCRUDRepo(
     readDelegate,
     writeDelegate
 ) {
@@ -23,15 +22,15 @@ class KtorStandardCrudRepoClient<ObjectType, IdType, InputValue> (
             objectTypeInfo: TypeInfo,
             contentType: ContentType,
             noinline idSerializer: suspend (IdType) -> String
-        ) = KtorStandardCrudRepoClient(
-            KtorReadStandardCrudRepoClient(
+        ) = KtorCRUDRepoClient(
+            KtorReadCRUDRepoClient(
                 baseUrl,
                 httpClient,
                 objectTypeInfo,
                 contentType,
                 idSerializer
             ),
-            KtorWriteStandardCrudRepoClient<ObjectType, IdType, InputValue>(
+            KtorWriteCrudRepoClient<ObjectType, IdType, InputValue>(
                 baseUrl,
                 httpClient,
                 contentType
@@ -45,7 +44,7 @@ class KtorStandardCrudRepoClient<ObjectType, IdType, InputValue> (
             objectTypeInfo: TypeInfo,
             contentType: ContentType,
             noinline idSerializer: suspend (IdType) -> String
-        ) = KtorStandardCrudRepoClient<ObjectType, IdType, InputValue>(
+        ) = KtorCRUDRepoClient<ObjectType, IdType, InputValue>(
             buildStandardUrl(baseUrl, subpart),
             httpClient,
             objectTypeInfo,
@@ -56,12 +55,12 @@ class KtorStandardCrudRepoClient<ObjectType, IdType, InputValue> (
 }
 
 
-inline fun <reified ObjectType, reified IdType, reified InputValue> KtorStandardCrudRepoClient(
+inline fun <reified ObjectType, reified IdType, reified InputValue> KtorCRUDRepoClient(
     baseUrl: String,
     httpClient: HttpClient,
     contentType: ContentType,
     noinline idSerializer: suspend (IdType) -> String
-) = KtorStandardCrudRepoClient<ObjectType, IdType, InputValue>(
+) = KtorCRUDRepoClient<ObjectType, IdType, InputValue>(
     baseUrl,
     httpClient,
     typeInfo<ObjectType>(),
@@ -69,54 +68,54 @@ inline fun <reified ObjectType, reified IdType, reified InputValue> KtorStandard
     idSerializer
 )
 
-inline fun <reified ObjectType, reified IdType, reified InputValue> KtorStandardCrudRepoClient(
+inline fun <reified ObjectType, reified IdType, reified InputValue> KtorCRUDRepoClient(
     baseUrl: String,
     httpClient: HttpClient,
     idsSerializer: KSerializer<IdType>,
     serialFormat: StringFormat,
     contentType: ContentType,
-) = KtorStandardCrudRepoClient<ObjectType, IdType, InputValue>(baseUrl, httpClient, contentType) {
+) = KtorCRUDRepoClient<ObjectType, IdType, InputValue>(baseUrl, httpClient, contentType) {
     serialFormat.encodeToString(idsSerializer, it)
 }
 
-inline fun <reified ObjectType, reified IdType, reified InputValue> KtorStandardCrudRepoClient(
+inline fun <reified ObjectType, reified IdType, reified InputValue> KtorCRUDRepoClient(
     baseUrl: String,
     httpClient: HttpClient,
     idsSerializer: KSerializer<IdType>,
     serialFormat: BinaryFormat,
     contentType: ContentType,
-) = KtorStandardCrudRepoClient<ObjectType, IdType, InputValue>(baseUrl, httpClient, contentType) {
+) = KtorCRUDRepoClient<ObjectType, IdType, InputValue>(baseUrl, httpClient, contentType) {
     serialFormat.encodeHex(idsSerializer, it)
 }
 
 
-inline fun <reified ObjectType, reified IdType, reified InputValue> KtorStandardCrudRepoClient(
+inline fun <reified ObjectType, reified IdType, reified InputValue> KtorCRUDRepoClient(
     baseUrl: String,
     subpart: String,
     httpClient: HttpClient,
     contentType: ContentType,
     noinline idSerializer: suspend (IdType) -> String
-) = KtorStandardCrudRepoClient<ObjectType, IdType, InputValue>(
+) = KtorCRUDRepoClient<ObjectType, IdType, InputValue>(
     buildStandardUrl(baseUrl, subpart),
     httpClient,
     contentType,
     idSerializer
 )
 
-inline fun <reified ObjectType, reified IdType, reified InputValue> KtorStandardCrudRepoClient(
+inline fun <reified ObjectType, reified IdType, reified InputValue> KtorCRUDRepoClient(
     baseUrl: String,
     subpart: String,
     httpClient: HttpClient,
     idsSerializer: KSerializer<IdType>,
     serialFormat: StringFormat,
     contentType: ContentType,
-) = KtorStandardCrudRepoClient<ObjectType, IdType, InputValue>(buildStandardUrl(baseUrl, subpart), httpClient, idsSerializer, serialFormat, contentType)
+) = KtorCRUDRepoClient<ObjectType, IdType, InputValue>(buildStandardUrl(baseUrl, subpart), httpClient, idsSerializer, serialFormat, contentType)
 
-inline fun <reified ObjectType, reified IdType, reified InputValue> KtorStandardCrudRepoClient(
+inline fun <reified ObjectType, reified IdType, reified InputValue> KtorCRUDRepoClient(
     baseUrl: String,
     subpart: String,
     httpClient: HttpClient,
     idsSerializer: KSerializer<IdType>,
     serialFormat: BinaryFormat,
     contentType: ContentType,
-) = KtorStandardCrudRepoClient<ObjectType, IdType, InputValue>(buildStandardUrl(baseUrl, subpart), httpClient, idsSerializer, serialFormat, contentType)
+) = KtorCRUDRepoClient<ObjectType, IdType, InputValue>(buildStandardUrl(baseUrl, subpart), httpClient, idsSerializer, serialFormat, contentType)

repos/ktor/client/src/commonMain/kotlin/dev/inmo/micro_utils/repos/ktor/client/crud/KtorReadCRUDRepoClient.kt

@@ -2,7 +2,7 @@ package dev.inmo.micro_utils.repos.ktor.client.crud
 
 import dev.inmo.micro_utils.ktor.common.*
 import dev.inmo.micro_utils.pagination.*
-import dev.inmo.micro_utils.repos.ReadStandardCRUDRepo
+import dev.inmo.micro_utils.repos.ReadCRUDRepo
 import dev.inmo.micro_utils.repos.ktor.common.countRouting
 import dev.inmo.micro_utils.repos.ktor.common.crud.*
 import dev.inmo.micro_utils.repos.ktor.common.idParameterName
@@ -14,13 +14,13 @@ import io.ktor.util.reflect.TypeInfo
 import io.ktor.util.reflect.typeInfo
 import kotlinx.serialization.*
 
-class KtorReadStandardCrudRepoClient<ObjectType, IdType> (
+class KtorReadCRUDRepoClient<ObjectType, IdType> (
     private val baseUrl: String,
     private val httpClient: HttpClient,
     private val objectType: TypeInfo,
     private val contentType: ContentType,
     private val idSerializer: suspend (IdType) -> String
-) : ReadStandardCRUDRepo<ObjectType, IdType> {
+) : ReadCRUDRepo<ObjectType, IdType> {
     override suspend fun getByPagination(pagination: Pagination): PaginationResult<ObjectType> = httpClient.get(
         buildStandardUrl(baseUrl, getByPaginationRouting, pagination.asUrlQueryParts)
     ) {
@@ -61,12 +61,12 @@ class KtorReadStandardCrudRepoClient<ObjectType, IdType> (
     }.body()
 }
 
-inline fun <reified ObjectType, IdType> KtorReadStandardCrudRepoClient(
+inline fun <reified ObjectType, IdType> KtorReadCRUDRepoClient(
     baseUrl: String,
     httpClient: HttpClient,
     contentType: ContentType,
     noinline idSerializer: suspend (IdType) -> String
-) = KtorReadStandardCrudRepoClient<ObjectType, IdType>(
+) = KtorReadCRUDRepoClient<ObjectType, IdType>(
     baseUrl,
     httpClient,
     typeInfo<ObjectType>(),
@@ -74,22 +74,22 @@ inline fun <reified ObjectType, IdType> KtorReadStandardCrudRepoClient(
     idSerializer
 )
 
-inline fun <reified ObjectType, IdType> KtorReadStandardCrudRepoClient(
+inline fun <reified ObjectType, IdType> KtorReadCRUDRepoClient(
     baseUrl: String,
     httpClient: HttpClient,
     idsSerializer: KSerializer<IdType>,
     serialFormat: StringFormat,
     contentType: ContentType,
-) = KtorReadStandardCrudRepoClient<ObjectType, IdType>(baseUrl, httpClient, contentType) {
+) = KtorReadCRUDRepoClient<ObjectType, IdType>(baseUrl, httpClient, contentType) {
     serialFormat.encodeToString(idsSerializer, it)
 }
 
-inline fun <reified ObjectType, IdType> KtorReadStandardCrudRepoClient(
+inline fun <reified ObjectType, IdType> KtorReadCRUDRepoClient(
     baseUrl: String,
     httpClient: HttpClient,
     idsSerializer: KSerializer<IdType>,
     serialFormat: BinaryFormat,
     contentType: ContentType,
-) = KtorReadStandardCrudRepoClient<ObjectType, IdType>(baseUrl, httpClient, contentType) {
+) = KtorReadCRUDRepoClient<ObjectType, IdType>(baseUrl, httpClient, contentType) {
     serialFormat.encodeHex(idsSerializer, it)
 }

repos/ktor/client/src/commonMain/kotlin/dev/inmo/micro_utils/repos/ktor/client/crud/KtorReadStandardCrudRepo.kt

@@ -3,7 +3,7 @@ package dev.inmo.micro_utils.repos.ktor.client.crud
 import dev.inmo.micro_utils.ktor.client.*
 import dev.inmo.micro_utils.ktor.common.*
 import dev.inmo.micro_utils.pagination.*
-import dev.inmo.micro_utils.repos.ReadStandardCRUDRepo
+import dev.inmo.micro_utils.repos.ReadCRUDRepo
 import dev.inmo.micro_utils.repos.ktor.common.countRouting
 import dev.inmo.micro_utils.repos.ktor.common.crud.*
 import dev.inmo.micro_utils.repos.ktor.common.idParameterName
@@ -11,14 +11,14 @@ import io.ktor.client.HttpClient
 import kotlinx.serialization.KSerializer
 import kotlinx.serialization.builtins.serializer
 
-@Deprecated("Use KtorReadStandardCrudRepoClient instead")
+@Deprecated("Use KtorReadCRUDRepoClient instead")
 class KtorReadStandardCrudRepo<ObjectType, IdType> (
     private val baseUrl: String,
     private val unifiedRequester: UnifiedRequester,
     private val objectsSerializer: KSerializer<ObjectType>,
     private val objectsSerializerNullable: KSerializer<ObjectType?>,
     private val idsSerializer: KSerializer<IdType>
-) : ReadStandardCRUDRepo<ObjectType, IdType> {
+) : ReadCRUDRepo<ObjectType, IdType> {
     private val paginationResultSerializer = PaginationResult.serializer(objectsSerializer)
 
     constructor(

repos/ktor/client/src/commonMain/kotlin/dev/inmo/micro_utils/repos/ktor/client/crud/KtorStandardCrudRepo.kt

@@ -7,7 +7,7 @@ import dev.inmo.micro_utils.repos.*
 import io.ktor.client.HttpClient
 import kotlinx.serialization.KSerializer
 
-@Deprecated("Use KtorStandardCrudRepoClient instead")
+@Deprecated("Use KtorCRUDRepoClient instead")
 class KtorStandardCrudRepo<ObjectType, IdType, InputValue> (
     baseUrl: String,
     baseSubpart: String,
@@ -16,15 +16,15 @@ class KtorStandardCrudRepo<ObjectType, IdType, InputValue> (
     objectsNullableSerializer: KSerializer<ObjectType?>,
     inputsSerializer: KSerializer<InputValue>,
     idsSerializer: KSerializer<IdType>
-) : StandardCRUDRepo<ObjectType, IdType, InputValue>,
-    ReadStandardCRUDRepo<ObjectType, IdType> by KtorReadStandardCrudRepo(
+) : CRUDRepo<ObjectType, IdType, InputValue>,
+    ReadCRUDRepo<ObjectType, IdType> by KtorReadStandardCrudRepo(
         "$baseUrl/$baseSubpart",
         unifiedRequester,
         objectsSerializer,
         objectsNullableSerializer,
         idsSerializer
     ),
-    WriteStandardCRUDRepo<ObjectType, IdType, InputValue> by KtorWriteStandardCrudRepo(
+    WriteCRUDRepo<ObjectType, IdType, InputValue> by KtorWriteStandardCrudRepo(
         "$baseUrl/$baseSubpart",
         unifiedRequester,
         objectsSerializer,

repos/ktor/client/src/commonMain/kotlin/dev/inmo/micro_utils/repos/ktor/client/crud/KtorWriteCrudRepoClient.kt

@@ -3,7 +3,7 @@ package dev.inmo.micro_utils.repos.ktor.client.crud
 import dev.inmo.micro_utils.ktor.client.*
 import dev.inmo.micro_utils.ktor.common.*
 import dev.inmo.micro_utils.repos.UpdatedValuePair
-import dev.inmo.micro_utils.repos.WriteStandardCRUDRepo
+import dev.inmo.micro_utils.repos.WriteCRUDRepo
 import dev.inmo.micro_utils.repos.ktor.common.crud.*
 import io.ktor.client.HttpClient
 import io.ktor.client.call.body
@@ -13,7 +13,7 @@ import io.ktor.http.ContentType
 import io.ktor.http.contentType
 import kotlinx.coroutines.flow.Flow
 
-class KtorWriteStandardCrudRepoClient<ObjectType, IdType, InputValue> (
+class KtorWriteCrudRepoClient<ObjectType, IdType, InputValue> (
     private val baseUrl: String,
     private val httpClient: HttpClient,
     override val newObjectsFlow: Flow<ObjectType>,
@@ -24,7 +24,7 @@ class KtorWriteStandardCrudRepoClient<ObjectType, IdType, InputValue> (
     private val deleteByIdSetup: suspend HttpRequestBuilder.(List<IdType>) -> Unit,
     private val createBodyGetter: suspend HttpResponse.() -> List<ObjectType>,
     private val updateBodyGetter: suspend HttpResponse.() -> List<ObjectType>
-) : WriteStandardCRUDRepo<ObjectType, IdType, InputValue> {
+) : WriteCRUDRepo<ObjectType, IdType, InputValue> {
     override suspend fun create(values: List<InputValue>): List<ObjectType> = httpClient.post(
         buildStandardUrl(baseUrl, createRouting)
     ) {
@@ -34,7 +34,7 @@ class KtorWriteStandardCrudRepoClient<ObjectType, IdType, InputValue> (
     override suspend fun update(
         values: List<UpdatedValuePair<IdType, InputValue>>
     ): List<ObjectType> = httpClient.post(
-        buildStandardUrl(baseUrl, updateManyRouting)
+        buildStandardUrl(baseUrl, updateRouting)
     ) {
         updateSetup(values)
     }.updateBodyGetter()
@@ -54,7 +54,7 @@ class KtorWriteStandardCrudRepoClient<ObjectType, IdType, InputValue> (
             baseUrl: String,
             httpClient: HttpClient,
             contentType: ContentType
-        ) = KtorWriteStandardCrudRepoClient<ObjectType, IdType, InputValue>(
+        ) = KtorWriteCrudRepoClient<ObjectType, IdType, InputValue>(
             baseUrl,
             httpClient,
             httpClient.createStandardWebsocketFlow(

repos/ktor/client/src/commonMain/kotlin/dev/inmo/micro_utils/repos/ktor/client/crud/KtorWriteStandardCrudRepo.kt

@@ -3,14 +3,14 @@ package dev.inmo.micro_utils.repos.ktor.client.crud
 import dev.inmo.micro_utils.ktor.client.*
 import dev.inmo.micro_utils.ktor.common.*
 import dev.inmo.micro_utils.repos.UpdatedValuePair
-import dev.inmo.micro_utils.repos.WriteStandardCRUDRepo
+import dev.inmo.micro_utils.repos.WriteCRUDRepo
 import dev.inmo.micro_utils.repos.ktor.common.crud.*
 import io.ktor.client.HttpClient
 import kotlinx.coroutines.flow.Flow
 import kotlinx.serialization.KSerializer
 import kotlinx.serialization.builtins.*
 
-@Deprecated("Use KtorWriteStandardCrudRepoClient instead")
+@Deprecated("Use KtorWriteCRUDRepoClient instead")
 class KtorWriteStandardCrudRepo<ObjectType, IdType, InputValue> (
     private val baseUrl: String,
     private val unifiedRequester: UnifiedRequester,
@@ -18,7 +18,7 @@ class KtorWriteStandardCrudRepo<ObjectType, IdType, InputValue> (
     private val objectsNullableSerializer: KSerializer<ObjectType?>,
     private val inputsSerializer: KSerializer<InputValue>,
     private val idsSerializer: KSerializer<IdType>
-) : WriteStandardCRUDRepo<ObjectType, IdType, InputValue> {
+) : WriteCRUDRepo<ObjectType, IdType, InputValue> {
     private val listObjectsSerializer = ListSerializer(objectsSerializer)
     private val listInputSerializer = ListSerializer(inputsSerializer)
     private val listIdsSerializer = ListSerializer(idsSerializer)

repos/ktor/client/src/commonMain/kotlin/dev/inmo/micro_utils/repos/ktor/client/key_value/KtorKeyValueRepoClient.kt

@@ -7,10 +7,10 @@ import io.ktor.http.ContentType
 import io.ktor.http.encodeURLQueryComponent
 import kotlinx.serialization.*
 
-class KtorStandardKeyValueRepoClient<Key, Value> (
-    readDelegate: ReadStandardKeyValueRepo<Key, Value>,
-    writeDelegate: WriteStandardKeyValueRepo<Key, Value>
-) : StandardKeyValueRepo<Key, Value> by DelegateBasedStandardKeyValueRepo(
+class KtorKeyValueRepoClient<Key, Value> (
+    readDelegate: ReadKeyValueRepo<Key, Value>,
+    writeDelegate: WriteKeyValueRepo<Key, Value>
+) : KeyValueRepo<Key, Value> by DelegateBasedKeyValueRepo(
     readDelegate,
     writeDelegate
 ) {
@@ -21,11 +21,11 @@ class KtorStandardKeyValueRepoClient<Key, Value> (
             contentType: ContentType,
             noinline idSerializer: suspend (Key) -> String,
             noinline valueSerializer: suspend (Value) -> String
-        ) = KtorStandardKeyValueRepoClient(
-            KtorReadStandardKeyValueRepoClient(
+        ) = KtorKeyValueRepoClient(
+            KtorReadKeyValueRepoClient(
                 baseUrl, httpClient, contentType, idSerializer, valueSerializer
             ),
-            KtorWriteStandardKeyValueRepoClient(
+            KtorWriteKeyValueRepoClient(
                 baseUrl,
                 httpClient,
                 contentType
@@ -38,7 +38,7 @@ class KtorStandardKeyValueRepoClient<Key, Value> (
             contentType: ContentType,
             noinline idSerializer: suspend (Key) -> String,
             noinline valueSerializer: suspend (Value) -> String
-        ) = KtorStandardKeyValueRepoClient(
+        ) = KtorKeyValueRepoClient(
             buildStandardUrl(baseUrl, subpart),
             httpClient,
             contentType,
@@ -48,14 +48,14 @@ class KtorStandardKeyValueRepoClient<Key, Value> (
     }
 }
 
-inline fun <reified Key, reified Value> KtorStandardKeyValueRepoClient(
+inline fun <reified Key, reified Value> KtorKeyValueRepoClient(
     baseUrl: String,
     httpClient: HttpClient,
     contentType: ContentType,
     idSerializer: SerializationStrategy<Key>,
     valueSerializer: SerializationStrategy<Value>,
     serialFormat: StringFormat,
-) = KtorStandardKeyValueRepoClient<Key, Value>(
+) = KtorKeyValueRepoClient<Key, Value>(
     baseUrl,
     httpClient,
     contentType,
@@ -66,14 +66,14 @@ inline fun <reified Key, reified Value> KtorStandardKeyValueRepoClient(
     serialFormat.encodeToString(valueSerializer, it).encodeURLQueryComponent()
 }
 
-inline fun <reified Key, reified Value> KtorStandardKeyValueRepoClient(
+inline fun <reified Key, reified Value> KtorKeyValueRepoClient(
     baseUrl: String,
     httpClient: HttpClient,
     contentType: ContentType,
     idSerializer: SerializationStrategy<Key>,
     valueSerializer: SerializationStrategy<Value>,
     serialFormat: BinaryFormat,
-) = KtorStandardKeyValueRepoClient<Key, Value>(
+) = KtorKeyValueRepoClient<Key, Value>(
     baseUrl,
     httpClient,
     contentType,

repos/ktor/client/src/commonMain/kotlin/dev/inmo/micro_utils/repos/ktor/client/key_value/KtorReadKeyValueRepoClient.kt

@@ -2,7 +2,7 @@ package dev.inmo.micro_utils.repos.ktor.client.key_value
 
 import dev.inmo.micro_utils.ktor.common.*
 import dev.inmo.micro_utils.pagination.*
-import dev.inmo.micro_utils.repos.ReadStandardKeyValueRepo
+import dev.inmo.micro_utils.repos.ReadKeyValueRepo
 import dev.inmo.micro_utils.repos.ktor.common.*
 import dev.inmo.micro_utils.repos.ktor.common.containsRoute
 import dev.inmo.micro_utils.repos.ktor.common.key_value.*
@@ -15,7 +15,7 @@ import io.ktor.util.reflect.TypeInfo
 import io.ktor.util.reflect.typeInfo
 import kotlinx.serialization.*
 
-class KtorReadStandardKeyValueRepoClient<Key, Value>(
+class KtorReadKeyValueRepoClient<Key, Value>(
     private val baseUrl: String,
     private val httpClient: HttpClient,
     private val contentType: ContentType,
@@ -24,7 +24,7 @@ class KtorReadStandardKeyValueRepoClient<Key, Value>(
     private val paginationResultIdsTypeInfo: TypeInfo,
     private val idSerializer: suspend (Key) -> String,
     private val valueSerializer: suspend (Value) -> String
-) : ReadStandardKeyValueRepo<Key, Value> {
+) : ReadKeyValueRepo<Key, Value> {
     override suspend fun get(k: Key): Value? = httpClient.get(
         buildStandardUrl(
             baseUrl,
@@ -89,13 +89,13 @@ class KtorReadStandardKeyValueRepoClient<Key, Value>(
     }.body()
 }
 
-inline fun <reified Key, reified Value> KtorReadStandardKeyValueRepoClient(
+inline fun <reified Key, reified Value> KtorReadKeyValueRepoClient(
     baseUrl: String,
     httpClient: HttpClient,
     contentType: ContentType,
     noinline idSerializer: suspend (Key) -> String,
     noinline valueSerializer: suspend (Value) -> String
-) = KtorReadStandardKeyValueRepoClient<Key, Value>(
+) = KtorReadKeyValueRepoClient<Key, Value>(
     baseUrl,
     httpClient,
     contentType,
@@ -106,14 +106,14 @@ inline fun <reified Key, reified Value> KtorReadStandardKeyValueRepoClient(
     valueSerializer
 )
 
-inline fun <reified Key, reified Value> KtorReadStandardKeyValueRepoClient(
+inline fun <reified Key, reified Value> KtorReadKeyValueRepoClient(
     baseUrl: String,
     httpClient: HttpClient,
     idsSerializer: KSerializer<Key>,
     valueSerializer: KSerializer<Value>,
     serialFormat: StringFormat,
     contentType: ContentType,
-) = KtorReadStandardKeyValueRepoClient<Key, Value>(
+) = KtorReadKeyValueRepoClient<Key, Value>(
     baseUrl,
     httpClient,
     contentType,
@@ -124,14 +124,14 @@ inline fun <reified Key, reified Value> KtorReadStandardKeyValueRepoClient(
     serialFormat.encodeToString(valueSerializer, it).encodeURLQueryComponent()
 }
 
-inline fun <reified Key, reified Value> KtorReadStandardKeyValueRepoClient(
+inline fun <reified Key, reified Value> KtorReadKeyValueRepoClient(
     baseUrl: String,
     httpClient: HttpClient,
     idsSerializer: KSerializer<Key>,
     valuesSerializer: KSerializer<Value>,
     serialFormat: BinaryFormat,
     contentType: ContentType,
-) = KtorReadStandardKeyValueRepoClient<Key, Value>(
+) = KtorReadKeyValueRepoClient<Key, Value>(
     baseUrl,
     httpClient,
     contentType,

repos/ktor/client/src/commonMain/kotlin/dev/inmo/micro_utils/repos/ktor/client/key_value/KtorReadStandardKeyValueRepo.kt

@@ -3,7 +3,7 @@ package dev.inmo.micro_utils.repos.ktor.client.key_value
 import dev.inmo.micro_utils.ktor.client.*
 import dev.inmo.micro_utils.ktor.common.*
 import dev.inmo.micro_utils.pagination.*
-import dev.inmo.micro_utils.repos.ReadStandardKeyValueRepo
+import dev.inmo.micro_utils.repos.ReadKeyValueRepo
 import dev.inmo.micro_utils.repos.ktor.common.*
 import dev.inmo.micro_utils.repos.ktor.common.containsRoute
 import dev.inmo.micro_utils.repos.ktor.common.countRoute
@@ -14,13 +14,14 @@ import io.ktor.client.HttpClient
 import kotlinx.serialization.*
 import kotlinx.serialization.builtins.serializer
 
+@Deprecated("Replaced with KtorReadKeyValueRepoClient")
 class KtorReadStandardKeyValueRepo<Key, Value> (
     private val baseUrl: String,
     private val unifiedRequester: UnifiedRequester,
     private val keySerializer: KSerializer<Key>,
     private val valueSerializer: KSerializer<Value>,
     private val valueNullableSerializer: KSerializer<Value?>
-) : ReadStandardKeyValueRepo<Key, Value> {
+) : ReadKeyValueRepo<Key, Value> {
     constructor(
         baseUrl: String,
         client: HttpClient,

repos/ktor/client/src/commonMain/kotlin/dev/inmo/micro_utils/repos/ktor/client/key_value/KtorStandartKeyValueRepo.kt

@@ -7,6 +7,7 @@ import dev.inmo.micro_utils.repos.*
 import io.ktor.client.HttpClient
 import kotlinx.serialization.*
 
+@Deprecated("Replaced with KtorKeyValueRepoClient")
 @Suppress("DELEGATED_MEMBER_HIDES_SUPERTYPE_OVERRIDE")
 class KtorStandartKeyValueRepo<K, V> (
     baseUrl: String,
@@ -15,15 +16,15 @@ class KtorStandartKeyValueRepo<K, V> (
     keySerializer: KSerializer<K>,
     valueSerializer: KSerializer<V>,
     valueNullableSerializer: KSerializer<V?>
-) : StandardKeyValueRepo<K, V>,
-    ReadStandardKeyValueRepo<K, V> by KtorReadStandardKeyValueRepo(
+) : KeyValueRepo<K, V>,
+    ReadKeyValueRepo<K, V> by KtorReadStandardKeyValueRepo(
         "$baseUrl/$baseSubpart",
         unifiedRequester,
         keySerializer,
         valueSerializer,
         valueNullableSerializer
     ),
-    WriteStandardKeyValueRepo<K, V> by KtorWriteStandardKeyValueRepo(
+    WriteKeyValueRepo<K, V> by KtorWriteStandardKeyValueRepo(
         "$baseUrl/$baseSubpart",
         unifiedRequester,
         keySerializer,
@@ -38,4 +39,4 @@ class KtorStandartKeyValueRepo<K, V> (
         valueNullableSerializer: KSerializer<V?>,
         serialFormat: StandardKtorSerialFormat = standardKtorSerialFormat
     ) : this(baseUrl, baseSubpart, UnifiedRequester(client, serialFormat), keySerializer, valueSerializer, valueNullableSerializer)
-}
+}

repos/ktor/client/src/commonMain/kotlin/dev/inmo/micro_utils/repos/ktor/client/key_value/KtorWriteKeyValueRepoClient.kt

@@ -3,7 +3,7 @@ package dev.inmo.micro_utils.repos.ktor.client.key_value
 import dev.inmo.micro_utils.ktor.client.createStandardWebsocketFlow
 import dev.inmo.micro_utils.ktor.client.throwOnUnsuccess
 import dev.inmo.micro_utils.ktor.common.*
-import dev.inmo.micro_utils.repos.WriteStandardKeyValueRepo
+import dev.inmo.micro_utils.repos.WriteKeyValueRepo
 import dev.inmo.micro_utils.repos.ktor.common.key_value.*
 import io.ktor.client.HttpClient
 import io.ktor.client.request.post
@@ -13,7 +13,7 @@ import io.ktor.util.reflect.TypeInfo
 import io.ktor.util.reflect.typeInfo
 import kotlinx.coroutines.flow.Flow
 
-class KtorWriteStandardKeyValueRepoClient<Key, Value>(
+class KtorWriteKeyValueRepoClient<Key, Value>(
     private val baseUrl: String,
     private val httpClient: HttpClient,
     private val contentType: ContentType,
@@ -22,7 +22,7 @@ class KtorWriteStandardKeyValueRepoClient<Key, Value>(
     private val idsListTypeInfo: TypeInfo,
     private val objectsListTypeInfo: TypeInfo,
     private val idsToObjectsMapTypeInfo: TypeInfo
-) : WriteStandardKeyValueRepo<Key, Value> {
+) : WriteKeyValueRepo<Key, Value> {
     @OptIn(InternalAPI::class)
     override suspend fun unsetWithValues(toUnset: List<Value>) {
         httpClient.post(
@@ -61,7 +61,7 @@ class KtorWriteStandardKeyValueRepoClient<Key, Value>(
             baseUrl: String,
             httpClient: HttpClient,
             contentType: ContentType
-        ) = KtorWriteStandardKeyValueRepoClient<Key, Value>(
+        ) = KtorWriteKeyValueRepoClient<Key, Value>(
             baseUrl,
             httpClient,
             contentType,

repos/ktor/client/src/commonMain/kotlin/dev/inmo/micro_utils/repos/ktor/client/key_value/KtorWriteStandardKeyValueRepo.kt

@@ -2,19 +2,20 @@ package dev.inmo.micro_utils.repos.ktor.client.key_value
 
 import dev.inmo.micro_utils.ktor.client.*
 import dev.inmo.micro_utils.ktor.common.*
-import dev.inmo.micro_utils.repos.WriteStandardKeyValueRepo
+import dev.inmo.micro_utils.repos.WriteKeyValueRepo
 import dev.inmo.micro_utils.repos.ktor.common.key_value.*
 import io.ktor.client.HttpClient
 import kotlinx.coroutines.flow.Flow
 import kotlinx.serialization.KSerializer
 import kotlinx.serialization.builtins.*
 
+@Deprecated("Replaced with KtorWriteKeyValueRepoClient")
 class KtorWriteStandardKeyValueRepo<K, V> (
     private var baseUrl: String,
     private var unifiedRequester: UnifiedRequester,
     private var keySerializer: KSerializer<K>,
     private var valueSerializer: KSerializer<V>,
-) : WriteStandardKeyValueRepo<K, V> {
+) : WriteKeyValueRepo<K, V> {
     private val keyValueMapSerializer = MapSerializer(keySerializer, valueSerializer)
     private val keysListSerializer = ListSerializer(keySerializer)
     private val valuesListSerializer = ListSerializer(valueSerializer)

repos/ktor/client/src/commonMain/kotlin/dev/inmo/micro_utils/repos/ktor/client/one_to_many/KtorKeyValuesRepoClient.kt

@@ -7,10 +7,10 @@ import io.ktor.http.ContentType
 import io.ktor.http.encodeURLQueryComponent
 import kotlinx.serialization.*
 
-class KtorStandardKeyValuesRepoClient<Key, Value> (
-    readDelegate: ReadOneToManyKeyValueRepo<Key, Value>,
-    writeDelegate: WriteOneToManyKeyValueRepo<Key, Value>
-) : OneToManyKeyValueRepo<Key, Value> by DelegateBasedOneToManyKeyValueRepo(
+class KtorKeyValuesRepoClient<Key, Value> (
+    readDelegate: ReadKeyValuesRepo<Key, Value>,
+    writeDelegate: WriteKeyValuesRepo<Key, Value>
+) : KeyValuesRepo<Key, Value> by DelegateBasedKeyValuesRepo(
     readDelegate,
     writeDelegate
 ) {
@@ -21,15 +21,15 @@ class KtorStandardKeyValuesRepoClient<Key, Value> (
             contentType: ContentType,
             noinline keySerializer: suspend (Key) -> String,
             noinline valueSerializer: suspend (Value) -> String
-        ) = KtorStandardKeyValuesRepoClient(
-            KtorReadStandardKeyValuesRepoClient(
+        ) = KtorKeyValuesRepoClient(
+            KtorReadKeyValuesRepoClient(
                 baseUrl,
                 httpClient,
                 contentType,
                 keySerializer,
                 valueSerializer
             ),
-            KtorWriteStandardKeyValuesRepoClient(
+            KtorWriteKeyValuesRepoClient(
                 baseUrl,
                 httpClient,
                 contentType
@@ -42,7 +42,7 @@ class KtorStandardKeyValuesRepoClient<Key, Value> (
             contentType: ContentType,
             noinline keySerializer: suspend (Key) -> String,
             noinline valueSerializer: suspend (Value) -> String
-        ) = KtorStandardKeyValuesRepoClient(
+        ) = KtorKeyValuesRepoClient(
             buildStandardUrl(baseUrl, subpart),
             httpClient,
             contentType,
@@ -52,14 +52,14 @@ class KtorStandardKeyValuesRepoClient<Key, Value> (
     }
 }
 
-inline fun <reified Key : Any, reified Value : Any> KtorStandardKeyValuesRepoClient(
+inline fun <reified Key : Any, reified Value : Any> KtorKeyValuesRepoClient(
     baseUrl: String,
     httpClient: HttpClient,
     contentType: ContentType,
     keySerializer: SerializationStrategy<Key>,
     valueSerializer: SerializationStrategy<Value>,
     serialFormat: StringFormat,
-) = KtorStandardKeyValuesRepoClient<Key, Value>(
+) = KtorKeyValuesRepoClient<Key, Value>(
     baseUrl,
     httpClient,
     contentType,
@@ -70,14 +70,14 @@ inline fun <reified Key : Any, reified Value : Any> KtorStandardKeyValuesRepoCli
     serialFormat.encodeToString(valueSerializer, it).encodeURLQueryComponent()
 }
 
-inline fun <reified Key : Any, reified Value : Any> KtorStandardKeyValuesRepoClient(
+inline fun <reified Key : Any, reified Value : Any> KtorKeyValuesRepoClient(
     baseUrl: String,
     httpClient: HttpClient,
     contentType: ContentType,
     keySerializer: SerializationStrategy<Key>,
     valueSerializer: SerializationStrategy<Value>,
     serialFormat: BinaryFormat,
-) = KtorStandardKeyValuesRepoClient<Key, Value>(
+) = KtorKeyValuesRepoClient<Key, Value>(
     baseUrl,
     httpClient,
     contentType,

repos/ktor/client/src/commonMain/kotlin/dev/inmo/micro_utils/repos/ktor/client/one_to_many/KtorOneToManyKeyValueRepo.kt

@@ -7,20 +7,21 @@ import dev.inmo.micro_utils.repos.*
 import io.ktor.client.HttpClient
 import kotlinx.serialization.KSerializer
 
+@Deprecated("Should be replaced with KtorKeyValuesRepoClient")
 class KtorOneToManyKeyValueRepo<Key, Value>(
     baseUrl: String,
     baseSubpart: String,
     unifiedRequester: UnifiedRequester,
     keySerializer: KSerializer<Key>,
     valueSerializer: KSerializer<Value>,
-) : OneToManyKeyValueRepo<Key, Value>,
-    ReadOneToManyKeyValueRepo<Key, Value> by KtorReadOneToManyKeyValueRepo<Key, Value> (
+) : KeyValuesRepo<Key, Value>,
+    ReadKeyValuesRepo<Key, Value> by KtorReadOneToManyKeyValueRepo<Key, Value> (
         "$baseUrl/$baseSubpart",
         unifiedRequester,
         keySerializer,
         valueSerializer,
     ),
-    WriteOneToManyKeyValueRepo<Key, Value> by KtorWriteOneToManyKeyValueRepo<Key, Value> (
+    WriteKeyValuesRepo<Key, Value> by KtorWriteOneToManyKeyValueRepo<Key, Value> (
         "$baseUrl/$baseSubpart",
         unifiedRequester,
         keySerializer,
@@ -34,4 +35,4 @@ class KtorOneToManyKeyValueRepo<Key, Value>(
         valueSerializer: KSerializer<Value>,
         serialFormat: StandardKtorSerialFormat = standardKtorSerialFormat
     ) : this (baseUrl, baseSubpart, UnifiedRequester(client, serialFormat), keySerializer, valueSerializer)
-}
+}

repos/ktor/client/src/commonMain/kotlin/dev/inmo/micro_utils/repos/ktor/client/one_to_many/KtorReadKeyValuesRepoClient.kt

@@ -2,9 +2,8 @@ package dev.inmo.micro_utils.repos.ktor.client.one_to_many
 
 import dev.inmo.micro_utils.ktor.common.*
 import dev.inmo.micro_utils.pagination.*
-import dev.inmo.micro_utils.repos.ReadOneToManyKeyValueRepo
+import dev.inmo.micro_utils.repos.ReadKeyValuesRepo
 import dev.inmo.micro_utils.repos.ktor.common.*
-import dev.inmo.micro_utils.repos.ktor.common.crud.*
 import dev.inmo.micro_utils.repos.ktor.common.one_to_many.*
 import dev.inmo.micro_utils.repos.ktor.common.reversedParameterName
 import io.ktor.client.HttpClient
@@ -15,7 +14,7 @@ import io.ktor.util.reflect.TypeInfo
 import io.ktor.util.reflect.typeInfo
 import kotlinx.serialization.*
 
-class KtorReadStandardKeyValuesRepoClient<Key, Value>(
+class KtorReadKeyValuesRepoClient<Key, Value>(
     private val baseUrl: String,
     private val httpClient: HttpClient,
     private val contentType: ContentType,
@@ -23,7 +22,7 @@ class KtorReadStandardKeyValuesRepoClient<Key, Value>(
     private val paginationResultKeysTypeInfo: TypeInfo,
     private val keySerializer: suspend (Key) -> String,
     private val valueSerializer: suspend (Value) -> String
-) : ReadOneToManyKeyValueRepo<Key, Value> {
+) : ReadKeyValuesRepo<Key, Value> {
     override suspend fun get(
         k: Key,
         pagination: Pagination,
@@ -106,13 +105,13 @@ class KtorReadStandardKeyValuesRepoClient<Key, Value>(
     }.body()
 }
 
-inline fun <reified Key, reified Value> KtorReadStandardKeyValuesRepoClient(
+inline fun <reified Key, reified Value> KtorReadKeyValuesRepoClient(
     baseUrl: String,
     httpClient: HttpClient,
     contentType: ContentType,
     noinline keySerializer: suspend (Key) -> String,
     noinline valueSerializer: suspend (Value) -> String
-) = KtorReadStandardKeyValuesRepoClient<Key, Value>(
+) = KtorReadKeyValuesRepoClient<Key, Value>(
     baseUrl,
     httpClient,
     contentType,
@@ -122,14 +121,14 @@ inline fun <reified Key, reified Value> KtorReadStandardKeyValuesRepoClient(
     valueSerializer
 )
 
-inline fun <reified Key, reified Value> KtorReadStandardKeyValuesRepoClient(
+inline fun <reified Key, reified Value> KtorReadKeyValuesRepoClient(
     baseUrl: String,
     httpClient: HttpClient,
     idsSerializer: KSerializer<Key>,
     valueSerializer: KSerializer<Value>,
     serialFormat: StringFormat,
     contentType: ContentType,
-) = KtorReadStandardKeyValuesRepoClient<Key, Value>(
+) = KtorReadKeyValuesRepoClient<Key, Value>(
     baseUrl,
     httpClient,
     contentType,
@@ -140,14 +139,14 @@ inline fun <reified Key, reified Value> KtorReadStandardKeyValuesRepoClient(
     serialFormat.encodeToString(valueSerializer, it).encodeURLQueryComponent()
 }
 
-inline fun <reified Key, reified Value> KtorReadStandardKeyValuesRepoClient(
+inline fun <reified Key, reified Value> KtorReadKeyValuesRepoClient(
     baseUrl: String,
     httpClient: HttpClient,
     idsSerializer: KSerializer<Key>,
     valuesSerializer: KSerializer<Value>,
     serialFormat: BinaryFormat,
     contentType: ContentType,
-) = KtorReadStandardKeyValuesRepoClient<Key, Value>(
+) = KtorReadKeyValuesRepoClient<Key, Value>(
     baseUrl,
     httpClient,
     contentType,

repos/ktor/client/src/commonMain/kotlin/dev/inmo/micro_utils/repos/ktor/client/one_to_many/KtorReadOneToManyKeyValueRepo.kt

@@ -3,7 +3,7 @@ package dev.inmo.micro_utils.repos.ktor.client.one_to_many
 import dev.inmo.micro_utils.ktor.client.*
 import dev.inmo.micro_utils.ktor.common.*
 import dev.inmo.micro_utils.pagination.*
-import dev.inmo.micro_utils.repos.ReadOneToManyKeyValueRepo
+import dev.inmo.micro_utils.repos.ReadKeyValuesRepo
 import dev.inmo.micro_utils.repos.ktor.common.keyParameterName
 import dev.inmo.micro_utils.repos.ktor.common.one_to_many.*
 import dev.inmo.micro_utils.repos.ktor.common.reversedParameterName
@@ -12,12 +12,13 @@ import io.ktor.client.HttpClient
 import kotlinx.serialization.KSerializer
 import kotlinx.serialization.builtins.serializer
 
+@Deprecated("Should be replaced with KtorReadKeyValuesRepoClient")
 class KtorReadOneToManyKeyValueRepo<Key, Value> (
     private val baseUrl: String,
     private val unifiedRequester: UnifiedRequester,
     private val keySerializer: KSerializer<Key>,
     private val valueSerializer: KSerializer<Value>
-) : ReadOneToManyKeyValueRepo<Key, Value> {
+) : ReadKeyValuesRepo<Key, Value> {
     private val paginationValueResultSerializer = PaginationResult.serializer(valueSerializer)
     private val paginationKeyResultSerializer = PaginationResult.serializer(keySerializer)
 
@@ -104,4 +105,4 @@ class KtorReadOneToManyKeyValueRepo<Key, Value> (
         Long.serializer()
     )
 
-}
+}

repos/ktor/client/src/commonMain/kotlin/dev/inmo/micro_utils/repos/ktor/client/one_to_many/KtorWriteKeyValuesRepoClient.kt

@@ -3,7 +3,7 @@ package dev.inmo.micro_utils.repos.ktor.client.one_to_many
 import dev.inmo.micro_utils.ktor.client.createStandardWebsocketFlow
 import dev.inmo.micro_utils.ktor.client.throwOnUnsuccess
 import dev.inmo.micro_utils.ktor.common.*
-import dev.inmo.micro_utils.repos.WriteOneToManyKeyValueRepo
+import dev.inmo.micro_utils.repos.WriteKeyValuesRepo
 import dev.inmo.micro_utils.repos.ktor.common.one_to_many.*
 import io.ktor.client.HttpClient
 import io.ktor.client.request.post
@@ -13,7 +13,7 @@ import io.ktor.util.reflect.TypeInfo
 import io.ktor.util.reflect.typeInfo
 import kotlinx.coroutines.flow.Flow
 
-class KtorWriteStandardKeyValuesRepoClient<Key : Any, Value : Any>(
+class KtorWriteKeyValuesRepoClient<Key : Any, Value : Any>(
     private val baseUrl: String,
     private val httpClient: HttpClient,
     private val contentType: ContentType,
@@ -23,7 +23,7 @@ class KtorWriteStandardKeyValuesRepoClient<Key : Any, Value : Any>(
     private val keyTypeInfo: TypeInfo,
     private val valueTypeInfo: TypeInfo,
     private val keyToValuesMapTypeInfo: TypeInfo
-) : WriteOneToManyKeyValueRepo<Key, Value> {
+) : WriteKeyValuesRepo<Key, Value> {
 
     @OptIn(InternalAPI::class)
     override suspend fun add(toAdd: Map<Key, List<Value>>) {
@@ -85,7 +85,7 @@ class KtorWriteStandardKeyValuesRepoClient<Key : Any, Value : Any>(
             baseUrl: String,
             httpClient: HttpClient,
             contentType: ContentType
-        ) = KtorWriteStandardKeyValuesRepoClient<Key, Value>(
+        ) = KtorWriteKeyValuesRepoClient<Key, Value>(
             baseUrl,
             httpClient,
             contentType,

repos/ktor/client/src/commonMain/kotlin/dev/inmo/micro_utils/repos/ktor/client/one_to_many/KtorWriteOneToManyKeyValueRepo.kt

@@ -2,19 +2,20 @@ package dev.inmo.micro_utils.repos.ktor.client.one_to_many
 
 import dev.inmo.micro_utils.ktor.client.*
 import dev.inmo.micro_utils.ktor.common.*
-import dev.inmo.micro_utils.repos.WriteOneToManyKeyValueRepo
+import dev.inmo.micro_utils.repos.WriteKeyValuesRepo
 import dev.inmo.micro_utils.repos.ktor.common.one_to_many.*
 import io.ktor.client.HttpClient
 import kotlinx.coroutines.flow.Flow
 import kotlinx.serialization.KSerializer
 import kotlinx.serialization.builtins.*
 
+@Deprecated("Should be replaced with KtorWriteKeyValuesRepoClient")
 class KtorWriteOneToManyKeyValueRepo<Key, Value> (
     private val baseUrl: String,
     private val unifiedRequester: UnifiedRequester,
     private val keySerializer: KSerializer<Key>,
     private val valueSerializer: KSerializer<Value>
-) : WriteOneToManyKeyValueRepo<Key, Value> {
+) : WriteKeyValuesRepo<Key, Value> {
     private val keyValueSerializer = PairSerializer(keySerializer, valueSerializer)
     private val keyValueMapSerializer = MapSerializer(keySerializer, ListSerializer(valueSerializer))
 

repos/ktor/common/src/jvmTest/kotlin/CRUDTests.kt

@@ -1,6 +1,6 @@
 import dev.inmo.micro_utils.repos.*
-import dev.inmo.micro_utils.repos.ktor.client.crud.KtorStandardCrudRepoClient
-import dev.inmo.micro_utils.repos.ktor.server.crud.configureStandardCrudRepoRoutes
+import dev.inmo.micro_utils.repos.ktor.client.crud.KtorCRUDRepoClient
+import dev.inmo.micro_utils.repos.ktor.server.crud.configureCRUDRepoRoutes
 import io.ktor.client.HttpClient
 import io.ktor.client.plugins.logging.Logging
 import io.ktor.http.ContentType
@@ -43,7 +43,7 @@ class CRUDTests {
                     contentConverter = KotlinxWebsocketSerializationConverter(Json)
                 }
                 routing {
-                    configureStandardCrudRepoRoutes(
+                    configureCRUDRepoRoutes(
                         repo
                     ) {
                         it.toInt()
@@ -59,7 +59,7 @@ class CRUDTests {
                     contentConverter = KotlinxWebsocketSerializationConverter(Json)
                 }
             }
-            val crudClient = KtorStandardCrudRepoClient<ComplexData, Int, SimpleData>(
+            val crudClient = KtorCRUDRepoClient<ComplexData, Int, SimpleData>(
                 "http://127.0.0.1:23456",
                 client,
                 ContentType.Application.Json

repos/ktor/common/src/jvmTest/kotlin/KVTests.kt

@@ -1,8 +1,8 @@
 import dev.inmo.micro_utils.pagination.firstPageWithOneElementPagination
 import dev.inmo.micro_utils.pagination.utils.getAllWithNextPaging
 import dev.inmo.micro_utils.repos.*
-import dev.inmo.micro_utils.repos.ktor.client.key_value.KtorStandardKeyValueRepoClient
-import dev.inmo.micro_utils.repos.ktor.server.key_value.configureStandardKeyValueRepoRoutes
+import dev.inmo.micro_utils.repos.ktor.client.key_value.KtorKeyValueRepoClient
+import dev.inmo.micro_utils.repos.ktor.server.key_value.configureKeyValueRepoRoutes
 import io.ktor.client.HttpClient
 import io.ktor.client.plugins.logging.Logging
 import io.ktor.http.ContentType
@@ -38,7 +38,7 @@ class KVTests {
                     contentConverter = KotlinxWebsocketSerializationConverter(Json)
                 }
                 routing {
-                    configureStandardKeyValueRepoRoutes(
+                    configureKeyValueRepoRoutes(
                         repo,
                         Int.serializer(),
                         ComplexData.serializer(),
@@ -55,7 +55,7 @@ class KVTests {
                     contentConverter = KotlinxWebsocketSerializationConverter(Json)
                 }
             }
-            val crudClient = KtorStandardKeyValueRepoClient<Int, ComplexData>(
+            val crudClient = KtorKeyValueRepoClient<Int, ComplexData>(
                 "http://127.0.0.1:23456",
                 client,
                 ContentType.Application.Json,

repos/ktor/common/src/jvmTest/kotlin/KVsTests.kt

@@ -1,9 +1,8 @@
 import dev.inmo.micro_utils.pagination.firstPageWithOneElementPagination
 import dev.inmo.micro_utils.pagination.utils.getAllWithNextPaging
 import dev.inmo.micro_utils.repos.*
-import dev.inmo.micro_utils.repos.ktor.client.key_value.KtorStandardKeyValueRepoClient
-import dev.inmo.micro_utils.repos.ktor.client.one_to_many.KtorStandardKeyValuesRepoClient
-import dev.inmo.micro_utils.repos.ktor.server.one_to_many.configureStandardKeyValuesRepoRoutes
+import dev.inmo.micro_utils.repos.ktor.client.one_to_many.KtorKeyValuesRepoClient
+import dev.inmo.micro_utils.repos.ktor.server.one_to_many.configureKeyValuesRepoRoutes
 import io.ktor.client.HttpClient
 import io.ktor.client.plugins.logging.Logging
 import io.ktor.http.ContentType
@@ -26,7 +25,7 @@ class KVsTests {
     fun testKVsFunctions() {
         runTest {
             val map = mutableMapOf<Int, MutableList<ComplexData>>()
-            val repo = MapOneToManyKeyValueRepo(map)
+            val repo = MapKeyValuesRepo(map)
             val server = io.ktor.server.engine.embeddedServer(
                 CIO,
                 23456,
@@ -39,7 +38,7 @@ class KVsTests {
                     contentConverter = KotlinxWebsocketSerializationConverter(Json)
                 }
                 routing {
-                    configureStandardKeyValuesRepoRoutes(
+                    configureKeyValuesRepoRoutes(
                         repo,
                         Int.serializer(),
                         ComplexData.serializer(),
@@ -56,7 +55,7 @@ class KVsTests {
                     contentConverter = KotlinxWebsocketSerializationConverter(Json)
                 }
             }
-            val crudClient = KtorStandardKeyValuesRepoClient(
+            val crudClient = KtorKeyValuesRepoClient(
                 "http://127.0.0.1:23456",
                 client,
                 ContentType.Application.Json,

repos/ktor/server/src/crud.yml

@@ -0,0 +1,196 @@
+swagger: "2.0"
+info:
+  description: "This is a template for the CRUD repositories from [microutils](https://github.com/InsanusMokrassar/MicroUtils/tree/master/repos/ktor/server/src/jvmMain/kotlin/dev/inmo/micro_utils/repos/ktor/server/crud)"
+  version: "0.11.0"
+  title: "CRUD Repo"
+  contact:
+    email: "ovsyannikov.alexey95@gmail.com"
+tags:
+  - name: "Read"
+    description: "Operations with `get` request in most cases"
+  - name: "Write"
+    description: "Operations with `post` request in most cases"
+
+parameters:
+  IdInQuery:
+    in: "query"
+    name: "id"
+    allOf:
+      - $ref: "#/definitions/Key"
+  IdsInBody:
+    in: "body"
+    name: "body"
+    type: array
+    items:
+      $ref: "#/definitions/Key"
+  NewValuesInBody:
+    in: "body"
+    name: "body"
+    type: array
+    allOf:
+      - $ref: "#/definitions/NewValues"
+  NewValuesWithIdsInBody:
+    in: "body"
+    name: "body"
+    type: array
+    items:
+      allOf:
+        - $ref: "#/definitions/Pair"
+        - properties:
+            first:
+              $ref: "#/definitions/Key"
+            second:
+              $ref: "#/definitions/NewValue"
+  PaginationInQueryPage:
+    in: "query"
+    type: integer
+    name: "ppage"
+    description: "Page of pagination"
+    required: false
+  PaginationInQuerySize:
+    in: "query"
+    type: integer
+    name: "psize"
+    description: "Size of each page in pagination"
+    required: false
+
+
+definitions:
+  Key:
+    type: integer
+    description: "REWRITE THIS TYPE AS KEY IN SWAGGER FILE"
+  Value:
+    type: integer
+    description: "REWRITE THIS TYPE AS VALUE IN SWAGGER FILE"
+  Values:
+    type: array
+    items:
+      $ref: "#/definitions/Value"
+  NewValue:
+    type: integer
+    description: "REWRITE THIS TYPE AS NEW VALUE IN SWAGGER FILE"
+  Pair:
+    type: object
+    description: "Pair of objects"
+    properties:
+      first:
+      second:
+  NewValues:
+    type: array
+    items:
+      $ref: "#/definitions/NewValue"
+  Pagination:
+    type: object
+    properties:
+      page:
+        type: integer
+        description: "Page of pagination"
+      size:
+        type: integer
+        description: "Size of each page in pagination"
+  PaginationResult:
+    type: object
+    properties:
+      page:
+        type: integer
+        description: "Page of pagination"
+      pagesNumber:
+        type: integer
+        description: "Count of pages with the size from this pagination"
+      size:
+        type: integer
+        description: "Size of each page in pagination"
+      results:
+        type: array
+        description: "Array of all elements on that page. Size of pagination and size of array can be different and it can be interpreted like current page is the last one"
+        items:
+          type: object
+
+paths:
+  /getByPagination:
+    get:
+      tags:
+        - "Read"
+      parameters:
+        - $ref: "#/parameters/PaginationInQueryPage"
+        - $ref: "#/parameters/PaginationInQuerySize"
+      responses:
+        "200":
+          description: "Pagination of elements"
+          schema:
+            allOf:
+              - $ref: "#/definitions/PaginationResult"
+              - properties:
+                  results:
+                    items:
+                      $ref: "#/definitions/Value"
+  /getById:
+    get:
+      tags:
+        - "Read"
+      parameters:
+        - $ref: "#/parameters/IdInQuery"
+          required: true
+      responses:
+        "200":
+          description: "Result object"
+          schema:
+            $ref: "#/definitions/Value"
+        "204":
+          description: "No value by id"
+  /contains:
+    get:
+      tags:
+        - "Read"
+      parameters:
+        - $ref: "#/parameters/IdInQuery"
+          required: true
+      responses:
+        "200":
+          description: "Object with id availability in repo"
+          schema:
+            type: boolean
+  /count:
+    get:
+      tags:
+        - "Read"
+      responses:
+        "200":
+          description: "Amount of objects in repo"
+          schema:
+            type: integer
+
+
+  /create:
+    post:
+      tags:
+        - "Write"
+      parameters:
+        - $ref: "#/parameters/NewValuesInBody"
+      responses:
+        "200":
+          description: "Objects has been created and saved"
+          schema:
+            $ref: "#/definitions/Values"
+  /update:
+    post:
+      tags:
+        - "Write"
+      parameters:
+        - $ref: "#/parameters/NewValuesWithIdsInBody"
+      responses:
+        "200":
+          description: "Objects has been updated"
+          schema:
+            $ref: "#/definitions/Values"
+  /deleteById:
+    post:
+      tags:
+        - "Write"
+      parameters:
+        - $ref: "#/parameters/IdsInBody"
+      responses:
+        "200":
+          description: "Objects has been updated"
+          schema:
+            $ref: "#/definitions/Values"

repos/ktor/server/src/jvmMain/kotlin/dev/inmo/micro_utils/repos/ktor/server/crud/KtorCRUDRepoRoutes.kt

@@ -0,0 +1,30 @@
+package dev.inmo.micro_utils.repos.ktor.server.crud
+
+import dev.inmo.micro_utils.ktor.common.*
+import dev.inmo.micro_utils.repos.CRUDRepo
+import io.ktor.server.routing.Route
+import kotlinx.serialization.*
+
+inline fun <reified ObjectType : Any, reified IdType : Any, reified InputValue : Any> Route.configureCRUDRepoRoutes(
+    originalRepo: CRUDRepo<ObjectType, IdType, InputValue>,
+    noinline idDeserializer: suspend (String) -> IdType
+) {
+    configureReadCRUDRepoRoutes(originalRepo, idDeserializer)
+    configureWriteCRUDRepoRoutes(originalRepo)
+}
+
+inline fun <reified ObjectType : Any, reified IdType : Any, reified InputValue : Any> Route.configureCRUDRepoRoutes(
+    originalRepo: CRUDRepo<ObjectType, IdType, InputValue>,
+    idsSerializer: KSerializer<IdType>,
+    serialFormat: StringFormat
+) = configureCRUDRepoRoutes(originalRepo) {
+    serialFormat.decodeFromString(idsSerializer, it)
+}
+
+inline fun <reified ObjectType : Any, reified IdType : Any, reified InputValue : Any> Route.configureCRUDRepoRoutes(
+    originalRepo: CRUDRepo<ObjectType, IdType, InputValue>,
+    idsSerializer: KSerializer<IdType>,
+    serialFormat: BinaryFormat
+) = configureCRUDRepoRoutes(originalRepo) {
+    serialFormat.decodeHex(idsSerializer, it)
+}

repos/ktor/server/src/jvmMain/kotlin/dev/inmo/micro_utils/repos/ktor/server/crud/KtorReadCRUDRepoRoutes.kt

@@ -3,11 +3,10 @@ package dev.inmo.micro_utils.repos.ktor.server.crud
 import dev.inmo.micro_utils.ktor.common.decodeHex
 import dev.inmo.micro_utils.ktor.server.*
 import dev.inmo.micro_utils.pagination.extractPagination
-import dev.inmo.micro_utils.repos.ReadStandardCRUDRepo
+import dev.inmo.micro_utils.repos.ReadCRUDRepo
 import dev.inmo.micro_utils.repos.ktor.common.countRouting
 import dev.inmo.micro_utils.repos.ktor.common.crud.*
 import dev.inmo.micro_utils.repos.ktor.common.idParameterName
-import io.ktor.http.ContentType
 import io.ktor.http.HttpStatusCode
 import io.ktor.server.application.call
 import io.ktor.server.response.respond
@@ -15,8 +14,8 @@ import io.ktor.server.routing.Route
 import io.ktor.server.routing.get
 import kotlinx.serialization.*
 
-inline fun <reified ObjectType, reified IdType> Route.configureReadStandardCrudRepoRoutes(
-    originalRepo: ReadStandardCRUDRepo<ObjectType, IdType>,
+inline fun <reified ObjectType, reified IdType> Route.configureReadCRUDRepoRoutes(
+    originalRepo: ReadCRUDRepo<ObjectType, IdType>,
     noinline idDeserializer: suspend (String) -> IdType
 ) {
     get(getByPaginationRouting) {
@@ -56,18 +55,18 @@ inline fun <reified ObjectType, reified IdType> Route.configureReadStandardCrudR
     }
 }
 
-inline fun <reified ObjectType, reified IdType> Route.configureReadStandardCrudRepoRoutes(
-    originalRepo: ReadStandardCRUDRepo<ObjectType, IdType>,
+inline fun <reified ObjectType, reified IdType> Route.configureReadCRUDRepoRoutes(
+    originalRepo: ReadCRUDRepo<ObjectType, IdType>,
     idsSerializer: KSerializer<IdType>,
     serialFormat: StringFormat
-) = configureReadStandardCrudRepoRoutes(originalRepo) {
+) = configureReadCRUDRepoRoutes(originalRepo) {
     serialFormat.decodeFromString(idsSerializer, it)
 }
 
-inline fun <reified ObjectType, reified IdType> Route.configureReadStandardCrudRepoRoutes(
-    originalRepo: ReadStandardCRUDRepo<ObjectType, IdType>,
+inline fun <reified ObjectType, reified IdType> Route.configureReadCRUDRepoRoutes(
+    originalRepo: ReadCRUDRepo<ObjectType, IdType>,
     idsSerializer: KSerializer<IdType>,
     serialFormat: BinaryFormat
-) = configureReadStandardCrudRepoRoutes(originalRepo) {
+) = configureReadCRUDRepoRoutes(originalRepo) {
     serialFormat.decodeHex(idsSerializer, it)
 }

repos/ktor/server/src/jvmMain/kotlin/dev/inmo/micro_utils/repos/ktor/server/crud/KtorReadStandardCrudRepo.kt

@@ -5,7 +5,7 @@ import dev.inmo.micro_utils.ktor.common.standardKtorSerialFormat
 import dev.inmo.micro_utils.ktor.server.*
 import dev.inmo.micro_utils.pagination.PaginationResult
 import dev.inmo.micro_utils.pagination.extractPagination
-import dev.inmo.micro_utils.repos.ReadStandardCRUDRepo
+import dev.inmo.micro_utils.repos.ReadCRUDRepo
 import dev.inmo.micro_utils.repos.ktor.common.countRouting
 import dev.inmo.micro_utils.repos.ktor.common.crud.*
 import io.ktor.http.ContentType
@@ -15,8 +15,8 @@ import io.ktor.server.routing.get
 import kotlinx.serialization.KSerializer
 import kotlinx.serialization.builtins.serializer
 
-fun <ObjectType, IdType> Route.configureReadStandardCrudRepoRoutes(
-    originalRepo: ReadStandardCRUDRepo<ObjectType, IdType>,
+fun <ObjectType, IdType> Route.configureReadCRUDRepoRoutes(
+    originalRepo: ReadCRUDRepo<ObjectType, IdType>,
     objectsSerializer: KSerializer<ObjectType>,
     objectsNullableSerializer: KSerializer<ObjectType?>,
     idsSerializer: KSerializer<IdType>,
@@ -73,11 +73,11 @@ fun <ObjectType, IdType> Route.configureReadStandardCrudRepoRoutes(
     }
 }
 
-inline fun <ObjectType, IdType> Route.configureReadStandardCrudRepoRoutes(
-    originalRepo: ReadStandardCRUDRepo<ObjectType, IdType>,
+inline fun <ObjectType, IdType> Route.configureReadCRUDRepoRoutes(
+    originalRepo: ReadCRUDRepo<ObjectType, IdType>,
     objectsSerializer: KSerializer<ObjectType>,
     objectsNullableSerializer: KSerializer<ObjectType?>,
     idsSerializer: KSerializer<IdType>,
     serialFormat: StandardKtorSerialFormat = standardKtorSerialFormat,
     serialFormatContentType: ContentType = standardKtorSerialFormatContentType
-) = configureReadStandardCrudRepoRoutes(originalRepo, objectsSerializer, objectsNullableSerializer, idsSerializer, UnifiedRouter(serialFormat, serialFormatContentType))
+) = configureReadCRUDRepoRoutes(originalRepo, objectsSerializer, objectsNullableSerializer, idsSerializer, UnifiedRouter(serialFormat, serialFormatContentType))

repos/ktor/server/src/jvmMain/kotlin/dev/inmo/micro_utils/repos/ktor/server/crud/KtorStandardCrudRepo.kt

@@ -4,15 +4,15 @@ import dev.inmo.micro_utils.ktor.common.StandardKtorSerialFormat
 import dev.inmo.micro_utils.ktor.common.standardKtorSerialFormat
 import dev.inmo.micro_utils.ktor.server.UnifiedRouter
 import dev.inmo.micro_utils.ktor.server.standardKtorSerialFormatContentType
-import dev.inmo.micro_utils.repos.StandardCRUDRepo
+import dev.inmo.micro_utils.repos.CRUDRepo
 import io.ktor.http.ContentType
 import io.ktor.server.routing.Route
 import io.ktor.server.routing.route
 import kotlinx.serialization.KSerializer
 
-fun <ObjectType, IdType, InputValue> Route.configureStandardCrudRepoRoutes(
+fun <ObjectType, IdType, InputValue> Route.configureCRUDRepoRoutes(
     baseSubpart: String,
-    originalRepo: StandardCRUDRepo<ObjectType, IdType, InputValue>,
+    originalRepo: CRUDRepo<ObjectType, IdType, InputValue>,
     objectsSerializer: KSerializer<ObjectType>,
     objectsNullableSerializer: KSerializer<ObjectType?>,
     inputsSerializer: KSerializer<InputValue>,
@@ -20,20 +20,20 @@ fun <ObjectType, IdType, InputValue> Route.configureStandardCrudRepoRoutes(
     unifiedRouter: UnifiedRouter
 ) {
     route(baseSubpart) {
-        configureReadStandardCrudRepoRoutes(originalRepo, objectsSerializer, objectsNullableSerializer, idsSerializer, unifiedRouter)
-        configureWriteStandardCrudRepoRoutes(originalRepo, objectsSerializer, objectsNullableSerializer, inputsSerializer, idsSerializer, unifiedRouter)
+        configureReadCRUDRepoRoutes(originalRepo, objectsSerializer, objectsNullableSerializer, idsSerializer, unifiedRouter)
+        configureWriteCRUDRepoRoutes(originalRepo, objectsSerializer, objectsNullableSerializer, inputsSerializer, idsSerializer, unifiedRouter)
     }
 }
 
-fun <ObjectType, IdType, InputValue> Route.configureStandardCrudRepoRoutes(
+fun <ObjectType, IdType, InputValue> Route.configureCRUDRepoRoutes(
     baseSubpart: String,
-    originalRepo: StandardCRUDRepo<ObjectType, IdType, InputValue>,
+    originalRepo: CRUDRepo<ObjectType, IdType, InputValue>,
     objectsSerializer: KSerializer<ObjectType>,
     objectsNullableSerializer: KSerializer<ObjectType?>,
     inputsSerializer: KSerializer<InputValue>,
     idsSerializer: KSerializer<IdType>,
     serialFormat: StandardKtorSerialFormat = standardKtorSerialFormat,
     serialFormatContentType: ContentType = standardKtorSerialFormatContentType
-) = configureStandardCrudRepoRoutes(
+) = configureCRUDRepoRoutes(
     baseSubpart, originalRepo, objectsSerializer, objectsNullableSerializer, inputsSerializer, idsSerializer, UnifiedRouter(serialFormat, serialFormatContentType)
 )

repos/ktor/server/src/jvmMain/kotlin/dev/inmo/micro_utils/repos/ktor/server/crud/KtorWriteCRUDRepoRoutes.kt

@@ -1,16 +1,17 @@
 package dev.inmo.micro_utils.repos.ktor.server.crud
 
 import dev.inmo.micro_utils.ktor.server.*
-import dev.inmo.micro_utils.repos.WriteStandardCRUDRepo
+import dev.inmo.micro_utils.repos.WriteCRUDRepo
 import dev.inmo.micro_utils.repos.ktor.common.crud.*
+import io.ktor.http.HttpStatusCode
 import io.ktor.server.application.call
 import io.ktor.server.request.receive
 import io.ktor.server.response.respond
 import io.ktor.server.routing.Route
 import io.ktor.server.routing.post
 
-inline fun <reified ObjectType : Any, reified IdType : Any, reified InputValue : Any> Route.configureWriteStandardCrudRepoRoutes(
-    originalRepo: WriteStandardCRUDRepo<ObjectType, IdType, InputValue>
+inline fun <reified ObjectType : Any, reified IdType : Any, reified InputValue : Any> Route.configureWriteCRUDRepoRoutes(
+    originalRepo: WriteCRUDRepo<ObjectType, IdType, InputValue>
 ) {
     includeWebsocketHandling(
         newObjectsFlowRouting,
@@ -29,11 +30,12 @@ inline fun <reified ObjectType : Any, reified IdType : Any, reified InputValue :
         call.respond(originalRepo.create(call.receive()))
     }
 
-    post(updateManyRouting) {
+    post(updateRouting) {
         call.respond(originalRepo.update(call.receive()))
     }
 
     post(deleteByIdRouting) {
-        call.respond(originalRepo.deleteById(call.receive()))
+        originalRepo.deleteById(call.receive())
+        call.respond(HttpStatusCode.OK)
     }
 }

repos/ktor/server/src/jvmMain/kotlin/dev/inmo/micro_utils/repos/ktor/server/crud/KtorWriteStandardCrudRepo.kt

@@ -3,7 +3,7 @@ package dev.inmo.micro_utils.repos.ktor.server.crud
 import dev.inmo.micro_utils.ktor.common.StandardKtorSerialFormat
 import dev.inmo.micro_utils.ktor.common.standardKtorSerialFormat
 import dev.inmo.micro_utils.ktor.server.*
-import dev.inmo.micro_utils.repos.WriteStandardCRUDRepo
+import dev.inmo.micro_utils.repos.WriteCRUDRepo
 import dev.inmo.micro_utils.repos.ktor.common.crud.*
 import io.ktor.http.ContentType
 import io.ktor.server.routing.Route
@@ -11,8 +11,8 @@ import io.ktor.server.routing.post
 import kotlinx.serialization.KSerializer
 import kotlinx.serialization.builtins.*
 
-fun <ObjectType, IdType, InputValue> Route.configureWriteStandardCrudRepoRoutes(
-    originalRepo: WriteStandardCRUDRepo<ObjectType, IdType, InputValue>,
+fun <ObjectType, IdType, InputValue> Route.configureWriteCRUDRepoRoutes(
+    originalRepo: WriteCRUDRepo<ObjectType, IdType, InputValue>,
     objectsSerializer: KSerializer<ObjectType>,
     objectsNullableSerializer: KSerializer<ObjectType?>,
     inputsSerializer: KSerializer<InputValue>,
@@ -94,14 +94,14 @@ fun <ObjectType, IdType, InputValue> Route.configureWriteStandardCrudRepoRoutes(
     }
 }
 
-fun <ObjectType, IdType, InputValue> Route.configureWriteStandardCrudRepoRoutes(
-    originalRepo: WriteStandardCRUDRepo<ObjectType, IdType, InputValue>,
+fun <ObjectType, IdType, InputValue> Route.configureWriteCRUDRepoRoutes(
+    originalRepo: WriteCRUDRepo<ObjectType, IdType, InputValue>,
     objectsSerializer: KSerializer<ObjectType>,
     objectsNullableSerializer: KSerializer<ObjectType?>,
     inputsSerializer: KSerializer<InputValue>,
     idsSerializer: KSerializer<IdType>,
     serialFormat: StandardKtorSerialFormat = standardKtorSerialFormat,
     serialFormatContentType: ContentType = standardKtorSerialFormatContentType
-) = configureWriteStandardCrudRepoRoutes(
+) = configureWriteCRUDRepoRoutes(
     originalRepo, objectsSerializer, objectsNullableSerializer, inputsSerializer, idsSerializer, UnifiedRouter(serialFormat, serialFormatContentType)
 )

repos/ktor/server/src/jvmMain/kotlin/dev/inmo/micro_utils/repos/ktor/server/crud/NewKtorStandardCrudRepo.kt

@@ -1,34 +0,0 @@
-package dev.inmo.micro_utils.repos.ktor.server.crud
-
-import dev.inmo.micro_utils.ktor.common.*
-import dev.inmo.micro_utils.ktor.server.UnifiedRouter
-import dev.inmo.micro_utils.ktor.server.standardKtorSerialFormatContentType
-import dev.inmo.micro_utils.repos.StandardCRUDRepo
-import io.ktor.http.ContentType
-import io.ktor.server.routing.Route
-import io.ktor.server.routing.route
-import kotlinx.serialization.*
-
-inline fun <reified ObjectType : Any, reified IdType : Any, reified InputValue : Any> Route.configureStandardCrudRepoRoutes(
-    originalRepo: StandardCRUDRepo<ObjectType, IdType, InputValue>,
-    noinline idDeserializer: suspend (String) -> IdType
-) {
-    configureReadStandardCrudRepoRoutes(originalRepo, idDeserializer)
-    configureWriteStandardCrudRepoRoutes(originalRepo)
-}
-
-inline fun <reified ObjectType : Any, reified IdType : Any, reified InputValue : Any> Route.configureStandardCrudRepoRoutes(
-    originalRepo: StandardCRUDRepo<ObjectType, IdType, InputValue>,
-    idsSerializer: KSerializer<IdType>,
-    serialFormat: StringFormat
-) = configureStandardCrudRepoRoutes(originalRepo) {
-    serialFormat.decodeFromString(idsSerializer, it)
-}
-
-inline fun <reified ObjectType : Any, reified IdType : Any, reified InputValue : Any> Route.configureStandardCrudRepoRoutes(
-    originalRepo: StandardCRUDRepo<ObjectType, IdType, InputValue>,
-    idsSerializer: KSerializer<IdType>,
-    serialFormat: BinaryFormat
-) = configureStandardCrudRepoRoutes(originalRepo) {
-    serialFormat.decodeHex(idsSerializer, it)
-}

repos/ktor/server/src/jvmMain/kotlin/dev/inmo/micro_utils/repos/ktor/server/key_value/KtorKeyValueRepoRoutes.kt

@@ -1,37 +1,26 @@
 package dev.inmo.micro_utils.repos.ktor.server.key_value
 
 import dev.inmo.micro_utils.ktor.common.*
-import dev.inmo.micro_utils.ktor.server.*
-import dev.inmo.micro_utils.pagination.PaginationResult
-import dev.inmo.micro_utils.pagination.extractPagination
-import dev.inmo.micro_utils.repos.StandardCRUDRepo
-import dev.inmo.micro_utils.repos.StandardKeyValueRepo
-import dev.inmo.micro_utils.repos.ktor.common.idParameterName
-import dev.inmo.micro_utils.repos.ktor.common.key_value.*
-import dev.inmo.micro_utils.repos.ktor.common.valueParameterName
+import dev.inmo.micro_utils.repos.KeyValueRepo
 import io.ktor.http.*
-import io.ktor.server.application.call
-import io.ktor.server.response.respond
 import io.ktor.server.routing.Route
-import io.ktor.server.routing.get
 import kotlinx.serialization.*
-import kotlinx.serialization.builtins.serializer
 
-inline fun <reified Key : Any, reified Value : Any> Route.configureStandardKeyValueRepoRoutes (
-    originalRepo: StandardKeyValueRepo<Key, Value>,
+inline fun <reified Key : Any, reified Value : Any> Route.configureKeyValueRepoRoutes (
+    originalRepo: KeyValueRepo<Key, Value>,
     noinline idDeserializer: suspend (String) -> Key,
     noinline valueDeserializer: suspend (String) -> Value
 ) {
-    configureReadStandardKeyValueRepoRoutes(originalRepo, idDeserializer, valueDeserializer)
-    configureWriteStandardKeyValueRepoRoutes(originalRepo)
+    configureReadKeyValueRepoRoutes(originalRepo, idDeserializer, valueDeserializer)
+    configureWriteKeyValueRepoRoutes(originalRepo)
 }
 
-inline fun <reified Key : Any, reified Value : Any> Route.configureStandardKeyValueRepoRoutes(
-    originalRepo: StandardKeyValueRepo<Key, Value>,
+inline fun <reified Key : Any, reified Value : Any> Route.configureKeyValueRepoRoutes(
+    originalRepo: KeyValueRepo<Key, Value>,
     idsSerializer: DeserializationStrategy<Key>,
     valueSerializer: DeserializationStrategy<Value>,
     serialFormat: StringFormat
-) = configureStandardKeyValueRepoRoutes(
+) = configureKeyValueRepoRoutes(
     originalRepo,
     {
         serialFormat.decodeFromString(idsSerializer, it.decodeURLQueryComponent())
@@ -41,12 +30,12 @@ inline fun <reified Key : Any, reified Value : Any> Route.configureStandardKeyVa
     }
 )
 
-inline fun <reified Key : Any, reified Value : Any> Route.configureStandardKeyValueRepoRoutes(
-    originalRepo: StandardKeyValueRepo<Key, Value>,
+inline fun <reified Key : Any, reified Value : Any> Route.configureKeyValueRepoRoutes(
+    originalRepo: KeyValueRepo<Key, Value>,
     idsSerializer: DeserializationStrategy<Key>,
     valueSerializer: DeserializationStrategy<Value>,
     serialFormat: BinaryFormat
-) = configureStandardKeyValueRepoRoutes(
+) = configureKeyValueRepoRoutes(
     originalRepo,
     {
         serialFormat.decodeHex(idsSerializer, it)

repos/ktor/server/src/jvmMain/kotlin/dev/inmo/micro_utils/repos/ktor/server/key_value/KtorReadKeyValueRepoRoutes.kt

@@ -4,7 +4,7 @@ import dev.inmo.micro_utils.ktor.common.*
 import dev.inmo.micro_utils.ktor.server.*
 import dev.inmo.micro_utils.pagination.PaginationResult
 import dev.inmo.micro_utils.pagination.extractPagination
-import dev.inmo.micro_utils.repos.ReadStandardKeyValueRepo
+import dev.inmo.micro_utils.repos.ReadKeyValueRepo
 import dev.inmo.micro_utils.repos.ktor.common.*
 import dev.inmo.micro_utils.repos.ktor.common.containsRoute
 import dev.inmo.micro_utils.repos.ktor.common.countRoute
@@ -20,8 +20,8 @@ import io.ktor.util.reflect.typeInfo
 import kotlinx.serialization.*
 
 @OptIn(InternalAPI::class)
-inline fun <reified Key, reified Value> Route.configureReadStandardKeyValueRepoRoutes (
-    originalRepo: ReadStandardKeyValueRepo<Key, Value>,
+inline fun <reified Key, reified Value> Route.configureReadKeyValueRepoRoutes (
+    originalRepo: ReadKeyValueRepo<Key, Value>,
     noinline idDeserializer: suspend (String) -> Key,
     noinline valueDeserializer: suspend (String) -> Value
 ) {
@@ -74,12 +74,12 @@ inline fun <reified Key, reified Value> Route.configureReadStandardKeyValueRepoR
     }
 }
 
-inline fun <reified Key, reified Value> Route.configureReadStandardKeyValueRepoRoutes(
-    originalRepo: ReadStandardKeyValueRepo<Key, Value>,
+inline fun <reified Key, reified Value> Route.configureReadKeyValueRepoRoutes(
+    originalRepo: ReadKeyValueRepo<Key, Value>,
     idsSerializer: DeserializationStrategy<Key>,
     valueSerializer: DeserializationStrategy<Value>,
     serialFormat: StringFormat
-) = configureReadStandardKeyValueRepoRoutes(
+) = configureReadKeyValueRepoRoutes(
     originalRepo,
     {
         serialFormat.decodeFromString(idsSerializer, it.decodeURLQueryComponent())
@@ -89,12 +89,12 @@ inline fun <reified Key, reified Value> Route.configureReadStandardKeyValueRepoR
     }
 )
 
-inline fun <reified Key, reified Value> Route.configureReadStandardKeyValueRepoRoutes(
-    originalRepo: ReadStandardKeyValueRepo<Key, Value>,
+inline fun <reified Key, reified Value> Route.configureReadKeyValueRepoRoutes(
+    originalRepo: ReadKeyValueRepo<Key, Value>,
     idsSerializer: DeserializationStrategy<Key>,
     valueSerializer: DeserializationStrategy<Value>,
     serialFormat: BinaryFormat
-) = configureReadStandardKeyValueRepoRoutes(
+) = configureReadKeyValueRepoRoutes(
     originalRepo,
     {
         serialFormat.decodeHex(idsSerializer, it)

repos/ktor/server/src/jvmMain/kotlin/dev/inmo/micro_utils/repos/ktor/server/key_value/KtorStandartKeyValueRepo.kt

@@ -4,15 +4,15 @@ import dev.inmo.micro_utils.ktor.common.StandardKtorSerialFormat
 import dev.inmo.micro_utils.ktor.common.standardKtorSerialFormat
 import dev.inmo.micro_utils.ktor.server.UnifiedRouter
 import dev.inmo.micro_utils.ktor.server.standardKtorSerialFormatContentType
-import dev.inmo.micro_utils.repos.StandardKeyValueRepo
+import dev.inmo.micro_utils.repos.KeyValueRepo
 import io.ktor.http.ContentType
 import io.ktor.server.routing.Route
 import io.ktor.server.routing.route
 import kotlinx.serialization.KSerializer
 
-fun <K, V> Route.configureStandardKeyValueRepoRoutes(
+fun <K, V> Route.configureKeyValueRepoRoutes(
     baseSubpart: String,
-    originalRepo: StandardKeyValueRepo<K, V>,
+    originalRepo: KeyValueRepo<K, V>,
     keySerializer: KSerializer<K>,
     valueSerializer: KSerializer<V>,
     valueNullableSerializer: KSerializer<V?>,
@@ -26,7 +26,7 @@ fun <K, V> Route.configureStandardKeyValueRepoRoutes(
             valueNullableSerializer,
             unifiedRouter
         )
-        configureWriteStandardKeyValueRepoRoutes(
+        configureWriteKeyValueRepoRoutes(
             originalRepo,
             keySerializer,
             valueSerializer,
@@ -37,10 +37,10 @@ fun <K, V> Route.configureStandardKeyValueRepoRoutes(
 
 fun <K, V> Route.configureStandartKeyValueRepoRoutes(
     baseSubpart: String,
-    originalRepo: StandardKeyValueRepo<K, V>,
+    originalRepo: KeyValueRepo<K, V>,
     keySerializer: KSerializer<K>,
     valueSerializer: KSerializer<V>,
     valueNullableSerializer: KSerializer<V?>,
     serialFormat: StandardKtorSerialFormat = standardKtorSerialFormat,
     serialFormatContentType: ContentType = standardKtorSerialFormatContentType
-) = configureStandardKeyValueRepoRoutes(baseSubpart, originalRepo, keySerializer, valueSerializer, valueNullableSerializer, UnifiedRouter(serialFormat, serialFormatContentType))
+) = configureKeyValueRepoRoutes(baseSubpart, originalRepo, keySerializer, valueSerializer, valueNullableSerializer, UnifiedRouter(serialFormat, serialFormatContentType))

repos/ktor/server/src/jvmMain/kotlin/dev/inmo/micro_utils/repos/ktor/server/key_value/KtorStandartReadKeyValueRepo.kt

@@ -5,7 +5,7 @@ import dev.inmo.micro_utils.ktor.common.standardKtorSerialFormat
 import dev.inmo.micro_utils.ktor.server.*
 import dev.inmo.micro_utils.pagination.PaginationResult
 import dev.inmo.micro_utils.pagination.extractPagination
-import dev.inmo.micro_utils.repos.ReadStandardKeyValueRepo
+import dev.inmo.micro_utils.repos.ReadKeyValueRepo
 import dev.inmo.micro_utils.repos.ktor.common.*
 import dev.inmo.micro_utils.repos.ktor.common.containsRoute
 import dev.inmo.micro_utils.repos.ktor.common.countRoute
@@ -20,7 +20,7 @@ import kotlinx.serialization.KSerializer
 import kotlinx.serialization.builtins.serializer
 
 fun <K, V> Route.configureReadStandartKeyValueRepoRoutes (
-    originalRepo: ReadStandardKeyValueRepo<K, V>,
+    originalRepo: ReadKeyValueRepo<K, V>,
     keySerializer: KSerializer<K>,
     valueSerializer: KSerializer<V>,
     valueNullableSerializer: KSerializer<V?>,
@@ -96,7 +96,7 @@ fun <K, V> Route.configureReadStandartKeyValueRepoRoutes (
 }
 
 inline fun <K, V> Route.configureReadStandartKeyValueRepoRoutes (
-    originalRepo: ReadStandardKeyValueRepo<K, V>,
+    originalRepo: ReadKeyValueRepo<K, V>,
     keySerializer: KSerializer<K>,
     valueSerializer: KSerializer<V>,
     valueNullableSerializer: KSerializer<V?>,

repos/ktor/server/src/jvmMain/kotlin/dev/inmo/micro_utils/repos/ktor/server/key_value/KtorStandartWriteKeyValueRepo.kt

@@ -3,7 +3,7 @@ package dev.inmo.micro_utils.repos.ktor.server.key_value
 import dev.inmo.micro_utils.ktor.common.StandardKtorSerialFormat
 import dev.inmo.micro_utils.ktor.common.standardKtorSerialFormat
 import dev.inmo.micro_utils.ktor.server.*
-import dev.inmo.micro_utils.repos.WriteStandardKeyValueRepo
+import dev.inmo.micro_utils.repos.WriteKeyValueRepo
 import dev.inmo.micro_utils.repos.ktor.common.key_value.*
 import io.ktor.http.ContentType
 import io.ktor.server.routing.Route
@@ -11,8 +11,8 @@ import io.ktor.server.routing.post
 import kotlinx.serialization.KSerializer
 import kotlinx.serialization.builtins.*
 
-fun <K, V> Route.configureWriteStandardKeyValueRepoRoutes (
-    originalRepo: WriteStandardKeyValueRepo<K, V>,
+fun <K, V> Route.configureWriteKeyValueRepoRoutes (
+    originalRepo: WriteKeyValueRepo<K, V>,
     keySerializer: KSerializer<K>,
     valueSerializer: KSerializer<V>,
     unifiedRouter: UnifiedRouter
@@ -62,9 +62,9 @@ fun <K, V> Route.configureWriteStandardKeyValueRepoRoutes (
 }
 
 fun <K, V> Route.configureWriteStandartKeyValueRepoRoutes (
-    originalRepo: WriteStandardKeyValueRepo<K, V>,
+    originalRepo: WriteKeyValueRepo<K, V>,
     keySerializer: KSerializer<K>,
     valueSerializer: KSerializer<V>,
     serialFormat: StandardKtorSerialFormat = standardKtorSerialFormat,
     serialFormatContentType: ContentType = standardKtorSerialFormatContentType
-) = configureWriteStandardKeyValueRepoRoutes(originalRepo, keySerializer, valueSerializer, UnifiedRouter(serialFormat, serialFormatContentType))
+) = configureWriteKeyValueRepoRoutes(originalRepo, keySerializer, valueSerializer, UnifiedRouter(serialFormat, serialFormatContentType))

repos/ktor/server/src/jvmMain/kotlin/dev/inmo/micro_utils/repos/ktor/server/key_value/KtorWriteKeyValueRepoRoutes.kt

@@ -1,7 +1,7 @@
 package dev.inmo.micro_utils.repos.ktor.server.key_value
 
 import dev.inmo.micro_utils.ktor.server.*
-import dev.inmo.micro_utils.repos.WriteStandardKeyValueRepo
+import dev.inmo.micro_utils.repos.WriteKeyValueRepo
 import dev.inmo.micro_utils.repos.ktor.common.key_value.*
 import io.ktor.http.HttpStatusCode
 import io.ktor.server.application.call
@@ -11,8 +11,8 @@ import io.ktor.server.routing.Route
 import io.ktor.server.routing.post
 import io.ktor.util.reflect.typeInfo
 
-inline fun <reified Key : Any, reified Value : Any> Route.configureWriteStandardKeyValueRepoRoutes (
-    originalRepo: WriteStandardKeyValueRepo<Key, Value>
+inline fun <reified Key : Any, reified Value : Any> Route.configureWriteKeyValueRepoRoutes (
+    originalRepo: WriteKeyValueRepo<Key, Value>
 ) {
     includeWebsocketHandling(
         onNewValueRoute,

repos/ktor/server/src/jvmMain/kotlin/dev/inmo/micro_utils/repos/ktor/server/one_to_many/ConfigureOneToManyKeyValueRepoRoutes.kt

@@ -4,7 +4,7 @@ import dev.inmo.micro_utils.ktor.common.StandardKtorSerialFormat
 import dev.inmo.micro_utils.ktor.common.standardKtorSerialFormat
 import dev.inmo.micro_utils.ktor.server.UnifiedRouter
 import dev.inmo.micro_utils.ktor.server.standardKtorSerialFormatContentType
-import dev.inmo.micro_utils.repos.OneToManyKeyValueRepo
+import dev.inmo.micro_utils.repos.KeyValuesRepo
 import io.ktor.http.ContentType
 import io.ktor.server.routing.Route
 import io.ktor.server.routing.route
@@ -12,7 +12,7 @@ import kotlinx.serialization.KSerializer
 
 fun <Key, Value> Route.configureOneToManyKeyValueRepoRoutes(
     baseSubpart: String,
-    originalRepo: OneToManyKeyValueRepo<Key, Value>,
+    originalRepo: KeyValuesRepo<Key, Value>,
     keySerializer: KSerializer<Key>,
     valueSerializer: KSerializer<Value>,
     unifiedRouter: UnifiedRouter
@@ -25,7 +25,7 @@ fun <Key, Value> Route.configureOneToManyKeyValueRepoRoutes(
 
 fun <Key, Value> Route.configureOneToManyKeyValueRepoRoutes(
     baseSubpart: String,
-    originalRepo: OneToManyKeyValueRepo<Key, Value>,
+    originalRepo: KeyValuesRepo<Key, Value>,
     keySerializer: KSerializer<Key>,
     valueSerializer: KSerializer<Value>,
     serialFormat: StandardKtorSerialFormat = standardKtorSerialFormat,

repos/ktor/server/src/jvmMain/kotlin/dev/inmo/micro_utils/repos/ktor/server/one_to_many/ConfigureOneToManyReadKeyValueRepoRoutes.kt

@@ -5,7 +5,7 @@ import dev.inmo.micro_utils.ktor.common.standardKtorSerialFormat
 import dev.inmo.micro_utils.ktor.server.*
 import dev.inmo.micro_utils.pagination.PaginationResult
 import dev.inmo.micro_utils.pagination.extractPagination
-import dev.inmo.micro_utils.repos.ReadOneToManyKeyValueRepo
+import dev.inmo.micro_utils.repos.ReadKeyValuesRepo
 import dev.inmo.micro_utils.repos.ktor.common.keyParameterName
 import dev.inmo.micro_utils.repos.ktor.common.one_to_many.*
 import dev.inmo.micro_utils.repos.ktor.common.valueParameterName
@@ -18,7 +18,7 @@ import kotlinx.serialization.KSerializer
 import kotlinx.serialization.builtins.serializer
 
 fun <Key, Value> Route.configureOneToManyReadKeyValueRepoRoutes(
-    originalRepo: ReadOneToManyKeyValueRepo<Key, Value>,
+    originalRepo: ReadKeyValuesRepo<Key, Value>,
     keySerializer: KSerializer<Key>,
     valueSerializer: KSerializer<Value>,
     unifiedRouter: UnifiedRouter
@@ -121,7 +121,7 @@ fun <Key, Value> Route.configureOneToManyReadKeyValueRepoRoutes(
 }
 
 inline fun <Key, Value> Route.configureOneToManyReadKeyValueRepoRoutes(
-    originalRepo: ReadOneToManyKeyValueRepo<Key, Value>,
+    originalRepo: ReadKeyValuesRepo<Key, Value>,
     keySerializer: KSerializer<Key>,
     valueSerializer: KSerializer<Value>,
     serialFormat: StandardKtorSerialFormat = standardKtorSerialFormat,

repos/ktor/server/src/jvmMain/kotlin/dev/inmo/micro_utils/repos/ktor/server/one_to_many/ConfigureOneToManyWriteKeyValueRepoRoutes.kt

@@ -3,7 +3,7 @@ package dev.inmo.micro_utils.repos.ktor.server.one_to_many
 import dev.inmo.micro_utils.ktor.common.StandardKtorSerialFormat
 import dev.inmo.micro_utils.ktor.common.standardKtorSerialFormat
 import dev.inmo.micro_utils.ktor.server.*
-import dev.inmo.micro_utils.repos.WriteOneToManyKeyValueRepo
+import dev.inmo.micro_utils.repos.WriteKeyValuesRepo
 import dev.inmo.micro_utils.repos.ktor.common.one_to_many.*
 import io.ktor.http.ContentType
 import io.ktor.server.routing.Route
@@ -12,7 +12,7 @@ import kotlinx.serialization.KSerializer
 import kotlinx.serialization.builtins.*
 
 fun <Key, Value> Route.configureOneToManyWriteKeyValueRepoRoutes(
-    originalRepo: WriteOneToManyKeyValueRepo<Key, Value>,
+    originalRepo: WriteKeyValuesRepo<Key, Value>,
     keySerializer: KSerializer<Key>,
     valueSerializer: KSerializer<Value>,
     unifiedRouter: UnifiedRouter
@@ -95,7 +95,7 @@ fun <Key, Value> Route.configureOneToManyWriteKeyValueRepoRoutes(
 }
 
 fun <Key, Value> Route.configureOneToManyWriteKeyValueRepoRoutes(
-    originalRepo: WriteOneToManyKeyValueRepo<Key, Value>,
+    originalRepo: WriteKeyValuesRepo<Key, Value>,
     keySerializer: KSerializer<Key>,
     valueSerializer: KSerializer<Value>,
     serialFormat: StandardKtorSerialFormat = standardKtorSerialFormat,

repos/ktor/server/src/jvmMain/kotlin/dev/inmo/micro_utils/repos/ktor/server/one_to_many/KtorKeyValuesRepoRoutes.kt

@@ -6,21 +6,21 @@ import io.ktor.http.*
 import io.ktor.server.routing.Route
 import kotlinx.serialization.*
 
-inline fun <reified Key : Any, reified Value : Any> Route.configureStandardKeyValuesRepoRoutes (
-    originalRepo: OneToManyKeyValueRepo<Key, Value>,
+inline fun <reified Key : Any, reified Value : Any> Route.configureKeyValuesRepoRoutes (
+    originalRepo: KeyValuesRepo<Key, Value>,
     noinline idDeserializer: suspend (String) -> Key,
     noinline valueDeserializer: suspend (String) -> Value
 ) {
-    configureReadStandardKeyValuesRepoRoutes(originalRepo, idDeserializer, valueDeserializer)
-    configureWriteStandardKeyValuesRepoRoutes(originalRepo)
+    configureReadKeyValuesRepoRoutes(originalRepo, idDeserializer, valueDeserializer)
+    configureWriteKeyValuesRepoRoutes(originalRepo)
 }
 
-inline fun <reified Key : Any, reified Value : Any> Route.configureStandardKeyValuesRepoRoutes(
-    originalRepo: OneToManyKeyValueRepo<Key, Value>,
+inline fun <reified Key : Any, reified Value : Any> Route.configureKeyValuesRepoRoutes(
+    originalRepo: KeyValuesRepo<Key, Value>,
     idsSerializer: DeserializationStrategy<Key>,
     valueSerializer: DeserializationStrategy<Value>,
     serialFormat: StringFormat
-) = configureStandardKeyValuesRepoRoutes(
+) = configureKeyValuesRepoRoutes(
     originalRepo,
     {
         serialFormat.decodeFromString(idsSerializer, it.decodeURLQueryComponent())
@@ -30,12 +30,12 @@ inline fun <reified Key : Any, reified Value : Any> Route.configureStandardKeyVa
     }
 )
 
-inline fun <reified Key : Any, reified Value : Any> Route.configureStandardKeyValuesRepoRoutes(
-    originalRepo: OneToManyKeyValueRepo<Key, Value>,
+inline fun <reified Key : Any, reified Value : Any> Route.configureKeyValuesRepoRoutes(
+    originalRepo: KeyValuesRepo<Key, Value>,
     idsSerializer: DeserializationStrategy<Key>,
     valueSerializer: DeserializationStrategy<Value>,
     serialFormat: BinaryFormat
-) = configureStandardKeyValuesRepoRoutes(
+) = configureKeyValuesRepoRoutes(
     originalRepo,
     {
         serialFormat.decodeHex(idsSerializer, it)

repos/ktor/server/src/jvmMain/kotlin/dev/inmo/micro_utils/repos/ktor/server/one_to_many/KtorReadKeyValuesRepoRoutes.kt

@@ -4,7 +4,7 @@ import dev.inmo.micro_utils.ktor.common.*
 import dev.inmo.micro_utils.ktor.server.*
 import dev.inmo.micro_utils.pagination.PaginationResult
 import dev.inmo.micro_utils.pagination.extractPagination
-import dev.inmo.micro_utils.repos.ReadOneToManyKeyValueRepo
+import dev.inmo.micro_utils.repos.ReadKeyValuesRepo
 import dev.inmo.micro_utils.repos.ktor.common.*
 import dev.inmo.micro_utils.repos.ktor.common.containsRoute
 import dev.inmo.micro_utils.repos.ktor.common.one_to_many.*
@@ -18,8 +18,8 @@ import io.ktor.util.reflect.typeInfo
 import kotlinx.serialization.*
 
 @OptIn(InternalAPI::class)
-inline fun <reified Key, reified Value> Route.configureReadStandardKeyValuesRepoRoutes (
-    originalRepo: ReadOneToManyKeyValueRepo<Key, Value>,
+inline fun <reified Key, reified Value> Route.configureReadKeyValuesRepoRoutes (
+    originalRepo: ReadKeyValuesRepo<Key, Value>,
     noinline idDeserializer: suspend (String) -> Key,
     noinline valueDeserializer: suspend (String) -> Value
 ) {
@@ -75,12 +75,12 @@ inline fun <reified Key, reified Value> Route.configureReadStandardKeyValuesRepo
     }
 }
 
-inline fun <reified Key, reified Value> Route.configureReadStandardKeyValuesRepoRoutes(
-    originalRepo: ReadOneToManyKeyValueRepo<Key, Value>,
+inline fun <reified Key, reified Value> Route.configureReadKeyValuesRepoRoutes(
+    originalRepo: ReadKeyValuesRepo<Key, Value>,
     idsSerializer: DeserializationStrategy<Key>,
     valueSerializer: DeserializationStrategy<Value>,
     serialFormat: StringFormat
-) = configureReadStandardKeyValuesRepoRoutes(
+) = configureReadKeyValuesRepoRoutes(
     originalRepo,
     {
         serialFormat.decodeFromString(idsSerializer, it.decodeURLQueryComponent())
@@ -90,12 +90,12 @@ inline fun <reified Key, reified Value> Route.configureReadStandardKeyValuesRepo
     }
 )
 
-inline fun <reified Key, reified Value> Route.configureReadStandardKeyValuesRepoRoutes(
-    originalRepo: ReadOneToManyKeyValueRepo<Key, Value>,
+inline fun <reified Key, reified Value> Route.configureReadKeyValuesRepoRoutes(
+    originalRepo: ReadKeyValuesRepo<Key, Value>,
     idsSerializer: DeserializationStrategy<Key>,
     valueSerializer: DeserializationStrategy<Value>,
     serialFormat: BinaryFormat
-) = configureReadStandardKeyValuesRepoRoutes(
+) = configureReadKeyValuesRepoRoutes(
     originalRepo,
     {
         serialFormat.decodeHex(idsSerializer, it)

repos/ktor/server/src/jvmMain/kotlin/dev/inmo/micro_utils/repos/ktor/server/one_to_many/KtorWriteKeyValuesRepoRoutes.kt

@@ -1,7 +1,7 @@
 package dev.inmo.micro_utils.repos.ktor.server.one_to_many
 
 import dev.inmo.micro_utils.ktor.server.*
-import dev.inmo.micro_utils.repos.WriteOneToManyKeyValueRepo
+import dev.inmo.micro_utils.repos.WriteKeyValuesRepo
 import dev.inmo.micro_utils.repos.ktor.common.one_to_many.*
 import io.ktor.http.HttpStatusCode
 import io.ktor.server.application.call
@@ -11,8 +11,8 @@ import io.ktor.server.routing.Route
 import io.ktor.server.routing.post
 import io.ktor.util.reflect.typeInfo
 
-inline fun <reified Key : Any, reified Value : Any> Route.configureWriteStandardKeyValuesRepoRoutes (
-    originalRepo: WriteOneToManyKeyValueRepo<Key, Value>
+inline fun <reified Key : Any, reified Value : Any> Route.configureWriteKeyValuesRepoRoutes (
+    originalRepo: WriteKeyValuesRepo<Key, Value>
 ) {
     includeWebsocketHandling(
         onNewValueRoute,