Update Gradle to v9

Merge pull request #351 from InsanusMokrassar/29.0.0
29.0.0
2025-12-05 13:55:38 +00:00 · 2025-11-17 15:01:04 +00:00 · 2025-09-28 10:54:27 +06:00 · 2025-09-25 14:05:44 +06:00 · 2025-09-25 14:04:47 +06:00 · 2025-09-23 18:29:42 +06:00
45 changed files with 2330 additions and 485 deletions
--- a/BusinessConnectionsBot/src/main/kotlin/BusinessConnectionsBot.kt
+++ b/BusinessConnectionsBot/src/main/kotlin/BusinessConnectionsBot.kt
@@ -2,24 +2,69 @@ 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.common.Percentage
+import dev.inmo.tgbotapi.extensions.api.answers.answer
 import dev.inmo.tgbotapi.extensions.api.bot.getMe
+import dev.inmo.tgbotapi.extensions.api.business.getBusinessAccountStarBalance
+import dev.inmo.tgbotapi.extensions.api.business.deleteBusinessMessages
+import dev.inmo.tgbotapi.extensions.api.business.getBusinessAccountGifts
+import dev.inmo.tgbotapi.extensions.api.business.getBusinessAccountGiftsFlow
+import dev.inmo.tgbotapi.extensions.api.business.readBusinessMessage
+import dev.inmo.tgbotapi.extensions.api.business.removeBusinessAccountProfilePhoto
+import dev.inmo.tgbotapi.extensions.api.business.setBusinessAccountBio
+import dev.inmo.tgbotapi.extensions.api.business.setBusinessAccountName
+import dev.inmo.tgbotapi.extensions.api.business.setBusinessAccountProfilePhoto
+import dev.inmo.tgbotapi.extensions.api.business.setBusinessAccountUsername
+import dev.inmo.tgbotapi.extensions.api.business.transferBusinessAccountStars
+import dev.inmo.tgbotapi.extensions.api.chat.get.getChat
 import dev.inmo.tgbotapi.extensions.api.chat.modify.pinChatMessage
 import dev.inmo.tgbotapi.extensions.api.chat.modify.unpinChatMessage
+import dev.inmo.tgbotapi.extensions.api.files.downloadFileToTemp
 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.api.stories.deleteStory
+import dev.inmo.tgbotapi.extensions.api.stories.postStory
 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.commonMessageOrNull
+import dev.inmo.tgbotapi.extensions.utils.extendedPrivateChatOrThrow
 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.extensions.utils.types.buttons.dataButton
+import dev.inmo.tgbotapi.extensions.utils.types.buttons.inlineKeyboard
+import dev.inmo.tgbotapi.extensions.utils.updates.retrieving.flushAccumulatedUpdates
+import dev.inmo.tgbotapi.extensions.utils.withContentOrNull
+import dev.inmo.tgbotapi.requests.abstracts.multipartFile
+import dev.inmo.tgbotapi.requests.business_connection.InputProfilePhoto
+import dev.inmo.tgbotapi.requests.stories.PostStory
 import dev.inmo.tgbotapi.types.ChatId
+import dev.inmo.tgbotapi.types.MessageId
+import dev.inmo.tgbotapi.types.RawChatId
 import dev.inmo.tgbotapi.types.business_connection.BusinessConnectionId
+import dev.inmo.tgbotapi.types.chat.PrivateChat
+import dev.inmo.tgbotapi.types.message.abstracts.CommonMessage
+import dev.inmo.tgbotapi.types.message.content.PhotoContent
+import dev.inmo.tgbotapi.types.message.content.StoryContent
+import dev.inmo.tgbotapi.types.message.content.TextContent
+import dev.inmo.tgbotapi.types.message.content.VideoContent
+import dev.inmo.tgbotapi.types.message.content.VisualMediaGroupPartContent
+import dev.inmo.tgbotapi.types.stories.InputStoryContent
+import dev.inmo.tgbotapi.types.stories.StoryArea
+import dev.inmo.tgbotapi.types.stories.StoryAreaPosition
+import dev.inmo.tgbotapi.types.stories.StoryAreaType
+import dev.inmo.tgbotapi.utils.botCommand
+import dev.inmo.tgbotapi.utils.code
+import dev.inmo.tgbotapi.utils.extensions.splitForText
+import dev.inmo.tgbotapi.utils.row
+import korlibs.time.seconds
 import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.delay
 import kotlinx.coroutines.sync.Mutex
 import kotlinx.coroutines.sync.withLock
+import kotlinx.serialization.json.Json

 suspend fun main(args: Array<String>) {
    val botToken = args.first()
@@ -34,21 +79,25 @@ suspend fun main(args: Array<String>) {
    }

    val businessConnectionsChats = mutableMapOf<BusinessConnectionId, ChatId>()
+    val chatsBusinessConnections = mutableMapOf<ChatId, BusinessConnectionId>()
    val businessConnectionsChatsMutex = Mutex()

    telegramBotWithBehaviourAndLongPolling(botToken, CoroutineScope(Dispatchers.IO)) {
        val me = getMe()
        println(me)
+        flushAccumulatedUpdates()

        onBusinessConnectionEnabled {
            businessConnectionsChatsMutex.withLock {
                businessConnectionsChats[it.id] = it.userChatId
+                chatsBusinessConnections[it.userChatId] = it.id
            }
            send(it.userChatId, "Business connection ${it.businessConnectionId.string} has been enabled")
        }
        onBusinessConnectionDisabled {
            businessConnectionsChatsMutex.withLock {
                businessConnectionsChats.remove(it.id)
+                chatsBusinessConnections.remove(it.userChatId)
            }
            send(it.userChatId, "Business connection ${it.businessConnectionId.string} has been disabled")
        }
@@ -71,7 +120,20 @@ suspend fun main(args: Array<String>) {
                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")
+                    reply(
+                        to = sent,
+                        text = "User have sent this message to you in the ${businessContentMessage.businessConnectionId.string} related chat",
+                    )
+                    send(
+                        chatId = businessConnectionsChats[it.businessConnectionId] ?: return@ifBusinessContentMessage,
+                        text = "User have sent this message to you in the ${businessContentMessage.businessConnectionId.string} related chat",
+                        replyMarkup = inlineKeyboard {
+                            row {
+                                dataButton("Read message", "read ${it.chat.id.chatId.long} ${it.messageId.long}")
+                                dataButton("Delete message", "delete ${it.chat.id.chatId.long} ${it.messageId.long}")
+                            }
+                        }
+                    )
                }
            }
        }
@@ -98,5 +160,328 @@ suspend fun main(args: Array<String>) {
            }
            send(businessConnectionOwnerChat, "There are several removed messages in chat ${it.chat.id}: ${it.messageIds}")
        }
+        onCommand("get_business_account_info", initialFilter = { it.chat is PrivateChat }) {
+            val businessConnectionId = chatsBusinessConnections[it.chat.id]
+            val businessConnectionInfo = businessConnectionId ?.let { getBusinessConnection(it) }
+            reply(it) {
+                if (businessConnectionInfo == null) {
+                    +"There is no business connection for current chat"
+                } else {
+                    +(Json { prettyPrint = true; encodeDefaults = true }.encodeToString(businessConnectionInfo))
+                }
+            }
+        }
+        onMessageDataCallbackQuery(Regex("read \\d+ \\d+")) {
+            val (_, chatIdString, messageIdString) = it.data.split(" ")
+            val chatId = chatIdString.toLongOrNull() ?.let(::RawChatId) ?.let(::ChatId) ?: return@onMessageDataCallbackQuery
+            val messageId = messageIdString.toLongOrNull() ?.let(::MessageId) ?: return@onMessageDataCallbackQuery
+            val businessConnectionId = chatsBusinessConnections[it.message.chat.id]
+
+            val readResponse = businessConnectionId ?.let { readBusinessMessage(it, chatId, messageId) }
+            answer(
+                it,
+                if (readResponse == null) {
+                    "There is no business connection for current chat"
+                } else {
+                    "Message has been read"
+                }
+            )
+        }
+        onMessageDataCallbackQuery(Regex("delete \\d+ \\d+")) {
+            val (_, chatIdString, messageIdString) = it.data.split(" ")
+            val chatId = chatIdString.toLongOrNull() ?.let(::RawChatId) ?.let(::ChatId) ?: return@onMessageDataCallbackQuery
+            val messageId = messageIdString.toLongOrNull() ?.let(::MessageId) ?: return@onMessageDataCallbackQuery
+            val businessConnectionId = chatsBusinessConnections[it.message.chat.id]
+
+            val readResponse = businessConnectionId ?.let { deleteBusinessMessages(it, listOf(messageId)) }
+            answer(
+                it,
+                if (readResponse == null) {
+                    "There is no business connection for current chat"
+                } else {
+                    "Message has been deleted"
+                }
+            )
+        }
+        onCommandWithArgs("set_business_account_name", initialFilter = { it.chat is PrivateChat }) { it, args ->
+            val firstName = args[0]
+            val secondName = args.getOrNull(1)
+            val businessConnectionId = chatsBusinessConnections[it.chat.id] ?: return@onCommandWithArgs
+            val set = runCatching {
+                setBusinessAccountName(
+                    businessConnectionId,
+                    firstName,
+                    secondName
+                )
+            }.getOrElse { false }
+            reply(it) {
+                if (set) {
+                    +"Account name has been set"
+                } else {
+                    +"Account name has not been set"
+                }
+            }
+        }
+        onCommandWithArgs("set_business_account_username", initialFilter = { it.chat is PrivateChat }) { it, args ->
+            val username = args[0]
+            val businessConnectionId = chatsBusinessConnections[it.chat.id] ?: return@onCommandWithArgs
+            val set = runCatching {
+                setBusinessAccountUsername(
+                    businessConnectionId,
+                    username
+                )
+            }.getOrElse {
+                it.printStackTrace()
+                false
+            }
+            reply(it) {
+                if (set) {
+                    +"Account username has been set"
+                } else {
+                    +"Account username has not been set"
+                }
+            }
+        }
+        onCommand("get_business_account_star_balance", initialFilter = { it.chat is PrivateChat }) {
+            val businessConnectionId = chatsBusinessConnections[it.chat.id] ?: return@onCommand
+            val starAmount = runCatching {
+                getBusinessAccountStarBalance(businessConnectionId)
+            }.getOrElse {
+                it.printStackTrace()
+                null
+            }
+            reply(it) {
+                if (starAmount != null) {
+                    +"Account stars amount: $starAmount"
+                } else {
+                    +"Account stars amount has not been got"
+                }
+            }
+        }
+        onCommandWithArgs("transfer_business_account_stars", initialFilter = { it.chat is PrivateChat }) { it, args ->
+            val businessConnectionId = chatsBusinessConnections[it.chat.id] ?: return@onCommandWithArgs
+            val count = args.firstOrNull() ?.toIntOrNull() ?: reply(it) {
+                "Pass amount of stars to transfer to bot with command"
+            }.let {
+                return@onCommandWithArgs
+            }
+            val transferred = runCatching {
+                transferBusinessAccountStars(businessConnectionId, count)
+            }.getOrElse {
+                it.printStackTrace()
+                false
+            }
+            reply(it) {
+                if (transferred) {
+                    +"Stars have been transferred"
+                } else {
+                    +"Stars have not been transferred"
+                }
+            }
+        }
+        onCommand("get_business_account_gifts", initialFilter = { it.chat is PrivateChat }) {
+            val businessConnectionId = chatsBusinessConnections[it.chat.id] ?: return@onCommand
+            val giftsFlow = runCatching {
+                getBusinessAccountGiftsFlow(businessConnectionId)
+            }.getOrElse {
+                it.printStackTrace()
+                null
+            }
+            if (giftsFlow == null) {
+                reply(it) {
+                    +"Error in receiving of gifts"
+                }
+            } else {
+                giftsFlow.collect { giftsPage ->
+                    giftsPage.gifts.joinToString {
+                        it.toString()
+                    }.splitForText().forEach { message ->
+                        reply(it, message)
+                    }
+                }
+            }
+        }
+        onCommand("set_business_account_bio", requireOnlyCommandInMessage = false, initialFilter = { it.chat is PrivateChat }) {
+            val initialBio = getChat(it.chat).extendedPrivateChatOrThrow().bio
+            val bio = it.content.text.removePrefix("/set_business_account_bio").trim()
+            val businessConnectionId = chatsBusinessConnections[it.chat.id] ?: return@onCommand
+            val set = runCatching {
+                setBusinessAccountBio(
+                    businessConnectionId,
+                    bio
+                )
+            }.getOrElse {
+                it.printStackTrace()
+                false
+            }
+            reply(it) {
+                if (set) {
+                    +"Account bio has been set. It will be reset within 15 seconds.\n\nInitial bio: " + code(initialBio)
+                } else {
+                    +"Account bio has not been set"
+                }
+            }
+            delay(15.seconds)
+            val reset = runCatching {
+                setBusinessAccountBio(
+                    businessConnectionId,
+                    initialBio
+                )
+            }.getOrElse {
+                it.printStackTrace()
+                false
+            }
+            reply(it) {
+                if (reset) {
+                    +"Account bio has been reset"
+                } else {
+                    +"Account bio has not been set. Set it manually: " + code(initialBio)
+                }
+            }
+        }
+        suspend fun handleSetProfilePhoto(it: CommonMessage<TextContent>, isPublic: Boolean) {
+            val businessConnectionId = chatsBusinessConnections[it.chat.id] ?: return@handleSetProfilePhoto
+            val replyTo = it.replyTo ?.commonMessageOrNull() ?.withContentOrNull<PhotoContent>()
+            if (replyTo == null) {
+                reply(it) {
+                    +"Reply to photo for using of this command"
+                }
+                return@handleSetProfilePhoto
+            }
+
+            val set = runCatching {
+                val file = downloadFileToTemp(replyTo.content)
+                setBusinessAccountProfilePhoto(
+                    businessConnectionId,
+                    InputProfilePhoto.Static(
+                        file.multipartFile()
+                    ),
+                    isPublic = isPublic
+                )
+            }.getOrElse {
+                it.printStackTrace()
+                false
+            }
+            reply(it) {
+                if (set) {
+                    +"Account profile photo has been set. It will be reset within 15 seconds"
+                } else {
+                    +"Account profile photo has not been set"
+                }
+            }
+            if (set == false) { return@handleSetProfilePhoto }
+            delay(15.seconds)
+            val reset = runCatching {
+                removeBusinessAccountProfilePhoto(
+                    businessConnectionId,
+                    isPublic = isPublic
+                )
+            }.getOrElse {
+                it.printStackTrace()
+                false
+            }
+            reply(it) {
+                if (reset) {
+                    +"Account profile photo has been reset"
+                } else {
+                    +"Account profile photo has not been set. Set it manually"
+                }
+            }
+        }
+        onCommand("set_business_account_profile_photo", initialFilter = { it.chat is PrivateChat }) {
+            handleSetProfilePhoto(it, false)
+        }
+        onCommand("set_business_account_profile_photo_public", initialFilter = { it.chat is PrivateChat }) {
+            handleSetProfilePhoto(it, true)
+        }
+
+        onCommand("post_story", initialFilter = { it.chat is PrivateChat }) {
+            val businessConnectionId = chatsBusinessConnections[it.chat.id] ?: return@onCommand
+            val replyTo = it.replyTo ?.commonMessageOrNull() ?.withContentOrNull<VisualMediaGroupPartContent>()
+            if (replyTo == null) {
+                reply(it) {
+                    +"Reply to photo or video for using of this command"
+                }
+                return@onCommand
+            }
+
+            val posted = runCatching {
+                val file = downloadFileToTemp(replyTo.content)
+                postStory(
+                    businessConnectionId,
+                    when (replyTo.content) {
+                        is PhotoContent -> InputStoryContent.Photo(
+                            file.multipartFile()
+                        )
+                        is VideoContent -> InputStoryContent.Video(
+                            file.multipartFile()
+                        )
+                    },
+                    activePeriod = PostStory.ACTIVE_PERIOD_6_HOURS,
+                    areas = listOf(
+                        StoryArea(
+                            StoryAreaPosition(
+                                x = Percentage.of100(50.0),
+                                y = Percentage.of100(50.0),
+                                width = Percentage.of100(8.0),
+                                height = Percentage.of100(8.0),
+                                rotationAngle = 45.0,
+                                cornerRadius = Percentage.of100(4.0),
+                            ),
+                            StoryAreaType.Link(
+                                "https://github.com/InsanusMokrassar/TelegramBotAPI-examples/blob/master/BusinessConnectionsBot/src/main/kotlin/BusinessConnectionsBot.kt"
+                            )
+                        )
+                    )
+                ) {
+                    +"It is test of postStory :)"
+                }
+            }.getOrElse {
+                it.printStackTrace()
+                null
+            }
+            reply(it) {
+                if (posted != null) {
+                    +"Story has been posted. You may unpost it with " + botCommand("remove_story")
+                } else {
+                    +"Story has not been posted"
+                }
+            }
+        }
+
+        onCommand("delete_story", initialFilter = { it.chat is PrivateChat }) {
+            val businessConnectionId = chatsBusinessConnections[it.chat.id] ?: return@onCommand
+            val replyTo = it.replyTo ?.commonMessageOrNull() ?.withContentOrNull<StoryContent>()
+            if (replyTo == null) {
+                reply(it) {
+                    +"Reply to photo or video for using of this command"
+                }
+                return@onCommand
+            }
+
+            val deleted = runCatching {
+                deleteStory(businessConnectionId, replyTo.content.story.id)
+            }.getOrElse {
+                it.printStackTrace()
+                false
+            }
+            reply(it) {
+                if (deleted) {
+                    +"Story has been deleted"
+                } else {
+                    +"Story has not been deleted"
+                }
+            }
+        }
+
+        // Will work when some premium user sending to some other user checklist
+        onChecklistContent {
+            execute(
+                it.content.createResend(
+                    it.chat.id,
+                    businessConnectionId = it.chat.id.businessConnectionId ?: chatsBusinessConnections[it.chat.id] ?: return@onChecklistContent
+                )
+            )
+        }
    }.second.join()
 }
--- a/ChecklistsBot/build.gradle
+++ b/ChecklistsBot/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="ChecklistsBotKt"
+
+
+dependencies {
+    implementation "org.jetbrains.kotlin:kotlin-stdlib:$kotlin_version"
+
+    implementation "dev.inmo:tgbotapi:$telegram_bot_api_version"
+}
--- a/ChecklistsBot/src/main/kotlin/ChecklistsBot.kt
+++ b/ChecklistsBot/src/main/kotlin/ChecklistsBot.kt
@@ -0,0 +1,120 @@
+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.runCatchingLogging
+import dev.inmo.micro_utils.coroutines.subscribeLoggingDropExceptions
+import dev.inmo.micro_utils.coroutines.subscribeSafelyWithoutExceptions
+import dev.inmo.tgbotapi.extensions.api.bot.getMe
+import dev.inmo.tgbotapi.extensions.api.bot.getMyStarBalance
+import dev.inmo.tgbotapi.extensions.api.chat.get.getChat
+import dev.inmo.tgbotapi.extensions.api.send.reply
+import dev.inmo.tgbotapi.extensions.api.send.resend
+import dev.inmo.tgbotapi.extensions.api.send.send
+import dev.inmo.tgbotapi.extensions.api.suggested.approveSuggestedPost
+import dev.inmo.tgbotapi.extensions.behaviour_builder.BehaviourContextData
+import dev.inmo.tgbotapi.extensions.behaviour_builder.buildSubcontextInitialAction
+import dev.inmo.tgbotapi.extensions.behaviour_builder.expectations.waitSuggestedPostApproved
+import dev.inmo.tgbotapi.extensions.behaviour_builder.expectations.waitSuggestedPostDeclined
+import dev.inmo.tgbotapi.extensions.behaviour_builder.telegramBotWithBehaviourAndLongPolling
+import dev.inmo.tgbotapi.extensions.behaviour_builder.triggers_handling.onChannelDirectMessagesConfigurationChanged
+import dev.inmo.tgbotapi.extensions.behaviour_builder.triggers_handling.onChecklistContent
+import dev.inmo.tgbotapi.extensions.behaviour_builder.triggers_handling.onChecklistTasksAdded
+import dev.inmo.tgbotapi.extensions.behaviour_builder.triggers_handling.onChecklistTasksDone
+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.onSuggestedPostApprovalFailed
+import dev.inmo.tgbotapi.extensions.behaviour_builder.triggers_handling.onSuggestedPostApproved
+import dev.inmo.tgbotapi.extensions.behaviour_builder.triggers_handling.onSuggestedPostDeclined
+import dev.inmo.tgbotapi.extensions.behaviour_builder.triggers_handling.onSuggestedPostPaid
+import dev.inmo.tgbotapi.extensions.behaviour_builder.triggers_handling.onSuggestedPostRefunded
+import dev.inmo.tgbotapi.extensions.utils.channelDirectMessagesContentMessageOrNull
+import dev.inmo.tgbotapi.extensions.utils.previewChannelDirectMessagesChatOrNull
+import dev.inmo.tgbotapi.extensions.utils.suggestedChannelDirectMessagesContentMessageOrNull
+import dev.inmo.tgbotapi.types.checklists.ChecklistTaskId
+import dev.inmo.tgbotapi.types.message.SuggestedPostParameters
+import dev.inmo.tgbotapi.types.message.abstracts.CommonMessage
+import dev.inmo.tgbotapi.types.message.content.ChecklistContent
+import dev.inmo.tgbotapi.types.message.textsources.TextSourcesList
+import dev.inmo.tgbotapi.types.update.abstracts.Update
+import dev.inmo.tgbotapi.utils.bold
+import dev.inmo.tgbotapi.utils.buildEntities
+import dev.inmo.tgbotapi.utils.code
+import dev.inmo.tgbotapi.utils.firstOf
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.delay
+import kotlinx.coroutines.flow.filter
+import kotlinx.coroutines.flow.first
+
+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.Default),
+        testServer = isTestServer,
+    ) {
+        // start here!!
+        val me = getMe()
+        println(me)
+
+        fun ChecklistContent.textBuilderTextSources(): TextSourcesList {
+            return buildEntities {
+                +checklist.textSources + "\n\n"
+                checklist.tasks.forEach { task ->
+                    +"• "
+                    code(
+                        if (task.completionDate != null) {
+                            "[x] "
+                        } else {
+                            "[ ] "
+                        }
+                    )
+
+                    bold(task.textSources) + "\n"
+                }
+            }
+        }
+
+        onChecklistContent { messageWithContent ->
+            reply(messageWithContent) {
+                +messageWithContent.content.textBuilderTextSources()
+            }
+        }
+
+        onChecklistTasksDone { eventMessage ->
+            reply(
+                eventMessage,
+                checklistTaskId = eventMessage.chatEvent.markedAsDone ?.firstOrNull()
+            ) {
+                eventMessage.chatEvent.checklistMessage.content.checklist
+                +eventMessage.chatEvent.checklistMessage.content.textBuilderTextSources()
+            }
+        }
+
+        onChecklistTasksAdded { messageWithContent ->
+            reply(
+                messageWithContent.chatEvent.checklistMessage,
+                checklistTaskId = messageWithContent.chatEvent.tasks.firstOrNull() ?.id
+            ) {
+                +messageWithContent.chatEvent.checklistMessage.content.textBuilderTextSources()
+            }
+        }
+
+        allUpdatesFlow.subscribeLoggingDropExceptions(this) {
+            println(it)
+        }
+    }.second.join()
+}
--- a/CustomBot/src/main/kotlin/CustomBot.kt
+++ b/CustomBot/src/main/kotlin/CustomBot.kt
@@ -4,10 +4,27 @@ 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.bot.getMyStarBalance
+import dev.inmo.tgbotapi.extensions.api.chat.get.getChat
+import dev.inmo.tgbotapi.extensions.api.send.reply
+import dev.inmo.tgbotapi.extensions.behaviour_builder.BehaviourContextData
+import dev.inmo.tgbotapi.extensions.behaviour_builder.buildSubcontextInitialAction
 import dev.inmo.tgbotapi.extensions.behaviour_builder.telegramBotWithBehaviourAndLongPolling
+import dev.inmo.tgbotapi.extensions.behaviour_builder.triggers_handling.onChannelDirectMessagesConfigurationChanged
+import dev.inmo.tgbotapi.extensions.behaviour_builder.triggers_handling.onCommand
+import dev.inmo.tgbotapi.types.message.abstracts.CommonMessage
+import dev.inmo.tgbotapi.types.update.abstracts.Update
 import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.Dispatchers

+private var BehaviourContextData.update: Update?
+    get() = get("update") as? Update
+    set(value) = set("update", value)
+
+private var BehaviourContextData.commonMessage: CommonMessage<*>?
+    get() = get("commonMessage") as? CommonMessage<*>
+    set(value) = set("commonMessage", value)
+
 /**
 * This place can be the playground for your code.
 */
@@ -15,6 +32,7 @@ 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(
@@ -24,11 +42,59 @@ suspend fun main(vararg args: String) {
        )
    }

-    telegramBotWithBehaviourAndLongPolling(botToken, CoroutineScope(Dispatchers.IO)) {
+    telegramBotWithBehaviourAndLongPolling(
+        botToken,
+        CoroutineScope(Dispatchers.IO),
+        testServer = isTestServer,
+        builder = {
+            includeMiddlewares {
+                addMiddleware {
+                    doOnRequestReturnResult { result, request, _ ->
+                        println("Result of $request:\n\n$result")
+                        null
+                    }
+                }
+            }
+        },
+        subcontextInitialAction = buildSubcontextInitialAction {
+            add {
+                data.update = it
+            }
+        }
+    ) {
        // start here!!
        val me = getMe()
        println(me)

-        allUpdatesFlow.subscribeSafelyWithoutExceptions(this) { println(it) }
+        onCommand("start") {
+            println(data.update)
+            println(data.commonMessage)
+            println(getChat(it.chat))
+        }
+
+        onCommand(
+            "additional_command",
+            additionalSubcontextInitialAction = { update, commonMessage ->
+                data.commonMessage = commonMessage
+            }
+        ) {
+            println(data.update)
+            println(data.commonMessage)
+        }
+
+        onCommand("getMyStarBalance") {
+            reply(
+                to = it,
+                text = getMyStarBalance().toString()
+            )
+        }
+
+        onChannelDirectMessagesConfigurationChanged {
+            println(it.chatEvent)
+        }
+
+        allUpdatesFlow.subscribeSafelyWithoutExceptions(this) {
+            println(it)
+        }
    }.second.join()
 }
--- a/FSMBot/src/main/kotlin/SimpleFSMBot.kt
+++ b/FSMBot/src/main/kotlin/SimpleFSMBot.kt
@@ -1,10 +1,13 @@
+import dev.inmo.micro_utils.coroutines.awaitFirst
 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.behaviour_builder.expectations.waitAnyContentMessage
+import dev.inmo.tgbotapi.extensions.behaviour_builder.expectations.waitCommandMessage
 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.behaviour_builder.utils.containsCommand
 import dev.inmo.tgbotapi.extensions.utils.extensions.parseCommandsWithArgs
 import dev.inmo.tgbotapi.extensions.utils.extensions.sameThread
 import dev.inmo.tgbotapi.extensions.utils.textContentOrNull
@@ -13,10 +16,12 @@ import dev.inmo.tgbotapi.types.IdChatIdentifier
 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.firstOf
 import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.flow.filter
 import kotlinx.coroutines.flow.first
+import kotlinx.coroutines.flow.map

 sealed interface BotState : State
 data class ExpectContentOrStopState(override val context: IdChatIdentifier, val sourceMessage: CommonMessage<TextContent>) : BotState
@@ -48,19 +53,29 @@ suspend fun main(args: Array<String>) {
                +"Send me some content or " + botCommand("stop") + " if you want to stop sending"
            }

-            val contentMessage = waitAnyContentMessage().filter { message ->
-                message.sameThread(it.sourceMessage)
-            }.first()
+            val contentMessage = firstOf(
+                {
+                    waitCommandMessage("stop").filter { message ->
+                        message.sameThread(it.sourceMessage)
+                    }.first()
+                    null
+                },
+                {
+                    waitAnyContentMessage().filter { message ->
+                        message.sameThread(it.sourceMessage)
+                    }.filter {
+                        containsCommand(
+                            "stop",
+                            it.withContentOrNull<TextContent>() ?.content ?.textSources ?: return@filter false
+                        ) == false
+                    }.first()
+                }
+            ) ?: return@strictlyOn StopState(it.context)
+
            val content = contentMessage.content

-            when {
-                content is TextContent && content.text == "/stop"
-                || content is TextContent && content.parseCommandsWithArgs().keys.contains("stop") -> StopState(it.context)
-                else -> {
-                    execute(content.createResend(it.context))
-                    it
-                }
-            }
+            execute(content.createResend(it.context))
+            it
        }
        strictlyOn<StopState> {
            send(it.context) { +"You have stopped sending of content" }
--- a/FilesLoaderBot/src/main/kotlin/FilesLoaderBot.kt
+++ b/FilesLoaderBot/src/main/kotlin/FilesLoaderBot.kt
@@ -7,7 +7,7 @@ import dev.inmo.tgbotapi.extensions.behaviour_builder.telegramBotWithBehaviourAn
 import dev.inmo.tgbotapi.extensions.behaviour_builder.triggers_handling.onCommand
 import dev.inmo.tgbotapi.extensions.behaviour_builder.triggers_handling.onMedia
 import dev.inmo.tgbotapi.requests.abstracts.asMultipartFile
-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
@@ -34,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/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
@@ -3,7 +3,10 @@ import dev.inmo.tgbotapi.extensions.api.bot.getMe
 import dev.inmo.tgbotapi.extensions.api.chat.get.getChat
 import dev.inmo.tgbotapi.extensions.api.send.reply
 import dev.inmo.tgbotapi.extensions.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.ifFromChannelGroupContentMessage
@@ -23,22 +26,35 @@ suspend fun main(vararg args: String) {

    telegramBotWithBehaviourAndLongPolling(botToken, CoroutineScope(Dispatchers.IO)) {
        val me = getMe()
-        onMentionWithAnyContent(me) { message ->
+        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<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 {
@@ -51,7 +67,7 @@ suspend fun main(vararg args: String) {
                }
                is PreviewBusinessChat -> {
                    reply(message, "Hi, " + "${chat.original.firstName} ${chat.original.lastName} (as business chat :) )".textMentionMarkdownV2(chat.original.id), MarkdownV2)
-                    return@onMentionWithAnyContent
+                    return@onContentMessage
                }
                is UnknownChatType -> "Unknown :(".escapeMarkdownV2Common()
            }
--- a/InlineQueriesBot/build.gradle
+++ b/InlineQueriesBot/build.gradle
@@ -12,14 +12,16 @@ plugins {
    id "org.jetbrains.kotlin.multiplatform"
 }

-apply plugin: 'application'
-
-mainClassName="InlineQueriesBotKt"
-
 apply from: "$nativePartTemplate"

 kotlin {
-    jvm()
+    jvm {
+        binaries {
+            executable {
+                mainClass.set("InlineQueriesBotKt")
+            }
+        }
+    }

    sourceSets {
        commonMain {
@@ -27,12 +29,9 @@ kotlin {
                implementation kotlin('stdlib')

                api "dev.inmo:tgbotapi:$telegram_bot_api_version"
+                api "io.ktor:ktor-client-logging:$ktor_version"
            }
        }
    }
 }

-dependencies {
-    implementation 'io.ktor:ktor-client-logging-jvm:2.3.7'
-}
-
--- a/InlineQueriesBot/src/commonMain/kotlin/Bot.kt
+++ b/InlineQueriesBot/src/commonMain/kotlin/Bot.kt
@@ -1,4 +1,4 @@
-import dev.inmo.micro_utils.coroutines.subscribeSafelyWithoutExceptions
+import dev.inmo.micro_utils.coroutines.subscribeLoggingDropExceptions
 import dev.inmo.tgbotapi.extensions.api.answers.answer
 import dev.inmo.tgbotapi.extensions.api.bot.getMe
 import dev.inmo.tgbotapi.extensions.api.send.reply
@@ -59,7 +59,7 @@ suspend fun doInlineQueriesBot(token: String) {
            reply(message, deepLink)
        }

-        allUpdatesFlow.subscribeSafelyWithoutExceptions(this) {
+        allUpdatesFlow.subscribeLoggingDropExceptions(scope = this) {
            println(it)
        }

--- a/KeyboardsBot/KeyboardsBotLib/src/commonMain/kotlin/KeyboardsBot.kt
+++ b/KeyboardsBot/KeyboardsBotLib/src/commonMain/kotlin/KeyboardsBot.kt
@@ -1,4 +1,4 @@
-import dev.inmo.micro_utils.coroutines.subscribeSafelyWithoutExceptions
+import dev.inmo.micro_utils.coroutines.subscribeLoggingDropExceptions
 import dev.inmo.tgbotapi.bot.ktor.telegramBot
 import dev.inmo.tgbotapi.extensions.api.answers.answer
 import dev.inmo.tgbotapi.extensions.api.bot.getMe
@@ -45,6 +45,9 @@ fun InlineKeyboardBuilder.includePageButtons(page: Int, count: Int) {
            }
        }
    }
+    row {
+        copyTextButton("Command copy button", "/inline $page $count")
+    }

    row {
        if (page - 1 > 2) {
@@ -84,11 +87,13 @@ suspend fun activateKeyboardsBot(

    bot.buildBehaviourWithLongPolling(CoroutineScope(currentCoroutineContext() + SupervisorJob())) {
        onCommandWithArgs("inline") { message, args ->
-            val numberOfPages = args.firstOrNull() ?.toIntOrNull() ?: 10
+            val numberArgs = args.mapNotNull { it.toIntOrNull() }
+            val numberOfPages = numberArgs.getOrNull(1) ?: numberArgs.firstOrNull() ?: 10
+            val page = numberArgs.firstOrNull()?.takeIf { numberArgs.size > 1 }?.coerceAtLeast(1) ?: 1
            reply(
                message,
                replyMarkup = inlineKeyboard {
-                    includePageButtons(1, numberOfPages)
+                    includePageButtons(page, numberOfPages)
                }
            ) {
                regular("Your inline keyboard with $numberOfPages pages")
@@ -133,7 +138,8 @@ suspend fun activateKeyboardsBot(

        onBaseInlineQuery {
            val page = it.query.takeWhile { it.isDigit() }.toIntOrNull() ?: return@onBaseInlineQuery
-            val count = it.query.removePrefix(page.toString()).dropWhile { !it.isDigit() }.takeWhile { it.isDigit() }.toIntOrNull() ?: return@onBaseInlineQuery
+            val count = it.query.removePrefix(page.toString()).dropWhile { !it.isDigit() }.takeWhile { it.isDigit() }
+                .toIntOrNull() ?: return@onBaseInlineQuery

            answer(
                it,
@@ -165,7 +171,7 @@ suspend fun activateKeyboardsBot(

        setMyCommands(BotCommand("inline", "Creates message with pagination inline keyboard"))

-        allUpdatesFlow.subscribeSafelyWithoutExceptions(this) {
+        allUpdatesFlow.subscribeLoggingDropExceptions(scope = this) {
            println(it)
        }
    }.join()
--- a/KeyboardsBot/jvm_launcher/src/main/kotlin/KeyboardsBotJvm.kt
+++ b/KeyboardsBot/jvm_launcher/src/main/kotlin/KeyboardsBotJvm.kt
@@ -1,7 +1,21 @@
+import dev.inmo.kslog.common.KSLog
+import dev.inmo.kslog.common.LogLevel
+import dev.inmo.kslog.common.defaultMessageFormatter
+import dev.inmo.kslog.common.setDefaultKSLog
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.withContext

 suspend fun main(args: Array<String>) {
+    val isDebug = args.any { it == "debug" }
+
+    if (isDebug) {
+        setDefaultKSLog(
+            KSLog { level: LogLevel, tag: String?, message: Any, throwable: Throwable? ->
+                println(defaultMessageFormatter(level, tag, message, throwable))
+            }
+        )
+    }
+
    withContext(Dispatchers.IO) { // IO for inheriting of it in side of activateKeyboardsBot
        activateKeyboardsBot(args.first()) {
            println(it)
--- a/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/RandomFileSenderBot/build.gradle
+++ b/RandomFileSenderBot/build.gradle
@@ -12,12 +12,14 @@ plugins {
    id "org.jetbrains.kotlin.multiplatform"
 }

-apply plugin: 'application'
-
-mainClassName="RandomFileSenderBotKt"
-
 kotlin {
-    jvm()
+    jvm {
+        binaries {
+            executable {
+                mainClass.set("RandomFileSenderBotKt")
+            }
+        }
+    }

    sourceSets {
        commonMain {
--- a/ReactionsInfoBot/src/main/kotlin/ReactionsInfoBot.kt
+++ b/ReactionsInfoBot/src/main/kotlin/ReactionsInfoBot.kt
@@ -48,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,4 +1,7 @@
-import dev.inmo.micro_utils.coroutines.subscribeSafelyWithoutExceptions
+import dev.inmo.kslog.common.KSLog
+import dev.inmo.kslog.common.defaultMessageFormatter
+import dev.inmo.kslog.common.filter.filtered
+import dev.inmo.micro_utils.coroutines.subscribeLoggingDropExceptions
 import dev.inmo.tgbotapi.extensions.api.bot.getMe
 import dev.inmo.tgbotapi.extensions.api.send.withTypingAction
 import dev.inmo.tgbotapi.extensions.behaviour_builder.filters.MessageFilterByChat
@@ -10,7 +13,9 @@ 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.utils.DefaultKTgBotAPIKSLog
 import dev.inmo.tgbotapi.utils.extensions.threadIdOrNull
+import kotlinx.coroutines.CancellationException
 import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.SupervisorJob
 import kotlinx.coroutines.currentCoroutineContext
@@ -19,7 +24,10 @@ suspend fun activateResenderBot(
    token: String,
    print: (Any) -> Unit
 ) {
-    telegramBotWithBehaviourAndLongPolling(token, scope = CoroutineScope(currentCoroutineContext() + SupervisorJob())) {
+    telegramBotWithBehaviourAndLongPolling(
+        token,
+        scope = CoroutineScope(currentCoroutineContext() + SupervisorJob()),
+    ) {
        onContentMessage(
            subcontextUpdatesFilter = MessageFilterByChat,
            initialFilter = { it !is BusinessContentMessage<*> || !it.sentByBusinessConnectionOwner }
@@ -31,15 +39,15 @@ suspend fun activateResenderBot(
                    it.content.createResend(
                        chat.id,
                        messageThreadId = it.threadIdOrNull,
-                        replyParameters = it.replyInfo ?.messageMeta ?.let { meta ->
-                            val quote = it.withContentOrNull<TextContent>() ?.content ?.quote
+                        replyParameters = it.replyInfo?.messageMeta?.let { meta ->
+                            val quote = it.withContentOrNull<TextContent>()?.content?.quote
                            ReplyParameters(
                                meta,
-                                entities = quote ?.textSources ?: emptyList(),
-                                quotePosition = quote ?.position
+                                entities = quote?.textSources ?: emptyList(),
+                                quotePosition = quote?.position
                            )
                        },
-                        effectId = it.possiblyWithEffectMessageOrNull() ?.effectId
+                        effectId = it.possiblyWithEffectMessageOrNull()?.effectId
                    )
                ) {
                    it.forEach(print)
@@ -49,7 +57,7 @@ suspend fun activateResenderBot(
            println("Answer info: $answer")
        }

-        allUpdatesFlow.subscribeSafelyWithoutExceptions(this) {
+        allUpdatesFlow.subscribeLoggingDropExceptions(scope = this) {
            println(it)
        }
        print(bot.getMe())
--- a/ResenderBot/jvm_launcher/src/main/kotlin/ResenderBotJvm.kt
+++ b/ResenderBot/jvm_launcher/src/main/kotlin/ResenderBotJvm.kt
@@ -1,4 +1,19 @@
+import dev.inmo.kslog.common.KSLog
+import dev.inmo.kslog.common.LogLevel
+import dev.inmo.kslog.common.defaultMessageFormatter
+import dev.inmo.kslog.common.setDefaultKSLog
+
 suspend fun main(args: Array<String>) {
+    val isDebug = args.getOrNull(1) == "debug"
+
+    if (isDebug) {
+        setDefaultKSLog(
+            KSLog { level: LogLevel, tag: String?, message: Any, throwable: Throwable? ->
+                println(defaultMessageFormatter(level, tag, message, throwable))
+            }
+        )
+    }
+
    activateResenderBot(args.first()) {
        println(it)
    }
--- a/RightsChangerBot/build.gradle
+++ b/RightsChangerBot/build.gradle
@@ -18,5 +18,5 @@ dependencies {
    implementation "org.jetbrains.kotlin:kotlin-stdlib:$kotlin_version"

    implementation "dev.inmo:tgbotapi:$telegram_bot_api_version"
-    implementation 'io.ktor:ktor-client-logging-jvm:2.3.7'
+    implementation 'io.ktor:ktor-client-logging-jvm:3.2.3'
 }
--- a/RightsChangerBot/src/main/kotlin/RightsChanger.kt
+++ b/RightsChangerBot/src/main/kotlin/RightsChanger.kt
@@ -106,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
        }
    }
--- a/StarTransactionsBot/README.md
+++ b/StarTransactionsBot/README.md
@@ -1,4 +1,4 @@
-# CustomBot
+# StarTransactionsBot

 This bot basically have no any useful behaviour, but you may customize it as a playground

--- a/StarTransactionsBot/src/main/kotlin/StarTransactionsBot.kt
+++ b/StarTransactionsBot/src/main/kotlin/StarTransactionsBot.kt
@@ -12,10 +12,7 @@ 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.dataButton
-import dev.inmo.tgbotapi.extensions.utils.types.buttons.flatInlineKeyboard
-import dev.inmo.tgbotapi.extensions.utils.types.buttons.inlineKeyboard
-import dev.inmo.tgbotapi.extensions.utils.types.buttons.payButton
+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
@@ -30,6 +27,7 @@ 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
--- a/StickerInfoBot/StickerInfoBotLib/src/commonMain/kotlin/StickerInfoBot.kt
+++ b/StickerInfoBot/StickerInfoBotLib/src/commonMain/kotlin/StickerInfoBot.kt
@@ -1,5 +1,5 @@
 import dev.inmo.micro_utils.coroutines.defaultSafelyWithoutExceptionHandler
-import dev.inmo.micro_utils.coroutines.subscribeSafelyWithoutExceptions
+import dev.inmo.micro_utils.coroutines.subscribeLoggingDropExceptions
 import dev.inmo.tgbotapi.bot.ktor.telegramBot
 import dev.inmo.tgbotapi.extensions.api.bot.getMe
 import dev.inmo.tgbotapi.extensions.api.get.getCustomEmojiStickerOrNull
@@ -12,7 +12,7 @@ import dev.inmo.tgbotapi.extensions.behaviour_builder.triggers_handling.onSticke
 import dev.inmo.tgbotapi.extensions.behaviour_builder.triggers_handling.onText
 import dev.inmo.tgbotapi.types.StickerType
 import dev.inmo.tgbotapi.types.message.textsources.CustomEmojiTextSource
-import dev.inmo.tgbotapi.types.message.textsources.regular
+import dev.inmo.tgbotapi.types.message.textsources.regularTextSource
 import dev.inmo.tgbotapi.types.message.textsources.separateForText
 import dev.inmo.tgbotapi.types.stickers.StickerSet
 import dev.inmo.tgbotapi.utils.bold
@@ -55,14 +55,14 @@ suspend fun activateStickerInfoBot(
            withTypingAction(it.chat) {
                it.content.textSources.mapNotNull {
                    if (it is CustomEmojiTextSource) {
-                        getCustomEmojiStickerOrNull(it.customEmojiId) ?.stickerSetName
+                        getCustomEmojiStickerOrNull(it.customEmojiId)?.stickerSetName
                    } else {
                        null
                    }
                }.distinct().map {
                    getStickerSet(it)
                }.distinct().flatMap {
-                    it.buildInfo() + regular("\n")
+                    it.buildInfo() + regularTextSource("\n")
                }.separateForText().map { entities ->
                    reply(it, entities)
                }
@@ -76,7 +76,7 @@ suspend fun activateStickerInfoBot(
            )
        }

-        allUpdatesFlow.subscribeSafelyWithoutExceptions(this) {
+        allUpdatesFlow.subscribeLoggingDropExceptions(scope = this) {
            println(it)
        }
    }.join()
--- a/SuggestedPosts/README.md
+++ b/SuggestedPosts/README.md
@@ -0,0 +1,9 @@
+# StickerSetHandler
+
+Send sticker to this bot to form your own stickers set. Send /delete to delete this sticker set
+
+## How to run
+
+```bash
+./gradlew run --args="TOKEN"
+```
--- a/SuggestedPosts/build.gradle
+++ b/SuggestedPosts/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="SuggestedPostsBotKt"
+
+
+dependencies {
+    implementation "org.jetbrains.kotlin:kotlin-stdlib:$kotlin_version"
+
+    implementation "dev.inmo:tgbotapi:$telegram_bot_api_version"
+}
--- a/SuggestedPosts/src/main/kotlin/SuggestedPostsBot.kt
+++ b/SuggestedPosts/src/main/kotlin/SuggestedPostsBot.kt
@@ -0,0 +1,140 @@
+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.runCatchingLogging
+import dev.inmo.micro_utils.coroutines.subscribeLoggingDropExceptions
+import dev.inmo.micro_utils.coroutines.subscribeSafelyWithoutExceptions
+import dev.inmo.tgbotapi.extensions.api.bot.getMe
+import dev.inmo.tgbotapi.extensions.api.bot.getMyStarBalance
+import dev.inmo.tgbotapi.extensions.api.chat.get.getChat
+import dev.inmo.tgbotapi.extensions.api.send.reply
+import dev.inmo.tgbotapi.extensions.api.send.resend
+import dev.inmo.tgbotapi.extensions.api.send.send
+import dev.inmo.tgbotapi.extensions.api.suggested.approveSuggestedPost
+import dev.inmo.tgbotapi.extensions.api.suggested.declineSuggestedPost
+import dev.inmo.tgbotapi.extensions.behaviour_builder.BehaviourContextData
+import dev.inmo.tgbotapi.extensions.behaviour_builder.buildSubcontextInitialAction
+import dev.inmo.tgbotapi.extensions.behaviour_builder.expectations.waitSuggestedPostApproved
+import dev.inmo.tgbotapi.extensions.behaviour_builder.expectations.waitSuggestedPostDeclined
+import dev.inmo.tgbotapi.extensions.behaviour_builder.telegramBotWithBehaviourAndLongPolling
+import dev.inmo.tgbotapi.extensions.behaviour_builder.triggers_handling.onChannelDirectMessagesConfigurationChanged
+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.onSuggestedPostApprovalFailed
+import dev.inmo.tgbotapi.extensions.behaviour_builder.triggers_handling.onSuggestedPostApproved
+import dev.inmo.tgbotapi.extensions.behaviour_builder.triggers_handling.onSuggestedPostDeclined
+import dev.inmo.tgbotapi.extensions.behaviour_builder.triggers_handling.onSuggestedPostPaid
+import dev.inmo.tgbotapi.extensions.behaviour_builder.triggers_handling.onSuggestedPostRefunded
+import dev.inmo.tgbotapi.extensions.utils.channelDirectMessagesContentMessageOrNull
+import dev.inmo.tgbotapi.extensions.utils.previewChannelDirectMessagesChatOrNull
+import dev.inmo.tgbotapi.extensions.utils.suggestedChannelDirectMessagesContentMessageOrNull
+import dev.inmo.tgbotapi.types.message.SuggestedPostParameters
+import dev.inmo.tgbotapi.types.message.abstracts.ChannelPaidPost
+import dev.inmo.tgbotapi.types.message.abstracts.CommonMessage
+import dev.inmo.tgbotapi.types.update.abstracts.Update
+import dev.inmo.tgbotapi.utils.firstOf
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.delay
+import kotlinx.coroutines.flow.filter
+import kotlinx.coroutines.flow.first
+
+/**
+ * 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.Default),
+        testServer = isTestServer,
+    ) {
+        // start here!!
+        val me = getMe()
+        println(me)
+
+        onCommand("start") {
+            println(getChat(it.chat))
+        }
+
+        onContentMessage {
+            val message = it.channelDirectMessagesContentMessageOrNull() ?: return@onContentMessage
+            val chat = getChat(it.chat)
+            println(chat)
+
+            resend(
+                message.chat.id,
+                message.content,
+                suggestedPostParameters = SuggestedPostParameters()
+            )
+        }
+
+        onContentMessage(
+            subcontextUpdatesFilter = { _, _ -> true } // important to not miss updates in channel for waitSuggestedPost events
+        ) { message ->
+            val suggestedPost = message.suggestedChannelDirectMessagesContentMessageOrNull() ?: return@onContentMessage
+
+            firstOf(
+                {
+                    waitSuggestedPostApproved().filter {
+                        it.suggestedPostMessage ?.chat ?.id == message.chat.id
+                    }.first()
+                },
+                {
+                    waitSuggestedPostDeclined().filter {
+                        it.suggestedPostMessage ?.chat ?.id == message.chat.id
+                    }.first()
+                },
+                {
+                    for (i in 0 until 3) {
+                        delay(1000L)
+                        send(suggestedPost.chat, "${3 - i}")
+                    }
+                    declineSuggestedPost(suggestedPost)
+                },
+            )
+        }
+
+        onContentMessage(initialFilter = { it is ChannelPaidPost<*> }) {
+            println(it)
+        }
+
+        onSuggestedPostPaid {
+            println(it)
+            reply(it, "Paid")
+        }
+        onSuggestedPostApproved {
+            println(it)
+            reply(it, "Approved")
+        }
+        onSuggestedPostDeclined {
+            println(it)
+            reply(it, "Declined")
+        }
+        onSuggestedPostRefunded {
+            println(it)
+            reply(it, "Refunded")
+        }
+        onSuggestedPostApprovalFailed {
+            println(it)
+            reply(it, "Approval failed")
+        }
+
+        allUpdatesFlow.subscribeLoggingDropExceptions(this) {
+            println(it)
+        }
+    }.second.join()
+}
--- a/UserChatShared/src/main/kotlin/UserChatShared.kt
+++ b/UserChatShared/src/main/kotlin/UserChatShared.kt
@@ -15,8 +15,8 @@ import dev.inmo.tgbotapi.extensions.utils.types.buttons.*
 import dev.inmo.tgbotapi.types.BotCommand
 import dev.inmo.tgbotapi.types.chat.PrivateChat
 import dev.inmo.tgbotapi.types.keyboardButtonRequestUserLimit
-import dev.inmo.tgbotapi.types.message.textsources.mention
 import dev.inmo.tgbotapi.types.request.RequestId
+import dev.inmo.tgbotapi.utils.mention
 import dev.inmo.tgbotapi.utils.row

 suspend fun main(args: Array<String>) {
@@ -287,7 +287,7 @@ suspend fun main(args: Array<String>) {
                    it,
                ) {
                    +"You have shared "
-                    +mention(
+                    mention(
                        when (it.chatEvent.requestId) {
                            requestIdUserOrBot -> "user or bot"
                            requestIdUserNonPremium -> "non premium user"
--- a/WebApp/build.gradle
+++ b/WebApp/build.gradle
@@ -11,12 +11,19 @@ buildscript {
 plugins {
    id "org.jetbrains.kotlin.multiplatform"
    id "org.jetbrains.kotlin.plugin.serialization"
+
+    id "org.jetbrains.kotlin.plugin.compose" version "$kotlin_version"
+    id "org.jetbrains.compose" version "$compose_version"
 }

-apply plugin: 'application'
-
 kotlin {
-    jvm()
+    jvm {
+        binaries {
+            executable {
+                mainClass.set("WebAppServerKt")
+            }
+        }
+    }
    js(IR) {
        browser()
        binaries.executable()
@@ -27,12 +34,15 @@ kotlin {
            dependencies {
                implementation kotlin('stdlib')
                implementation "org.jetbrains.kotlinx:kotlinx-serialization-json:$serialization_version"
+                implementation "dev.inmo:tgbotapi.core:$telegram_bot_api_version"
+                implementation compose.runtime
            }
        }

        jsMain {
            dependencies {
                implementation "dev.inmo:tgbotapi.webapps:$telegram_bot_api_version"
+                implementation compose.web.core
            }
        }

@@ -41,15 +51,12 @@ kotlin {
                implementation "dev.inmo:tgbotapi:$telegram_bot_api_version"
                implementation "dev.inmo:micro_utils.ktor.server:$micro_utils_version"
                implementation "io.ktor:ktor-server-cio:$ktor_version"
+                implementation compose.desktop.currentOs
            }
        }
    }
 }

-application {
-    mainClassName = "WebAppServerKt"
-}
-
 tasks.getByName("compileKotlinJvm")
        .dependsOn(jsBrowserDistribution)
 tasks.getByName("compileKotlinJvm").configure {
--- a/WebApp/src/commonMain/kotlin/CustomEmojiIdToSet.kt
+++ b/WebApp/src/commonMain/kotlin/CustomEmojiIdToSet.kt
@@ -0,0 +1,3 @@
+import dev.inmo.tgbotapi.types.CustomEmojiId
+
+val CustomEmojiIdToSet = CustomEmojiId("5424939566278649034")
--- a/WebApp/src/jsMain/kotlin/main.kt
+++ b/WebApp/src/jsMain/kotlin/main.kt
--- a/WebApp/src/jsMain/resources/index.html
+++ b/WebApp/src/jsMain/resources/index.html
@@ -10,6 +10,7 @@
        <title>Web App Example</title>
    </head>
    <body>
+        <div id="root"></div>
        <script type="application/javascript" src="https://telegram.org/js/telegram-web-app.js"></script>
        <script type="application/javascript" src="WebApp.js"></script>
    </body>
--- a/WebApp/src/jvmMain/kotlin/WebAppServer.kt
+++ b/WebApp/src/jvmMain/kotlin/WebAppServer.kt
@@ -1,4 +1,5 @@
 import dev.inmo.kslog.common.*
+import dev.inmo.micro_utils.coroutines.subscribeLoggingDropExceptions
 import dev.inmo.micro_utils.coroutines.subscribeSafelyWithoutExceptions
 import dev.inmo.micro_utils.ktor.server.createKtorServer
 import dev.inmo.tgbotapi.extensions.api.answers.answerInlineQuery
@@ -6,6 +7,7 @@ import dev.inmo.tgbotapi.extensions.api.bot.getMe
 import dev.inmo.tgbotapi.extensions.api.bot.setMyCommands
 import dev.inmo.tgbotapi.extensions.api.send.reply
 import dev.inmo.tgbotapi.extensions.api.send.send
+import dev.inmo.tgbotapi.extensions.api.set.setUserEmojiStatus
 import dev.inmo.tgbotapi.extensions.api.telegramBot
 import dev.inmo.tgbotapi.extensions.behaviour_builder.buildBehaviourWithLongPolling
 import dev.inmo.tgbotapi.extensions.behaviour_builder.triggers_handling.onBaseInlineQuery
@@ -16,12 +18,9 @@ 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.*
 import dev.inmo.tgbotapi.types.InlineQueries.InlineQueryResult.InlineQueryResultArticle
 import dev.inmo.tgbotapi.types.InlineQueries.InputMessageContent.InputTextMessageContent
-import dev.inmo.tgbotapi.types.InlineQueryId
-import dev.inmo.tgbotapi.types.LinkPreviewOptions
-import dev.inmo.tgbotapi.types.webAppQueryIdField
 import dev.inmo.tgbotapi.types.webapps.WebAppInfo
 import dev.inmo.tgbotapi.utils.*
 import io.ktor.http.*
@@ -30,7 +29,6 @@ import io.ktor.server.http.content.*
 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

@@ -63,10 +61,7 @@ suspend fun main(vararg args: String) {
    val bot = telegramBot(telegramBotAPIUrlsKeeper)
    createKtorServer(
        "0.0.0.0",
-        args.getOrNull(2) ?.toIntOrNull() ?: 8080,
-        additionalEngineEnvironmentConfigurator = {
-            parentCoroutineContext += Dispatchers.IO
-        }
+        args.getOrNull(2) ?.toIntOrNull() ?: 8080
    ) {
        routing {
            val baseJsFolder = File("WebApp/build/dist/js/")
@@ -108,6 +103,26 @@ suspend fun main(vararg args: String) {

                call.respond(HttpStatusCode.OK, isSafe.toString())
            }
+            post("setCustomEmoji") {
+                val requestBody = call.receiveText()
+                val webAppCheckData = Json.decodeFromString(WebAppDataWrapper.serializer(), requestBody)
+
+                val isSafe = telegramBotAPIUrlsKeeper.checkWebAppData(webAppCheckData.data, webAppCheckData.hash)
+                val rawUserId = call.parameters[userIdField] ?.toLongOrNull() ?.let(::RawChatId) ?: error("$userIdField should be presented as long value")
+
+                val set = if (isSafe) {
+                    runCatching {
+                        bot.setUserEmojiStatus(
+                            UserId(rawUserId),
+                            CustomEmojiIdToSet
+                        )
+                    }.getOrElse { false }
+                } else {
+                    false
+                }
+
+                call.respond(HttpStatusCode.OK, set.toString())
+            }
        }
    }.start(false)

@@ -181,7 +196,7 @@ suspend fun main(vararg args: String) {
            BotCommand("reply_markup", "Use to get reply markup keyboard with web app trigger"),
            BotCommand("inline", "Use to get inline keyboard with web app trigger"),
        )
-        allUpdatesFlow.subscribeSafelyWithoutExceptions(this) {
+        allUpdatesFlow.subscribeLoggingDropExceptions(this) {
            println(it)
        }
        println(getMe())
--- a/WebHooks/README.md
+++ b/WebHooks/README.md
@@ -0,0 +1,28 @@
+# WebHooks
+
+Launches webhook-based simple bot. Use `/start` with bot to get simple info about webhooks
+
+## Launch
+
+```bash
+../gradlew run --args="BOT_TOKEN https://sample.com it/is/subpath 8080 debug"
+```
+
+Required arguments:
+
+1. Token
+2. Arguments starting with `https://`
+
+Optional arguments:
+
+* Any argument == `debug` to enable debug mode
+* Any argument **not** starting with `https://` and **not** equal to `debug` as **subpath** (will be used as
+subroute to place listening of webhooks)
+* Any argument as number of port
+
+Sample: `TOKEN https://sample.com it/is/subpath 8080` will result to:
+
+* `TOKEN` used as token
+* Bot will set up its webhook info as `https://sample.com/it/is/subpath`
+* Bot will set up to listen webhooks on route `it/is/subpath`
+* Bot will start to listen any incoming request on port `8080` and url `0.0.0.0`
--- a/WebHooks/build.gradle
+++ b/WebHooks/build.gradle
@@ -0,0 +1,23 @@
+buildscript {
+    repositories {
+        mavenCentral()
+    }
+
+    dependencies {
+        classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:$kotlin_version"
+    }
+}
+
+apply plugin: 'kotlin'
+apply plugin: 'application'
+
+mainClassName="WebHooksKt"
+
+
+dependencies {
+    implementation "org.jetbrains.kotlin:kotlin-stdlib:$kotlin_version"
+
+    implementation "dev.inmo:tgbotapi:$telegram_bot_api_version"
+    implementation "dev.inmo:micro_utils.ktor.server:$micro_utils_version"
+    implementation "io.ktor:ktor-server-cio:$ktor_version"
+}
--- a/WebHooks/src/main/kotlin/WebHooks.kt
+++ b/WebHooks/src/main/kotlin/WebHooks.kt
@@ -0,0 +1,87 @@
+import dev.inmo.kslog.common.KSLog
+import dev.inmo.kslog.common.LogLevel
+import dev.inmo.kslog.common.defaultMessageFormatter
+import dev.inmo.kslog.common.setDefaultKSLog
+import dev.inmo.micro_utils.ktor.server.createKtorServer
+import dev.inmo.tgbotapi.bot.ktor.telegramBot
+import dev.inmo.tgbotapi.extensions.api.bot.setMyCommands
+import dev.inmo.tgbotapi.extensions.api.send.reply
+import dev.inmo.tgbotapi.extensions.api.webhook.setWebhookInfo
+import dev.inmo.tgbotapi.extensions.behaviour_builder.buildBehaviour
+import dev.inmo.tgbotapi.extensions.behaviour_builder.triggers_handling.onCommand
+import dev.inmo.tgbotapi.extensions.utils.updates.retrieving.includeWebhookHandlingInRoute
+import dev.inmo.tgbotapi.types.BotCommand
+import dev.inmo.tgbotapi.types.chat.PrivateChat
+import dev.inmo.tgbotapi.utils.buildEntities
+import io.ktor.server.routing.*
+
+/**
+ * Launches webhook-based simple bot. Required arguments:
+ *
+ * 1. Token
+ * *. Arguments starting with `https://`
+ *
+ * Optional arguments:
+ *
+ * *. Any argument == `debug` to enable debug mode
+ * *. Any argument **not** starting with `https://` and **not** equal to `debug` as **subpath** (will be used as
+ * subroute to place listening of webhooks)
+ * *. Any argument as number of port
+ *
+ * Sample: `TOKEN https://sample.com it/is/subpath 8080` will result to:
+ *
+ * * `TOKEN` used as token
+ * * Bot will set up its webhook info as `https://sample.com/it/is/subpath`
+ * * Bot will set up to listen webhooks on route `it/is/subpath`
+ * * Bot will start to listen any incoming request on port `8080` and url `0.0.0.0`
+ */
+suspend fun main(args: Array<String>) {
+    val botToken = args.first()
+    val address = args.first { it.startsWith("https://") }
+    val subpath = args.drop(1).firstOrNull { it != address && it != "debug" }
+    val port = args.firstNotNullOfOrNull { it.toIntOrNull() } ?: 8080
+    val isDebug = args.any { it == "debug" }
+
+    if (isDebug) {
+        setDefaultKSLog(
+            KSLog { level: LogLevel, tag: String?, message: Any, throwable: Throwable? ->
+                println(defaultMessageFormatter(level, tag, message, throwable))
+            }
+        )
+    }
+
+    val bot = telegramBot(botToken)
+
+    val behaviourContext = bot.buildBehaviour (defaultExceptionsHandler = { it.printStackTrace() }) {
+        onCommand("start", initialFilter = { it.chat is PrivateChat }) {
+            reply(
+                it,
+                buildEntities {
+                    +"Url: $address" + "\n"
+                    +"Listening server: 0.0.0.0" + "\n"
+                    +"Listening port: $port"
+                }
+            )
+        }
+
+        setMyCommands(BotCommand("start", "Get webhook info"))
+    }
+
+    val webhookInfoSubpath = subpath ?.let { "/" + it.removePrefix("/") } ?: "" // drop leading `/` to add it in the beginning for correct construction of subpath
+    bot.setWebhookInfo(address + webhookInfoSubpath)
+
+    createKtorServer(
+        "0.0.0.0",
+        port,
+    ) {
+        routing {
+            if (subpath == null) {
+                includeWebhookHandlingInRoute(behaviourContext, block = behaviourContext.asUpdateReceiver)
+            } else {
+                route(subpath) {
+                    includeWebhookHandlingInRoute(behaviourContext, block = behaviourContext.asUpdateReceiver)
+                }
+            }
+        }
+    }.start(true)
+}
--- a/build.gradle
+++ b/build.gradle
@@ -14,8 +14,8 @@ allprojects {
        nativePartTemplate = "${rootProject.projectDir.absolutePath}/native_template.gradle"
    }
    repositories {
-        mavenLocal()
        mavenCentral()
+        google()
        if (project.hasProperty("GITHUB_USER") && project.hasProperty("GITHUB_TOKEN")) {
            maven {
                url "https://maven.pkg.github.com/InsanusMokrassar/TelegramBotAPI"
@@ -26,6 +26,12 @@ allprojects {
            }
        }

-        maven { url "https://nexus.inmo.dev/repository/maven-releases/" }
+        maven { url "https://proxy.nexus.inmo.dev/repository/maven-releases/" }
+        mavenLocal()
    }
 }
+
+// Fix of https://youtrack.jetbrains.com/issue/KTOR-7912/Module-not-found-errors-when-executing-browserProductionWebpack-task-since-3.0.2
+rootProject.plugins.withType(org.jetbrains.kotlin.gradle.targets.js.yarn.YarnPlugin.class) {
+    rootProject.kotlinYarn.resolution("ws", "8.18.0")
+}
--- a/gradle.properties
+++ b/gradle.properties
@@ -5,8 +5,9 @@ org.gradle.jvmargs=-Xmx3148m
 kotlin.daemon.jvmargs=-Xmx3g -Xms500m


-kotlin_version=2.0.10
-telegram_bot_api_version=16.0.0
-micro_utils_version=0.22.0
-serialization_version=1.7.1
-ktor_version=2.3.11
+kotlin_version=2.2.10
+telegram_bot_api_version=29.0.0
+micro_utils_version=0.26.3
+serialization_version=1.9.0
+ktor_version=3.2.3
+compose_version=1.8.2
--- a/gradle/wrapper/gradle-wrapper.jar
+++ b/gradle/wrapper/gradle-wrapper.jar
--- a/gradle/wrapper/gradle-wrapper.properties
+++ b/gradle/wrapper/gradle-wrapper.properties
@@ -1,5 +1,7 @@
 distributionBase=GRADLE_USER_HOME
 distributionPath=wrapper/dists
+distributionUrl=https\://services.gradle.org/distributions/gradle-9.2.1-bin.zip
+networkTimeout=10000
+validateDistributionUrl=true
 zipStoreBase=GRADLE_USER_HOME
 zipStorePath=wrapper/dists
-distributionUrl=https\://services.gradle.org/distributions/gradle-8.9-bin.zip
--- a/310
+++ b/310
@@ -1,78 +1,128 @@
-#!/usr/bin/env sh
+#!/bin/sh
+
+#
+# Copyright © 2015 the original authors.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      https://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+# SPDX-License-Identifier: Apache-2.0
+#

 ##############################################################################
-##
-##  Gradle start up script for UN*X
-##
+#
+#   Gradle start up script for POSIX generated by Gradle.
+#
+#   Important for running:
+#
+#   (1) You need a POSIX-compliant shell to run this script. If your /bin/sh is
+#       noncompliant, but you have some other compliant shell such as ksh or
+#       bash, then to run this script, type that shell name before the whole
+#       command line, like:
+#
+#           ksh Gradle
+#
+#       Busybox and similar reduced shells will NOT work, because this script
+#       requires all of these POSIX shell features:
+#         * functions;
+#         * expansions «$var», «${var}», «${var:-default}», «${var+SET}»,
+#           «${var#prefix}», «${var%suffix}», and «$( cmd )»;
+#         * compound commands having a testable exit status, especially «case»;
+#         * various built-in commands including «command», «set», and «ulimit».
+#
+#   Important for patching:
+#
+#   (2) This script targets any POSIX shell, so it avoids extensions provided
+#       by Bash, Ksh, etc; in particular arrays are avoided.
+#
+#       The "traditional" practice of packing multiple parameters into a
+#       space-separated string is a well documented source of bugs and security
+#       problems, so this is (mostly) avoided, by progressively accumulating
+#       options in "$@", and eventually passing that to Java.
+#
+#       Where the inherited environment variables (DEFAULT_JVM_OPTS, JAVA_OPTS,
+#       and GRADLE_OPTS) rely on word-splitting, this is performed explicitly;
+#       see the in-line comments for details.
+#
+#       There are tweaks for specific operating systems such as AIX, CygWin,
+#       Darwin, MinGW, and NonStop.
+#
+#   (3) This script is generated from the Groovy template
+#       https://github.com/gradle/gradle/blob/HEAD/platforms/jvm/plugins-application/src/main/resources/org/gradle/api/internal/plugins/unixStartScript.txt
+#       within the Gradle project.
+#
+#       You can find Gradle at https://github.com/gradle/gradle/.
+#
 ##############################################################################

 # Attempt to set APP_HOME
+
 # Resolve links: $0 may be a link
-PRG="$0"
-# Need this for relative symlinks.
-while [ -h "$PRG" ] ; do
-    ls=`ls -ld "$PRG"`
-    link=`expr "$ls" : '.*-> \(.*\)$'`
-    if expr "$link" : '/.*' > /dev/null; then
-        PRG="$link"
-    else
-        PRG=`dirname "$PRG"`"/$link"
-    fi
+app_path=$0
+
+# Need this for daisy-chained symlinks.
+while
+    APP_HOME=${app_path%"${app_path##*/}"}  # leaves a trailing /; empty if no leading path
+    [ -h "$app_path" ]
+do
+    ls=$( ls -ld "$app_path" )
+    link=${ls#*' -> '}
+    case $link in             #(
+      /*)   app_path=$link ;; #(
+      *)    app_path=$APP_HOME$link ;;
+    esac
 done
-SAVED="`pwd`"
-cd "`dirname \"$PRG\"`/" >/dev/null
-APP_HOME="`pwd -P`"
-cd "$SAVED" >/dev/null

-APP_NAME="Gradle"
-APP_BASE_NAME=`basename "$0"`
-
-# Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
-DEFAULT_JVM_OPTS=""
+# This is normally unused
+# shellcheck disable=SC2034
+APP_BASE_NAME=${0##*/}
+# Discard cd standard output in case $CDPATH is set (https://github.com/gradle/gradle/issues/25036)
+APP_HOME=$( cd -P "${APP_HOME:-./}" > /dev/null && printf '%s\n' "$PWD" ) || exit

 # Use the maximum available, or set MAX_FD != -1 to use that value.
-MAX_FD="maximum"
+MAX_FD=maximum

 warn () {
    echo "$*"
-}
+} >&2

 die () {
    echo
    echo "$*"
    echo
    exit 1
-}
+} >&2

 # OS specific support (must be 'true' or 'false').
 cygwin=false
 msys=false
 darwin=false
 nonstop=false
-case "`uname`" in
-  CYGWIN* )
-    cygwin=true
-    ;;
-  Darwin* )
-    darwin=true
-    ;;
-  MINGW* )
-    msys=true
-    ;;
-  NONSTOP* )
-    nonstop=true
-    ;;
+case "$( uname )" in                #(
+  CYGWIN* )         cygwin=true  ;; #(
+  Darwin* )         darwin=true  ;; #(
+  MSYS* | MINGW* )  msys=true    ;; #(
+  NONSTOP* )        nonstop=true ;;
 esac

-CLASSPATH=$APP_HOME/gradle/wrapper/gradle-wrapper.jar
+

 # Determine the Java command to use to start the JVM.
 if [ -n "$JAVA_HOME" ] ; then
    if [ -x "$JAVA_HOME/jre/sh/java" ] ; then
        # IBM's JDK on AIX uses strange locations for the executables
-        JAVACMD="$JAVA_HOME/jre/sh/java"
+        JAVACMD=$JAVA_HOME/jre/sh/java
    else
-        JAVACMD="$JAVA_HOME/bin/java"
+        JAVACMD=$JAVA_HOME/bin/java
    fi
    if [ ! -x "$JAVACMD" ] ; then
        die "ERROR: JAVA_HOME is set to an invalid directory: $JAVA_HOME
@@ -81,92 +131,118 @@ Please set the JAVA_HOME variable in your environment to match the
 location of your Java installation."
    fi
 else
-    JAVACMD="java"
-    which java >/dev/null 2>&1 || die "ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH.
+    JAVACMD=java
+    if ! command -v java >/dev/null 2>&1
+    then
+        die "ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH.

 Please set the JAVA_HOME variable in your environment to match the
 location of your Java installation."
+    fi
 fi

 # Increase the maximum file descriptors if we can.
-if [ "$cygwin" = "false" -a "$darwin" = "false" -a "$nonstop" = "false" ] ; then
-    MAX_FD_LIMIT=`ulimit -H -n`
-    if [ $? -eq 0 ] ; then
-        if [ "$MAX_FD" = "maximum" -o "$MAX_FD" = "max" ] ; then
-            MAX_FD="$MAX_FD_LIMIT"
-        fi
-        ulimit -n $MAX_FD
-        if [ $? -ne 0 ] ; then
-            warn "Could not set maximum file descriptor limit: $MAX_FD"
-        fi
-    else
-        warn "Could not query maximum file descriptor limit: $MAX_FD_LIMIT"
-    fi
-fi
-
-# For Darwin, add options to specify how the application appears in the dock
-if $darwin; then
-    GRADLE_OPTS="$GRADLE_OPTS \"-Xdock:name=$APP_NAME\" \"-Xdock:icon=$APP_HOME/media/gradle.icns\""
-fi
-
-# For Cygwin, switch paths to Windows format before running java
-if $cygwin ; then
-    APP_HOME=`cygpath --path --mixed "$APP_HOME"`
-    CLASSPATH=`cygpath --path --mixed "$CLASSPATH"`
-    JAVACMD=`cygpath --unix "$JAVACMD"`
-
-    # We build the pattern for arguments to be converted via cygpath
-    ROOTDIRSRAW=`find -L / -maxdepth 1 -mindepth 1 -type d 2>/dev/null`
-    SEP=""
-    for dir in $ROOTDIRSRAW ; do
-        ROOTDIRS="$ROOTDIRS$SEP$dir"
-        SEP="|"
-    done
-    OURCYGPATTERN="(^($ROOTDIRS))"
-    # Add a user-defined pattern to the cygpath arguments
-    if [ "$GRADLE_CYGPATTERN" != "" ] ; then
-        OURCYGPATTERN="$OURCYGPATTERN|($GRADLE_CYGPATTERN)"
-    fi
-    # Now convert the arguments - kludge to limit ourselves to /bin/sh
-    i=0
-    for arg in "$@" ; do
-        CHECK=`echo "$arg"|egrep -c "$OURCYGPATTERN" -`
-        CHECK2=`echo "$arg"|egrep -c "^-"`                                 ### Determine if an option
-
-        if [ $CHECK -ne 0 ] && [ $CHECK2 -eq 0 ] ; then                    ### Added a condition
-            eval `echo args$i`=`cygpath --path --ignore --mixed "$arg"`
-        else
-            eval `echo args$i`="\"$arg\""
-        fi
-        i=$((i+1))
-    done
-    case $i in
-        (0) set -- ;;
-        (1) set -- "$args0" ;;
-        (2) set -- "$args0" "$args1" ;;
-        (3) set -- "$args0" "$args1" "$args2" ;;
-        (4) set -- "$args0" "$args1" "$args2" "$args3" ;;
-        (5) set -- "$args0" "$args1" "$args2" "$args3" "$args4" ;;
-        (6) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" ;;
-        (7) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" ;;
-        (8) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" "$args7" ;;
-        (9) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" "$args7" "$args8" ;;
+if ! "$cygwin" && ! "$darwin" && ! "$nonstop" ; then
+    case $MAX_FD in #(
+      max*)
+        # In POSIX sh, ulimit -H is undefined. That's why the result is checked to see if it worked.
+        # shellcheck disable=SC2039,SC3045
+        MAX_FD=$( ulimit -H -n ) ||
+            warn "Could not query maximum file descriptor limit"
+    esac
+    case $MAX_FD in  #(
+      '' | soft) :;; #(
+      *)
+        # In POSIX sh, ulimit -n is undefined. That's why the result is checked to see if it worked.
+        # shellcheck disable=SC2039,SC3045
+        ulimit -n "$MAX_FD" ||
+            warn "Could not set maximum file descriptor limit to $MAX_FD"
    esac
 fi

-# Escape application args
-save () {
-    for i do printf %s\\n "$i" | sed "s/'/'\\\\''/g;1s/^/'/;\$s/\$/' \\\\/" ; done
-    echo " "
-}
-APP_ARGS=$(save "$@")
+# Collect all arguments for the java command, stacking in reverse order:
+#   * args from the command line
+#   * the main class name
+#   * -classpath
+#   * -D...appname settings
+#   * --module-path (only if needed)
+#   * DEFAULT_JVM_OPTS, JAVA_OPTS, and GRADLE_OPTS environment variables.

-# Collect all arguments for the java command, following the shell quoting and substitution rules
-eval set -- $DEFAULT_JVM_OPTS $JAVA_OPTS $GRADLE_OPTS "\"-Dorg.gradle.appname=$APP_BASE_NAME\"" -classpath "\"$CLASSPATH\"" org.gradle.wrapper.GradleWrapperMain "$APP_ARGS"
+# For Cygwin or MSYS, switch paths to Windows format before running java
+if "$cygwin" || "$msys" ; then
+    APP_HOME=$( cygpath --path --mixed "$APP_HOME" )

-# by default we should be in the correct project dir, but when run from Finder on Mac, the cwd is wrong
-if [ "$(uname)" = "Darwin" ] && [ "$HOME" = "$PWD" ]; then
-  cd "$(dirname "$0")"
+    JAVACMD=$( cygpath --unix "$JAVACMD" )
+
+    # Now convert the arguments - kludge to limit ourselves to /bin/sh
+    for arg do
+        if
+            case $arg in                                #(
+              -*)   false ;;                            # don't mess with options #(
+              /?*)  t=${arg#/} t=/${t%%/*}              # looks like a POSIX filepath
+                    [ -e "$t" ] ;;                      #(
+              *)    false ;;
+            esac
+        then
+            arg=$( cygpath --path --ignore --mixed "$arg" )
+        fi
+        # Roll the args list around exactly as many times as the number of
+        # args, so each arg winds up back in the position where it started, but
+        # possibly modified.
+        #
+        # NB: a `for` loop captures its iteration list before it begins, so
+        # changing the positional parameters here affects neither the number of
+        # iterations, nor the values presented in `arg`.
+        shift                   # remove old arg
+        set -- "$@" "$arg"      # push replacement arg
+    done
 fi

+
+# Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
+DEFAULT_JVM_OPTS='"-Xmx64m" "-Xms64m"'
+
+# Collect all arguments for the java command:
+#   * DEFAULT_JVM_OPTS, JAVA_OPTS, and optsEnvironmentVar are not allowed to contain shell fragments,
+#     and any embedded shellness will be escaped.
+#   * For example: A user cannot expect ${Hostname} to be expanded, as it is an environment variable and will be
+#     treated as '${Hostname}' itself on the command line.
+
+set -- \
+        "-Dorg.gradle.appname=$APP_BASE_NAME" \
+        -jar "$APP_HOME/gradle/wrapper/gradle-wrapper.jar" \
+        "$@"
+
+# Stop when "xargs" is not available.
+if ! command -v xargs >/dev/null 2>&1
+then
+    die "xargs is not available"
+fi
+
+# Use "xargs" to parse quoted args.
+#
+# With -n1 it outputs one arg per line, with the quotes and backslashes removed.
+#
+# In Bash we could simply go:
+#
+#   readarray ARGS < <( xargs -n1 <<<"$var" ) &&
+#   set -- "${ARGS[@]}" "$@"
+#
+# but POSIX shell has neither arrays nor command substitution, so instead we
+# post-process each arg (as a line of input to sed) to backslash-escape any
+# character that might be a shell metacharacter, then use eval to reverse
+# that process (while maintaining the separation between arguments), and wrap
+# the whole thing up as a single "set" statement.
+#
+# This will of course break if any of these variables contains a newline or
+# an unmatched quote.
+#
+
+eval "set -- $(
+        printf '%s\n' "$DEFAULT_JVM_OPTS $JAVA_OPTS $GRADLE_OPTS" |
+        xargs -n1 |
+        sed ' s~[^-[:alnum:]+,./:=@_]~\\&~g; ' |
+        tr '\n' ' '
+    )" '"$@"'
+
 exec "$JAVACMD" "$@"
--- a/gradlew.bat
+++ b/gradlew.bat
@@ -1,4 +1,22 @@
-@if "%DEBUG%" == "" @echo off
+@rem
+@rem Copyright 2015 the original author or authors.
+@rem
+@rem Licensed under the Apache License, Version 2.0 (the "License");
+@rem you may not use this file except in compliance with the License.
+@rem You may obtain a copy of the License at
+@rem
+@rem      https://www.apache.org/licenses/LICENSE-2.0
+@rem
+@rem Unless required by applicable law or agreed to in writing, software
+@rem distributed under the License is distributed on an "AS IS" BASIS,
+@rem WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+@rem See the License for the specific language governing permissions and
+@rem limitations under the License.
+@rem
+@rem SPDX-License-Identifier: Apache-2.0
+@rem
+
+@if "%DEBUG%"=="" @echo off
@rem ##########################################################################
@rem
@rem  Gradle startup script for Windows
@@ -9,25 +27,29 @@
 if "%OS%"=="Windows_NT" setlocal

 set DIRNAME=%~dp0
-if "%DIRNAME%" == "" set DIRNAME=.
+if "%DIRNAME%"=="" set DIRNAME=.
+@rem This is normally unused
 set APP_BASE_NAME=%~n0
 set APP_HOME=%DIRNAME%

+@rem Resolve any "." and ".." in APP_HOME to make it shorter.
+for %%i in ("%APP_HOME%") do set APP_HOME=%%~fi
+
@rem Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
-set DEFAULT_JVM_OPTS=
+set DEFAULT_JVM_OPTS="-Xmx64m" "-Xms64m"

@rem Find java.exe
 if defined JAVA_HOME goto findJavaFromJavaHome

 set JAVA_EXE=java.exe
 %JAVA_EXE% -version >NUL 2>&1
-if "%ERRORLEVEL%" == "0" goto init
+if %ERRORLEVEL% equ 0 goto execute

-echo.
-echo ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH.
-echo.
-echo Please set the JAVA_HOME variable in your environment to match the
-echo location of your Java installation.
+echo. 1>&2
+echo ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH. 1>&2
+echo. 1>&2
+echo Please set the JAVA_HOME variable in your environment to match the 1>&2
+echo location of your Java installation. 1>&2

 goto fail

@@ -35,48 +57,35 @@ goto fail
 set JAVA_HOME=%JAVA_HOME:"=%
 set JAVA_EXE=%JAVA_HOME%/bin/java.exe

-if exist "%JAVA_EXE%" goto init
+if exist "%JAVA_EXE%" goto execute

-echo.
-echo ERROR: JAVA_HOME is set to an invalid directory: %JAVA_HOME%
-echo.
-echo Please set the JAVA_HOME variable in your environment to match the
-echo location of your Java installation.
+echo. 1>&2
+echo ERROR: JAVA_HOME is set to an invalid directory: %JAVA_HOME% 1>&2
+echo. 1>&2
+echo Please set the JAVA_HOME variable in your environment to match the 1>&2
+echo location of your Java installation. 1>&2

 goto fail

-:init
-@rem Get command-line arguments, handling Windows variants
-
-if not "%OS%" == "Windows_NT" goto win9xME_args
-
-:win9xME_args
-@rem Slurp the command line arguments.
-set CMD_LINE_ARGS=
-set _SKIP=2
-
-:win9xME_args_slurp
-if "x%~1" == "x" goto execute
-
-set CMD_LINE_ARGS=%*
-
 :execute
@rem Setup the command line

-set CLASSPATH=%APP_HOME%\gradle\wrapper\gradle-wrapper.jar
+

@rem Execute Gradle
-"%JAVA_EXE%" %DEFAULT_JVM_OPTS% %JAVA_OPTS% %GRADLE_OPTS% "-Dorg.gradle.appname=%APP_BASE_NAME%" -classpath "%CLASSPATH%" org.gradle.wrapper.GradleWrapperMain %CMD_LINE_ARGS%
+"%JAVA_EXE%" %DEFAULT_JVM_OPTS% %JAVA_OPTS% %GRADLE_OPTS% "-Dorg.gradle.appname=%APP_BASE_NAME%" -jar "%APP_HOME%\gradle\wrapper\gradle-wrapper.jar" %*

 :end
@rem End local scope for the variables with windows NT shell
-if "%ERRORLEVEL%"=="0" goto mainEnd
+if %ERRORLEVEL% equ 0 goto mainEnd

 :fail
 rem Set variable GRADLE_EXIT_CONSOLE if you need the _script_ return code instead of
 rem the _cmd.exe /c_ return code!
-if  not "" == "%GRADLE_EXIT_CONSOLE%" exit 1
-exit /b 1
+set EXIT_CODE=%ERRORLEVEL%
+if %EXIT_CODE% equ 0 set EXIT_CODE=1
+if not ""=="%GRADLE_EXIT_CONSOLE%" exit %EXIT_CODE%
+exit /b %EXIT_CODE%

 :mainEnd
 if "%OS%"=="Windows_NT" endlocal
--- a/settings.gradle
+++ b/settings.gradle
@@ -52,4 +52,14 @@ include ":BusinessConnectionsBot"

 include ":StarTransactionsBot"

+include ":GiveawaysBot"
+
 include ":CustomBot"
+
+include ":MemberUpdatedWatcherBot"
+
+include ":WebHooks"
+
+include ":SuggestedPosts"
+
+include ":ChecklistsBot"
Author	SHA1	Message	Date
renovate[bot]	fd44bd5360	Update Gradle to v9	2025-11-17 15:01:04 +00:00
InsanusMokrassar	0e8714cf2b	Merge pull request #351 from InsanusMokrassar/29.0.0 29.0.0	2025-09-28 10:54:27 +06:00
InsanusMokrassar	ea74f884bf	change vrsion of telegram bot api	2025-09-25 14:05:44 +06:00
InsanusMokrassar	69cbc257b5	Merge branch 'master' into 29.0.0	2025-09-25 14:04:47 +06:00
InsanusMokrassar	d3e6014e06	fix dependencies	2025-09-23 18:29:42 +06:00
InsanusMokrassar	1d260f82e9	Merge branch 'master' into 29.0.0	2025-09-23 18:29:13 +06:00
InsanusMokrassar	5d0b48c4b7	update dependencies	2025-09-23 18:16:40 +06:00
InsanusMokrassar	34be1a25b2	update SuggestedPostsBot to include printing of paid post publishing	2025-09-23 16:34:57 +06:00
InsanusMokrassar	990614e257	add checklists tasks	2025-09-23 15:43:58 +06:00
InsanusMokrassar	0d1bcf05fd	improve SuggestedPostsBot	2025-09-23 13:38:54 +06:00
InsanusMokrassar	7d5cb58a3f	small improvement with suggested post approvement failes	2025-09-23 12:52:31 +06:00
InsanusMokrassar	261df14412	improvements in suggested posts bot	2025-09-23 12:49:11 +06:00
InsanusMokrassar	81ba5831c3	add suggested posts sample	2025-09-22 12:44:52 +06:00
InsanusMokrassar	0b9c715e25	start migration onto 29.0.0	2025-09-18 01:05:03 +06:00
InsanusMokrassar	0216919145	Merge pull request #345 from InsanusMokrassar/28.0.0 28.0.0	2025-08-23 16:14:17 +06:00
InsanusMokrassar	e2d56a4d80	finalize changes	2025-08-11 15:56:20 +06:00
InsanusMokrassar	70aca52960	update dependency	2025-08-11 15:22:21 +06:00
InsanusMokrassar	6c0d961339	temporal improvements for fsm	2025-08-11 15:22:21 +06:00
renovate[bot]	a3cdf693f2	Update ktor monorepo to v3.2.3	2025-08-11 15:22:02 +06:00
renovate[bot]	e378c6630c	Update telegram_bot_api_version to v27.1.2	2025-08-07 10:58:59 +00:00
InsanusMokrassar	707ad9a160	Merge pull request #331 from InsanusMokrassar/renovate/compose_version Update plugin org.jetbrains.compose to v1.8.2	2025-07-29 17:31:19 +06:00
InsanusMokrassar	68e9830a8f	Merge pull request #341 from InsanusMokrassar/27.1.0 27.1.0	2025-07-29 17:28:01 +06:00
InsanusMokrassar	55ebdeadbc	migration onto 27.1.0	2025-07-27 14:32:39 +06:00
renovate[bot]	d4f3d4bc68	Update plugin org.jetbrains.compose to v1.8.2	2025-07-25 17:23:59 +00:00
InsanusMokrassar	b3d06c9773	Merge pull request #340 from InsanusMokrassar/27.0.0 27.0.0	2025-07-25 23:22:44 +06:00
InsanusMokrassar	e6e3eabf97	update dependencies	2025-07-22 19:52:24 +06:00
InsanusMokrassar	47efedf311	start migration onto 27.0.0	2025-07-15 13:35:35 +06:00
InsanusMokrassar	8423b1377b	Merge pull request #336 from InsanusMokrassar/26.1.0 26.1.0	2025-07-10 17:21:41 +06:00
InsanusMokrassar	d0029603ce	improvements according to latest changes	2025-07-08 18:41:18 +06:00
InsanusMokrassar	8d8fa74779	start migration onto 26.1.0	2025-07-08 11:58:35 +06:00
InsanusMokrassar	459a70c47b	Merge pull request #333 from InsanusMokrassar/26.0.0 26.0.0	2025-06-16 12:15:06 +06:00
InsanusMokrassar	88102f3afa	update telegram bot api version up to last release one	2025-06-15 10:33:03 +06:00
InsanusMokrassar	a621058fdd	update dependencies	2025-06-14 23:48:32 +06:00
InsanusMokrassar	56e072aabe	Merge pull request #332 from InsanusMokrassar/25.0.0 25.0.0	2025-06-14 23:35:44 +06:00
InsanusMokrassar	73f05bbcd7	fix in repositories	2025-06-14 23:21:00 +06:00
InsanusMokrassar	f053013360	fix of build with adding google repository in webapp sample?	2025-06-14 22:28:14 +06:00
InsanusMokrassar	bc39279c6c	update telegram bot api version	2025-06-01 22:18:08 +06:00
InsanusMokrassar	ad8fa92e87	protess on tests	2025-06-01 22:15:57 +06:00
InsanusMokrassar	b0554adb7f	add delete_story test	2025-06-01 21:19:37 +06:00
InsanusMokrassar	ad90180def	fixes	2025-06-01 20:23:19 +06:00
InsanusMokrassar	69eda92bc7	add set business account profile photo tests	2025-06-01 19:24:01 +06:00
InsanusMokrassar	aee070c6c6	add check of set business account bio	2025-05-25 19:42:47 +06:00
InsanusMokrassar	36163d5619	add sample for set business account username	2025-05-25 19:30:51 +06:00
InsanusMokrassar	92d1c7a402	add sections and update version of library	2025-05-25 13:49:02 +06:00
InsanusMokrassar	7ce784d0a2	add device storage sample and beckground/text color config in webapps	2025-05-25 13:01:22 +06:00
InsanusMokrassar	d203d48391	add support of setBusinessAccountName	2025-05-24 22:32:10 +06:00
InsanusMokrassar	9352bb0090	add tests for reading and removing business messages	2025-05-18 22:04:03 +06:00
InsanusMokrassar	b1bb11d826	update nexus.inmo.dev maven repo	2025-05-18 21:13:43 +06:00
InsanusMokrassar	349517462e	start add tests for new business account features	2025-05-11 21:28:32 +06:00
InsanusMokrassar	1708cad654	start migration onto 25.0.0	2025-05-11 21:13:58 +06:00
InsanusMokrassar	f87a9c5c66	Merge pull request #316 from InsanusMokrassar/renovate/kotlin-monorepo Update kotlin monorepo to v2.1.10	2025-02-15 16:46:54 +06:00
InsanusMokrassar	a7b54e4b63	Merge pull request #320 from InsanusMokrassar/renovate/micro_utils_version Update dependency dev.inmo:micro_utils.ktor.server to v0.24.6	2025-02-15 16:45:39 +06:00
renovate[bot]	436213492d	Update kotlin monorepo to v2.1.10	2025-02-15 10:45:34 +00:00
renovate[bot]	0c2110a71d	Update dependency dev.inmo:micro_utils.ktor.server to v0.24.6	2025-02-15 10:45:29 +00:00
InsanusMokrassar	949fa1a429	Merge pull request #319 from InsanusMokrassar/renovate/ktor-monorepo Update ktor monorepo to v3.1.0	2025-02-15 16:45:04 +06:00
InsanusMokrassar	97cdd5a95f	Merge pull request #321 from InsanusMokrassar/renovate/telegram_bot_api_version Update telegram_bot_api_version to v23.2.0	2025-02-15 16:44:49 +06:00
renovate[bot]	0cb116acef	Update telegram_bot_api_version to v23.2.0	2025-02-15 10:32:03 +00:00
renovate[bot]	a0332c4efd	Update ktor monorepo to v3.1.0	2025-02-11 19:14:32 +00:00
InsanusMokrassar	f6bce640da	update dependencies	2025-02-01 09:26:06 +06:00
InsanusMokrassar	d22a99da19	Merge pull request #315 from InsanusMokrassar/23.1.1 23.1.1	2025-01-29 09:09:14 +06:00
InsanusMokrassar	467a3a1710	Update gradle.properties	2025-01-27 10:57:07 +06:00
InsanusMokrassar	5810bc5930	migration onto 23.1.1	2025-01-27 09:20:08 +06:00
InsanusMokrassar	2cf2c4264e	Merge pull request #310 from InsanusMokrassar/renovate/ktor-monorepo Update ktor monorepo to v3.0.3	2025-01-03 14:17:33 +06:00
renovate[bot]	3d5c2ee4b8	Update ktor monorepo to v3.0.3	2025-01-03 08:17:24 +00:00
InsanusMokrassar	360c6b4364	Merge pull request #312 from InsanusMokrassar/renovate/compose_version Update plugin org.jetbrains.compose to v1.7.3	2025-01-03 14:16:48 +06:00
renovate[bot]	bb6a0a125a	Update plugin org.jetbrains.compose to v1.7.3	2024-12-20 01:19:28 +00:00
InsanusMokrassar	6a61da2eb7	Merge pull request #311 from InsanusMokrassar/22.0.0 22.0.0	2024-12-09 08:54:48 +06:00
InsanusMokrassar	8cd75673f5	add opportunity to set custom emoji status from webapp	2024-12-08 13:17:39 +06:00
InsanusMokrassar	d294d0ef59	update events listeners	2024-12-08 11:58:47 +06:00
InsanusMokrassar	2ab8ccbfdf	small refactor in webapp	2024-12-08 10:20:37 +06:00
InsanusMokrassar	d12e9aa032	rework to use compose	2024-12-08 10:14:42 +06:00
InsanusMokrassar	76f151586e	start migration to compose in webapp	2024-12-07 11:36:39 +06:00
InsanusMokrassar	1c437690e4	migrate webapp	2024-12-06 16:32:47 +06:00
InsanusMokrassar	222c7ec8ee	22.0.0	2024-12-06 13:18:18 +06:00
InsanusMokrassar	59778a3add	Merge pull request #309 from InsanusMokrassar/21.0.0 21.0.0	2024-11-30 17:58:05 +06:00
InsanusMokrassar	3e20835bc6	Update gradle.properties	2024-11-30 17:11:07 +06:00
InsanusMokrassar	c3ad2d4319	upgrade custom bot to include context data and additional context data	2024-11-30 14:42:21 +06:00
InsanusMokrassar	59fca968d7	update tgbotapi and include sample of context data in custom bot	2024-11-29 12:50:33 +06:00
InsanusMokrassar	f03ba5f177	Merge pull request #302 from InsanusMokrassar/renovate/telegram_bot_api_version Update telegram_bot_api_version to v20.0.1	2024-11-13 13:53:07 +06:00
renovate[bot]	855d2c1296	Update telegram_bot_api_version to v20.0.1	2024-11-11 10:46:16 +00:00
InsanusMokrassar	280f5abce0	Merge pull request #294 from InsanusMokrassar/renovate/major-ktor-monorepo Update dependency io.ktor:ktor-client-logging-jvm to v3	2024-11-04 01:39:22 +06:00
renovate[bot]	ed81e76ef8	Update dependency io.ktor:ktor-client-logging-jvm to v3	2024-11-03 19:39:16 +00:00
InsanusMokrassar	541b76b292	Merge pull request #301 from InsanusMokrassar/20.0.0 20.0.0	2024-11-02 00:34:52 +06:00
InsanusMokrassar	5b580b5a15	migration onto 20.0.0	2024-11-01 23:48:29 +06:00
InsanusMokrassar	86790ee414	add copyText sample button	2024-11-01 23:21:33 +06:00
InsanusMokrassar	0bbe430374	update ktgbotapi	2024-11-01 15:27:17 +06:00
InsanusMokrassar	b7d53a7410	Merge pull request #298 from InsanusMokrassar/19.0.0 19.0.0	2024-11-01 14:55:49 +06:00
InsanusMokrassar	73064db226	small adaptation	2024-10-30 18:09:23 +06:00
InsanusMokrassar	a50eda366d	update dependencies and add webhooks sample	2024-10-30 14:38:46 +06:00
InsanusMokrassar	e34f0ec9d8	Update gradle-wrapper.properties	2024-10-22 17:36:59 +06:00
InsanusMokrassar	c2237f7e87	Merge pull request #297 from InsanusMokrassar/18.2.2 18.2.2	2024-10-22 17:35:39 +06:00
InsanusMokrassar	0bbc6a9555	Update gradle.properties	2024-10-22 17:22:41 +06:00
InsanusMokrassar	d4d8508abf	add middlewares sample in custom bot	2024-10-15 13:52:26 +06:00
InsanusMokrassar	9acb64fda9	Merge pull request #291 from InsanusMokrassar/renovate/micro_utils_version Update dependency dev.inmo:micro_utils.ktor.server to v0.22.4	2024-09-26 07:59:14 +06:00
renovate[bot]	760ae36207	Update dependency dev.inmo:micro_utils.ktor.server to v0.22.4	2024-09-26 01:59:00 +00:00
InsanusMokrassar	5c6b1b7171	Merge pull request #290 from InsanusMokrassar/renovate/serialization_version Update dependency org.jetbrains.kotlinx:kotlinx-serialization-json to v1.7.3	2024-09-26 07:58:43 +06:00
InsanusMokrassar	6e06357541	Merge pull request #265 from InsanusMokrassar/renovate/ktor-monorepo Update dependency io.ktor:ktor-client-logging-jvm to v2.3.12	2024-09-26 07:58:28 +06:00
InsanusMokrassar	38f46dfa3b	Merge pull request #292 from InsanusMokrassar/renovate/telegram_bot_api_version Update telegram_bot_api_version to v18.2.1	2024-09-26 07:57:57 +06:00
renovate[bot]	e7f7ef16ac	Update telegram_bot_api_version to v18.2.1	2024-09-25 21:35:02 +00:00
renovate[bot]	d100a5a336	Update dependency org.jetbrains.kotlinx:kotlinx-serialization-json to v1.7.3	2024-09-19 18:27:24 +00:00
InsanusMokrassar	5f0f2ce76d	Merge pull request #289 from InsanusMokrassar/18.2.0 18.2.0	2024-09-09 02:33:18 +06:00
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
renovate[bot]	cea610a0f8	Update dependency io.ktor:ktor-client-logging-jvm to v2.3.12	2024-09-02 02:00:00 +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