update GiveawaysBot

add println of giveaway content
add giveaways bot
2025-12-05 13:55:38 +00:00 · 2024-09-08 23:38:19 +06:00 · 2024-09-08 19:44:51 +06:00 · 2024-09-08 19:33:43 +06:00 · 2024-09-08 15:53:46 +06:00 · 2024-09-07 02:43:05 +06:00
47 changed files with 1403 additions and 270 deletions
--- a/.github/workflows/build.yml
+++ b/.github/workflows/build.yml
@@ -10,10 +10,11 @@ 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
+        run: ./gradlew build --no-daemon
--- a/.gitignore
+++ b/.gitignore
@@ -1,4 +1,5 @@
 .idea
+.kotlin
 out/*
 *.iml
 target
--- a/.template/bot/.env
+++ b/.template/bot/.env
@@ -0,0 +1,2 @@
+title=$prompt
+subtitle=Subtitle of {{$title}}
--- a/.template/bot/{{$title}}/README.md
+++ b/.template/bot/{{$title}}/README.md
@@ -0,0 +1,9 @@
+# {{$title}}
+
+
+
+## Launch
+
+```bash
+../gradlew run --args="BOT_TOKEN"
+```
--- a/.template/bot/{{$title}}/build.gradle
+++ b/.template/bot/{{$title}}/build.gradle
@@ -0,0 +1,22 @@
+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
@@ -0,0 +1,34 @@
+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
@@ -0,0 +1,208 @@
+#!/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.*
+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.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.*
-import dev.inmo.tgbotapi.types.chat.member.ChatCommonAdministratorRights
+import dev.inmo.tgbotapi.extensions.utils.types.buttons.flatReplyKeyboard
+import dev.inmo.tgbotapi.extensions.utils.types.buttons.requestChannelButton
 import dev.inmo.tgbotapi.types.request.RequestId
 import dev.inmo.tgbotapi.utils.regular
 import korlibs.time.DateFormat
@@ -52,12 +52,19 @@ suspend fun main(args: Array<String>) {
        }

        onChatShared(initialFilter = { it.chatEvent.requestId == requestChatId }) {
-            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"
+            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"
+                        }
+                    }
                }
            }
        }
--- a/BusinessConnectionsBot/README.md
+++ b/BusinessConnectionsBot/README.md
@@ -0,0 +1,9 @@
+# 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
@@ -0,0 +1,21 @@
+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
@@ -0,0 +1,102 @@
+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.*
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Dispatchers

 suspend fun main(args: Array<String>) {
    val bot = telegramBot(args.first())
--- a/CustomBot/README.md
+++ b/CustomBot/README.md
@@ -0,0 +1,9 @@
+# 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
@@ -0,0 +1,21 @@
+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
@@ -0,0 +1,37 @@
+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) {
+        // 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.*
+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.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.AccumulatorFlow
+import dev.inmo.micro_utils.coroutines.subscribeSafelyWithoutExceptions
 import dev.inmo.micro_utils.fsm.common.State
 import dev.inmo.tgbotapi.extensions.api.send.send
-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.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.utils.extensions.sameThread
-import dev.inmo.tgbotapi.extensions.utils.formatting.*
+import dev.inmo.tgbotapi.extensions.utils.textContentOrNull
+import dev.inmo.tgbotapi.extensions.utils.withContentOrNull
 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 dev.inmo.tgbotapi.utils.extensions.threadIdOrNull
-import kotlinx.coroutines.*
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.flow.filter
 import kotlinx.coroutines.flow.first

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

            when {
-                content is TextContent && content.parseCommandsWithArgs().keys.contains("stop") -> StopState(it.context)
+                content is TextContent && content.text == "/stop"
+                || content is TextContent && content.parseCommandsWithArgs().keys.contains("stop") -> StopState(it.context)
                else -> {
                    execute(content.createResend(it.context))
                    it
@@ -72,5 +73,17 @@ 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,38 +2,17 @@ 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.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.api.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.onContentMessage
 import dev.inmo.tgbotapi.extensions.behaviour_builder.triggers_handling.onMedia
 import dev.inmo.tgbotapi.requests.abstracts.asMultipartFile
-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.actions.*
 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.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.types.message.content.*
 import dev.inmo.tgbotapi.utils.filenameFromUrl
 import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.Dispatchers
@@ -55,13 +34,27 @@ suspend fun main(args: Array<String>) {
            val content = it.content
            val pathedFile = bot.getFileAdditionalInfo(content.media)
            val outFile = File(directoryOrFile, pathedFile.filePath.filenameFromUrl)
-            runCatching {
-                bot.downloadFile(content.media, outFile)
-            }.onFailure {
-                it.printStackTrace()
+            withTypingAction(it.chat.id) {
+                runCatching {
+                    bot.downloadFile(content.media, outFile)
+                }.onFailure {
+                    it.printStackTrace()
+                }.onSuccess { _ ->
+                    reply(it, "Saved to ${outFile.absolutePath}")
+                }
            }.onSuccess { _ ->
-                reply(it, "Saved to ${outFile.absolutePath}")
-                withAction(it.chat.id, TypingAction) {
+                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) {
                    when (content) {
                        is PhotoContent -> replyWithPhoto(
                            it,
--- a/GetMeBot/src/main/kotlin/GetMeBot.kt
+++ b/GetMeBot/src/main/kotlin/GetMeBot.kt
@@ -1,15 +1,13 @@
 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 most easiest bot - it will just print information about itself
+ * This is one of the easiest bots - 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
@@ -0,0 +1,9 @@
+# CustomBot
+
+Printing giveaways
+
+## Launch
+
+```bash
+../gradlew run --args="BOT_TOKEN"
+```
--- a/GiveawaysBot/build.gradle
+++ b/GiveawaysBot/build.gradle
@@ -0,0 +1,21 @@
+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
@@ -0,0 +1,57 @@
+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,23 +1,21 @@
 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.*
+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.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.*
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Dispatchers

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

    telegramBotWithBehaviourAndLongPolling(botToken, CoroutineScope(Dispatchers.IO)) {
        val me = getMe()
-        onMentionWithAnyContent(me) { message ->
-            val chat = message.chat
-
+        onContentMessage(
+            initialFilter = initialFilter@{ it.text ?.contains(me.username ?.full ?: return@initialFilter false) == true }
+        ) { message ->
            val answerText = when (val chat = message.chat) {
                is PreviewChannelChat -> {
-                    val answer = "Hi everybody in this channel \"${chat.title}\""
-                    reply(message, answer, MarkdownV2)
-                    return@onMentionWithAnyContent
+                    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
                }
                is PreviewPrivateChat -> {
                    reply(message, "Hi, " + "${chat.firstName} ${chat.lastName}".textMentionMarkdownV2(chat.id), MarkdownV2)
-                    return@onMentionWithAnyContent
+                    return@onContentMessage
                }
                is PreviewGroupChat -> {
-                    message.ifFromChannelGroupContentMessage {
+                    message.ifFromChannelGroupContentMessage<Unit> {
                        val answer = "Hi, ${it.senderChat.title}"
                        reply(message, answer, MarkdownV2)
-                        return@onMentionWithAnyContent
+                        return@onContentMessage
                    }
                    "Oh, hi, " + when (chat) {
                        is SupergroupChat -> (chat.username ?.username ?: getChat(chat).inviteLink) ?.let {
@@ -56,6 +65,10 @@ 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/src/jvmMain/kotlin/InlineQueriesBot.kt
+++ b/InlineQueriesBot/src/jvmMain/kotlin/InlineQueriesBot.kt
@@ -1,5 +1,3 @@
-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,14 +1,12 @@
 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.*
-import dev.inmo.tgbotapi.extensions.behaviour_builder.*
+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.*
 import dev.inmo.tgbotapi.extensions.utils.types.buttons.*
 import dev.inmo.tgbotapi.extensions.utils.withContent
@@ -17,11 +15,13 @@ import dev.inmo.tgbotapi.types.InlineQueries.InlineQueryResult.InlineQueryResult
 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.*
-import kotlinx.coroutines.*
-
-private const val nextPageData = "next"
-private const val previousPageData = "previous"
+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

 fun String.parsePageAndCount(): Pair<Int, Int>? {
    val (pageString, countString) = split(" ").takeIf { it.count() > 1 } ?: return null
@@ -73,6 +73,7 @@ fun InlineKeyboardBuilder.includePageButtons(page: Int, count: Int) {
    }
 }

+@OptIn(PreviewFeature::class)
 suspend fun activateKeyboardsBot(
    token: String,
    print: (Any) -> Unit
--- a/LinkPreviewsBot/src/main/kotlin/LinkPreviewsBot.kt
+++ b/LinkPreviewsBot/src/main/kotlin/LinkPreviewsBot.kt
@@ -3,24 +3,15 @@ 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

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

    bot.buildBehaviourWithLongPolling {
-        onContentMessage {
-            val url = it.withContentOrNull<TextedContent>() ?.let {
-                it.content.textSources.firstNotNullOfOrNull {
+        onContentMessage { contentMessage ->
+            val url = contentMessage.withContentOrNull<TextedContent>() ?.let { message ->
+                message.content.textSources.firstNotNullOfOrNull {
                    it.textLinkTextSourceOrNull() ?.url ?: it.uRLTextSourceOrNull() ?.source
                }
            } ?: null.apply {
-                reply(it) {
+                reply(contentMessage) {
                    regular("I am support only content with text contains url only")
                }
            } ?: return@onContentMessage
-            it.withContentOrNull<TextedContent>() ?.let {
+            contentMessage.withContentOrNull<TextedContent>() ?.let {
                send(
                    it.chat,
                    it.content.textSources,
--- a/LiveLocationsBot/src/main/kotlin/LiveLocationsBot.kt
+++ b/LiveLocationsBot/src/main/kotlin/LiveLocationsBot.kt
@@ -1,33 +1,15 @@
 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
@@ -64,7 +46,7 @@ suspend fun main(vararg args: String) {
                handleLiveLocation(
                    it.chat.id,
                    locationsFlow,
-                    sentMessageFlow = FlowCollector { currentMessageState.emit(it) }
+                    sentMessageFlow = { currentMessageState.emit(it) },
                )
            }

--- a/MemberUpdatedWatcherBot/README.md
+++ b/MemberUpdatedWatcherBot/README.md
@@ -0,0 +1,10 @@
+# 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
@@ -0,0 +1,21 @@
+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
@@ -0,0 +1,98 @@
+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,55 +1,78 @@
-import com.benasher44.uuid.uuid4
+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.api.chat.get.getChat
-import dev.inmo.tgbotapi.extensions.api.send.*
+import dev.inmo.tgbotapi.extensions.api.bot.setMyCommands
+import dev.inmo.tgbotapi.extensions.api.send.polls.sendQuizPoll
 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.*
-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.*
-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.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.types.IdChatIdentifier
+import dev.inmo.tgbotapi.types.PollId
+import dev.inmo.tgbotapi.types.ReplyParameters
+import dev.inmo.tgbotapi.types.polls.InputPollOption
 import dev.inmo.tgbotapi.types.polls.PollAnswer
-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 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 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
- * updates of any of it.
+ * any update.
 * 
 * * 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 me = getMe()
-
        val pollToChat = mutableMapOf<PollId, IdChatIdentifier>()
        val pollToChatMutex = Mutex()

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

-        onCommand("public") {
+        onCommand("public", requireOnlyCommandInMessage = false) {
+            val customEmoji = it.content.parseCommandsWithArgsSources()
+                .toList()
+                .firstOrNull { it.first.command == "public" }
+                ?.second
+                ?.firstNotNullOfOrNull { it.customEmojiTextSourceOrNull() }
            val sentPoll = sendRegularPoll(
-                it.chat,
-                "Test regular anonymous poll",
+                it.chat.id,
+                buildEntities {
+                    regular("Test regular non anonymous poll")
+                    if (customEmoji != null) {
+                        customEmoji(customEmoji.customEmojiId, customEmoji.subsources)
+                    }
+                },
                (1 .. 10).map {
-                    it.toString()
+                    InputPollOption {
+                        regular(it.toString()) + " "
+                        if (customEmoji != null) {
+                            customEmoji(customEmoji.customEmojiId, customEmoji.subsources)
+                        }
+                    }
                },
                isAnonymous = false,
                replyParameters = ReplyParameters(it)
@@ -74,6 +112,44 @@ 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

@@ -92,6 +168,12 @@ 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,7 +6,6 @@ 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
@@ -49,6 +48,7 @@ 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.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.api.send.withTypingAction
 import dev.inmo.tgbotapi.extensions.behaviour_builder.filters.MessageFilterByChat
-import dev.inmo.tgbotapi.extensions.behaviour_builder.triggers_handling.*
-import dev.inmo.tgbotapi.extensions.utils.shortcuts.*
+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.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.*
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.SupervisorJob
+import kotlinx.coroutines.currentCoroutineContext

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

@@ -37,7 +38,8 @@ suspend fun activateResenderBot(
                                entities = quote ?.textSources ?: emptyList(),
                                quotePosition = quote ?.position
                            )
-                        }
+                        },
+                        effectId = it.possiblyWithEffectMessageOrNull() ?.effectId
                    )
                ) {
                    it.forEach(print)
--- a/RightsChangerBot/src/main/kotlin/RightsChanger.kt
+++ b/RightsChangerBot/src/main/kotlin/RightsChanger.kt
@@ -16,7 +16,9 @@ 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.*
+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.triggers_handling.onCommand
 import dev.inmo.tgbotapi.extensions.behaviour_builder.triggers_handling.onMessageDataCallbackQuery
 import dev.inmo.tgbotapi.extensions.utils.*
@@ -27,12 +29,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.*
+import dev.inmo.tgbotapi.types.chat.member.AdministratorChatMember
+import dev.inmo.tgbotapi.types.chat.member.ChatCommonAdministratorRights
 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
@@ -52,6 +54,7 @@ sealed interface UserRetrievingStep : State {
    ) : UserRetrievingStep
 }

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

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

    suspend fun BehaviourContext.getUserChatPermissions(chatId: ChatId, userId: UserId): ChatPermissions? {
        val chatMember = getChatMember(chatId, userId)
-        return chatMember.restrictedChatMemberOrNull() ?: chatMember.whenMemberChatMember {
+        return chatMember.restrictedMemberChatMemberOrNull() ?: chatMember.whenMemberChatMember {
            getChat(chatId).extendedGroupChatOrNull() ?.permissions
        }
    }
@@ -224,7 +227,6 @@ 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) {
@@ -381,7 +383,6 @@ suspend fun main(args: Array<String>) {
            val userId = ChatId(RawChatId(userIdString.toLong()))
            val chatMember = getChatMember(channelId, userId)
            val asAdmin = chatMember.administratorChatMemberOrNull()
-            val asMember = chatMember.memberChatMemberOrNull()

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

@@ -504,7 +505,6 @@ 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
@@ -0,0 +1,9 @@
+# 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
@@ -0,0 +1,21 @@
+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
@@ -0,0 +1,184 @@
+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,29 +1,25 @@
 import dev.inmo.micro_utils.coroutines.defaultSafelyWithoutExceptionHandler
 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.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.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.types.StickerType
-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.message.textsources.CustomEmojiTextSource
+import dev.inmo.tgbotapi.types.message.textsources.regular
+import dev.inmo.tgbotapi.types.message.textsources.separateForText
 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.*
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.SupervisorJob
+import kotlinx.coroutines.currentCoroutineContext

 fun StickerSet?.buildInfo() = buildEntities {
    if (this@buildInfo == null) {
@@ -31,12 +27,6 @@ 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"
--- 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,12 +10,14 @@ 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.*
+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.toChatId
 import dev.inmo.tgbotapi.utils.botCommand
 import kotlinx.coroutines.CoroutineScope
@@ -56,16 +58,19 @@ 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()
                )
@@ -74,18 +79,25 @@ suspend fun main(args: Array<String>) {
            runCatchingSafely {
                getStickerSet(stickerSetName)
            }.onSuccess { stickerSet ->
-                addStickerToSet(it.chat.id.toChatId(), stickerSet.name, newSticker).also { _ ->
+                runCatching {
+                    addStickerToSet(it.chat.id.toChatId(), stickerSet.name, newSticker).also { _ ->
+                        reply(
+                            it,
+                            getStickerSet(stickerSetName).stickers.last()
+                        )
+                    }
+                }.onFailure { exception ->
+                    exception.printStackTrace()
                    reply(
                        it,
-                        getStickerSet(stickerSetName).stickers.last()
+                        "Unable to add sticker in stickerset"
                    )
                }
-            }.onFailure { _ ->
+            }.onFailure { exception ->
                createNewStickerSet(
                    it.chat.id.toChatId(),
                    stickerSetName.string,
                    "Sticker set by ${me.firstName}",
-                    it.content.media.stickerFormat,
                    listOf(
                        newSticker
                    ),
@@ -98,5 +110,9 @@ 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,18 +1,8 @@
 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.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.chat.forum.*
 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,12 +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.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.*
+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.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
@@ -18,6 +21,15 @@ 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)

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

+@OptIn(ExperimentalUnsignedTypes::class)
 fun main() {
    console.log("Web app started")
    val client = HttpClient()
@@ -38,7 +39,7 @@ fun main() {
            scope.launchSafelyWithoutExceptions {
                val response = client.post("$baseUrl/check") {
                    setBody(
-                        Json { }.encodeToString(
+                        Json.encodeToString(
                            WebAppDataWrapper.serializer(),
                            WebAppDataWrapper(webApp.initData, webApp.initDataUnsafe.hash)
                        )
@@ -181,7 +182,7 @@ fun main() {
                    val hex = Color.Hex(r, g, b)
                    webApp.setHeaderColor(hex)
                    (this as? HTMLButtonElement) ?.style ?.backgroundColor = hex.value
-                    textContent = "Header color: ${hex.value.uppercase()} (click to change)"
+                    textContent = "Header color: ${webApp.headerColor ?.uppercase()} (click to change)"
                }
                addEventListener("click", {
                    updateHeaderColor()
@@ -191,6 +192,38 @@ 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 {
@@ -286,6 +319,16 @@ 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,19 +1,20 @@
-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.kslog.common.*
 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.*
+import dev.inmo.tgbotapi.extensions.api.send.reply
+import dev.inmo.tgbotapi.extensions.api.send.send
 import dev.inmo.tgbotapi.extensions.api.telegramBot
-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.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.requests.answers.InlineQueryResultsButton
 import dev.inmo.tgbotapi.types.BotCommand
 import dev.inmo.tgbotapi.types.InlineQueries.InlineQueryResult.InlineQueryResultArticle
@@ -24,22 +25,21 @@ 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.call
+import io.ktor.server.application.*
 import io.ktor.server.http.content.*
-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 io.ktor.server.request.*
+import io.ktor.server.response.*
+import io.ktor.server.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,6 +58,7 @@ suspend fun main(vararg args: String) {
            }
        )
    }
+    val initiationLogger = KSLog("Initialization")

    val bot = telegramBot(telegramBotAPIUrlsKeeper)
    createKtorServer(
@@ -69,12 +70,28 @@ suspend fun main(vararg args: String) {
    ) {
        routing {
            val baseJsFolder = File("WebApp/build/dist/js/")
-            baseJsFolder.list() ?.forEach {
-                if (it == "productionExecutable" || it == "developmentExecutable") {
-                    staticFiles("", File(baseJsFolder, it)) {
-                        default("WebApp/build/dist/js/$it/index.html")
-                    }
+            val prodSubFolder = File(baseJsFolder, "productionExecutable")
+            val devSubFolder = File(baseJsFolder, "developmentExecutable")
+
+            val staticFolder = when {
+                prodSubFolder.exists() -> {
+                    initiationLogger.i("Folder for static is ${prodSubFolder.absolutePath}")
+                    prodSubFolder
                }
+                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()
@@ -85,7 +102,7 @@ suspend fun main(vararg args: String) {
            }
            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)

@@ -97,7 +114,6 @@ suspend fun main(vararg args: String) {
    bot.buildBehaviourWithLongPolling(
        defaultExceptionsHandler = { it.printStackTrace() }
    ) {
-        val me = getMe()
        onCommand("reply_markup") {
            reply(
                it,
--- a/gradle.properties
+++ b/gradle.properties
@@ -1,11 +1,12 @@
 kotlin.code.style=official
 org.gradle.parallel=true
 # Due to parallel compilation project require next amount of memory on full build
-org.gradle.jvmargs=-Xmx2344m
+org.gradle.jvmargs=-Xmx3148m
+kotlin.daemon.jvmargs=-Xmx3g -Xms500m


-kotlin_version=1.9.23
-telegram_bot_api_version=11.0.0
-micro_utils_version=0.20.39
-serialization_version=1.6.3
-ktor_version=2.3.9
+kotlin_version=2.0.20
+telegram_bot_api_version=18.2.0
+micro_utils_version=0.22.2
+serialization_version=1.7.2
+ktor_version=2.3.12
--- 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.6-bin.zip
+distributionUrl=https\://services.gradle.org/distributions/gradle-8.9-bin.zip
--- a/settings.gradle
+++ b/settings.gradle
@@ -47,3 +47,13 @@ include ":ReactionsInfoBot"
 include ":LinkPreviewsBot"

 include ":BoostsInfoBot"
+
+include ":BusinessConnectionsBot"
+
+include ":StarTransactionsBot"
+
+include ":GiveawaysBot"
+
+include ":CustomBot"
+
+include ":MemberUpdatedWatcherBot"
Author	SHA1	Message	Date
InsanusMokrassar	14235e7bd4	update GiveawaysBot	2024-09-08 23:38:19 +06:00
InsanusMokrassar	6eafd89542	add println of giveaway content	2024-09-08 19:44:51 +06:00
InsanusMokrassar	ed2922045c	add giveaways bot	2024-09-08 19:33:43 +06:00
InsanusMokrassar	21ec50c773	add opportunity to use test server in custom bot	2024-09-08 15:53:46 +06:00
InsanusMokrassar	ab362e8c3b	start updating up to 18.2.0	2024-09-07 02:43:05 +06:00
InsanusMokrassar	346755b41c	Merge pull request #282 from InsanusMokrassar/renovate/telegram_bot_api_version Update telegram_bot_api_version to v18.1.0	2024-09-05 03:17:20 +06:00
renovate[bot]	a601674d71	Update telegram_bot_api_version to v18.1.0	2024-09-04 21:02:48 +00:00
InsanusMokrassar	b6c92f754f	Merge pull request #287 from InsanusMokrassar/18.0.0 18.0.0	2024-09-02 07:59:08 +06:00
InsanusMokrassar	023b810d07	update micro_utils dependency	2024-09-02 01:24:11 +06:00
InsanusMokrassar	0ec543d5c5	update sample of MemberUpdatedWatcher bot	2024-08-30 23:32:29 +06:00
InsanusMokrassar	777604e5a0	update new samples	2024-08-30 19:06:38 +06:00
InsanusMokrassar	999c33b2f5	Merge pull request #286 from Nik-mmzd/chatmemberupdated Add MemberUpdatedWatcherBot example utilizing new 18.0.0 extensions	2024-08-30 18:42:18 +06:00
InsanusMokrassar	ca0427bfdd	Merge branch '18.0.0' into chatmemberupdated	2024-08-30 18:41:59 +06:00
InsanusMokrassar	a62a14a599	migration onto 18.0.0	2024-08-30 18:40:39 +06:00
McModder	3efd3463a3	Add MemberUpdatedWatcherBot example utilizing new 18.0.0 extensions	2024-08-29 22:40:47 +03:00
InsanusMokrassar	590f9ec6d8	Merge pull request #280 from InsanusMokrassar/17.0.0 17.0.0	2024-08-15 19:17:08 +06:00
InsanusMokrassar	acdbd4d2ea	update HelloBot	2024-08-15 01:51:10 +06:00
InsanusMokrassar	d2d913fca8	update telegram bots api	2024-08-14 23:33:43 +06:00
InsanusMokrassar	75726cac89	Merge pull request #276 from InsanusMokrassar/16.0.0 16.0.0	2024-08-12 08:13:59 +06:00
InsanusMokrassar	71b64689d0	Update gradle.properties	2024-08-12 02:32:28 +06:00
InsanusMokrassar	5ba2fc5bab	update githab workflow	2024-08-11 19:52:15 +06:00
InsanusMokrassar	51a5bfb81a	update gradle wrapper	2024-08-11 19:49:31 +06:00
InsanusMokrassar	35e330c016	update kotlin	2024-08-11 19:49:31 +06:00
InsanusMokrassar	90d447fbcf	update up to 16.0.0	2024-08-11 19:49:31 +06:00
InsanusMokrassar	2c5da5da9f	Merge pull request #278 from InsanusMokrassar/15.3.0 15.3.0	2024-08-02 19:29:33 +06:00
InsanusMokrassar	f79e43364a	fixes in sample of business_connections bot	2024-08-02 16:48:56 +06:00
InsanusMokrassar	f5a9efa3e7	add pin/unpin in business connection	2024-08-02 00:39:37 +06:00
InsanusMokrassar	b70b6d1e2b	Merge pull request #273 from InsanusMokrassar/renovate/telegram_bot_api_version Update telegram_bot_api_version to v15.2.0	2024-07-29 15:48:37 +06:00
renovate[bot]	3f36a04ac2	Update telegram_bot_api_version to v15.2.0	2024-07-15 15:22:03 +00:00
InsanusMokrassar	62b830d31b	Merge pull request #274 from InsanusMokrassar/15.1.0 15.1.0	2024-07-12 14:55:52 +06:00
InsanusMokrassar	06459ebc0a	improve boosts info bot	2024-07-11 21:14:53 +06:00
InsanusMokrassar	673424b234	Merge pull request #275 from bpavuk/bpavuk.code-cleanup code cleanup	2024-07-11 19:55:13 +06:00
bpavuk	5d156f6708	reverted explicit class cast removal	2024-07-11 16:48:54 +03:00
bpavuk	529f4156fd	reverted elvis fold	2024-07-11 16:47:57 +03:00
bpavuk	7842ac0dac	Added description for StarTransactionsBot	2024-07-10 19:51:07 +03:00
bpavuk	358f2d27d3	reverted CustomBot body	2024-07-10 19:33:40 +03:00
bpavuk	7964dc4eea	code cleanup optimized imports here and there, made CustomBot working as intended	2024-07-10 19:25:00 +03:00
InsanusMokrassar	9fb6570d21	add refund reply and paid media info content additional println	2024-07-10 17:48:43 +06:00
InsanusMokrassar	f750589fd3	add sendPaid in StarTransactions bot	2024-07-10 17:07:36 +06:00
InsanusMokrassar	481533bee2	start update up to 15.1.0	2024-07-09 17:00:26 +06:00
InsanusMokrassar	a1a4338869	Merge pull request #272 from InsanusMokrassar/15.0.0 15.0.0	2024-07-07 22:27:40 +06:00
InsanusMokrassar	d8e5825ccf	update gradle parameters	2024-07-07 19:35:21 +06:00
InsanusMokrassar	3a4c0c4226	start 15.0.0	2024-06-24 18:13:19 +06:00
InsanusMokrassar	b85d7a697c	update dependencies	2024-06-21 22:40:19 +06:00
InsanusMokrassar	ad57e4142c	Merge pull request #268 from InsanusMokrassar/14.0.0 14.0.0	2024-06-01 20:32:53 +06:00
InsanusMokrassar	c7068182e3	make initialization of web app server more verbose	2024-06-01 20:31:51 +06:00
InsanusMokrassar	a5740e6315	change telegram bot api version to release one	2024-06-01 13:37:31 +06:00
InsanusMokrassar	3a35995bc7	several fixes and improvements	2024-06-01 13:19:05 +06:00
InsanusMokrassar	41fc5a9a4c	Merge pull request #264 from InsanusMokrassar/13.0.0 13.0.0	2024-05-10 20:56:51 +06:00
InsanusMokrassar	79700f24e5	small updates	2024-05-10 19:53:21 +06:00
InsanusMokrassar	73c1af15b3	add CustomBot	2024-05-10 18:46:47 +06:00
InsanusMokrassar	aa9ca976f0	update polls to include showing of polls question and explanation text sources passing	2024-05-10 16:45:47 +06:00
InsanusMokrassar	238533a350	update polls sample	2024-05-10 16:35:07 +06:00
InsanusMokrassar	6f2a8bb0be	Update gradle.properties	2024-04-26 10:45:55 +06:00
InsanusMokrassar	99232b53d7	Merge pull request #260 from InsanusMokrassar/12.0.0 12.0.0	2024-04-21 00:25:25 +06:00
InsanusMokrassar	30358f7d2f	Merge pull request #258 from InsanusMokrassar/11.0.0 11.0.0	2024-04-21 00:24:07 +06:00
InsanusMokrassar	11a97c520a	update	2024-04-19 19:34:48 +06:00
InsanusMokrassar	d6a6ad8d37	improvements in samples	2024-04-19 18:10:46 +06:00
InsanusMokrassar	c04a367375	fixes and improvements	2024-04-18 20:06:59 +06:00
InsanusMokrassar	b660bf5f42	upgrade to support new ktgbotapi	2024-04-18 17:03:53 +06:00