Update dependency org.jetbrains.kotlinx:kotlinx-serialization-json to v1.6.3

2025-12-05 13:55:38 +00:00 · 2024-02-17 07:38:38 +00:00
54 changed files with 292 additions and 1596 deletions
--- a/.github/workflows/build.yml
+++ b/.github/workflows/build.yml
@@ -10,11 +10,10 @@ jobs:
      - uses: actions/checkout@v2
      - name: Install dependencies
        run: |
-          sudo apt update
          sudo apt install -y libcurl4-openssl-dev
      - name: Set up JDK 17
        uses: actions/setup-java@v1
        with:
          java-version: 17
      - name: Build with Gradle
-        run: ./gradlew build --no-daemon
+        run: ./gradlew build
--- a/.gitignore
+++ b/.gitignore
@@ -1,5 +1,4 @@
 .idea
-.kotlin
 out/*
 *.iml
 target
--- a/.template/bot/.env
+++ b/.template/bot/.env
@@ -1,2 +0,0 @@
-title=$prompt
-subtitle=Subtitle of {{$title}}
--- a/.template/bot/{{$title}}/README.md
+++ b/.template/bot/{{$title}}/README.md
@@ -1,9 +0,0 @@
-# {{$title}}
-
-
-
-## Launch
-
-```bash
-../gradlew run --args="BOT_TOKEN"
-```
--- a/.template/bot/{{$title}}/build.gradle
+++ b/.template/bot/{{$title}}/build.gradle
@@ -1,22 +0,0 @@
-buildscript {
-    repositories {
-        mavenCentral()
-    }
-
-    dependencies {
-        classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:$kotlin_version"
-    }
-}
-
-apply plugin: 'kotlin'
-apply plugin: 'application'
-
-mainClassName="{{$title}}Kt"
-        {{$subtitle}}
-
-
-dependencies {
-    implementation "org.jetbrains.kotlin:kotlin-stdlib:$kotlin_version"
-
-    implementation "dev.inmo:tgbotapi:$telegram_bot_api_version"
-}
--- a/.template/bot/{{$title}}/src/main/kotlin/{{$title}}.kt
+++ b/.template/bot/{{$title}}/src/main/kotlin/{{$title}}.kt
@@ -1,34 +0,0 @@
-import dev.inmo.kslog.common.KSLog
-import dev.inmo.kslog.common.LogLevel
-import dev.inmo.kslog.common.defaultMessageFormatter
-import dev.inmo.kslog.common.setDefaultKSLog
-import dev.inmo.micro_utils.coroutines.subscribeSafelyWithoutExceptions
-import dev.inmo.tgbotapi.extensions.api.bot.getMe
-import dev.inmo.tgbotapi.extensions.behaviour_builder.telegramBotWithBehaviourAndLongPolling
-import kotlinx.coroutines.CoroutineScope
-import kotlinx.coroutines.Dispatchers
-
-/**
- * This place can be the playground for your code.
- */
-suspend fun main(vararg args: String) {
-    val botToken = args.first()
-
-    val isDebug = args.any { it == "debug" }
-
-    if (isDebug) {
-        setDefaultKSLog(
-            KSLog { level: LogLevel, tag: String?, message: Any, throwable: Throwable? ->
-                println(defaultMessageFormatter(level, tag, message, throwable))
-            }
-        )
-    }
-
-    telegramBotWithBehaviourAndLongPolling(botToken, CoroutineScope(Dispatchers.IO)) {
-        // start here!!
-        val me = getMe()
-        println(me)
-
-        allUpdatesFlow.subscribeSafelyWithoutExceptions(this) { println(it) }
-    }.second.join()
-}
--- a/.template/module_generator.main.kts
+++ b/.template/module_generator.main.kts
@@ -1,208 +0,0 @@
-#!/usr/bin/env kotlin
-/**
- * Generates files and folders as they have been put in the folder. Envs uses common syntax, but
- * values may contains {{${'$'}sampleVariable}} parts, where {{${'$'}sampleVariable}} will be replaced with variable value.
- * Example:
- *
- * .env:
- * sampleVariable=${'$'}prompt # require request from command line
- *         sampleVariable2=just some value
- * sampleVariable3=${'$'}{sampleVariable}.${'$'}{sampleVariable2}
- *
- * Result variables:
- * sampleVariable=your input in console # lets imagine you typed it
- * sampleVariable2=just some value
- * sampleVariable3=your input in console.just some value
- *
- * To use these variables in template, you will need to write {{${'$'}sampleVariable}}.
- * You may use it in text of files as well as in files/folders names.
- *
- * Usage: kotlin generator.kts [args] folders...
- * Args:
- * -e, --env: Path to file with args for generation; Use "${'$'}prompt" as values to read variable value from console
- * -o, --outputFolder: Folder where templates should be used. Folder of calling by default
- *         folders: Folders-templates
- */
-import java.io.File
-
-val console = System.console()
-
-fun String.replaceWithVariables(envs: Map<String, String>): String {
-    var currentString = this
-    var changed = false
-
-    do {
-        changed = false
-        envs.forEach { (k, v) ->
-            val previousString = currentString
-            currentString = currentString.replace("{{$${k}}}", v)
-            changed = changed || currentString != previousString
-        }
-    } while (changed)
-
-    return currentString
-}
-
-fun requestVariable(variableName: String, defaultValue: String?): String {
-    console.printf("Enter value for variable $variableName${defaultValue ?.let { " [$it]" } ?: ""}: ")
-    return console.readLine().ifEmpty { defaultValue } ?: ""
-}
-
-fun readEnvs(content: String, presets: Map<String, String>): Map<String, String> {
-    val initialEnvs = mutableMapOf<String, String>()
-    content.split("\n").forEach {
-        val withoutComment = it.replace(Regex("\\#.*"), "")
-
-        runCatching {
-            val (key, value) = withoutComment.split("=")
-            val existsValue = presets[key]
-            if (value == "\$prompt") {
-                initialEnvs[key] = requestVariable(key, existsValue)
-            } else {
-                initialEnvs[key] = requestVariable(key, value.replaceWithVariables(initialEnvs))
-            }
-        }
-    }
-    var i = 0
-    val readEnvs = initialEnvs.toMutableMap()
-    while (i < readEnvs.size) {
-        val key = readEnvs.keys.elementAt(i)
-        val currentValue = readEnvs.getValue(key)
-        val withReplaced = currentValue.replaceWithVariables(readEnvs)
-        var changed = false
-        if (withReplaced != currentValue) {
-            i = 0
-            readEnvs[key] = withReplaced
-        } else {
-            i++
-        }
-    }
-    return presets + readEnvs
-}
-
-var envFile: File? = null
-var outputFolder: File = File("./") // current folder by default
-val templatesFolders = mutableListOf<File>()
-var extensions: List<String>? = null
-
-fun readParameters() {
-    var i = 0
-    while (i < args.size) {
-        val arg = args[i]
-        when (arg) {
-            "--env",
-            "-e" -> {
-                i++
-                envFile = File(args[i])
-            }
-            "--extensions",
-            "-ex" -> {
-                i++
-                extensions = args[i].split(",")
-            }
-            "--outputFolder",
-            "-o" -> {
-                i++
-                outputFolder = File(args[i])
-            }
-            "--help",
-            "-h" -> {
-                println("""
-                    Generates files and folders as the have been put in the folder. Envs uses common syntax, but
-                    values may contains {{${'$'}sampleVariable}} parts, where {{${'$'}sampleVariable}} will be replaced with variable value.
-                    Example:
-                    
-                    .env:
-                    sampleVariable=${'$'}prompt # require request from command line
-                    sampleVariable2=just some value
-                    sampleVariable3=${'$'}{sampleVariable}.${'$'}{sampleVariable2}
-                    
-                    Result variables:
-                    sampleVariable=your input in console # lets imagine you typed it
-                    sampleVariable2=just some value
-                    sampleVariable3=your input in console.just some value
-                    
-                    To use these variables in template, you will need to write {{${'$'}sampleVariable}}.
-                    You may use it in text of files as well as in files/folders names.
-                    
-                    Usage: kotlin generator.kts [args] folders...
-                    Args:
-                        -e, --env: Path to file with args for generation; Use "${'$'}prompt" as values to read variable value from console
-                        -o, --outputFolder: Folder where templates should be used. Folder of calling by default
-                        folders: Folders-templates
-                """.trimIndent())
-                Runtime.getRuntime().exit(0)
-            }
-            else -> {
-                val potentialFile = File(arg)
-                println("Potential file/folder as template: ${potentialFile.absolutePath}")
-                runCatching {
-                    if (potentialFile.exists()) {
-                        println("Adding file/folder as template: ${potentialFile.absolutePath}")
-                        templatesFolders.add(potentialFile)
-                    }
-                }.onFailure { e ->
-                    println("Unable to use folder $arg as template folder")
-                    e.printStackTrace()
-                }
-            }
-        }
-        i++
-    }
-}
-
-readParameters()
-
-val envs: MutableMap<String, String> = envFile ?.let { readEnvs(it.readText(), emptyMap()) } ?.toMutableMap() ?: mutableMapOf()
-
-println(
-    """
-    Result environments:
-        ${envs.toList().joinToString("\n        ") { (k, v) -> "$k=$v" }}
-    Result extensions:
-        ${extensions ?.joinToString()}
-    Input folders:
-        ${templatesFolders.joinToString("\n        ") { it.absolutePath }}
-    Output folder:
-        ${outputFolder.absolutePath}
-    """.trimIndent()
-)
-
-fun File.handleTemplate(targetFolder: File, envs: Map<String, String>) {
-    println("Handling $absolutePath")
-    val localEnvs = File(absolutePath, ".env").takeIf { it.exists() } ?.let {
-        println("Reading .env in ${absolutePath}")
-        readEnvs(it.readText(), envs)
-    } ?: envs
-    println(
-        """
-    Local environments:
-        ${localEnvs.toList().joinToString("\n        ") { (k, v) -> "$k=$v" }}
-    """.trimIndent()
-    )
-    val newName = name.replaceWithVariables(localEnvs)
-    println("New name $newName")
-    when {
-        !exists() -> return
-        isFile -> {
-            val content = useLines {
-                it.map { it.replaceWithVariables(localEnvs) }.toList()
-            }.joinToString("\n")
-            val targetFile = File(targetFolder, newName)
-            targetFile.writeText(content)
-            println("Target file: ${targetFile.absolutePath}")
-        }
-        else -> {
-            val folder = File(targetFolder, newName)
-            println("Target folder: ${folder.absolutePath}")
-            folder.mkdirs()
-            listFiles() ?.forEach { fileOrFolder ->
-                fileOrFolder.handleTemplate(folder, localEnvs)
-            }
-        }
-    }
-}
-
-templatesFolders.forEach { folderOrFile ->
-    folderOrFile.handleTemplate(outputFolder, envs)
-}
--- a/BoostsInfoBot/src/main/kotlin/BoostsInfo.kt
+++ b/BoostsInfoBot/src/main/kotlin/BoostsInfo.kt
@@ -4,13 +4,13 @@ import dev.inmo.kslog.common.defaultMessageFormatter
 import dev.inmo.kslog.common.setDefaultKSLog
 import dev.inmo.tgbotapi.bot.ktor.telegramBot
 import dev.inmo.tgbotapi.extensions.api.get.getUserChatBoosts
-import dev.inmo.tgbotapi.extensions.api.send.reply
+import dev.inmo.tgbotapi.extensions.api.send.*
 import dev.inmo.tgbotapi.extensions.behaviour_builder.buildBehaviourWithLongPolling
 import dev.inmo.tgbotapi.extensions.behaviour_builder.triggers_handling.onChatBoostUpdated
 import dev.inmo.tgbotapi.extensions.behaviour_builder.triggers_handling.onChatShared
 import dev.inmo.tgbotapi.extensions.behaviour_builder.triggers_handling.onCommand
-import dev.inmo.tgbotapi.extensions.utils.types.buttons.flatReplyKeyboard
-import dev.inmo.tgbotapi.extensions.utils.types.buttons.requestChannelButton
+import dev.inmo.tgbotapi.extensions.utils.types.buttons.*
+import dev.inmo.tgbotapi.types.chat.member.ChatCommonAdministratorRights
 import dev.inmo.tgbotapi.types.request.RequestId
 import dev.inmo.tgbotapi.utils.regular
 import korlibs.time.DateFormat
@@ -52,19 +52,12 @@ suspend fun main(args: Array<String>) {
        }

        onChatShared(initialFilter = { it.chatEvent.requestId == requestChatId }) {
-            val boostsInfoContrainer = runCatching {
-                getUserChatBoosts(it.chatEvent.chatId, it.chat.id)
-            }.getOrNull()
-
-            reply(it) {
-                when {
-                    boostsInfoContrainer == null -> +"Unable to take info about boosts in shared chat"
-                    boostsInfoContrainer.boosts.isEmpty() -> +"There is no any boosts in passed chat"
-                    else -> {
-                        boostsInfoContrainer.boosts.forEach {
-                            regular("Boost added: ${DateFormat.FORMAT1.format(it.addDate.asDate)}; Boost expire: ${DateFormat.FORMAT1.format(it.expirationDate.asDate)}; Unformatted: $it") + "\n"
-                        }
-                    }
+            val boosts = getUserChatBoosts(it.chatEvent.chatId, it.chat.id)
+            reply(
+                it
+            ) {
+                boosts.boosts.forEach {
+                    regular("Boost added: ${DateFormat.FORMAT1.format(it.addDate.asDate)}; Boost expire: ${DateFormat.FORMAT1.format(it.expirationDate.asDate)}; Unformatted: $it") + "\n"
                }
            }
        }
--- a/BusinessConnectionsBot/README.md
+++ b/BusinessConnectionsBot/README.md
@@ -1,9 +0,0 @@
-# BusinessConnectionBotBot
-
-When bot connected or disconnected to the business chat, it will notify this chat
-
-## Launch
-
-```bash
-../gradlew run --args="BOT_TOKEN"
-```
--- a/BusinessConnectionsBot/build.gradle
+++ b/BusinessConnectionsBot/build.gradle
@@ -1,21 +0,0 @@
-buildscript {
-    repositories {
-        mavenCentral()
-    }
-
-    dependencies {
-        classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:$kotlin_version"
-    }
-}
-
-apply plugin: 'kotlin'
-apply plugin: 'application'
-
-mainClassName="BusinessConnectionsBotKt"
-
-
-dependencies {
-    implementation "org.jetbrains.kotlin:kotlin-stdlib:$kotlin_version"
-
-    implementation "dev.inmo:tgbotapi:$telegram_bot_api_version"
-}
--- a/BusinessConnectionsBot/src/main/kotlin/BusinessConnectionsBot.kt
+++ b/BusinessConnectionsBot/src/main/kotlin/BusinessConnectionsBot.kt
@@ -1,102 +0,0 @@
-import dev.inmo.kslog.common.KSLog
-import dev.inmo.kslog.common.LogLevel
-import dev.inmo.kslog.common.defaultMessageFormatter
-import dev.inmo.kslog.common.setDefaultKSLog
-import dev.inmo.tgbotapi.extensions.api.bot.getMe
-import dev.inmo.tgbotapi.extensions.api.chat.modify.pinChatMessage
-import dev.inmo.tgbotapi.extensions.api.chat.modify.unpinChatMessage
-import dev.inmo.tgbotapi.extensions.api.get.getBusinessConnection
-import dev.inmo.tgbotapi.extensions.api.send.reply
-import dev.inmo.tgbotapi.extensions.api.send.send
-import dev.inmo.tgbotapi.extensions.behaviour_builder.telegramBotWithBehaviourAndLongPolling
-import dev.inmo.tgbotapi.extensions.behaviour_builder.triggers_handling.*
-import dev.inmo.tgbotapi.extensions.utils.accessibleMessageOrNull
-import dev.inmo.tgbotapi.extensions.utils.ifAccessibleMessage
-import dev.inmo.tgbotapi.extensions.utils.ifBusinessContentMessage
-import dev.inmo.tgbotapi.extensions.utils.textContentOrNull
-import dev.inmo.tgbotapi.types.ChatId
-import dev.inmo.tgbotapi.types.business_connection.BusinessConnectionId
-import kotlinx.coroutines.CoroutineScope
-import kotlinx.coroutines.Dispatchers
-import kotlinx.coroutines.sync.Mutex
-import kotlinx.coroutines.sync.withLock
-
-suspend fun main(args: Array<String>) {
-    val botToken = args.first()
-    val isDebug = args.getOrNull(1) == "debug"
-
-    if (isDebug) {
-        setDefaultKSLog(
-            KSLog { level: LogLevel, tag: String?, message: Any, throwable: Throwable? ->
-                println(defaultMessageFormatter(level, tag, message, throwable))
-            }
-        )
-    }
-
-    val businessConnectionsChats = mutableMapOf<BusinessConnectionId, ChatId>()
-    val businessConnectionsChatsMutex = Mutex()
-
-    telegramBotWithBehaviourAndLongPolling(botToken, CoroutineScope(Dispatchers.IO)) {
-        val me = getMe()
-        println(me)
-
-        onBusinessConnectionEnabled {
-            businessConnectionsChatsMutex.withLock {
-                businessConnectionsChats[it.id] = it.userChatId
-            }
-            send(it.userChatId, "Business connection ${it.businessConnectionId.string} has been enabled")
-        }
-        onBusinessConnectionDisabled {
-            businessConnectionsChatsMutex.withLock {
-                businessConnectionsChats.remove(it.id)
-            }
-            send(it.userChatId, "Business connection ${it.businessConnectionId.string} has been disabled")
-        }
-
-        onContentMessage {
-            it.ifBusinessContentMessage { businessContentMessage ->
-                if (businessContentMessage.content.textContentOrNull() ?.text ?.startsWith("/pin") == true) {
-                    businessContentMessage.replyTo ?.ifAccessibleMessage {
-                        pinChatMessage(it)
-                        return@ifBusinessContentMessage
-                    }
-                }
-                if (businessContentMessage.content.textContentOrNull() ?.text ?.startsWith("/unpin") == true) {
-                    businessContentMessage.replyTo ?.ifAccessibleMessage {
-                        unpinChatMessage(it)
-                        return@ifBusinessContentMessage
-                    }
-                }
-                val sent = execute(it.content.createResend(businessContentMessage.from.id))
-                if (businessContentMessage.sentByBusinessConnectionOwner) {
-                    reply(sent, "You have sent this message to the ${businessContentMessage.businessConnectionId.string} related chat")
-                } else {
-                    reply(sent, "User have sent this message to you in the ${businessContentMessage.businessConnectionId.string} related chat")
-                }
-            }
-        }
-        onEditedContentMessage {
-            it.ifBusinessContentMessage { businessContentMessage ->
-                val sent = execute(businessContentMessage.content.createResend(businessContentMessage.from.id))
-                if (businessContentMessage.sentByBusinessConnectionOwner) {
-                    reply(sent, "You have edited this message in the ${businessContentMessage.businessConnectionId.string} related chat")
-                } else {
-                    reply(sent, "User have edited this message to you in the ${businessContentMessage.businessConnectionId.string} related chat")
-                }
-            }
-        }
-        onBusinessMessagesDeleted {
-            var businessConnectionOwnerChat = businessConnectionsChatsMutex.withLock {
-                businessConnectionsChats[it.businessConnectionId]
-            }
-            if (businessConnectionOwnerChat == null) {
-                val businessConnection = getBusinessConnection(it.businessConnectionId)
-                businessConnectionsChatsMutex.withLock {
-                    businessConnectionsChats[businessConnection.businessConnectionId] = businessConnection.userChatId
-                }
-                businessConnectionOwnerChat = businessConnection.userChatId
-            }
-            send(businessConnectionOwnerChat, "There are several removed messages in chat ${it.chat.id}: ${it.messageIds}")
-        }
-    }.second.join()
-}
--- a/ChatAvatarSetter/src/main/kotlin/ChatAvatarSetter.kt
+++ b/ChatAvatarSetter/src/main/kotlin/ChatAvatarSetter.kt
@@ -5,9 +5,9 @@ import dev.inmo.tgbotapi.extensions.api.files.downloadFile
 import dev.inmo.tgbotapi.extensions.api.send.reply
 import dev.inmo.tgbotapi.extensions.behaviour_builder.buildBehaviourWithLongPolling
 import dev.inmo.tgbotapi.extensions.behaviour_builder.triggers_handling.onPhoto
+import dev.inmo.tgbotapi.extensions.utils.*
 import dev.inmo.tgbotapi.requests.abstracts.asMultipartFile
-import kotlinx.coroutines.CoroutineScope
-import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.*

 suspend fun main(args: Array<String>) {
    val bot = telegramBot(args.first())
--- a/CustomBot/README.md
+++ b/CustomBot/README.md
@@ -1,9 +0,0 @@
-# CustomBot
-
-This bot basically have no any useful behaviour, but you may customize it as a playground
-
-## Launch
-
-```bash
-../gradlew run --args="BOT_TOKEN"
-```
--- a/CustomBot/build.gradle
+++ b/CustomBot/build.gradle
@@ -1,21 +0,0 @@
-buildscript {
-    repositories {
-        mavenCentral()
-    }
-
-    dependencies {
-        classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:$kotlin_version"
-    }
-}
-
-apply plugin: 'kotlin'
-apply plugin: 'application'
-
-mainClassName="CustomBotKt"
-
-
-dependencies {
-    implementation "org.jetbrains.kotlin:kotlin-stdlib:$kotlin_version"
-
-    implementation "dev.inmo:tgbotapi:$telegram_bot_api_version"
-}
--- a/CustomBot/src/main/kotlin/CustomBot.kt
+++ b/CustomBot/src/main/kotlin/CustomBot.kt
@@ -1,51 +0,0 @@
-import dev.inmo.kslog.common.KSLog
-import dev.inmo.kslog.common.LogLevel
-import dev.inmo.kslog.common.defaultMessageFormatter
-import dev.inmo.kslog.common.setDefaultKSLog
-import dev.inmo.micro_utils.coroutines.subscribeSafelyWithoutExceptions
-import dev.inmo.tgbotapi.extensions.api.bot.getMe
-import dev.inmo.tgbotapi.extensions.behaviour_builder.telegramBotWithBehaviourAndLongPolling
-import kotlinx.coroutines.CoroutineScope
-import kotlinx.coroutines.Dispatchers
-
-/**
- * This place can be the playground for your code.
- */
-suspend fun main(vararg args: String) {
-    val botToken = args.first()
-
-    val isDebug = args.any { it == "debug" }
-    val isTestServer = args.any { it == "testServer" }
-
-    if (isDebug) {
-        setDefaultKSLog(
-            KSLog { level: LogLevel, tag: String?, message: Any, throwable: Throwable? ->
-                println(defaultMessageFormatter(level, tag, message, throwable))
-            }
-        )
-    }
-
-    telegramBotWithBehaviourAndLongPolling(
-        botToken,
-        CoroutineScope(Dispatchers.IO),
-        testServer = isTestServer,
-        builder = {
-            includeMiddlewares {
-                addMiddleware {
-                    doOnRequestReturnResult { result, request, _ ->
-                        println("Result of $request:\n\n$result")
-                        null
-                    }
-                }
-            }
-        }
-    ) {
-        // start here!!
-        val me = getMe()
-        println(me)
-
-        allUpdatesFlow.subscribeSafelyWithoutExceptions(this) {
-            println(it)
-        }
-    }.second.join()
-}
--- a/DeepLinksBot/src/main/kotlin/DeepLinksBot.kt
+++ b/DeepLinksBot/src/main/kotlin/DeepLinksBot.kt
@@ -1,11 +1,11 @@
+import dev.inmo.micro_utils.coroutines.subscribeSafelySkippingExceptions
 import dev.inmo.micro_utils.coroutines.subscribeSafelyWithoutExceptions
+import dev.inmo.tgbotapi.bot.ktor.telegramBot
 import dev.inmo.tgbotapi.extensions.api.bot.getMe
 import dev.inmo.tgbotapi.extensions.api.send.reply
 import dev.inmo.tgbotapi.extensions.behaviour_builder.expectations.waitDeepLinks
 import dev.inmo.tgbotapi.extensions.behaviour_builder.telegramBotWithBehaviourAndLongPolling
-import dev.inmo.tgbotapi.extensions.behaviour_builder.triggers_handling.onCommand
-import dev.inmo.tgbotapi.extensions.behaviour_builder.triggers_handling.onDeepLink
-import dev.inmo.tgbotapi.extensions.behaviour_builder.triggers_handling.onText
+import dev.inmo.tgbotapi.extensions.behaviour_builder.triggers_handling.*
 import dev.inmo.tgbotapi.extensions.utils.formatting.makeTelegramDeepLink
 import dev.inmo.tgbotapi.types.message.textsources.BotCommandTextSource

--- a/FSMBot/src/main/kotlin/SimpleFSMBot.kt
+++ b/FSMBot/src/main/kotlin/SimpleFSMBot.kt
@@ -1,20 +1,20 @@
-import dev.inmo.micro_utils.coroutines.subscribeSafelyWithoutExceptions
+import dev.inmo.micro_utils.coroutines.AccumulatorFlow
 import dev.inmo.micro_utils.fsm.common.State
 import dev.inmo.tgbotapi.extensions.api.send.send
-import dev.inmo.tgbotapi.extensions.behaviour_builder.expectations.waitAnyContentMessage
-import dev.inmo.tgbotapi.extensions.behaviour_builder.telegramBotWithBehaviourAndFSMAndStartLongPolling
-import dev.inmo.tgbotapi.extensions.behaviour_builder.triggers_handling.command
-import dev.inmo.tgbotapi.extensions.behaviour_builder.triggers_handling.onContentMessage
-import dev.inmo.tgbotapi.extensions.utils.extensions.parseCommandsWithArgs
+import dev.inmo.tgbotapi.extensions.api.send.sendMessage
+import dev.inmo.tgbotapi.extensions.behaviour_builder.*
+import dev.inmo.tgbotapi.extensions.behaviour_builder.expectations.*
+import dev.inmo.tgbotapi.extensions.behaviour_builder.triggers_handling.*
+import dev.inmo.tgbotapi.extensions.utils.extensions.parseCommandsWithParams
 import dev.inmo.tgbotapi.extensions.utils.extensions.sameThread
-import dev.inmo.tgbotapi.extensions.utils.textContentOrNull
-import dev.inmo.tgbotapi.extensions.utils.withContentOrNull
+import dev.inmo.tgbotapi.extensions.utils.formatting.*
 import dev.inmo.tgbotapi.types.IdChatIdentifier
+import dev.inmo.tgbotapi.types.MessageThreadId
 import dev.inmo.tgbotapi.types.message.abstracts.CommonMessage
 import dev.inmo.tgbotapi.types.message.content.TextContent
 import dev.inmo.tgbotapi.utils.botCommand
-import kotlinx.coroutines.CoroutineScope
-import kotlinx.coroutines.Dispatchers
+import dev.inmo.tgbotapi.utils.extensions.threadIdOrNull
+import kotlinx.coroutines.*
 import kotlinx.coroutines.flow.filter
 import kotlinx.coroutines.flow.first

@@ -54,8 +54,7 @@ suspend fun main(args: Array<String>) {
            val content = contentMessage.content

            when {
-                content is TextContent && content.text == "/stop"
-                || content is TextContent && content.parseCommandsWithArgs().keys.contains("stop") -> StopState(it.context)
+                content is TextContent && content.parseCommandsWithParams().keys.contains("stop") -> StopState(it.context)
                else -> {
                    execute(content.createResend(it.context))
                    it
@@ -73,17 +72,5 @@ suspend fun main(args: Array<String>) {
        ) {
            startChain(ExpectContentOrStopState(it.chat.id, it))
        }
-
-        onContentMessage(
-            {
-                it.content.textContentOrNull() ?.text == "/start"
-            }
-        ) {
-            startChain(ExpectContentOrStopState(it.chat.id, it.withContentOrNull() ?: return@onContentMessage))
-        }
-
-        allUpdatesFlow.subscribeSafelyWithoutExceptions(this) {
-            println(it)
-        }
    }.second.join()
 }
--- a/FilesLoaderBot/src/main/kotlin/FilesLoaderBot.kt
+++ b/FilesLoaderBot/src/main/kotlin/FilesLoaderBot.kt
@@ -2,17 +2,38 @@ import dev.inmo.micro_utils.coroutines.subscribeSafelyWithoutExceptions
 import dev.inmo.tgbotapi.extensions.api.files.downloadFile
 import dev.inmo.tgbotapi.extensions.api.files.downloadFileToTemp
 import dev.inmo.tgbotapi.extensions.api.get.getFileAdditionalInfo
-import dev.inmo.tgbotapi.extensions.api.send.*
+import dev.inmo.tgbotapi.extensions.api.send.reply
+import dev.inmo.tgbotapi.extensions.api.send.replyWithAnimation
+import dev.inmo.tgbotapi.extensions.api.send.replyWithAudio
+import dev.inmo.tgbotapi.extensions.api.send.replyWithDocument
+import dev.inmo.tgbotapi.extensions.api.send.replyWithMediaGroup
+import dev.inmo.tgbotapi.extensions.api.send.replyWithPhoto
+import dev.inmo.tgbotapi.extensions.api.send.replyWithSticker
+import dev.inmo.tgbotapi.extensions.api.send.replyWithVideo
+import dev.inmo.tgbotapi.extensions.api.send.replyWithVideoNote
+import dev.inmo.tgbotapi.extensions.api.send.replyWithVoice
+import dev.inmo.tgbotapi.extensions.api.send.withAction
 import dev.inmo.tgbotapi.extensions.behaviour_builder.telegramBotWithBehaviourAndLongPolling
 import dev.inmo.tgbotapi.extensions.behaviour_builder.triggers_handling.onCommand
+import dev.inmo.tgbotapi.extensions.behaviour_builder.triggers_handling.onContentMessage
 import dev.inmo.tgbotapi.extensions.behaviour_builder.triggers_handling.onMedia
 import dev.inmo.tgbotapi.requests.abstracts.asMultipartFile
-import dev.inmo.tgbotapi.types.actions.*
+import dev.inmo.tgbotapi.requests.send.SendAction
+import dev.inmo.tgbotapi.types.actions.BotAction
+import dev.inmo.tgbotapi.types.actions.TypingAction
 import dev.inmo.tgbotapi.types.media.TelegramMediaAudio
 import dev.inmo.tgbotapi.types.media.TelegramMediaDocument
 import dev.inmo.tgbotapi.types.media.TelegramMediaPhoto
 import dev.inmo.tgbotapi.types.media.TelegramMediaVideo
-import dev.inmo.tgbotapi.types.message.content.*
+import dev.inmo.tgbotapi.types.message.content.AnimationContent
+import dev.inmo.tgbotapi.types.message.content.AudioContent
+import dev.inmo.tgbotapi.types.message.content.DocumentContent
+import dev.inmo.tgbotapi.types.message.content.MediaGroupContent
+import dev.inmo.tgbotapi.types.message.content.PhotoContent
+import dev.inmo.tgbotapi.types.message.content.StickerContent
+import dev.inmo.tgbotapi.types.message.content.VideoContent
+import dev.inmo.tgbotapi.types.message.content.VideoNoteContent
+import dev.inmo.tgbotapi.types.message.content.VoiceContent
 import dev.inmo.tgbotapi.utils.filenameFromUrl
 import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.Dispatchers
@@ -34,27 +55,13 @@ suspend fun main(args: Array<String>) {
            val content = it.content
            val pathedFile = bot.getFileAdditionalInfo(content.media)
            val outFile = File(directoryOrFile, pathedFile.filePath.filenameFromUrl)
-            withTypingAction(it.chat.id) {
-                runCatching {
-                    bot.downloadFile(content.media, outFile)
-                }.onFailure {
-                    it.printStackTrace()
-                }.onSuccess { _ ->
-                    reply(it, "Saved to ${outFile.absolutePath}")
-                }
+            runCatching {
+                bot.downloadFile(content.media, outFile)
+            }.onFailure {
+                it.printStackTrace()
            }.onSuccess { _ ->
-                val action = when (content) {
-                    is PhotoContent -> UploadPhotoAction
-                    is AnimationContent,
-                    is VideoContent -> UploadVideoAction
-                    is StickerContent -> ChooseStickerAction
-                    is MediaGroupContent<*> -> UploadPhotoAction
-                    is DocumentContent -> UploadDocumentAction
-                    is VoiceContent,
-                    is AudioContent -> RecordVoiceAction
-                    is VideoNoteContent -> UploadVideoNoteAction
-                }
-                withAction(it.chat.id, action) {
+                reply(it, "Saved to ${outFile.absolutePath}")
+                withAction(it.chat.id, TypingAction) {
                    when (content) {
                        is PhotoContent -> replyWithPhoto(
                            it,
--- a/GetMeBot/src/main/kotlin/GetMeBot.kt
+++ b/GetMeBot/src/main/kotlin/GetMeBot.kt
@@ -1,13 +1,15 @@
 import dev.inmo.kslog.common.KSLog
 import dev.inmo.kslog.common.LogLevel
 import dev.inmo.kslog.common.defaultMessageFormatter
+import dev.inmo.kslog.common.filter.filtered
 import dev.inmo.kslog.common.setDefaultKSLog
 import dev.inmo.tgbotapi.bot.ktor.telegramBot
 import dev.inmo.tgbotapi.extensions.api.bot.getMe
 import dev.inmo.tgbotapi.extensions.api.chat.get.getChat
+import dev.inmo.tgbotapi.utils.DefaultKTgBotAPIKSLog

 /**
- * This is one of the easiest bots - it will just print information about itself
+ * This is one of the most easiest bot - it will just print information about itself
 */
 suspend fun main(vararg args: String) {
    val botToken = args.first()
--- a/GiveawaysBot/README.md
+++ b/GiveawaysBot/README.md
@@ -1,9 +0,0 @@
-# CustomBot
-
-Printing giveaways
-
-## Launch
-
-```bash
-../gradlew run --args="BOT_TOKEN"
-```
--- a/GiveawaysBot/build.gradle
+++ b/GiveawaysBot/build.gradle
@@ -1,21 +0,0 @@
-buildscript {
-    repositories {
-        mavenCentral()
-    }
-
-    dependencies {
-        classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:$kotlin_version"
-    }
-}
-
-apply plugin: 'kotlin'
-apply plugin: 'application'
-
-mainClassName="GiveawaysBotKt"
-
-
-dependencies {
-    implementation "org.jetbrains.kotlin:kotlin-stdlib:$kotlin_version"
-
-    implementation "dev.inmo:tgbotapi:$telegram_bot_api_version"
-}
--- a/GiveawaysBot/src/main/kotlin/GiveawaysBot.kt
+++ b/GiveawaysBot/src/main/kotlin/GiveawaysBot.kt
@@ -1,57 +0,0 @@
-import dev.inmo.kslog.common.KSLog
-import dev.inmo.kslog.common.LogLevel
-import dev.inmo.kslog.common.defaultMessageFormatter
-import dev.inmo.kslog.common.setDefaultKSLog
-import dev.inmo.micro_utils.coroutines.subscribeSafelyWithoutExceptions
-import dev.inmo.tgbotapi.extensions.api.bot.getMe
-import dev.inmo.tgbotapi.extensions.behaviour_builder.telegramBotWithBehaviourAndLongPolling
-import dev.inmo.tgbotapi.extensions.behaviour_builder.triggers_handling.onGiveawayCompleted
-import dev.inmo.tgbotapi.extensions.behaviour_builder.triggers_handling.onGiveawayContent
-import dev.inmo.tgbotapi.extensions.behaviour_builder.triggers_handling.onGiveawayCreated
-import dev.inmo.tgbotapi.extensions.behaviour_builder.triggers_handling.onGiveawayWinners
-import kotlinx.coroutines.CoroutineScope
-import kotlinx.coroutines.Dispatchers
-
-/**
- * This place can be the playground for your code.
- */
-suspend fun main(vararg args: String) {
-    val botToken = args.first()
-
-    val isDebug = args.any { it == "debug" }
-    val isTestServer = args.any { it == "testServer" }
-
-    if (isDebug) {
-        setDefaultKSLog(
-            KSLog { level: LogLevel, tag: String?, message: Any, throwable: Throwable? ->
-                println(defaultMessageFormatter(level, tag, message, throwable))
-            }
-        )
-    }
-
-    telegramBotWithBehaviourAndLongPolling(botToken, testServer = isTestServer) {
-        // start here!!
-        val me = getMe()
-        println(me)
-
-        onGiveawayCreated {
-            println(it)
-        }
-
-        onGiveawayCompleted {
-            println(it)
-        }
-
-        onGiveawayWinners {
-            println(it)
-        }
-
-        onGiveawayContent {
-            println(it)
-        }
-
-//        allUpdatesFlow.subscribeSafelyWithoutExceptions(this) {
-//            println(it)
-//        }
-    }.second.join()
-}
--- a/HelloBot/src/main/kotlin/HelloBot.kt
+++ b/HelloBot/src/main/kotlin/HelloBot.kt
@@ -1,21 +1,23 @@
 import dev.inmo.micro_utils.coroutines.subscribeSafelyWithoutExceptions
 import dev.inmo.tgbotapi.extensions.api.bot.getMe
 import dev.inmo.tgbotapi.extensions.api.chat.get.getChat
-import dev.inmo.tgbotapi.extensions.api.send.reply
+import dev.inmo.tgbotapi.extensions.api.send.*
 import dev.inmo.tgbotapi.extensions.behaviour_builder.telegramBotWithBehaviourAndLongPolling
 import dev.inmo.tgbotapi.extensions.behaviour_builder.triggers_handling.onContentMessage
 import dev.inmo.tgbotapi.extensions.behaviour_builder.triggers_handling.onMentionWithAnyContent
 import dev.inmo.tgbotapi.extensions.utils.extensions.raw.sender_chat
-import dev.inmo.tgbotapi.extensions.utils.extensions.raw.text
 import dev.inmo.tgbotapi.extensions.utils.formatting.linkMarkdownV2
 import dev.inmo.tgbotapi.extensions.utils.formatting.textMentionMarkdownV2
+import dev.inmo.tgbotapi.extensions.utils.ifChannelChat
 import dev.inmo.tgbotapi.extensions.utils.ifFromChannelGroupContentMessage
 import dev.inmo.tgbotapi.types.chat.*
+import dev.inmo.tgbotapi.types.chat.GroupChat
+import dev.inmo.tgbotapi.types.chat.PrivateChat
+import dev.inmo.tgbotapi.types.chat.SupergroupChat
 import dev.inmo.tgbotapi.types.message.MarkdownV2
 import dev.inmo.tgbotapi.utils.PreviewFeature
 import dev.inmo.tgbotapi.utils.extensions.escapeMarkdownV2Common
-import kotlinx.coroutines.CoroutineScope
-import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.*

 /**
 * The main purpose of this bot is just to answer "Oh, hi, " and add user mention here
@@ -26,35 +28,24 @@ suspend fun main(vararg args: String) {

    telegramBotWithBehaviourAndLongPolling(botToken, CoroutineScope(Dispatchers.IO)) {
        val me = getMe()
-        onContentMessage(
-            initialFilter = initialFilter@{ it.text ?.contains(me.username ?.full ?: return@initialFilter false) == true }
-        ) { message ->
+        onMentionWithAnyContent(me) { message ->
+            val chat = message.chat
+
            val answerText = when (val chat = message.chat) {
                is PreviewChannelChat -> {
-                    val sender = message.sender_chat
-                    val answer = "Hi everybody in this channel \"${chat.title}\"" + if (sender != null) {
-                        " and you, " + when (sender) {
-                            is BusinessChat -> "business chat (wat) ${sender.original}"
-                            is PrivateChat -> "${sender.lastName} ${sender.firstName}"
-                            is GroupChat -> "group ${sender.title}"
-                            is ChannelChat ->  "channel ${sender.title}"
-                            is UnknownChatType -> "wat chat (${sender})"
-                        }
-                    } else {
-                        ""
-                    }
-                    reply(message, answer.escapeMarkdownV2Common(), MarkdownV2)
-                    return@onContentMessage
+                    val answer = "Hi everybody in this channel \"${chat.title}\""
+                    reply(message, answer, MarkdownV2)
+                    return@onMentionWithAnyContent
                }
                is PreviewPrivateChat -> {
                    reply(message, "Hi, " + "${chat.firstName} ${chat.lastName}".textMentionMarkdownV2(chat.id), MarkdownV2)
-                    return@onContentMessage
+                    return@onMentionWithAnyContent
                }
                is PreviewGroupChat -> {
-                    message.ifFromChannelGroupContentMessage<Unit> {
+                    message.ifFromChannelGroupContentMessage {
                        val answer = "Hi, ${it.senderChat.title}"
                        reply(message, answer, MarkdownV2)
-                        return@onContentMessage
+                        return@onMentionWithAnyContent
                    }
                    "Oh, hi, " + when (chat) {
                        is SupergroupChat -> (chat.username ?.username ?: getChat(chat).inviteLink) ?.let {
@@ -65,10 +56,6 @@ suspend fun main(vararg args: String) {
                        } ?: chat.title
                    }
                }
-                is PreviewBusinessChat -> {
-                    reply(message, "Hi, " + "${chat.original.firstName} ${chat.original.lastName} (as business chat :) )".textMentionMarkdownV2(chat.original.id), MarkdownV2)
-                    return@onContentMessage
-                }
                is UnknownChatType -> "Unknown :(".escapeMarkdownV2Common()
            }
            reply(
--- a/InlineQueriesBot/build.gradle
+++ b/InlineQueriesBot/build.gradle
@@ -33,6 +33,6 @@ kotlin {
 }

 dependencies {
-    implementation 'io.ktor:ktor-client-logging-jvm:2.3.12'
+    implementation 'io.ktor:ktor-client-logging-jvm:2.3.7'
 }

--- a/InlineQueriesBot/src/commonMain/kotlin/Bot.kt
+++ b/InlineQueriesBot/src/commonMain/kotlin/Bot.kt
@@ -9,7 +9,6 @@ import dev.inmo.tgbotapi.extensions.behaviour_builder.triggers_handling.onDeepLi
 import dev.inmo.tgbotapi.requests.answers.InlineQueryResultsButton
 import dev.inmo.tgbotapi.types.InlineQueries.InlineQueryResult.InlineQueryResultArticle
 import dev.inmo.tgbotapi.types.InlineQueries.InputMessageContent.InputTextMessageContent
-import dev.inmo.tgbotapi.types.InlineQueryId
 import dev.inmo.tgbotapi.types.inlineQueryAnswerResultsLimit
 import dev.inmo.tgbotapi.utils.buildEntities

@@ -32,9 +31,9 @@ suspend fun doInlineQueriesBot(token: String) {
            answer(
                it,
                results = results.map { resultNumber ->
-                    val inlineQueryId = InlineQueryId(resultNumber.toString())
+                    val resultAsString = resultNumber.toString()
                    InlineQueryResultArticle(
-                        inlineQueryId,
+                        resultAsString,
                        "Title $resultNumber",
                        InputTextMessageContent(
                            buildEntities {
--- a/InlineQueriesBot/src/jvmMain/kotlin/InlineQueriesBot.kt
+++ b/InlineQueriesBot/src/jvmMain/kotlin/InlineQueriesBot.kt
@@ -1,3 +1,5 @@
+import dev.inmo.micro_utils.common.MPPFile
+
 suspend fun main(args: Array<String>) {
    doInlineQueriesBot(args.first())
 }
--- a/KeyboardsBot/KeyboardsBotLib/src/commonMain/kotlin/KeyboardsBot.kt
+++ b/KeyboardsBot/KeyboardsBotLib/src/commonMain/kotlin/KeyboardsBot.kt
@@ -1,27 +1,26 @@
 import dev.inmo.micro_utils.coroutines.subscribeSafelyWithoutExceptions
+import dev.inmo.tgbotapi.extensions.api.bot.getMe
 import dev.inmo.tgbotapi.bot.ktor.telegramBot
 import dev.inmo.tgbotapi.extensions.api.answers.answer
-import dev.inmo.tgbotapi.extensions.api.bot.getMe
 import dev.inmo.tgbotapi.extensions.api.bot.setMyCommands
 import dev.inmo.tgbotapi.extensions.api.edit.edit
+import dev.inmo.tgbotapi.extensions.api.edit.editMessageText
+import dev.inmo.tgbotapi.extensions.api.edit.reply_markup.editMessageReplyMarkup
 import dev.inmo.tgbotapi.extensions.api.edit.text.editMessageText
-import dev.inmo.tgbotapi.extensions.api.send.reply
-import dev.inmo.tgbotapi.extensions.behaviour_builder.buildBehaviourWithLongPolling
+import dev.inmo.tgbotapi.extensions.api.send.*
+import dev.inmo.tgbotapi.extensions.behaviour_builder.*
 import dev.inmo.tgbotapi.extensions.behaviour_builder.triggers_handling.*
 import dev.inmo.tgbotapi.extensions.utils.types.buttons.*
 import dev.inmo.tgbotapi.extensions.utils.withContent
 import dev.inmo.tgbotapi.types.BotCommand
 import dev.inmo.tgbotapi.types.InlineQueries.InlineQueryResult.InlineQueryResultArticle
 import dev.inmo.tgbotapi.types.InlineQueries.InputMessageContent.InputTextMessageContent
-import dev.inmo.tgbotapi.types.InlineQueryId
 import dev.inmo.tgbotapi.types.message.content.TextContent
-import dev.inmo.tgbotapi.utils.PreviewFeature
-import dev.inmo.tgbotapi.utils.botCommand
-import dev.inmo.tgbotapi.utils.regular
-import dev.inmo.tgbotapi.utils.row
-import kotlinx.coroutines.CoroutineScope
-import kotlinx.coroutines.SupervisorJob
-import kotlinx.coroutines.currentCoroutineContext
+import dev.inmo.tgbotapi.utils.*
+import kotlinx.coroutines.*
+
+private const val nextPageData = "next"
+private const val previousPageData = "previous"

 fun String.parsePageAndCount(): Pair<Int, Int>? {
    val (pageString, countString) = split(" ").takeIf { it.count() > 1 } ?: return null
@@ -45,9 +44,6 @@ fun InlineKeyboardBuilder.includePageButtons(page: Int, count: Int) {
            }
        }
    }
-    row {
-        copyTextButton("Command copy button", "/inline $page $count")
-    }

    row {
        if (page - 1 > 2) {
@@ -76,7 +72,6 @@ fun InlineKeyboardBuilder.includePageButtons(page: Int, count: Int) {
    }
 }

-@OptIn(PreviewFeature::class)
 suspend fun activateKeyboardsBot(
    token: String,
    print: (Any) -> Unit
@@ -87,13 +82,11 @@ suspend fun activateKeyboardsBot(

    bot.buildBehaviourWithLongPolling(CoroutineScope(currentCoroutineContext() + SupervisorJob())) {
        onCommandWithArgs("inline") { message, args ->
-            val numberArgs = args.mapNotNull { it.toIntOrNull() }
-            val numberOfPages = numberArgs.getOrNull(1) ?: numberArgs.firstOrNull() ?: 10
-            val page = numberArgs.firstOrNull() ?.takeIf { numberArgs.size > 1 } ?.coerceAtLeast(1) ?: 1
+            val numberOfPages = args.firstOrNull() ?.toIntOrNull() ?: 10
            reply(
                message,
                replyMarkup = inlineKeyboard {
-                    includePageButtons(page, numberOfPages)
+                    includePageButtons(1, numberOfPages)
                }
            ) {
                regular("Your inline keyboard with $numberOfPages pages")
@@ -144,7 +137,7 @@ suspend fun activateKeyboardsBot(
                it,
                results = listOf(
                    InlineQueryResultArticle(
-                        InlineQueryId(it.query),
+                        it.query,
                        "Send buttons",
                        InputTextMessageContent("It is sent via inline mode inline buttons"),
                        replyMarkup = inlineKeyboard {
--- a/KeyboardsBot/jvm_launcher/src/main/kotlin/KeyboardsBotJvm.kt
+++ b/KeyboardsBot/jvm_launcher/src/main/kotlin/KeyboardsBotJvm.kt
@@ -1,21 +1,7 @@
-import dev.inmo.kslog.common.KSLog
-import dev.inmo.kslog.common.LogLevel
-import dev.inmo.kslog.common.defaultMessageFormatter
-import dev.inmo.kslog.common.setDefaultKSLog
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.withContext

 suspend fun main(args: Array<String>) {
-    val isDebug = args.any { it == "debug" }
-
-    if (isDebug) {
-        setDefaultKSLog(
-            KSLog { level: LogLevel, tag: String?, message: Any, throwable: Throwable? ->
-                println(defaultMessageFormatter(level, tag, message, throwable))
-            }
-        )
-    }
-
    withContext(Dispatchers.IO) { // IO for inheriting of it in side of activateKeyboardsBot
        activateKeyboardsBot(args.first()) {
            println(it)
--- a/LinkPreviewsBot/src/main/kotlin/LinkPreviewsBot.kt
+++ b/LinkPreviewsBot/src/main/kotlin/LinkPreviewsBot.kt
@@ -3,15 +3,24 @@ import dev.inmo.kslog.common.LogLevel
 import dev.inmo.kslog.common.defaultMessageFormatter
 import dev.inmo.kslog.common.setDefaultKSLog
 import dev.inmo.tgbotapi.bot.ktor.telegramBot
+import dev.inmo.tgbotapi.extensions.api.chat.get.getChat
+import dev.inmo.tgbotapi.extensions.api.send.copyMessage
 import dev.inmo.tgbotapi.extensions.api.send.reply
 import dev.inmo.tgbotapi.extensions.api.send.send
+import dev.inmo.tgbotapi.extensions.api.send.setMessageReaction
 import dev.inmo.tgbotapi.extensions.behaviour_builder.buildBehaviourWithLongPolling
+import dev.inmo.tgbotapi.extensions.behaviour_builder.triggers_handling.onChatMessageReactionUpdatedByUser
+import dev.inmo.tgbotapi.extensions.behaviour_builder.triggers_handling.onChatMessageReactionsCountUpdated
 import dev.inmo.tgbotapi.extensions.behaviour_builder.triggers_handling.onContentMessage
 import dev.inmo.tgbotapi.extensions.utils.textLinkTextSourceOrNull
 import dev.inmo.tgbotapi.extensions.utils.uRLTextSourceOrNull
 import dev.inmo.tgbotapi.extensions.utils.withContentOrNull
 import dev.inmo.tgbotapi.types.LinkPreviewOptions
+import dev.inmo.tgbotapi.types.chat.ExtendedChat
+import dev.inmo.tgbotapi.types.message.content.TextContent
 import dev.inmo.tgbotapi.types.message.content.TextedContent
+import dev.inmo.tgbotapi.types.reactions.Reaction
+import dev.inmo.tgbotapi.utils.customEmoji
 import dev.inmo.tgbotapi.utils.regular

 /**
@@ -32,17 +41,17 @@ suspend fun main(vararg args: String) {
    val bot = telegramBot(botToken)

    bot.buildBehaviourWithLongPolling {
-        onContentMessage { contentMessage ->
-            val url = contentMessage.withContentOrNull<TextedContent>() ?.let { message ->
-                message.content.textSources.firstNotNullOfOrNull {
+        onContentMessage {
+            val url = it.withContentOrNull<TextedContent>() ?.let {
+                it.content.textSources.firstNotNullOfOrNull {
                    it.textLinkTextSourceOrNull() ?.url ?: it.uRLTextSourceOrNull() ?.source
                }
            } ?: null.apply {
-                reply(contentMessage) {
+                reply(it) {
                    regular("I am support only content with text contains url only")
                }
            } ?: return@onContentMessage
-            contentMessage.withContentOrNull<TextedContent>() ?.let {
+            it.withContentOrNull<TextedContent>() ?.let {
                send(
                    it.chat,
                    it.content.textSources,
--- a/LiveLocationsBot/src/main/kotlin/LiveLocationsBot.kt
+++ b/LiveLocationsBot/src/main/kotlin/LiveLocationsBot.kt
@@ -1,15 +1,33 @@
 import dev.inmo.micro_utils.coroutines.subscribeSafelyWithoutExceptions
 import dev.inmo.tgbotapi.extensions.api.EditLiveLocationInfo
+import dev.inmo.tgbotapi.extensions.api.chat.get.getChat
+import dev.inmo.tgbotapi.extensions.api.edit.edit
 import dev.inmo.tgbotapi.extensions.api.edit.location.live.stopLiveLocation
 import dev.inmo.tgbotapi.extensions.api.handleLiveLocation
+import dev.inmo.tgbotapi.extensions.api.send.*
 import dev.inmo.tgbotapi.extensions.behaviour_builder.expectations.waitMessageDataCallbackQuery
+import dev.inmo.tgbotapi.extensions.behaviour_builder.oneOf
+import dev.inmo.tgbotapi.extensions.behaviour_builder.parallel
 import dev.inmo.tgbotapi.extensions.behaviour_builder.telegramBotWithBehaviourAndLongPolling
 import dev.inmo.tgbotapi.extensions.behaviour_builder.triggers_handling.onCommand
+import dev.inmo.tgbotapi.extensions.behaviour_builder.triggers_handling.onContentMessage
 import dev.inmo.tgbotapi.extensions.utils.extensions.sameMessage
+import dev.inmo.tgbotapi.extensions.utils.formatting.linkMarkdownV2
+import dev.inmo.tgbotapi.extensions.utils.formatting.textMentionMarkdownV2
+import dev.inmo.tgbotapi.extensions.utils.ifFromChannelGroupContentMessage
 import dev.inmo.tgbotapi.extensions.utils.types.buttons.dataButton
 import dev.inmo.tgbotapi.extensions.utils.types.buttons.flatInlineKeyboard
+import dev.inmo.tgbotapi.types.chat.*
+import dev.inmo.tgbotapi.types.chat.GroupChat
+import dev.inmo.tgbotapi.types.chat.PrivateChat
+import dev.inmo.tgbotapi.types.chat.SupergroupChat
+import dev.inmo.tgbotapi.types.location.LiveLocation
+import dev.inmo.tgbotapi.types.message.MarkdownV2
 import dev.inmo.tgbotapi.types.message.abstracts.ContentMessage
+import dev.inmo.tgbotapi.types.message.content.LiveLocationContent
 import dev.inmo.tgbotapi.types.message.content.LocationContent
+import dev.inmo.tgbotapi.utils.PreviewFeature
+import dev.inmo.tgbotapi.utils.extensions.escapeMarkdownV2Common
 import kotlinx.coroutines.*
 import kotlinx.coroutines.flow.FlowCollector
 import kotlinx.coroutines.flow.MutableStateFlow
@@ -46,7 +64,7 @@ suspend fun main(vararg args: String) {
                handleLiveLocation(
                    it.chat.id,
                    locationsFlow,
-                    sentMessageFlow = { currentMessageState.emit(it) },
+                    sentMessageFlow = FlowCollector { currentMessageState.emit(it) }
                )
            }

--- a/MemberUpdatedWatcherBot/README.md
+++ b/MemberUpdatedWatcherBot/README.md
@@ -1,10 +0,0 @@
-# MemberUpdatedWatcherBot
-
-This bot will watch for some ChatMemberUpdated events using new extensions from 18.0.0
-
-
-## Launch
-
-```bash
-../gradlew run --args="BOT_TOKEN"
-```
--- a/MemberUpdatedWatcherBot/build.gradle
+++ b/MemberUpdatedWatcherBot/build.gradle
@@ -1,21 +0,0 @@
-buildscript {
-    repositories {
-        mavenCentral()
-    }
-
-    dependencies {
-        classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:$kotlin_version"
-    }
-}
-
-apply plugin: 'kotlin'
-apply plugin: 'application'
-
-mainClassName="MemberUpdatedWatcherKt"
-
-
-dependencies {
-    implementation "org.jetbrains.kotlin:kotlin-stdlib:$kotlin_version"
-
-    implementation "dev.inmo:tgbotapi:$telegram_bot_api_version"
-}
--- a/MemberUpdatedWatcherBot/src/main/kotlin/MemberUpdatedWatcher.kt
+++ b/MemberUpdatedWatcherBot/src/main/kotlin/MemberUpdatedWatcher.kt
@@ -1,98 +0,0 @@
-import dev.inmo.kslog.common.*
-import dev.inmo.tgbotapi.extensions.api.*
-import dev.inmo.tgbotapi.extensions.api.bot.*
-import dev.inmo.tgbotapi.extensions.api.send.*
-import dev.inmo.tgbotapi.extensions.behaviour_builder.*
-import dev.inmo.tgbotapi.extensions.behaviour_builder.filters.chatMemberGotRestrictedFilter
-import dev.inmo.tgbotapi.extensions.behaviour_builder.filters.chatMemberGotRestrictionsChangedFilter
-import dev.inmo.tgbotapi.extensions.behaviour_builder.triggers_handling.*
-import dev.inmo.tgbotapi.extensions.behaviour_builder.utils.*
-import dev.inmo.tgbotapi.extensions.utils.*
-import dev.inmo.tgbotapi.types.chat.member.*
-import dev.inmo.tgbotapi.utils.*
-
-
-@OptIn(PreviewFeature::class)
-suspend fun main(args: Array<String>) {
-    val token = args.first()
-
-    val isDebug = args.any { it == "debug" }
-
-    if (isDebug) {
-        setDefaultKSLog(
-            KSLog { level: LogLevel, tag: String?, message: Any, throwable: Throwable? ->
-                println(defaultMessageFormatter(level, tag, message, throwable))
-            }
-        )
-    }
-
-    val internalLogger = KSLog { level: LogLevel, tag: String?, message: Any, throwable: Throwable? ->
-        println(defaultMessageFormatter(level, tag ?: "ChatMemberUpdates", message, throwable))
-    }
-
-    val bot = telegramBot(token)
-
-    bot.buildBehaviourWithLongPolling {
-        val me = getMe()
-        val filterSelfUpdates = SimpleFilter<ChatMemberUpdated> {
-            it.member.id == me.id
-        }
-
-        // This bot updates
-        onChatMemberJoined(initialFilter = filterSelfUpdates) {
-            internalLogger.i("Bot was added to chat")
-            send(it.chat.id, "I was added to chat. Please grant me admin permissions to make me able to watch other users' events")
-        }
-
-        onChatMemberGotPromoted(initialFilter = filterSelfUpdates) {
-            internalLogger.i("Bot was granted admin permissions")
-            send(it.chat.id, "I was promoted to admin. I now can watch other users' events")
-        }
-
-        onChatMemberGotDemoted(initialFilter = filterSelfUpdates) {
-            internalLogger.i("Admin permissions were revoked")
-            send(it.chat.id, "I'm no longer an admin. Admin permissions are required to watch other users' events")
-        }
-
-        // All users updates
-        onChatMemberJoined {
-            val member = it.member
-            internalLogger.i("${member.firstName} joined the chat: ${it.oldChatMemberState::class.simpleName} => ${it.newChatMemberState::class.simpleName}")
-            send(it.chat.id, "Welcome ${member.firstName}")
-        }
-
-        onChatMemberLeft {
-            val member = it.member
-            internalLogger.i("${member.firstName} left the chat: ${it.oldChatMemberState::class.simpleName} => ${it.newChatMemberState::class.simpleName}")
-            send(it.chat.id, "Goodbye ${member.firstName}")
-        }
-
-        onChatMemberGotPromoted {
-            val newState = it.newChatMemberState.administratorChatMemberOrThrow()
-            internalLogger.i("${newState.user.firstName} got promoted to ${newState.customTitle ?: "Admin"}: ${it.oldChatMemberState::class.simpleName} => ${it.newChatMemberState::class.simpleName}")
-            send(it.chat.id, "${newState.user.firstName} is now an ${newState.customTitle ?: "Admin"}")
-        }
-
-        onChatMemberGotDemoted {
-            val member = it.member
-            internalLogger.i("${member.firstName} got demoted: ${it.oldChatMemberState::class.simpleName} => ${it.newChatMemberState::class.simpleName}")
-            send(it.chat.id, "${member.firstName} is now got demoted back to member")
-        }
-
-        onChatMemberGotPromotionChanged {
-            val member = it.member
-            val message = "${member.firstName} has the permissions changed: ${it.oldChatMemberState::class.simpleName} => ${it.newChatMemberState::class.simpleName}"
-            internalLogger.i(message)
-            send(it.chat.id, message)
-        }
-
-        onChatMemberUpdated(
-            initialFilter = chatMemberGotRestrictedFilter + chatMemberGotRestrictionsChangedFilter,
-        ) {
-            val member = it.member
-            val message = "${member.firstName} has the permissions changed: ${it.oldChatMemberState::class.simpleName} => ${it.newChatMemberState::class.simpleName}"
-            internalLogger.i(message)
-            send(it.chat.id, message)
-        }
-    }.join()
-}
--- a/PollsBot/src/main/kotlin/PollsBot.kt
+++ b/PollsBot/src/main/kotlin/PollsBot.kt
@@ -1,78 +1,58 @@
-import dev.inmo.kslog.common.KSLog
-import dev.inmo.kslog.common.LogLevel
-import dev.inmo.kslog.common.defaultMessageFormatter
-import dev.inmo.kslog.common.setDefaultKSLog
+import com.benasher44.uuid.uuid4
 import dev.inmo.micro_utils.coroutines.subscribeSafelyWithoutExceptions
-import dev.inmo.tgbotapi.extensions.api.bot.setMyCommands
-import dev.inmo.tgbotapi.extensions.api.send.polls.sendQuizPoll
+import dev.inmo.tgbotapi.extensions.api.bot.getMe
+import dev.inmo.tgbotapi.extensions.api.chat.get.getChat
+import dev.inmo.tgbotapi.extensions.api.send.*
 import dev.inmo.tgbotapi.extensions.api.send.polls.sendRegularPoll
-import dev.inmo.tgbotapi.extensions.api.send.send
 import dev.inmo.tgbotapi.extensions.behaviour_builder.telegramBotWithBehaviourAndLongPolling
-import dev.inmo.tgbotapi.extensions.behaviour_builder.triggers_handling.onCommand
-import dev.inmo.tgbotapi.extensions.behaviour_builder.triggers_handling.onPollAnswer
-import dev.inmo.tgbotapi.extensions.behaviour_builder.triggers_handling.onPollUpdates
-import dev.inmo.tgbotapi.extensions.utils.customEmojiTextSourceOrNull
-import dev.inmo.tgbotapi.extensions.utils.extensions.parseCommandsWithArgsSources
-import dev.inmo.tgbotapi.types.BotCommand
+import dev.inmo.tgbotapi.extensions.behaviour_builder.triggers_handling.*
+import dev.inmo.tgbotapi.extensions.utils.extensions.raw.sender_chat
+import dev.inmo.tgbotapi.extensions.utils.formatting.linkMarkdownV2
+import dev.inmo.tgbotapi.extensions.utils.formatting.textMentionMarkdownV2
+import dev.inmo.tgbotapi.extensions.utils.ifChannelChat
+import dev.inmo.tgbotapi.extensions.utils.ifFromChannelGroupContentMessage
+import dev.inmo.tgbotapi.types.ChatId
 import dev.inmo.tgbotapi.types.IdChatIdentifier
-import dev.inmo.tgbotapi.types.PollId
+import dev.inmo.tgbotapi.types.PollIdentifier
 import dev.inmo.tgbotapi.types.ReplyParameters
-import dev.inmo.tgbotapi.types.polls.InputPollOption
+import dev.inmo.tgbotapi.types.chat.*
+import dev.inmo.tgbotapi.types.chat.GroupChat
+import dev.inmo.tgbotapi.types.chat.PrivateChat
+import dev.inmo.tgbotapi.types.chat.SupergroupChat
+import dev.inmo.tgbotapi.types.message.MarkdownV2
+import dev.inmo.tgbotapi.types.polls.Poll
 import dev.inmo.tgbotapi.types.polls.PollAnswer
-import dev.inmo.tgbotapi.utils.buildEntities
-import dev.inmo.tgbotapi.utils.customEmoji
-import dev.inmo.tgbotapi.utils.regular
-import dev.inmo.tgbotapi.utils.underline
-import kotlinx.coroutines.CoroutineScope
-import kotlinx.coroutines.Dispatchers
+import dev.inmo.tgbotapi.types.polls.PollOption
+import dev.inmo.tgbotapi.types.polls.RegularPoll
+import dev.inmo.tgbotapi.utils.PreviewFeature
+import dev.inmo.tgbotapi.utils.extensions.escapeMarkdownV2Common
+import kotlinx.coroutines.*
 import kotlinx.coroutines.sync.Mutex
 import kotlinx.coroutines.sync.withLock
-import kotlin.random.Random

 /**
 * This bot will answer with anonymous or public poll and send message on
- * any update.
+ * updates of any of it.
 * 
 * * Use `/anonymous` to take anonymous regular poll
 * * Use `/public` to take public regular poll
 */
+@OptIn(PreviewFeature::class)
 suspend fun main(vararg args: String) {
    val botToken = args.first()
-    val isDebug = args.any { it == "debug" }
-
-    if (isDebug) {
-        setDefaultKSLog(
-            KSLog { level: LogLevel, tag: String?, message: Any, throwable: Throwable? ->
-                println(defaultMessageFormatter(level, tag, message, throwable))
-            }
-        )
-    }

    telegramBotWithBehaviourAndLongPolling(botToken, CoroutineScope(Dispatchers.IO)) {
-        val pollToChat = mutableMapOf<PollId, IdChatIdentifier>()
+        val me = getMe()
+
+        val pollToChat = mutableMapOf<PollIdentifier, IdChatIdentifier>()
        val pollToChatMutex = Mutex()

-        onCommand("anonymous", requireOnlyCommandInMessage = false) {
-            val customEmoji = it.content.parseCommandsWithArgsSources()
-                .toList()
-                .firstOrNull { it.first.command == "anonymous" }
-                ?.second
-                ?.firstNotNullOfOrNull { it.customEmojiTextSourceOrNull() }
+        onCommand("anonymous") {
            val sentPoll = sendRegularPoll(
-                it.chat.id,
-                buildEntities {
-                    regular("Test regular anonymous poll")
-                    if (customEmoji != null) {
-                        customEmoji(customEmoji.customEmojiId, customEmoji.subsources)
-                    }
-                },
+                it.chat,
+                "Test regular anonymous poll",
                (1 .. 10).map {
-                    InputPollOption {
-                        regular(it.toString()) + " "
-                        if (customEmoji != null) {
-                            customEmoji(customEmoji.customEmojiId, customEmoji.subsources)
-                        }
-                    }
+                    it.toString()
                },
                isAnonymous = true,
                replyParameters = ReplyParameters(it)
@@ -82,27 +62,12 @@ suspend fun main(vararg args: String) {
            }
        }

-        onCommand("public", requireOnlyCommandInMessage = false) {
-            val customEmoji = it.content.parseCommandsWithArgsSources()
-                .toList()
-                .firstOrNull { it.first.command == "public" }
-                ?.second
-                ?.firstNotNullOfOrNull { it.customEmojiTextSourceOrNull() }
+        onCommand("public") {
            val sentPoll = sendRegularPoll(
-                it.chat.id,
-                buildEntities {
-                    regular("Test regular non anonymous poll")
-                    if (customEmoji != null) {
-                        customEmoji(customEmoji.customEmojiId, customEmoji.subsources)
-                    }
-                },
+                it.chat,
+                "Test regular anonymous poll",
                (1 .. 10).map {
-                    InputPollOption {
-                        regular(it.toString()) + " "
-                        if (customEmoji != null) {
-                            customEmoji(customEmoji.customEmojiId, customEmoji.subsources)
-                        }
-                    }
+                    it.toString()
                },
                isAnonymous = false,
                replyParameters = ReplyParameters(it)
@@ -112,44 +77,6 @@ suspend fun main(vararg args: String) {
            }
        }

-        onCommand("quiz", requireOnlyCommandInMessage = false) {
-            val customEmoji = it.content.parseCommandsWithArgsSources()
-                .toList()
-                .firstOrNull { it.first.command == "quiz" }
-                ?.second
-                ?.firstNotNullOfOrNull { it.customEmojiTextSourceOrNull() }
-            val correctAnswer = Random.nextInt(10)
-            val sentPoll = sendQuizPoll(
-                it.chat.id,
-                questionEntities = buildEntities {
-                    regular("Test quiz poll")
-                    if (customEmoji != null) {
-                        customEmoji(customEmoji.customEmojiId, customEmoji.subsources)
-                    }
-                },
-                (1 .. 10).map {
-                    InputPollOption {
-                        regular(it.toString()) + " "
-                        if (customEmoji != null) {
-                            customEmoji(customEmoji.customEmojiId, customEmoji.subsources)
-                        }
-                    }
-                },
-                isAnonymous = false,
-                replyParameters = ReplyParameters(it),
-                correctOptionId = correctAnswer,
-                explanationTextSources = buildEntities {
-                    regular("Random solved it to be ") + underline((correctAnswer + 1).toString()) + " "
-                    if (customEmoji != null) {
-                        customEmoji(customEmoji.customEmojiId, customEmoji.subsources)
-                    }
-                }
-            )
-            pollToChatMutex.withLock {
-                pollToChat[sentPoll.content.poll.id] = sentPoll.chat.id
-            }
-        }
-
        onPollAnswer {
            val chatId = pollToChat[it.pollId] ?: return@onPollAnswer

@@ -168,12 +95,6 @@ suspend fun main(vararg args: String) {
            }
        }

-        setMyCommands(
-            BotCommand("anonymous", "Create anonymous regular poll"),
-            BotCommand("public", "Create non anonymous regular poll"),
-            BotCommand("quiz", "Create quiz poll with random right answer"),
-        )
-
        allUpdatesFlow.subscribeSafelyWithoutExceptions(this) { println(it) }
    }.second.join()
 }
--- a/RandomFileSenderBot/src/commonMain/kotlin/PickFile.kt
+++ b/RandomFileSenderBot/src/commonMain/kotlin/PickFile.kt
--- a/ReactionsInfoBot/src/main/kotlin/ReactionsInfoBot.kt
+++ b/ReactionsInfoBot/src/main/kotlin/ReactionsInfoBot.kt
@@ -6,6 +6,7 @@ import dev.inmo.tgbotapi.bot.ktor.telegramBot
 import dev.inmo.tgbotapi.extensions.api.chat.get.getChat
 import dev.inmo.tgbotapi.extensions.api.send.reply
 import dev.inmo.tgbotapi.extensions.api.send.setMessageReaction
+import dev.inmo.tgbotapi.extensions.api.send.setMessageReactions
 import dev.inmo.tgbotapi.extensions.behaviour_builder.buildBehaviourWithLongPolling
 import dev.inmo.tgbotapi.extensions.behaviour_builder.triggers_handling.onChatMessageReactionUpdatedByUser
 import dev.inmo.tgbotapi.extensions.behaviour_builder.triggers_handling.onChatMessageReactionsCountUpdated
@@ -48,7 +49,6 @@ suspend fun main(vararg args: String) {
                    when (it) {
                        is Reaction.CustomEmoji -> regular("• ") + customEmoji(it.customEmojiId) + regular("(customEmojiId: ${it.customEmojiId})")
                        is Reaction.Emoji -> regular("• ${it.emoji}")
-                        is Reaction.Paid -> regular("• Some paid reaction")
                        is Reaction.Unknown -> regular("• Unknown emoji ($it)")
                    }
                    regular("\n")
--- a/ResenderBot/ResenderBotLib/src/commonMain/kotlin/ResenderBot.kt
+++ b/ResenderBot/ResenderBotLib/src/commonMain/kotlin/ResenderBot.kt
@@ -1,19 +1,19 @@
 import dev.inmo.micro_utils.coroutines.subscribeSafelyWithoutExceptions
 import dev.inmo.tgbotapi.extensions.api.bot.getMe
-import dev.inmo.tgbotapi.extensions.api.send.withTypingAction
+import dev.inmo.tgbotapi.bot.ktor.telegramBot
+import dev.inmo.tgbotapi.extensions.api.send.*
+import dev.inmo.tgbotapi.extensions.api.send.media.*
+import dev.inmo.tgbotapi.extensions.behaviour_builder.*
+import dev.inmo.tgbotapi.extensions.behaviour_builder.filters.CommonMessageFilterExcludeMediaGroups
 import dev.inmo.tgbotapi.extensions.behaviour_builder.filters.MessageFilterByChat
-import dev.inmo.tgbotapi.extensions.behaviour_builder.telegramBotWithBehaviourAndLongPolling
-import dev.inmo.tgbotapi.extensions.behaviour_builder.triggers_handling.onContentMessage
-import dev.inmo.tgbotapi.extensions.utils.possiblyWithEffectMessageOrNull
-import dev.inmo.tgbotapi.extensions.utils.shortcuts.executeUnsafe
+import dev.inmo.tgbotapi.extensions.behaviour_builder.triggers_handling.*
+import dev.inmo.tgbotapi.extensions.utils.shortcuts.*
 import dev.inmo.tgbotapi.extensions.utils.withContentOrNull
 import dev.inmo.tgbotapi.types.ReplyParameters
-import dev.inmo.tgbotapi.types.message.abstracts.BusinessContentMessage
 import dev.inmo.tgbotapi.types.message.content.TextContent
+import dev.inmo.tgbotapi.types.quoteEntitiesField
 import dev.inmo.tgbotapi.utils.extensions.threadIdOrNull
-import kotlinx.coroutines.CoroutineScope
-import kotlinx.coroutines.SupervisorJob
-import kotlinx.coroutines.currentCoroutineContext
+import kotlinx.coroutines.*

 suspend fun activateResenderBot(
    token: String,
@@ -22,7 +22,6 @@ suspend fun activateResenderBot(
    telegramBotWithBehaviourAndLongPolling(token, scope = CoroutineScope(currentCoroutineContext() + SupervisorJob())) {
        onContentMessage(
            subcontextUpdatesFilter = MessageFilterByChat,
-            initialFilter = { it !is BusinessContentMessage<*> || !it.sentByBusinessConnectionOwner }
        ) {
            val chat = it.chat

@@ -38,8 +37,7 @@ suspend fun activateResenderBot(
                                entities = quote ?.textSources ?: emptyList(),
                                quotePosition = quote ?.position
                            )
-                        },
-                        effectId = it.possiblyWithEffectMessageOrNull() ?.effectId
+                        }
                    )
                ) {
                    it.forEach(print)
--- a/RightsChangerBot/build.gradle
+++ b/RightsChangerBot/build.gradle
@@ -18,5 +18,5 @@ dependencies {
    implementation "org.jetbrains.kotlin:kotlin-stdlib:$kotlin_version"

    implementation "dev.inmo:tgbotapi:$telegram_bot_api_version"
-    implementation 'io.ktor:ktor-client-logging-jvm:2.3.12'
+    implementation 'io.ktor:ktor-client-logging-jvm:2.3.7'
 }
--- a/RightsChangerBot/src/main/kotlin/RightsChanger.kt
+++ b/RightsChangerBot/src/main/kotlin/RightsChanger.kt
@@ -16,9 +16,7 @@ import dev.inmo.tgbotapi.extensions.api.send.reply
 import dev.inmo.tgbotapi.extensions.api.send.send
 import dev.inmo.tgbotapi.extensions.behaviour_builder.BehaviourContext
 import dev.inmo.tgbotapi.extensions.behaviour_builder.buildBehaviourWithFSMAndStartLongPolling
-import dev.inmo.tgbotapi.extensions.behaviour_builder.expectations.waitChatSharedEventsMessages
-import dev.inmo.tgbotapi.extensions.behaviour_builder.expectations.waitCommandMessage
-import dev.inmo.tgbotapi.extensions.behaviour_builder.expectations.waitUserSharedEventsMessages
+import dev.inmo.tgbotapi.extensions.behaviour_builder.expectations.*
 import dev.inmo.tgbotapi.extensions.behaviour_builder.triggers_handling.onCommand
 import dev.inmo.tgbotapi.extensions.behaviour_builder.triggers_handling.onMessageDataCallbackQuery
 import dev.inmo.tgbotapi.extensions.utils.*
@@ -29,12 +27,12 @@ import dev.inmo.tgbotapi.types.buttons.InlineKeyboardMarkup
 import dev.inmo.tgbotapi.types.chat.ChannelChat
 import dev.inmo.tgbotapi.types.chat.ChatPermissions
 import dev.inmo.tgbotapi.types.chat.PublicChat
-import dev.inmo.tgbotapi.types.chat.member.AdministratorChatMember
-import dev.inmo.tgbotapi.types.chat.member.ChatCommonAdministratorRights
+import dev.inmo.tgbotapi.types.chat.member.*
 import dev.inmo.tgbotapi.types.commands.BotCommandScope
 import dev.inmo.tgbotapi.types.message.abstracts.AccessibleMessage
 import dev.inmo.tgbotapi.types.request.RequestId
 import dev.inmo.tgbotapi.utils.*
+import dev.inmo.tgbotapi.utils.mention
 import kotlinx.coroutines.flow.filter
 import kotlinx.coroutines.flow.first
 import kotlinx.coroutines.flow.mapNotNull
@@ -54,7 +52,6 @@ sealed interface UserRetrievingStep : State {
    ) : UserRetrievingStep
 }

-@OptIn(PreviewFeature::class)
 suspend fun main(args: Array<String>) {
    val botToken = args.first()

@@ -70,7 +67,7 @@ suspend fun main(args: Array<String>) {

    val bot = telegramBot(botToken)

-    val allowedAdmin = ChatId(RawChatId(args[1].toLong()))
+    val allowedAdmin = ChatId(args[1].toLong())

    fun Boolean?.allowedSymbol() = when (this) {
        true -> "✅"
@@ -106,7 +103,7 @@ suspend fun main(args: Array<String>) {

    suspend fun BehaviourContext.getUserChatPermissions(chatId: ChatId, userId: UserId): ChatPermissions? {
        val chatMember = getChatMember(chatId, userId)
-        return chatMember.restrictedMemberChatMemberOrNull() ?: chatMember.whenMemberChatMember {
+        return chatMember.restrictedChatMemberOrNull() ?: chatMember.whenMemberChatMember {
            getChat(chatId).extendedGroupChatOrNull() ?.permissions
        }
    }
@@ -227,6 +224,7 @@ suspend fun main(args: Array<String>) {
            }
        ) {
            val replyMessage = it.replyTo
+            val usernameInText = it.content.textSources.firstNotNullOfOrNull { it.mentionTextSourceOrNull() } ?.username
            val userInReply = replyMessage?.fromUserMessageOrNull()?.user?.id ?: return@onCommand

            if (replyMessage is AccessibleMessage) {
@@ -379,10 +377,11 @@ suspend fun main(args: Array<String>) {
            initialFilter = { it.user.id == allowedAdmin }
        ) {
            val (channelIdString, userIdString) = it.data.split(" ").drop(1)
-            val channelId = ChatId(RawChatId(channelIdString.toLong()))
-            val userId = ChatId(RawChatId(userIdString.toLong()))
+            val channelId = ChatId(channelIdString.toLong())
+            val userId = ChatId(userIdString.toLong())
            val chatMember = getChatMember(channelId, userId)
            val asAdmin = chatMember.administratorChatMemberOrNull()
+            val asMember = chatMember.memberChatMemberOrNull()

            val realData = it.data.takeWhile { it != ' ' }

@@ -505,6 +504,7 @@ suspend fun main(args: Array<String>) {
        strictlyOn<UserRetrievingStep.RetrievingChatInfoDoneState> { state ->
            val chatMember = getChatMember(state.channelId, state.userId).administratorChatMemberOrNull()
            if (chatMember == null) {
+
                return@strictlyOn null
            }
            send(
--- a/StarTransactionsBot/README.md
+++ b/StarTransactionsBot/README.md
@@ -1,9 +0,0 @@
-# CustomBot
-
-This bot basically have no any useful behaviour, but you may customize it as a playground
-
-## Launch
-
-```bash
-../gradlew run --args="BOT_TOKEN"
-```
--- a/StarTransactionsBot/build.gradle
+++ b/StarTransactionsBot/build.gradle
@@ -1,21 +0,0 @@
-buildscript {
-    repositories {
-        mavenCentral()
-    }
-
-    dependencies {
-        classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:$kotlin_version"
-    }
-}
-
-apply plugin: 'kotlin'
-apply plugin: 'application'
-
-mainClassName="StarTransactionsBotKt"
-
-
-dependencies {
-    implementation "org.jetbrains.kotlin:kotlin-stdlib:$kotlin_version"
-
-    implementation "dev.inmo:tgbotapi:$telegram_bot_api_version"
-}
--- a/StarTransactionsBot/src/main/kotlin/StarTransactionsBot.kt
+++ b/StarTransactionsBot/src/main/kotlin/StarTransactionsBot.kt
@@ -1,184 +0,0 @@
-import dev.inmo.kslog.common.KSLog
-import dev.inmo.kslog.common.LogLevel
-import dev.inmo.kslog.common.defaultMessageFormatter
-import dev.inmo.kslog.common.setDefaultKSLog
-import dev.inmo.micro_utils.coroutines.subscribeSafelyWithoutExceptions
-import dev.inmo.tgbotapi.extensions.api.answers.payments.answerPreCheckoutQueryOk
-import dev.inmo.tgbotapi.extensions.api.edit.edit
-import dev.inmo.tgbotapi.extensions.api.files.downloadFileToTemp
-import dev.inmo.tgbotapi.extensions.api.get.getStarTransactions
-import dev.inmo.tgbotapi.extensions.api.send.reply
-import dev.inmo.tgbotapi.extensions.api.send.send
-import dev.inmo.tgbotapi.extensions.behaviour_builder.telegramBotWithBehaviourAndLongPolling
-import dev.inmo.tgbotapi.extensions.behaviour_builder.triggers_handling.*
-import dev.inmo.tgbotapi.extensions.utils.extensions.sameChat
-import dev.inmo.tgbotapi.extensions.utils.types.buttons.*
-import dev.inmo.tgbotapi.extensions.utils.withContentOrNull
-import dev.inmo.tgbotapi.requests.abstracts.asMultipartFile
-import dev.inmo.tgbotapi.types.RawChatId
-import dev.inmo.tgbotapi.types.UserId
-import dev.inmo.tgbotapi.types.buttons.InlineKeyboardMarkup
-import dev.inmo.tgbotapi.types.files.*
-import dev.inmo.tgbotapi.types.media.TelegramPaidMediaPhoto
-import dev.inmo.tgbotapi.types.media.TelegramPaidMediaVideo
-import dev.inmo.tgbotapi.types.media.toTelegramPaidMediaPhoto
-import dev.inmo.tgbotapi.types.media.toTelegramPaidMediaVideo
-import dev.inmo.tgbotapi.types.message.content.TextContent
-import dev.inmo.tgbotapi.types.message.textsources.TextSourcesList
-import dev.inmo.tgbotapi.types.payments.LabeledPrice
-import dev.inmo.tgbotapi.types.payments.stars.StarTransaction
-import dev.inmo.tgbotapi.types.request.RequestId
-import dev.inmo.tgbotapi.utils.bold
-import dev.inmo.tgbotapi.utils.buildEntities
-import dev.inmo.tgbotapi.utils.regular
-import dev.inmo.tgbotapi.utils.row
-import kotlinx.coroutines.CoroutineScope
-import kotlinx.coroutines.Dispatchers
-
-/**
- * An example bot that interacts with Telegram Stars API (used for payments)
- */
-suspend fun main(vararg args: String) {
-    val botToken = args.first()
-    val adminUserId = args.getOrNull(1) ?.toLongOrNull() ?.let(::RawChatId) ?.let(::UserId) ?: error("Pass user-admin for full access to the bot")
-
-    val isDebug = args.any { it == "debug" }
-    val isTestServer = args.any { it == "testServer" }
-
-    if (isDebug) {
-        setDefaultKSLog(
-            KSLog { level: LogLevel, tag: String?, message: Any, throwable: Throwable? ->
-                println(defaultMessageFormatter(level, tag, message, throwable))
-            }
-        )
-    }
-
-    telegramBotWithBehaviourAndLongPolling(botToken, CoroutineScope(Dispatchers.IO), testServer = isTestServer) {
-        val payload = "sample payload"
-        command("start") {
-            reply(
-                it,
-                price = LabeledPrice("1", 1L),
-                title = "Sample",
-                description = "Sample description",
-                payload = payload,
-                replyMarkup = flatInlineKeyboard {
-                    payButton("Pay")
-                },
-            )
-        }
-
-        onPreCheckoutQuery(initialFilter = { it.invoicePayload == payload }) {
-            answerPreCheckoutQueryOk(it)
-        }
-
-        val transactionsDataPrefix = "getStarTransactions"
-        fun buildTransactionsData(offset: Int, limit: Int = 10) = "$transactionsDataPrefix $offset $limit"
-        fun parseTransactionsData(data: String): Pair<Int, Int> = data.split(" ").drop(1).let {
-            it.first().toInt() to it.last().toInt()
-        }
-        suspend fun buildStarTransactionsPage(offset: Int, limit: Int = 10): Pair<TextSourcesList, InlineKeyboardMarkup> {
-            val transactions = getStarTransactions(offset, limit)
-            return buildEntities {
-                transactions.transactions.forEach {
-                    regular("Transaction Id: ") + bold(it.id.string) + "\n"
-                    regular("Date: ") + bold(it.date.asDate.toStringDefault()) + "\n"
-                    regular("Amount: ") + bold(it.amount.toString()) + "\n"
-                    when (it) {
-                        is StarTransaction.Incoming -> {
-                            regular("Type: ") + bold("incoming") + "\n"
-                            regular("Partner: ") + bold(it.partner.type) + "\n"
-                        }
-                        is StarTransaction.Outgoing -> {
-                            regular("Type: ") + bold("outgoing") + "\n"
-                            regular("Partner: ") + bold(it.partner.type) + "\n"
-                        }
-                        is StarTransaction.Unknown -> {
-                            regular("Type: ") + bold("unknown") + "\n"
-                            regular("Partner: ") + bold(it.partner.type) + "\n"
-                        }
-                    }
-                }
-            } to inlineKeyboard {
-                row {
-                    val prevOffset = (offset - limit).coerceAtLeast(0)
-                    if (prevOffset < offset) {
-                        dataButton("<", buildTransactionsData(prevOffset, limit))
-                    }
-                    val nextOffset = (offset + limit)
-                    dataButton(">", buildTransactionsData(nextOffset, limit))
-                }
-            }
-        }
-
-        onCommand("transactions", initialFilter = { it.sameChat(adminUserId) }) {
-            val (text, keyboard) = buildStarTransactionsPage(0)
-
-            reply(it, text, replyMarkup = keyboard)
-        }
-
-        onMessageDataCallbackQuery(Regex("$transactionsDataPrefix \\d+ \\d+")) {
-            val (offset, limit) = parseTransactionsData(it.data)
-            val (text, keyboard) = buildStarTransactionsPage(offset, limit)
-            edit(
-                it.message.withContentOrNull<TextContent>() ?: return@onMessageDataCallbackQuery,
-                text,
-                replyMarkup = keyboard,
-            )
-        }
-
-        onVisualGalleryMessages {
-            send(
-                it.chat,
-                1,
-                it.content.group.mapNotNull {
-                    val file = downloadFileToTemp(it.content.media)
-                    when (it.content.media) {
-                        is VideoFile -> {
-                            TelegramPaidMediaVideo(
-                                file.asMultipartFile()
-                            )
-                        }
-                        is PhotoSize -> {
-                            TelegramPaidMediaPhoto(
-                                file.asMultipartFile()
-                            )
-                        }
-                        else -> null
-                    }
-                },
-                it.content.textSources,
-                showCaptionAboveMedia = true
-            )
-        }
-
-        onPhoto {
-            send(
-                it.chat,
-                1,
-                listOf(it.content.media.toTelegramPaidMediaPhoto())
-            )
-        }
-
-        onVideo {
-            send(
-                it.chat,
-                1,
-                listOf(it.content.media.toTelegramPaidMediaVideo())
-            )
-        }
-
-        onPaidMediaInfoContent {
-            println(it)
-        }
-
-        onRefundedPayment {
-            reply(
-                it,
-                "Received your refund: ${it.chatEvent.payment}"
-            )
-        }
-
-        allUpdatesFlow.subscribeSafelyWithoutExceptions(this) { println(it) }
-    }.second.join()
-}
--- a/StickerInfoBot/StickerInfoBotLib/src/commonMain/kotlin/StickerInfoBot.kt
+++ b/StickerInfoBot/StickerInfoBotLib/src/commonMain/kotlin/StickerInfoBot.kt
@@ -1,25 +1,29 @@
 import dev.inmo.micro_utils.coroutines.defaultSafelyWithoutExceptionHandler
 import dev.inmo.micro_utils.coroutines.subscribeSafelyWithoutExceptions
-import dev.inmo.tgbotapi.bot.ktor.telegramBot
 import dev.inmo.tgbotapi.extensions.api.bot.getMe
-import dev.inmo.tgbotapi.extensions.api.get.getCustomEmojiStickerOrNull
-import dev.inmo.tgbotapi.extensions.api.get.getStickerSet
-import dev.inmo.tgbotapi.extensions.api.get.getStickerSetOrNull
-import dev.inmo.tgbotapi.extensions.api.send.reply
-import dev.inmo.tgbotapi.extensions.api.send.withTypingAction
-import dev.inmo.tgbotapi.extensions.behaviour_builder.buildBehaviourWithLongPolling
-import dev.inmo.tgbotapi.extensions.behaviour_builder.triggers_handling.onSticker
-import dev.inmo.tgbotapi.extensions.behaviour_builder.triggers_handling.onText
+import dev.inmo.tgbotapi.bot.ktor.telegramBot
+import dev.inmo.tgbotapi.extensions.api.get.*
+import dev.inmo.tgbotapi.extensions.api.send.*
+import dev.inmo.tgbotapi.extensions.behaviour_builder.*
+import dev.inmo.tgbotapi.extensions.behaviour_builder.triggers_handling.*
+import dev.inmo.tgbotapi.types.StickerFormat
 import dev.inmo.tgbotapi.types.StickerType
-import dev.inmo.tgbotapi.types.message.textsources.CustomEmojiTextSource
-import dev.inmo.tgbotapi.types.message.textsources.regular
-import dev.inmo.tgbotapi.types.message.textsources.separateForText
+import dev.inmo.tgbotapi.types.message.textsources.*
+import dev.inmo.tgbotapi.types.stickers.AnimatedStickerSet
+import dev.inmo.tgbotapi.types.stickers.CustomEmojiSimpleStickerSet
+import dev.inmo.tgbotapi.types.stickers.CustomEmojiStickerSet
+import dev.inmo.tgbotapi.types.stickers.CustomEmojiVideoStickerSet
+import dev.inmo.tgbotapi.types.stickers.MaskSimpleStickerSet
+import dev.inmo.tgbotapi.types.stickers.MaskStickerSet
+import dev.inmo.tgbotapi.types.stickers.MaskVideoStickerSet
+import dev.inmo.tgbotapi.types.stickers.RegularSimpleStickerSet
+import dev.inmo.tgbotapi.types.stickers.RegularStickerSet
+import dev.inmo.tgbotapi.types.stickers.RegularVideoStickerSet
 import dev.inmo.tgbotapi.types.stickers.StickerSet
+import dev.inmo.tgbotapi.types.stickers.UnknownStickerSet
 import dev.inmo.tgbotapi.utils.bold
 import dev.inmo.tgbotapi.utils.buildEntities
-import kotlinx.coroutines.CoroutineScope
-import kotlinx.coroutines.SupervisorJob
-import kotlinx.coroutines.currentCoroutineContext
+import kotlinx.coroutines.*

 fun StickerSet?.buildInfo() = buildEntities {
    if (this@buildInfo == null) {
@@ -27,6 +31,12 @@ fun StickerSet?.buildInfo() = buildEntities {
    } else {
        bold("StickerSet name: ") + "${name}\n"
        bold("StickerSet title: ") + "${title}\n"
+        bold("Sticker format: ") + when (stickerFormat) {
+            StickerFormat.Animated -> "Animated"
+            StickerFormat.Static -> "Static"
+            is StickerFormat.Unknown -> stickerFormat.type
+            StickerFormat.Video -> "Video"
+        } + "\n"
        bold(
            when (stickerType) {
                StickerType.CustomEmoji -> "Custom emoji"
@@ -34,7 +44,7 @@ fun StickerSet?.buildInfo() = buildEntities {
                StickerType.Regular -> "Regular"
                is StickerType.Unknown -> "Unknown type \"${stickerType.type}\""
            }
-        ) + " sticker set with title " + bold(title) + " and name " + bold(name.string)
+        ) + " sticker set with title " + bold(title) + " and name " + bold(name)
    }
 }

--- a/StickerSetHandler/src/main/kotlin/StickerSetHandlerBot.kt
+++ b/StickerSetHandler/src/main/kotlin/StickerSetHandlerBot.kt
@@ -1,6 +1,6 @@
 import dev.inmo.micro_utils.coroutines.runCatchingSafely
-import dev.inmo.micro_utils.coroutines.subscribeSafelyWithoutExceptions
 import dev.inmo.tgbotapi.extensions.api.bot.getMe
+import dev.inmo.tgbotapi.extensions.api.files.downloadFile
 import dev.inmo.tgbotapi.extensions.api.files.downloadFileToTemp
 import dev.inmo.tgbotapi.extensions.api.get.getStickerSet
 import dev.inmo.tgbotapi.extensions.api.send.reply
@@ -10,14 +10,11 @@ import dev.inmo.tgbotapi.extensions.api.stickers.deleteStickerSet
 import dev.inmo.tgbotapi.extensions.behaviour_builder.telegramBotWithBehaviourAndLongPolling
 import dev.inmo.tgbotapi.extensions.behaviour_builder.triggers_handling.onCommand
 import dev.inmo.tgbotapi.extensions.behaviour_builder.triggers_handling.onSticker
+import dev.inmo.tgbotapi.extensions.utils.extensions.raw.sticker
 import dev.inmo.tgbotapi.requests.abstracts.asMultipartFile
 import dev.inmo.tgbotapi.requests.stickers.InputSticker
-import dev.inmo.tgbotapi.types.StickerSetName
 import dev.inmo.tgbotapi.types.chat.Chat
-import dev.inmo.tgbotapi.types.files.CustomEmojiSticker
-import dev.inmo.tgbotapi.types.files.MaskSticker
-import dev.inmo.tgbotapi.types.files.RegularSticker
-import dev.inmo.tgbotapi.types.files.UnknownSticker
+import dev.inmo.tgbotapi.types.files.*
 import dev.inmo.tgbotapi.types.toChatId
 import dev.inmo.tgbotapi.utils.botCommand
 import kotlinx.coroutines.CoroutineScope
@@ -35,7 +32,7 @@ suspend fun main(args: Array<String>) {
        }
    ) {
        val me = getMe()
-        fun Chat.stickerSetName() = StickerSetName("s${id.chatId}_by_${me.username ?.withoutAt}")
+        fun Chat.stickerSetName() = "s${id.chatId}_by_${me.username ?.usernameWithoutAt}"
        onCommand("start") {
            reply(it) {
                botCommand("delete") + " - to clear stickers"
@@ -58,19 +55,16 @@ suspend fun main(args: Array<String>) {
            val newSticker = when (sticker) {
                is CustomEmojiSticker -> InputSticker.WithKeywords.CustomEmoji(
                    downloadFileToTemp(sticker.fileId).asMultipartFile(),
-                    sticker.stickerFormat,
                    listOf(sticker.emoji ?: "\uD83D\uDE0A"),
                    emptyList()
                )
                is MaskSticker -> InputSticker.Mask(
                    downloadFileToTemp(sticker.fileId).asMultipartFile(),
-                    sticker.stickerFormat,
                    listOf(sticker.emoji ?: "\uD83D\uDE0A"),
                    sticker.maskPosition
                )
                is RegularSticker -> InputSticker.WithKeywords.Regular(
                    downloadFileToTemp(sticker.fileId).asMultipartFile(),
-                    sticker.stickerFormat,
                    listOf(sticker.emoji ?: "\uD83D\uDE0A"),
                    emptyList()
                )
@@ -79,25 +73,18 @@ suspend fun main(args: Array<String>) {
            runCatchingSafely {
                getStickerSet(stickerSetName)
            }.onSuccess { stickerSet ->
-                runCatching {
-                    addStickerToSet(it.chat.id.toChatId(), stickerSet.name, newSticker).also { _ ->
-                        reply(
-                            it,
-                            getStickerSet(stickerSetName).stickers.last()
-                        )
-                    }
-                }.onFailure { exception ->
-                    exception.printStackTrace()
+                addStickerToSet(it.chat.id.toChatId(), stickerSet.name, newSticker).also { _ ->
                    reply(
                        it,
-                        "Unable to add sticker in stickerset"
+                        getStickerSet(stickerSetName).stickers.last()
                    )
                }
-            }.onFailure { exception ->
+            }.onFailure { _ ->
                createNewStickerSet(
                    it.chat.id.toChatId(),
-                    stickerSetName.string,
+                    stickerSetName,
                    "Sticker set by ${me.firstName}",
+                    it.content.media.stickerFormat,
                    listOf(
                        newSticker
                    ),
@@ -110,9 +97,5 @@ suspend fun main(args: Array<String>) {
                }
            }
        }
-
-        allUpdatesFlow.subscribeSafelyWithoutExceptions(this) {
-            println(it)
-        }
    }.second.join()
 }
--- a/TopicsHandling/src/main/kotlin/TopicsHandling.kt
+++ b/TopicsHandling/src/main/kotlin/TopicsHandling.kt
@@ -1,8 +1,18 @@
 import com.benasher44.uuid.uuid4
+import dev.inmo.micro_utils.common.repeatOnFailure
 import dev.inmo.micro_utils.coroutines.runCatchingSafely
 import dev.inmo.micro_utils.coroutines.subscribeSafelyWithoutExceptions
 import dev.inmo.tgbotapi.extensions.api.bot.setMyCommands
-import dev.inmo.tgbotapi.extensions.api.chat.forum.*
+import dev.inmo.tgbotapi.extensions.api.chat.forum.closeForumTopic
+import dev.inmo.tgbotapi.extensions.api.chat.forum.closeGeneralForumTopic
+import dev.inmo.tgbotapi.extensions.api.chat.forum.createForumTopic
+import dev.inmo.tgbotapi.extensions.api.chat.forum.deleteForumTopic
+import dev.inmo.tgbotapi.extensions.api.chat.forum.editForumTopic
+import dev.inmo.tgbotapi.extensions.api.chat.forum.editGeneralForumTopic
+import dev.inmo.tgbotapi.extensions.api.chat.forum.hideGeneralForumTopic
+import dev.inmo.tgbotapi.extensions.api.chat.forum.reopenForumTopic
+import dev.inmo.tgbotapi.extensions.api.chat.forum.reopenGeneralForumTopic
+import dev.inmo.tgbotapi.extensions.api.chat.forum.unhideGeneralForumTopic
 import dev.inmo.tgbotapi.extensions.api.send.reply
 import dev.inmo.tgbotapi.extensions.behaviour_builder.telegramBotWithBehaviourAndLongPolling
 import dev.inmo.tgbotapi.extensions.behaviour_builder.triggers_handling.onCommand
--- a/UserChatShared/src/main/kotlin/UserChatShared.kt
+++ b/UserChatShared/src/main/kotlin/UserChatShared.kt
@@ -1,15 +1,12 @@
-import dev.inmo.kslog.common.KSLog
-import dev.inmo.kslog.common.LogLevel
-import dev.inmo.kslog.common.defaultMessageFormatter
-import dev.inmo.kslog.common.setDefaultKSLog
 import dev.inmo.micro_utils.coroutines.runCatchingSafely
 import dev.inmo.tgbotapi.bot.ktor.telegramBot
 import dev.inmo.tgbotapi.extensions.api.bot.setMyCommands
 import dev.inmo.tgbotapi.extensions.api.chat.get.getChat
-import dev.inmo.tgbotapi.extensions.api.send.reply
+import dev.inmo.tgbotapi.extensions.api.send.*
 import dev.inmo.tgbotapi.extensions.behaviour_builder.buildBehaviourWithLongPolling
 import dev.inmo.tgbotapi.extensions.behaviour_builder.triggers_handling.onChatShared
 import dev.inmo.tgbotapi.extensions.behaviour_builder.triggers_handling.onCommand
+import dev.inmo.tgbotapi.extensions.behaviour_builder.triggers_handling.onUserShared
 import dev.inmo.tgbotapi.extensions.behaviour_builder.triggers_handling.onUsersShared
 import dev.inmo.tgbotapi.extensions.utils.types.buttons.*
 import dev.inmo.tgbotapi.types.BotCommand
@@ -21,15 +18,6 @@ import dev.inmo.tgbotapi.utils.row

 suspend fun main(args: Array<String>) {
    val botToken = args.first()
-    val isDebug = args.getOrNull(1) == "debug"
-
-    if (isDebug) {
-        setDefaultKSLog(
-            KSLog { level: LogLevel, tag: String?, message: Any, throwable: Throwable? ->
-                println(defaultMessageFormatter(level, tag, message, throwable))
-            }
-        )
-    }

    val bot = telegramBot(botToken)

@@ -67,53 +55,35 @@ suspend fun main(args: Array<String>) {
        row {
            requestUserOrBotButton(
                "\uD83D\uDC64/\uD83E\uDD16 (1)",
-                requestIdUserOrBot,
-                requestName = true,
-                requestUsername = true,
-                requestPhoto = true
+                requestIdUserOrBot
            )
        }
        row {
            requestUserButton(
                "\uD83D\uDC64☆ (1)",
                requestIdUserNonPremium,
-                premiumUser = false,
-                requestName = true,
-                requestUsername = true,
-                requestPhoto = true
+                premiumUser = false
            )
            requestUserButton(
                "\uD83D\uDC64 (1)",
                requestIdUserAny,
-                premiumUser = null,
-                requestName = true,
-                requestUsername = true,
-                requestPhoto = true
+                premiumUser = null
            )
            requestUserButton(
                "\uD83D\uDC64★ (1)",
                requestIdUserPremium,
-                premiumUser = true,
-                requestName = true,
-                requestUsername = true,
-                requestPhoto = true
+                premiumUser = true
            )
            requestBotButton(
                "\uD83E\uDD16 (1)",
-                requestIdBot,
-                requestName = true,
-                requestUsername = true,
-                requestPhoto = true
+                requestIdBot
            )
        }
        row {
            requestUsersOrBotsButton(
                "\uD83D\uDC64/\uD83E\uDD16",
                requestIdUsersOrBots,
-                maxCount = keyboardButtonRequestUserLimit.last,
-                requestName = true,
-                requestUsername = true,
-                requestPhoto = true
+                maxCount = keyboardButtonRequestUserLimit.last
            )
        }
        row {
@@ -121,152 +91,101 @@ suspend fun main(args: Array<String>) {
                "\uD83D\uDC64☆",
                requestIdUsersNonPremium,
                premiumUser = false,
-                maxCount = keyboardButtonRequestUserLimit.last,
-                requestName = true,
-                requestUsername = true,
-                requestPhoto = true
+                maxCount = keyboardButtonRequestUserLimit.last
            )
            requestUsersButton(
                "\uD83D\uDC64",
                requestIdUsersAny,
                premiumUser = null,
-                maxCount = keyboardButtonRequestUserLimit.last,
-                requestName = true,
-                requestUsername = true,
-                requestPhoto = true
+                maxCount = keyboardButtonRequestUserLimit.last
            )
            requestUsersButton(
                "\uD83D\uDC64★",
                requestIdUsersPremium,
                premiumUser = true,
-                maxCount = keyboardButtonRequestUserLimit.last,
-                requestName = true,
-                requestUsername = true,
-                requestPhoto = true
+                maxCount = keyboardButtonRequestUserLimit.last
            )
            requestBotsButton(
                "\uD83E\uDD16",
                requestIdBots,
-                maxCount = keyboardButtonRequestUserLimit.last,
-                requestName = true,
-                requestUsername = true,
-                requestPhoto = true
+                maxCount = keyboardButtonRequestUserLimit.last
            )
        }
        row {
            requestChatButton(
                "\uD83D\uDDE3/\uD83D\uDC65",
-                requestIdAnyChat,
-                requestTitle = true,
-                requestUsername = true,
-                requestPhoto = true
+                requestIdAnyChat
            )
        }
        row {
            requestChatButton(
                "\uD83D\uDDE3",
                requestIdChannel,
-                isChannel = true,
-                requestTitle = true,
-                requestUsername = true,
-                requestPhoto = true
+                isChannel = true
            )
            requestChatButton(
                "\uD83D\uDDE3\uD83D\uDD17",
                requestIdPublicChannel,
                isChannel = true,
-                isPublic = true,
-                requestTitle = true,
-                requestUsername = true,
-                requestPhoto = true
+                isPublic = true
            )
            requestChatButton(
                "\uD83D\uDDE3❌\uD83D\uDD17",
                requestIdPrivateChannel,
                isChannel = true,
-                isPublic = false,
-                requestTitle = true,
-                requestUsername = true,
-                requestPhoto = true
+                isPublic = false
            )
            requestChatButton(
                "\uD83D\uDDE3\uD83D\uDC6E",
                requestIdChannelUserOwner,
                isChannel = true,
-                isOwnedBy = true,
-                requestTitle = true,
-                requestUsername = true,
-                requestPhoto = true
+                isOwnedBy = true
            )
        }
        row {
            requestGroupButton(
                "👥",
-                requestIdGroup,
-                requestTitle = true,
-                requestUsername = true,
-                requestPhoto = true
+                requestIdGroup
            )
            requestGroupButton(
                "👥\uD83D\uDD17",
                requestIdPublicGroup,
-                isPublic = true,
-                requestTitle = true,
-                requestUsername = true,
-                requestPhoto = true
+                isPublic = true
            )
            requestGroupButton(
                "👥❌\uD83D\uDD17",
                requestIdPrivateGroup,
-                isPublic = false,
-                requestTitle = true,
-                requestUsername = true,
-                requestPhoto = true
+                isPublic = false
            )
            requestGroupButton(
                "👥\uD83D\uDC6E",
                requestIdGroupUserOwner,
-                isOwnedBy = true,
-                requestTitle = true,
-                requestUsername = true,
-                requestPhoto = true
+                isOwnedBy = true
            )
        }
        row {
            requestGroupButton(
                "🏛",
                requestIdForum,
-                isForum = true,
-                requestTitle = true,
-                requestUsername = true,
-                requestPhoto = true
+                isForum = true
            )
            requestGroupButton(
                "🏛\uD83D\uDD17",
                requestIdPublicForum,
                isPublic = true,
-                isForum = true,
-                requestTitle = true,
-                requestUsername = true,
-                requestPhoto = true
+                isForum = true
            )
            requestGroupButton(
                "🏛❌\uD83D\uDD17",
                requestIdPrivateForum,
                isPublic = false,
-                isForum = true,
-                requestTitle = true,
-                requestUsername = true,
-                requestPhoto = true
+                isForum = true
            )
            requestGroupButton(
                "🏛\uD83D\uDC6E",
                requestIdForumUserOwner,
                isOwnedBy = true,
-                isForum = true,
-                requestTitle = true,
-                requestUsername = true,
-                requestPhoto = true
+                isForum = true
            )
        }
    }
--- a/WebApp/src/jsMain/kotlin/main.kt
+++ b/WebApp/src/jsMain/kotlin/main.kt
@@ -26,7 +26,6 @@ fun HTMLElement.log(text: String) {
    appendElement("p", {})
 }

-@OptIn(ExperimentalUnsignedTypes::class)
 fun main() {
    console.log("Web app started")
    val client = HttpClient()
@@ -39,7 +38,7 @@ fun main() {
            scope.launchSafelyWithoutExceptions {
                val response = client.post("$baseUrl/check") {
                    setBody(
-                        Json.encodeToString(
+                        Json { }.encodeToString(
                            WebAppDataWrapper.serializer(),
                            WebAppDataWrapper(webApp.initData, webApp.initDataUnsafe.hash)
                        )
@@ -182,7 +181,7 @@ fun main() {
                    val hex = Color.Hex(r, g, b)
                    webApp.setHeaderColor(hex)
                    (this as? HTMLButtonElement) ?.style ?.backgroundColor = hex.value
-                    textContent = "Header color: ${webApp.headerColor ?.uppercase()} (click to change)"
+                    textContent = "Header color: ${hex.value.uppercase()} (click to change)"
                }
                addEventListener("click", {
                    updateHeaderColor()
@@ -192,38 +191,6 @@ fun main() {

            document.body ?.appendElement("p", {})

-            document.body ?.appendElement("button") {
-                fun updateBackgroundColor() {
-                    val (r, g, b) = Random.nextUBytes(3)
-                    val hex = Color.Hex(r, g, b)
-                    webApp.setBackgroundColor(hex)
-                    (this as? HTMLButtonElement) ?.style ?.backgroundColor = hex.value
-                    textContent = "Background color: ${webApp.backgroundColor ?.uppercase()} (click to change)"
-                }
-                addEventListener("click", {
-                    updateBackgroundColor()
-                })
-                updateBackgroundColor()
-            } ?: window.alert("Unable to load body")
-
-            document.body ?.appendElement("p", {})
-
-            document.body ?.appendElement("button") {
-                fun updateBottomBarColor() {
-                    val (r, g, b) = Random.nextUBytes(3)
-                    val hex = Color.Hex(r, g, b)
-                    webApp.setBottomBarColor(hex)
-                    (this as? HTMLButtonElement) ?.style ?.backgroundColor = hex.value
-                    textContent = "Bottom bar color: ${webApp.bottomBarColor ?.uppercase()} (click to change)"
-                }
-                addEventListener("click", {
-                    updateBottomBarColor()
-                })
-                updateBottomBarColor()
-            } ?: window.alert("Unable to load body")
-
-            document.body ?.appendElement("p", {})
-
            fun Element.updateCloudStorageContent() {
                clear()
                webApp.cloudStorage.getAll {
@@ -319,16 +286,6 @@ fun main() {
                    }
                    show()
                }
-                secondaryButton.apply {
-                    setText("Secondary button")
-                    onClick {
-                        document.body ?.log("Secondary button clicked")
-                        hapticFeedback.notificationOccurred(
-                            HapticFeedbackType.Warning
-                        )
-                    }
-                    show()
-                }
                onSettingsButtonClicked {
                    document.body ?.log("Settings button clicked")
                }
--- a/WebApp/src/jvmMain/kotlin/WebAppServer.kt
+++ b/WebApp/src/jvmMain/kotlin/WebAppServer.kt
@@ -1,45 +1,44 @@
-import dev.inmo.kslog.common.*
+import dev.inmo.kslog.common.KSLog
+import dev.inmo.kslog.common.LogLevel
+import dev.inmo.kslog.common.defaultMessageFormatter
+import dev.inmo.kslog.common.setDefaultKSLog
 import dev.inmo.micro_utils.coroutines.subscribeSafelyWithoutExceptions
 import dev.inmo.micro_utils.ktor.server.createKtorServer
+import dev.inmo.tgbotapi.extensions.api.answers.answer
 import dev.inmo.tgbotapi.extensions.api.answers.answerInlineQuery
 import dev.inmo.tgbotapi.extensions.api.bot.getMe
 import dev.inmo.tgbotapi.extensions.api.bot.setMyCommands
-import dev.inmo.tgbotapi.extensions.api.send.reply
-import dev.inmo.tgbotapi.extensions.api.send.send
+import dev.inmo.tgbotapi.extensions.api.send.*
 import dev.inmo.tgbotapi.extensions.api.telegramBot
-import dev.inmo.tgbotapi.extensions.behaviour_builder.buildBehaviourWithLongPolling
-import dev.inmo.tgbotapi.extensions.behaviour_builder.triggers_handling.onBaseInlineQuery
-import dev.inmo.tgbotapi.extensions.behaviour_builder.triggers_handling.onCommand
-import dev.inmo.tgbotapi.extensions.behaviour_builder.triggers_handling.onUnhandledCommand
-import dev.inmo.tgbotapi.extensions.behaviour_builder.triggers_handling.onWriteAccessAllowed
-import dev.inmo.tgbotapi.extensions.utils.types.buttons.inlineKeyboard
-import dev.inmo.tgbotapi.extensions.utils.types.buttons.replyKeyboard
-import dev.inmo.tgbotapi.extensions.utils.types.buttons.webAppButton
+import dev.inmo.tgbotapi.extensions.behaviour_builder.*
+import dev.inmo.tgbotapi.extensions.behaviour_builder.triggers_handling.*
+import dev.inmo.tgbotapi.extensions.utils.formatting.makeTelegramStartattach
+import dev.inmo.tgbotapi.extensions.utils.types.buttons.*
 import dev.inmo.tgbotapi.requests.answers.InlineQueryResultsButton
 import dev.inmo.tgbotapi.types.BotCommand
 import dev.inmo.tgbotapi.types.InlineQueries.InlineQueryResult.InlineQueryResultArticle
 import dev.inmo.tgbotapi.types.InlineQueries.InputMessageContent.InputTextMessageContent
-import dev.inmo.tgbotapi.types.InlineQueryId
 import dev.inmo.tgbotapi.types.LinkPreviewOptions
 import dev.inmo.tgbotapi.types.webAppQueryIdField
 import dev.inmo.tgbotapi.types.webapps.WebAppInfo
 import dev.inmo.tgbotapi.utils.*
 import io.ktor.http.*
-import io.ktor.server.application.*
+import io.ktor.server.application.call
 import io.ktor.server.http.content.*
-import io.ktor.server.request.*
-import io.ktor.server.response.*
-import io.ktor.server.routing.*
+import io.ktor.server.request.receiveText
+import io.ktor.server.response.respond
+import io.ktor.server.routing.post
+import io.ktor.server.routing.routing
 import kotlinx.coroutines.Dispatchers
 import kotlinx.serialization.json.Json
 import java.io.File
+import java.nio.charset.Charset

 /**
 * Accepts two parameters:
 *
 * * Telegram Token
 * * URL where will be placed
- * * Port (default 8080)
 *
 * Will start the server to share the static (index.html and WebApp.js) on 0.0.0.0:8080
 */
@@ -58,48 +57,34 @@ suspend fun main(vararg args: String) {
            }
        )
    }
-    val initiationLogger = KSLog("Initialization")

    val bot = telegramBot(telegramBotAPIUrlsKeeper)
    createKtorServer(
        "0.0.0.0",
-        args.getOrNull(2) ?.toIntOrNull() ?: 8080
+        args.getOrNull(2) ?.toIntOrNull() ?: 8080,
+        additionalEngineEnvironmentConfigurator = {
+            parentCoroutineContext += Dispatchers.IO
+        }
    ) {
        routing {
            val baseJsFolder = File("WebApp/build/dist/js/")
-            val prodSubFolder = File(baseJsFolder, "productionExecutable")
-            val devSubFolder = File(baseJsFolder, "developmentExecutable")
-
-            val staticFolder = when {
-                prodSubFolder.exists() -> {
-                    initiationLogger.i("Folder for static is ${prodSubFolder.absolutePath}")
-                    prodSubFolder
+            baseJsFolder.list() ?.forEach {
+                if (it == "productionExecutable" || it == "developmentExecutable") {
+                    staticFiles("", File(baseJsFolder, it)) {
+                        default("WebApp/build/dist/js/$it/index.html")
+                    }
                }
-                devSubFolder.exists() -> {
-                    initiationLogger.i("Folder for static is ${devSubFolder.absolutePath}")
-                    devSubFolder
-                }
-                else -> error("""
-                    Unable to detect any folder with static. Current working directory: ${File("").absolutePath}.
-                    Searched paths:
-                    * ${prodSubFolder.absolutePath}
-                    * ${devSubFolder.absolutePath}
-                """.trimIndent())
-            }
-
-            staticFiles("", staticFolder) {
-                default("${staticFolder.absolutePath}${File.separator}index.html")
            }
            post("inline") {
                val requestBody = call.receiveText()
-                val queryId = call.parameters[webAppQueryIdField] ?.let(::InlineQueryId) ?: error("$webAppQueryIdField should be presented")
+                val queryId = call.parameters[webAppQueryIdField] ?: error("$webAppQueryIdField should be presented")

-                bot.answerInlineQuery(queryId, listOf(InlineQueryResultArticle(queryId, "Result", InputTextMessageContent(requestBody))))
+                bot.answer(queryId, InlineQueryResultArticle(queryId, "Result", InputTextMessageContent(requestBody)))
                call.respond(HttpStatusCode.OK)
            }
            post("check") {
                val requestBody = call.receiveText()
-                val webAppCheckData = Json.decodeFromString(WebAppDataWrapper.serializer(), requestBody)
+                val webAppCheckData = Json {  }.decodeFromString(WebAppDataWrapper.serializer(), requestBody)

                val isSafe = telegramBotAPIUrlsKeeper.checkWebAppData(webAppCheckData.data, webAppCheckData.hash)

@@ -111,6 +96,7 @@ suspend fun main(vararg args: String) {
    bot.buildBehaviourWithLongPolling(
        defaultExceptionsHandler = { it.printStackTrace() }
    ) {
+        val me = getMe()
        onCommand("reply_markup") {
            reply(
                it,
--- a/WebHooks/README.md
+++ b/WebHooks/README.md
@@ -1,28 +0,0 @@
-# WebHooks
-
-Launches webhook-based simple bot. Use `/start` with bot to get simple info about webhooks
-
-## Launch
-
-```bash
-../gradlew run --args="BOT_TOKEN https://sample.com it/is/subpath 8080 debug"
-```
-
-Required arguments:
-
-1. Token
-2. Arguments starting with `https://`
-
-Optional arguments:
-
-* Any argument == `debug` to enable debug mode
-* Any argument **not** starting with `https://` and **not** equal to `debug` as **subpath** (will be used as
-subroute to place listening of webhooks)
-* Any argument as number of port
-
-Sample: `TOKEN https://sample.com it/is/subpath 8080` will result to:
-
-* `TOKEN` used as token
-* Bot will set up its webhook info as `https://sample.com/it/is/subpath`
-* Bot will set up to listen webhooks on route `it/is/subpath`
-* Bot will start to listen any incoming request on port `8080` and url `0.0.0.0`
--- a/WebHooks/build.gradle
+++ b/WebHooks/build.gradle
@@ -1,23 +0,0 @@
-buildscript {
-    repositories {
-        mavenCentral()
-    }
-
-    dependencies {
-        classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:$kotlin_version"
-    }
-}
-
-apply plugin: 'kotlin'
-apply plugin: 'application'
-
-mainClassName="WebHooksKt"
-
-
-dependencies {
-    implementation "org.jetbrains.kotlin:kotlin-stdlib:$kotlin_version"
-
-    implementation "dev.inmo:tgbotapi:$telegram_bot_api_version"
-    implementation "dev.inmo:micro_utils.ktor.server:$micro_utils_version"
-    implementation "io.ktor:ktor-server-cio:$ktor_version"
-}
--- a/WebHooks/src/main/kotlin/WebHooks.kt
+++ b/WebHooks/src/main/kotlin/WebHooks.kt
@@ -1,87 +0,0 @@
-import dev.inmo.kslog.common.KSLog
-import dev.inmo.kslog.common.LogLevel
-import dev.inmo.kslog.common.defaultMessageFormatter
-import dev.inmo.kslog.common.setDefaultKSLog
-import dev.inmo.micro_utils.ktor.server.createKtorServer
-import dev.inmo.tgbotapi.bot.ktor.telegramBot
-import dev.inmo.tgbotapi.extensions.api.bot.setMyCommands
-import dev.inmo.tgbotapi.extensions.api.send.reply
-import dev.inmo.tgbotapi.extensions.api.webhook.setWebhookInfo
-import dev.inmo.tgbotapi.extensions.behaviour_builder.buildBehaviour
-import dev.inmo.tgbotapi.extensions.behaviour_builder.triggers_handling.onCommand
-import dev.inmo.tgbotapi.extensions.utils.updates.retrieving.includeWebhookHandlingInRoute
-import dev.inmo.tgbotapi.types.BotCommand
-import dev.inmo.tgbotapi.types.chat.PrivateChat
-import dev.inmo.tgbotapi.utils.buildEntities
-import io.ktor.server.routing.*
-
-/**
- * Launches webhook-based simple bot. Required arguments:
- *
- * 1. Token
- * *. Arguments starting with `https://`
- *
- * Optional arguments:
- *
- * *. Any argument == `debug` to enable debug mode
- * *. Any argument **not** starting with `https://` and **not** equal to `debug` as **subpath** (will be used as
- * subroute to place listening of webhooks)
- * *. Any argument as number of port
- *
- * Sample: `TOKEN https://sample.com it/is/subpath 8080` will result to:
- *
- * * `TOKEN` used as token
- * * Bot will set up its webhook info as `https://sample.com/it/is/subpath`
- * * Bot will set up to listen webhooks on route `it/is/subpath`
- * * Bot will start to listen any incoming request on port `8080` and url `0.0.0.0`
- */
-suspend fun main(args: Array<String>) {
-    val botToken = args.first()
-    val address = args.first { it.startsWith("https://") }
-    val subpath = args.drop(1).firstOrNull { it != address && it != "debug" }
-    val port = args.firstNotNullOfOrNull { it.toIntOrNull() } ?: 8080
-    val isDebug = args.any { it == "debug" }
-
-    if (isDebug) {
-        setDefaultKSLog(
-            KSLog { level: LogLevel, tag: String?, message: Any, throwable: Throwable? ->
-                println(defaultMessageFormatter(level, tag, message, throwable))
-            }
-        )
-    }
-
-    val bot = telegramBot(botToken)
-
-    val behaviourContext = bot.buildBehaviour (defaultExceptionsHandler = { it.printStackTrace() }) {
-        onCommand("start", initialFilter = { it.chat is PrivateChat }) {
-            reply(
-                it,
-                buildEntities {
-                    +"Url: $address" + "\n"
-                    +"Listening server: 0.0.0.0" + "\n"
-                    +"Listening port: $port"
-                }
-            )
-        }
-
-        setMyCommands(BotCommand("start", "Get webhook info"))
-    }
-
-    val webhookInfoSubpath = subpath ?.let { "/" + it.removePrefix("/") } ?: "" // drop leading `/` to add it in the beginning for correct construction of subpath
-    bot.setWebhookInfo(address + webhookInfoSubpath)
-
-    createKtorServer(
-        "0.0.0.0",
-        port,
-    ) {
-        routing {
-            if (subpath == null) {
-                includeWebhookHandlingInRoute(behaviourContext, block = behaviourContext.asUpdateReceiver)
-            } else {
-                route(subpath) {
-                    includeWebhookHandlingInRoute(behaviourContext, block = behaviourContext.asUpdateReceiver)
-                }
-            }
-        }
-    }.start(true)
-}
--- a/gradle.properties
+++ b/gradle.properties
@@ -1,12 +1,11 @@
 kotlin.code.style=official
 org.gradle.parallel=true
 # Due to parallel compilation project require next amount of memory on full build
-org.gradle.jvmargs=-Xmx3148m
-kotlin.daemon.jvmargs=-Xmx3g -Xms500m
+org.gradle.jvmargs=-Xmx2344m


-kotlin_version=2.0.21
-telegram_bot_api_version=20.0.0
-micro_utils_version=0.23.0
-serialization_version=1.7.3
-ktor_version=3.0.1
+kotlin_version=1.9.22
+telegram_bot_api_version=10.1.0
+micro_utils_version=0.20.34
+serialization_version=1.6.3
+ktor_version=2.3.8
--- a/gradle/wrapper/gradle-wrapper.properties
+++ b/gradle/wrapper/gradle-wrapper.properties
@@ -2,4 +2,4 @@ distributionBase=GRADLE_USER_HOME
 distributionPath=wrapper/dists
 zipStoreBase=GRADLE_USER_HOME
 zipStorePath=wrapper/dists
-distributionUrl=https\://services.gradle.org/distributions/gradle-8.10.2-bin.zip
+distributionUrl=https\://services.gradle.org/distributions/gradle-8.4-bin.zip
--- a/settings.gradle
+++ b/settings.gradle
@@ -47,15 +47,3 @@ include ":ReactionsInfoBot"
 include ":LinkPreviewsBot"

 include ":BoostsInfoBot"
-
-include ":BusinessConnectionsBot"
-
-include ":StarTransactionsBot"
-
-include ":GiveawaysBot"
-
-include ":CustomBot"
-
-include ":MemberUpdatedWatcherBot"
-
-include ":WebHooks"