Update CHANGELOG.md

6.0.1

CHANGELOG.md

@@ -1,5 +1,52 @@
 # TelegramBotAPI changelog
 
+## 6.0.2
+
+* `Core`:
+    * Long polling now uses media groups debounce as in webhooks
+
+## 6.0.1
+
+* `Versions`:
+    * `Ktor`: `2.2.3` -> `2.2.4`
+    * `MicroUtils`: `0.17.0` -> `0.17.1`
+
+## 6.0.0
+
+* `Versions`:
+    * `Kotlin`: `1.7.22` -> `1.8.10`
+    * `MicroUtils`: `0.16.10` -> `0.17.0`
+    * `Serialization`: `1.4.1` -> `1.5.0`
+    * `uuid`: `0.6.0` -> `0.7.0`
+* `Core`:
+    * `*.link` extensions have been deprecated with renaming to avoid collisions with `link` methods
+* `API`:
+    * Add `TelegramBot.resend` methods
+* `BehaviourBuilder`:
+    * Add triggers and waiters for `VisualMediaGroupPartContent`
+* `Utils`:
+    * `*.link` extensions have been deprecated with renaming to avoid collisions with `link` methods
+
+## 5.2.1
+
+* `Core`:
+    * All the `CallbackQuery`es now will receive `CommonUser` instead of `User` due inability of bots to trigger any
+      inline interaction with others bots
+* `API`:
+    * Now `sentMessageFlow` will take each sent message in `handleLiveLocation`
+
+## 5.2.0
+
+* `Versions`:
+    * `MicroUtils`: `0.16.8` -> `0.16.10`
+
+## 5.1.1
+
+* `Core`:
+    * Add opportunity to get user link with `makeUserLink`
+* `BehaviourBuilder`:
+    * Fixes in content waiting expectators
+
 ## 5.1.0
 
 [Bot API 6.5](https://core.telegram.org/bots/api-changelog#february-3-2023) support

README.md

@@ -5,10 +5,10 @@
 | Useful repos | [![Create bot](https://img.shields.io/static/v1?label=Github&message=Template&color=blue&logo=github)](https://github.com/InsanusMokrassar/TelegramBotAPI-bot_template/generate) [![Examples](https://img.shields.io/static/v1?label=Github&message=Examples&color=blue&logo=github)](https://github.com/InsanusMokrassar/TelegramBotAPI-examples/) |
 | Misc | [![Awesome Kotlin Badge](https://kotlin.link/awesome-kotlin.svg)](https://github.com/KotlinBy/awesome-kotlin) [![Small survey](https://img.shields.io/static/v1?label=Google&message=Survey&color=blue&logo=google-sheets)](https://docs.google.com/forms/d/e/1FAIpQLSctdJHT_aEniyYT0-IUAEfo1hsIlezX2owlkEAYX4KPl2V2_A/viewform?usp=sf_link) |
 
-<!--- [![Telegram Channel](./resources/tg_channel_qr.jpg)](https://t.me/InMoTelegramBotAPI) --->
+<!--- [![Telegram Channel](./resources/tg_channel_qr.jpg)](https://t.me/ktgbotapi) --->
 
 <p align="center">
-  <a href="https://t.me/InMoTelegramBotAPI">
+  <a href="https://t.me/ktgbotapi">
     <img src="./resources/tg_channel_qr.jpg">
   </a>
 </p>

gradle.properties

@@ -6,4 +6,4 @@ kotlin.incremental=true
 kotlin.incremental.js=true
 
 library_group=dev.inmo
-library_version=5.1.0
+library_version=6.0.2

gradle/libs.versions.toml

@@ -1,19 +1,19 @@
 [versions]
 
-kotlin = "1.7.22"
+kotlin = "1.8.10"
-kotlin-serialization = "1.4.1"
+kotlin-serialization = "1.5.0"
 kotlin-coroutines = "1.6.4"
 
 javax-activation = "1.1.1"
 
 korlibs = "3.4.0"
-uuid = "0.6.0"
+uuid = "0.7.0"
-ktor = "2.2.3"
+ktor = "2.2.4"
 
-ksp = "1.7.22-1.0.8"
+ksp = "1.8.10-1.0.9"
 kotlin-poet = "1.12.0"
 
-microutils = "0.16.8"
+microutils = "0.17.1"
 
 github-release-plugin = "2.4.1"
 dokka = "1.7.20"

gradle/wrapper/gradle-wrapper.properties

@@ -2,4 +2,4 @@ distributionBase=GRADLE_USER_HOME
 distributionPath=wrapper/dists
 zipStoreBase=GRADLE_USER_HOME
 zipStorePath=wrapper/dists
-distributionUrl=https\://services.gradle.org/distributions/gradle-7.6-bin.zip
+distributionUrl=https\://services.gradle.org/distributions/gradle-7.6.1-bin.zip

publish.gradle

@@ -1,7 +1,8 @@
 apply plugin: 'maven-publish'
 
 task javadocsJar(type: Jar) {
-    classifier = 'javadoc'
+    archiveClassifier.convention("javadoc")
+    archiveClassifier.set("javadoc")
 }
 
 publishing {
@@ -19,22 +20,22 @@ publishing {
             }
 
             developers {
-                
+
                     developer {
                         id = "InsanusMokrassar"
                         name = "Ovsiannikov Aleksei"
                         email = "ovsyannikov.alexey95@gmail.com"
                     }
-                
+
             }
 
             licenses {
-                
+
                     license {
                         name = "Apache Software License 2.0"
                         url = "https://github.com/InsanusMokrassar/TelegramBotAPI/blob/master/LICENSE"
                     }
-                
+
             }
         }
         repositories {
@@ -42,55 +43,55 @@ publishing {
                 maven {
                     name = "GithubPackages"
                     url = uri("https://maven.pkg.github.com/InsanusMokrassar/TelegramBotAPI")
-            
+
                     credentials {
                         username = project.hasProperty('GITHUBPACKAGES_USER') ? project.property('GITHUBPACKAGES_USER') : System.getenv('GITHUBPACKAGES_USER')
                         password = project.hasProperty('GITHUBPACKAGES_PASSWORD') ? project.property('GITHUBPACKAGES_PASSWORD') : System.getenv('GITHUBPACKAGES_PASSWORD')
                     }
-            
+
                 }
             }
             if (project.hasProperty('GITEA_TOKEN') || System.getenv('GITEA_TOKEN') != null) {
                 maven {
                     name = "Gitea"
                     url = uri("https://git.inmo.dev/api/packages/InsanusMokrassar/maven")
-            
+
                     credentials(HttpHeaderCredentials) {
                         name = "Authorization"
                         value = project.hasProperty('GITEA_TOKEN') ? project.property('GITEA_TOKEN') : System.getenv('GITEA_TOKEN')
                     }
-            
+
                     authentication {
                         header(HttpHeaderAuthentication)
                     }
-            
+
                 }
             }
             if ((project.hasProperty('SONATYPE_USER') || System.getenv('SONATYPE_USER') != null) && (project.hasProperty('SONATYPE_PASSWORD') || System.getenv('SONATYPE_PASSWORD') != null)) {
                 maven {
                     name = "sonatype"
                     url = uri("https://oss.sonatype.org/service/local/staging/deploy/maven2/")
-            
+
                     credentials {
                         username = project.hasProperty('SONATYPE_USER') ? project.property('SONATYPE_USER') : System.getenv('SONATYPE_USER')
                         password = project.hasProperty('SONATYPE_PASSWORD') ? project.property('SONATYPE_PASSWORD') : System.getenv('SONATYPE_PASSWORD')
                     }
-            
+
                 }
             }
         }
     }
 }
-    
+
 if (project.hasProperty("signing.gnupg.keyName")) {
     apply plugin: 'signing'
-    
+
     signing {
         useGpgCmd()
-    
+
         sign publishing.publications
     }
-    
+
     task signAll {
         tasks.withType(Sign).forEach {
             dependsOn(it)

tgbotapi.api/src/commonMain/kotlin/dev/inmo/tgbotapi/extensions/api/LiveFlowLocation.kt

@@ -6,7 +6,6 @@ import dev.inmo.tgbotapi.abstracts.*
 import dev.inmo.tgbotapi.abstracts.types.WithReplyMarkup
 import dev.inmo.tgbotapi.bot.TelegramBot
 import dev.inmo.tgbotapi.extensions.api.edit.edit
-import dev.inmo.tgbotapi.extensions.api.edit.location.live.editLiveLocation
 import dev.inmo.tgbotapi.extensions.api.send.send
 import dev.inmo.tgbotapi.extensions.api.send.sendLiveLocation
 import dev.inmo.tgbotapi.types.*
@@ -17,6 +16,7 @@ import dev.inmo.tgbotapi.types.message.abstracts.ContentMessage
 import dev.inmo.tgbotapi.types.message.content.LocationContent
 import kotlinx.coroutines.*
 import kotlinx.coroutines.flow.Flow
+import kotlinx.coroutines.flow.FlowCollector
 import kotlinx.coroutines.flow.map
 import kotlinx.serialization.Serializable
 import kotlin.js.JsName
@@ -45,7 +45,8 @@ suspend fun TelegramBot.handleLiveLocation(
     disableNotification: Boolean = false,
     protectContent: Boolean = false,
     replyToMessageId: MessageId? = null,
-    allowSendingWithoutReply: Boolean? = null
+    allowSendingWithoutReply: Boolean? = null,
+    sentMessageFlow: FlowCollector<ContentMessage<LocationContent>>? = null
 ) {
     var currentLiveLocationMessage: ContentMessage<LocationContent>? = null
     val updateMessageJob = CoroutineScope(currentCoroutineContext().LinkedSupervisorJob()).launchSafelyWithoutExceptions(start = CoroutineStart.LAZY) {
@@ -73,7 +74,9 @@ suspend fun TelegramBot.handleLiveLocation(
                 replyToMessageId,
                 allowSendingWithoutReply,
                 it.replyMarkup
-            )
+            ).also {
+                sentMessageFlow ?.emit(it)
+            }
         } else {
             edit(
                 capturedLiveLocationMessage,
@@ -83,7 +86,9 @@ suspend fun TelegramBot.handleLiveLocation(
                 it.heading,
                 it.proximityAlertRadius,
                 it.replyMarkup
-            )
+            ).also {
+                sentMessageFlow ?.emit(it)
+            }
         }
     }
 }
@@ -102,7 +107,8 @@ suspend fun TelegramBot.handleLiveLocation(
     disableNotification: Boolean = false,
     protectContent: Boolean = false,
     replyToMessageId: MessageId? = null,
-    allowSendingWithoutReply: Boolean? = null
+    allowSendingWithoutReply: Boolean? = null,
+    sentMessageFlow: FlowCollector<ContentMessage<LocationContent>>? = null
 ) {
     handleLiveLocation(
         chatId,
@@ -121,7 +127,8 @@ suspend fun TelegramBot.handleLiveLocation(
         disableNotification,
         protectContent,
         replyToMessageId,
-        allowSendingWithoutReply
+        allowSendingWithoutReply,
+        sentMessageFlow
     )
 }
 
@@ -139,7 +146,8 @@ suspend fun TelegramBot.handleLiveLocation(
     disableNotification: Boolean = false,
     protectContent: Boolean = false,
     replyToMessageId: MessageId? = null,
-    allowSendingWithoutReply: Boolean? = null
+    allowSendingWithoutReply: Boolean? = null,
+    sentMessageFlow: FlowCollector<ContentMessage<LocationContent>>? = null
 ) {
     handleLiveLocation(
         chatId,
@@ -154,6 +162,7 @@ suspend fun TelegramBot.handleLiveLocation(
         disableNotification,
         protectContent,
         replyToMessageId,
-        allowSendingWithoutReply
+        allowSendingWithoutReply,
+        sentMessageFlow
     )
 }

tgbotapi.api/src/commonMain/kotlin/dev/inmo/tgbotapi/extensions/api/LiveLocationProvider.kt

@@ -2,15 +2,22 @@ package dev.inmo.tgbotapi.extensions.api
 
 import com.soywiz.klock.DateTime
 import com.soywiz.klock.TimeSpan
+import dev.inmo.micro_utils.coroutines.LinkedSupervisorJob
+import dev.inmo.micro_utils.coroutines.launchSafelyWithoutExceptions
+import dev.inmo.tgbotapi.abstracts.types.WithReplyMarkup
 import dev.inmo.tgbotapi.bot.TelegramBot
+import dev.inmo.tgbotapi.extensions.api.edit.edit
 import dev.inmo.tgbotapi.extensions.api.edit.location.live.editLiveLocation
 import dev.inmo.tgbotapi.extensions.api.edit.location.live.stopLiveLocation
+import dev.inmo.tgbotapi.extensions.api.send.send
+import dev.inmo.tgbotapi.extensions.api.send.sendLiveLocation
 import dev.inmo.tgbotapi.requests.send.SendLiveLocation
 import dev.inmo.tgbotapi.types.*
 import dev.inmo.tgbotapi.types.buttons.InlineKeyboardMarkup
 import dev.inmo.tgbotapi.types.buttons.KeyboardMarkup
 import dev.inmo.tgbotapi.types.chat.Chat
 import dev.inmo.tgbotapi.types.location.LiveLocation
+import dev.inmo.tgbotapi.types.location.Location
 import dev.inmo.tgbotapi.types.location.StaticLocation
 import dev.inmo.tgbotapi.types.message.abstracts.ContentMessage
 import dev.inmo.tgbotapi.types.message.abstracts.Message
@@ -18,7 +25,15 @@ import dev.inmo.tgbotapi.types.message.content.LocationContent
 import dev.inmo.tgbotapi.utils.extensions.threadIdOrNull
 import io.ktor.utils.io.core.Closeable
 import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.CoroutineStart
+import kotlinx.coroutines.currentCoroutineContext
+import kotlinx.coroutines.delay
+import kotlinx.coroutines.flow.Flow
+import kotlinx.coroutines.flow.map
+import kotlinx.coroutines.isActive
 import kotlinx.coroutines.launch
+import kotlin.js.JsName
+import kotlin.jvm.JvmName
 import kotlin.math.ceil
 
 val defaultLivePeriodDelayMillis = (livePeriodLimit.last - 60L) * 1000L
@@ -45,7 +60,8 @@ class LiveLocationProvider internal constructor(
         private set
         get() = field || leftUntilCloseMillis.millisecondsLong < 0L
 
-    private var message: ContentMessage<LocationContent> = initMessage
+    var message: ContentMessage<LocationContent> = initMessage
+        private set
     val lastLocation: LiveLocation
         get() = message.content.location as LiveLocation
 

tgbotapi.api/src/commonMain/kotlin/dev/inmo/tgbotapi/extensions/api/send/ResendMessage.kt

@@ -0,0 +1,108 @@
+package dev.inmo.tgbotapi.extensions.api.send
+
+import dev.inmo.tgbotapi.bot.TelegramBot
+import dev.inmo.tgbotapi.types.ChatIdentifier
+import dev.inmo.tgbotapi.types.MessageId
+import dev.inmo.tgbotapi.types.MessageThreadId
+import dev.inmo.tgbotapi.types.buttons.KeyboardMarkup
+import dev.inmo.tgbotapi.types.chat.Chat
+import dev.inmo.tgbotapi.types.message.abstracts.ContentMessage
+import dev.inmo.tgbotapi.types.message.content.MessageContent
+import dev.inmo.tgbotapi.types.threadId
+
+/**
+ * This method will send [content] to the [chatId] as is
+ */
+suspend inline fun <T : MessageContent> TelegramBot.resend(
+    chatId: ChatIdentifier,
+    content: T,
+    messageThreadId: MessageThreadId? = chatId.threadId,
+    disableNotification: Boolean = false,
+    protectContent: Boolean = false,
+    replyToMessageId: MessageId? = null,
+    allowSendingWithoutReply: Boolean? = null,
+    replyMarkup: KeyboardMarkup? = null
+) = execute(
+    content.createResend(
+        chatId = chatId,
+        messageThreadId = messageThreadId,
+        disableNotification = disableNotification,
+        protectContent = protectContent,
+        replyToMessageId = replyToMessageId,
+        allowSendingWithoutReply = allowSendingWithoutReply,
+        replyMarkup = replyMarkup
+    )
+) as ContentMessage<T>
+
+/**
+ * This method will send [content] to the [chatId] as is
+ */
+suspend inline fun <T : MessageContent> TelegramBot.resend(
+    chat: Chat,
+    content: T,
+    messageThreadId: MessageThreadId? = chat.id.threadId,
+    disableNotification: Boolean = false,
+    protectContent: Boolean = false,
+    replyToMessageId: MessageId? = null,
+    allowSendingWithoutReply: Boolean? = null,
+    replyMarkup: KeyboardMarkup? = null
+) = resend(
+    chatId = chat.id,
+    content = content,
+    messageThreadId = messageThreadId,
+    disableNotification = disableNotification,
+    protectContent = protectContent,
+    replyToMessageId = replyToMessageId,
+    allowSendingWithoutReply = allowSendingWithoutReply,
+    replyMarkup = replyMarkup
+)
+
+/**
+ * This method will send [message] content to the [chatId]. In difference with [copyMessage], this method will use
+ * native methods for data sending (like [dev.inmo.tgbotapi.extensions.api.send.media.sendPhoto] if inoming content is
+ * [dev.inmo.tgbotapi.types.message.content.PhotoContent])
+ */
+suspend inline fun <T : MessageContent> TelegramBot.resend(
+    chatId: ChatIdentifier,
+    message: ContentMessage<T>,
+    messageThreadId: MessageThreadId? = chatId.threadId,
+    disableNotification: Boolean = false,
+    protectContent: Boolean = false,
+    replyToMessageId: MessageId? = null,
+    allowSendingWithoutReply: Boolean? = null,
+    replyMarkup: KeyboardMarkup? = null
+) = resend(
+    chatId = chatId,
+    content = message.content,
+    messageThreadId = messageThreadId,
+    disableNotification = disableNotification,
+    protectContent = protectContent,
+    replyToMessageId = replyToMessageId,
+    allowSendingWithoutReply = allowSendingWithoutReply,
+    replyMarkup = replyMarkup
+)
+
+/**
+ * This method will send [message] content to the [chat]. In difference with [copyMessage], this method will use
+ * native methods for data sending (like [dev.inmo.tgbotapi.extensions.api.send.media.sendPhoto] if inoming content is
+ * [dev.inmo.tgbotapi.types.message.content.PhotoContent])
+ */
+suspend inline fun <T : MessageContent> TelegramBot.resend(
+    chat: Chat,
+    message: ContentMessage<T>,
+    messageThreadId: MessageThreadId? = chat.id.threadId,
+    disableNotification: Boolean = false,
+    protectContent: Boolean = false,
+    replyToMessageId: MessageId? = null,
+    allowSendingWithoutReply: Boolean? = null,
+    replyMarkup: KeyboardMarkup? = null
+) = resend(
+    chatId = chat.id,
+    message = message,
+    messageThreadId = messageThreadId,
+    disableNotification = disableNotification,
+    protectContent = protectContent,
+    replyToMessageId = replyToMessageId,
+    allowSendingWithoutReply = allowSendingWithoutReply,
+    replyMarkup = replyMarkup
+)

tgbotapi.api/src/commonMain/kotlin/dev/inmo/tgbotapi/extensions/api/utils/UpdatesHandling.kt

@@ -1,7 +1,8 @@
 package dev.inmo.tgbotapi.extensions.api.utils
 
+import dev.inmo.micro_utils.coroutines.launchSafelyWithoutExceptions
 import dev.inmo.tgbotapi.extensions.api.InternalUtils.convertWithMediaGroupUpdates
-import dev.inmo.tgbotapi.types.message.abstracts.PossiblySentViaBotCommonMessage
+import dev.inmo.tgbotapi.types.message.abstracts.PossiblyMediaGroupMessage
 import dev.inmo.tgbotapi.types.update.abstracts.BaseMessageUpdate
 import dev.inmo.tgbotapi.types.update.abstracts.Update
 import dev.inmo.tgbotapi.updateshandlers.UpdateReceiver
@@ -28,26 +29,18 @@ fun CoroutineScope.updateHandlerWithMediaGroupsAdaptation(
     )
 
     launch {
-        launch {
+        launchSafelyWithoutExceptions {
             for (update in updatesChannel) {
-                val dataAsPossiblySentViaBotCommonMessage = update.data as? PossiblySentViaBotCommonMessage<*>
+                val data = update.data
-
+                when {
-                if (dataAsPossiblySentViaBotCommonMessage == null) {
+                    data is PossiblyMediaGroupMessage<*> && data.mediaGroupId != null -> {
-                    output(update)
+                        mediaGroupChannel.send("${data.mediaGroupId}${update::class.simpleName}" to update as BaseMessageUpdate)
-                    continue
+                    }
+                    else -> output(update)
                 }
-
-                val mediaGroupId = dataAsPossiblySentViaBotCommonMessage.mediaGroupId
-
-                if (mediaGroupId == null) {
-                    output(update)
-                    continue
-                }
-
-                mediaGroupChannel.send("${mediaGroupId}${update::class.simpleName}" to update as BaseMessageUpdate)
             }
         }
-        launch {
+        launchSafelyWithoutExceptions {
             for ((_, mediaGroup) in mediaGroupAccumulatedChannel) {
                 mediaGroup.convertWithMediaGroupUpdates().forEach {
                     output(it)

tgbotapi.behaviour_builder.fsm/src/commonMain/kotlin/dev/inmo/tgbotapi/extensions/behaviour_builder/BehaviourContextWithFSMBuilder.kt

@@ -8,6 +8,7 @@ import dev.inmo.micro_utils.fsm.common.utils.StateHandlingErrorHandler
 import dev.inmo.micro_utils.fsm.common.utils.defaultStateHandlingErrorHandler
 import dev.inmo.tgbotapi.bot.TelegramBot
 import dev.inmo.tgbotapi.extensions.utils.updates.retrieving.longPolling
+import dev.inmo.tgbotapi.extensions.utils.updates.retrieving.updateHandlerWithMediaGroupsAdaptation
 import dev.inmo.tgbotapi.types.Seconds
 import dev.inmo.tgbotapi.types.update.abstracts.Update
 import dev.inmo.tgbotapi.updateshandlers.FlowsUpdatesFilter
@@ -47,6 +48,10 @@ suspend fun <T : State> TelegramBot.buildBehaviourWithFSM(
  * Use [buildBehaviourWithFSM] to create [BehaviourContextWithFSM] and launch getting of updates
  * using [longPolling]. For [longPolling] will be used result [BehaviourContextWithFSM] for both parameters
  * flowsUpdatesFilter and scope
+ *
+ * @param mediaGroupsDebounceTimeMillis Will be used for calling of [updateHandlerWithMediaGroupsAdaptation]. Pass null
+ * in case you wish to enable classic way of updates handling, but in that mode some media group messages can be
+ * retrieved in different updates
  */
 suspend fun <T : State> TelegramBot.buildBehaviourWithFSMAndStartLongPolling(
     upstreamUpdatesFlow: Flow<Update>? = null,
@@ -58,6 +63,7 @@ suspend fun <T : State> TelegramBot.buildBehaviourWithFSMAndStartLongPolling(
     timeoutSeconds: Seconds = 30,
     autoDisableWebhooks: Boolean = true,
     autoSkipTimeoutExceptions: Boolean = true,
+    mediaGroupsDebounceTimeMillis: Long? = 1000L,
     block: CustomBehaviourContextReceiver<DefaultBehaviourContextWithFSM<T>, Unit>
 ): Pair<DefaultBehaviourContextWithFSM<T>, Job> = buildBehaviourWithFSM(
     upstreamUpdatesFlow,
@@ -70,7 +76,7 @@ suspend fun <T : State> TelegramBot.buildBehaviourWithFSMAndStartLongPolling(
 ).run {
     this to scope.launch {
         start()
-        longPolling(flowsUpdatesFilter, timeoutSeconds, scope, autoDisableWebhooks, autoSkipTimeoutExceptions, defaultExceptionsHandler)
+        longPolling(flowsUpdatesFilter, timeoutSeconds, scope, autoDisableWebhooks, autoSkipTimeoutExceptions, mediaGroupsDebounceTimeMillis, defaultExceptionsHandler)
     }
 }
 
@@ -116,6 +122,10 @@ suspend fun <T : State> TelegramBot.buildBehaviourWithFSM(
  * using [longPolling]. For [longPolling] will be used result [BehaviourContextWithFSM] for both parameters
  * flowsUpdatesFilter and scope
  *
+ * @param mediaGroupsDebounceTimeMillis Will be used for calling of [updateHandlerWithMediaGroupsAdaptation]. Pass null
+ * in case you wish to enable classic way of updates handling, but in that mode some media group messages can be
+ * retrieved in different updates
+ *
  * @see buildBehaviourWithFSMAndStartLongPolling
  * @see BehaviourContext
  * @see longPolling
@@ -131,6 +141,7 @@ suspend fun <T : State> TelegramBot.buildBehaviourWithFSMAndStartLongPolling(
     timeoutSeconds: Seconds = 30,
     autoDisableWebhooks: Boolean = true,
     autoSkipTimeoutExceptions: Boolean = true,
+    mediaGroupsDebounceTimeMillis: Long? = 1000L,
     block: CustomBehaviourContextReceiver<DefaultBehaviourContextWithFSM<T>, Unit>
 ) = FlowsUpdatesFilter().let {
     buildBehaviourWithFSM(
@@ -149,6 +160,7 @@ suspend fun <T : State> TelegramBot.buildBehaviourWithFSMAndStartLongPolling(
             scope,
             autoDisableWebhooks,
             autoSkipTimeoutExceptions,
+            mediaGroupsDebounceTimeMillis,
             defaultExceptionsHandler
         )
     }

tgbotapi.behaviour_builder.fsm/src/commonMain/kotlin/dev/inmo/tgbotapi/extensions/behaviour_builder/TelegramBotWithFSM.kt

@@ -11,6 +11,7 @@ import dev.inmo.tgbotapi.bot.ktor.KtorRequestsExecutorBuilder
 import dev.inmo.tgbotapi.bot.ktor.telegramBot
 import dev.inmo.tgbotapi.bot.TelegramBot
 import dev.inmo.tgbotapi.extensions.utils.updates.retrieving.startGettingOfUpdatesByLongPolling
+import dev.inmo.tgbotapi.extensions.utils.updates.retrieving.updateHandlerWithMediaGroupsAdaptation
 import dev.inmo.tgbotapi.types.Seconds
 import dev.inmo.tgbotapi.updateshandlers.FlowsUpdatesFilter
 import dev.inmo.tgbotapi.utils.telegramBotAPIDefaultUrl
@@ -26,6 +27,10 @@ import kotlin.coroutines.coroutineContext
  * **WARNING** This method WILL NOT launch any listening of updates. Use something like
  * [startGettingOfUpdatesByLongPolling] or tools for work with webhooks
  *
+ * @param mediaGroupsDebounceTimeMillis Will be used for calling of [updateHandlerWithMediaGroupsAdaptation]. Pass null
+ * in case you wish to enable classic way of updates handling, but in that mode some media group messages can be
+ * retrieved in different updates
+ *
  * @return Created bot which has been used to create [BehaviourContext] via [buildBehaviourWithFSM]
  *
  * @see [BehaviourContext]
@@ -46,6 +51,7 @@ suspend fun <T : State> telegramBotWithBehaviourAndFSM(
     timeoutSeconds: Seconds = 30,
     autoDisableWebhooks: Boolean = true,
     autoSkipTimeoutExceptions: Boolean = true,
+    mediaGroupsDebounceTimeMillis: Long? = 1000L,
     block: CustomBehaviourContextReceiver<DefaultBehaviourContextWithFSM<T>, Unit>
 ): TelegramBot = telegramBot(
     token,
@@ -63,6 +69,7 @@ suspend fun <T : State> telegramBotWithBehaviourAndFSM(
         timeoutSeconds,
         autoDisableWebhooks,
         autoSkipTimeoutExceptions,
+        mediaGroupsDebounceTimeMillis,
         block
     )
 }
@@ -71,6 +78,10 @@ suspend fun <T : State> telegramBotWithBehaviourAndFSM(
  * Create bot using [telegramBot] and start listening for updates using [buildBehaviourWithFSMAndStartLongPolling]. This
  * method will launch updates retrieving via long polling inside of [buildBehaviourWithFSMAndStartLongPolling]
  *
+ * @param mediaGroupsDebounceTimeMillis Will be used for calling of [updateHandlerWithMediaGroupsAdaptation]. Pass null
+ * in case you wish to enable classic way of updates handling, but in that mode some media group messages can be
+ * retrieved in different updates
+ *
  * @return Pair of [TelegramBot] and [Job]. This [Job] can be used to stop listening updates in your [block] you passed
  * here
  *
@@ -91,6 +102,7 @@ suspend fun <T : State> telegramBotWithBehaviourAndFSMAndStartLongPolling(
     timeoutSeconds: Seconds = 30,
     autoDisableWebhooks: Boolean = true,
     autoSkipTimeoutExceptions: Boolean = true,
+    mediaGroupsDebounceTimeMillis: Long? = 1000L,
     block: CustomBehaviourContextReceiver<DefaultBehaviourContextWithFSM<T>, Unit>
 ): Pair<TelegramBot, Job> {
     return telegramBot(
@@ -108,6 +120,7 @@ suspend fun <T : State> telegramBotWithBehaviourAndFSMAndStartLongPolling(
             timeoutSeconds,
             autoDisableWebhooks,
             autoSkipTimeoutExceptions,
+            mediaGroupsDebounceTimeMillis,
             block
         )
     }

tgbotapi.behaviour_builder/src/commonMain/kotlin/dev/inmo/tgbotapi/extensions/behaviour_builder/BehaviourBuilders.kt

@@ -5,6 +5,7 @@ import dev.inmo.micro_utils.coroutines.ExceptionHandler
 import dev.inmo.tgbotapi.bot.TelegramBot
 import dev.inmo.tgbotapi.extensions.utils.updates.retrieving.longPolling
 import dev.inmo.tgbotapi.extensions.utils.updates.retrieving.startGettingOfUpdatesByLongPolling
+import dev.inmo.tgbotapi.extensions.utils.updates.retrieving.updateHandlerWithMediaGroupsAdaptation
 import dev.inmo.tgbotapi.types.Seconds
 import dev.inmo.tgbotapi.updateshandlers.FlowsUpdatesFilter
 import kotlinx.coroutines.*
@@ -47,6 +48,10 @@ suspend fun TelegramBot.buildBehaviour(
  * Use this method to build bot behaviour and run it via long polling. In case you wish to get [FlowsUpdatesFilter] for
  * additional manipulations, you must provide external [FlowsUpdatesFilter] in other [buildBehaviour] function.
  *
+ * @param mediaGroupsDebounceTimeMillis Will be used for calling of [updateHandlerWithMediaGroupsAdaptation]. Pass null
+ * in case you wish to enable classic way of updates handling, but in that mode some media group messages can be
+ * retrieved in different updates
+ *
  * @see buildBehaviour
  * @see BehaviourContext
  * @see startGettingOfUpdatesByLongPolling
@@ -57,6 +62,7 @@ suspend fun TelegramBot.buildBehaviourWithLongPolling(
     timeoutSeconds: Seconds = 30,
     autoDisableWebhooks: Boolean = true,
     autoSkipTimeoutExceptions: Boolean = true,
+    mediaGroupsDebounceTimeMillis: Long? = 1000L,
     block: BehaviourContextReceiver<Unit>
 ): Job {
     val behaviourContext = buildBehaviour(
@@ -69,6 +75,7 @@ suspend fun TelegramBot.buildBehaviourWithLongPolling(
         scope = behaviourContext,
         timeoutSeconds = timeoutSeconds,
         autoDisableWebhooks = autoDisableWebhooks,
-        autoSkipTimeoutExceptions = autoSkipTimeoutExceptions
+        autoSkipTimeoutExceptions = autoSkipTimeoutExceptions,
+        mediaGroupsDebounceTimeMillis = mediaGroupsDebounceTimeMillis
     )
 }

tgbotapi.behaviour_builder/src/commonMain/kotlin/dev/inmo/tgbotapi/extensions/behaviour_builder/TelegramBot.kt

@@ -5,6 +5,7 @@ import dev.inmo.tgbotapi.bot.TelegramBot
 import dev.inmo.tgbotapi.bot.ktor.KtorRequestsExecutorBuilder
 import dev.inmo.tgbotapi.bot.ktor.telegramBot
 import dev.inmo.tgbotapi.extensions.utils.updates.retrieving.startGettingOfUpdatesByLongPolling
+import dev.inmo.tgbotapi.extensions.utils.updates.retrieving.updateHandlerWithMediaGroupsAdaptation
 import dev.inmo.tgbotapi.types.Seconds
 import dev.inmo.tgbotapi.updateshandlers.FlowsUpdatesFilter
 import dev.inmo.tgbotapi.utils.telegramBotAPIDefaultUrl
@@ -53,6 +54,10 @@ suspend fun telegramBotWithBehaviour(
  *
  * **WARNING** This method WILL launch updates listening inside of calling [buildBehaviourWithLongPolling]
  *
+ * @param mediaGroupsDebounceTimeMillis Will be used for calling of [updateHandlerWithMediaGroupsAdaptation]. Pass null
+ * in case you wish to enable classic way of updates handling, but in that mode some media group messages can be
+ * retrieved in different updates
+ *
  * @return Pair of [TelegramBot] and [Job]. This [Job] can be used to stop listening updates in your [block] you passed
  * here
  *
@@ -70,6 +75,7 @@ suspend fun telegramBotWithBehaviourAndLongPolling(
     timeoutSeconds: Seconds = 30,
     autoDisableWebhooks: Boolean = true,
     autoSkipTimeoutExceptions: Boolean = true,
+    mediaGroupsDebounceTimeMillis: Long? = 1000L,
     block: BehaviourContextReceiver<Unit>
 ): Pair<TelegramBot, Job> {
     return telegramBot(
@@ -84,6 +90,7 @@ suspend fun telegramBotWithBehaviourAndLongPolling(
             timeoutSeconds,
             autoDisableWebhooks,
             autoSkipTimeoutExceptions,
+            mediaGroupsDebounceTimeMillis,
             block
         )
     }

tgbotapi.behaviour_builder/src/commonMain/kotlin/dev/inmo/tgbotapi/extensions/behaviour_builder/expectations/WaitContent.kt

@@ -16,119 +16,180 @@ typealias CommonMessageToContentMapper<T> = suspend CommonMessage<T>.() -> T?
 @RiskFeature(lowLevelRiskFeatureMessage)
 suspend inline fun <reified O : MessageContent> BehaviourContext.waitContent(
     initRequest: Request<*>? = null,
-    includeMediaGroups: Boolean = true,
     noinline errorFactory: NullableRequestBuilder<*> = { null }
-): Flow<O> = waitContentMessage<O>(initRequest, includeMediaGroups, errorFactory).map { it.content }
+): Flow<O> = waitContentMessage<O>(initRequest, errorFactory).map { it.content }
 
 
+@Deprecated(
+    includeMediaGroupsDeprecationMessage,
+    ReplaceWith("waitAnyContent(initRequest, errorFactory)", "dev.inmo.tgbotapi.extensions.behaviour_builder.expectations.waitAnyContent")
+)
 suspend fun BehaviourContext.waitContent(
     initRequest: Request<*>? = null,
     errorFactory: NullableRequestBuilder<*> = { null },
-    includeMediaGroups: Boolean = true
+    includeMediaGroups: Boolean
-) = waitContent<MessageContent>(initRequest, includeMediaGroups, errorFactory)
+) = waitContent<MessageContent>(initRequest, errorFactory)
+suspend fun BehaviourContext.waitAnyContent(
+    initRequest: Request<*>? = null,
+    errorFactory: NullableRequestBuilder<*> = { null }
+) = waitContent<MessageContent>(initRequest, errorFactory)
 suspend fun BehaviourContext.waitContact(
     initRequest: Request<*>? = null,
     errorFactory: NullableRequestBuilder<*> = { null }
-) = waitContent<ContactContent>(initRequest, false, errorFactory)
+) = waitContent<ContactContent>(initRequest, errorFactory)
 suspend fun BehaviourContext.waitDice(
     initRequest: Request<*>? = null,
     errorFactory: NullableRequestBuilder<*> = { null }
-) = waitContent<DiceContent>(initRequest, false, errorFactory)
+) = waitContent<DiceContent>(initRequest, errorFactory)
 suspend fun BehaviourContext.waitGame(
     initRequest: Request<*>? = null,
     errorFactory: NullableRequestBuilder<*> = { null }
-) = waitContent<GameContent>(initRequest, false, errorFactory)
+) = waitContent<GameContent>(initRequest, errorFactory)
 suspend fun BehaviourContext.waitLocation(
     initRequest: Request<*>? = null,
     errorFactory: NullableRequestBuilder<*> = { null }
-) = waitContent<LocationContent>(initRequest, false, errorFactory)
+) = waitContent<LocationContent>(initRequest, errorFactory)
 suspend fun BehaviourContext.waitLiveLocation(
     initRequest: Request<*>? = null,
     errorFactory: NullableRequestBuilder<*> = { null }
-) = waitContent<LiveLocationContent>(initRequest, false, errorFactory)
+) = waitContent<LiveLocationContent>(initRequest, errorFactory)
 suspend fun BehaviourContext.waitStaticLocation(
     initRequest: Request<*>? = null,
     errorFactory: NullableRequestBuilder<*> = { null }
-) = waitContent<StaticLocationContent>(initRequest, false, errorFactory)
+) = waitContent<StaticLocationContent>(initRequest, errorFactory)
 suspend fun BehaviourContext.waitPoll(
     initRequest: Request<*>? = null,
     errorFactory: NullableRequestBuilder<*> = { null }
-) = waitContent<PollContent>(initRequest, false, errorFactory)
+) = waitContent<PollContent>(initRequest, errorFactory)
 suspend fun BehaviourContext.waitText(
     initRequest: Request<*>? = null,
     errorFactory: NullableRequestBuilder<*> = { null }
-) = waitContent<TextContent>(initRequest, false, errorFactory)
+) = waitContent<TextContent>(initRequest, errorFactory)
 suspend fun BehaviourContext.waitVenue(
     initRequest: Request<*>? = null,
     errorFactory: NullableRequestBuilder<*> = { null }
-) = waitContent<VenueContent>(initRequest, false, errorFactory)
+) = waitContent<VenueContent>(initRequest, errorFactory)
+@Deprecated(includeMediaGroupsDeprecationMessage)
 suspend fun BehaviourContext.waitAudioMediaGroupContent(
     initRequest: Request<*>? = null,
     errorFactory: NullableRequestBuilder<*> = { null },
-    includeMediaGroups: Boolean = true
+    includeMediaGroups: Boolean
-) = waitContent<AudioMediaGroupPartContent>(initRequest, includeMediaGroups, errorFactory)
+) = waitContent<AudioMediaGroupPartContent>(initRequest, errorFactory)
+suspend fun BehaviourContext.waitAudioMediaGroupContent(
+    initRequest: Request<*>? = null,
+    errorFactory: NullableRequestBuilder<*> = { null },
+) = waitContent<AudioMediaGroupPartContent>(initRequest, errorFactory)
+@Deprecated(includeMediaGroupsDeprecationMessage)
 suspend fun BehaviourContext.waitDocumentMediaGroupContent(
     initRequest: Request<*>? = null,
     errorFactory: NullableRequestBuilder<*> = { null },
-    includeMediaGroups: Boolean = true
+    includeMediaGroups: Boolean
-) = waitContent<DocumentMediaGroupPartContent>(initRequest, includeMediaGroups, errorFactory)
+) = waitContent<DocumentMediaGroupPartContent>(initRequest, errorFactory)
+suspend fun BehaviourContext.waitDocumentMediaGroupContent(
+    initRequest: Request<*>? = null,
+    errorFactory: NullableRequestBuilder<*> = { null }
+) = waitContent<DocumentMediaGroupPartContent>(initRequest, errorFactory)
+@Deprecated(includeMediaGroupsDeprecationMessage)
 suspend fun BehaviourContext.waitMedia(
     initRequest: Request<*>? = null,
     errorFactory: NullableRequestBuilder<*> = { null },
-    includeMediaGroups: Boolean = false
+    includeMediaGroups: Boolean
-) = waitContent<MediaContent>(initRequest, includeMediaGroups, errorFactory)
+) = waitContent<MediaContent>(initRequest, errorFactory)
+suspend fun BehaviourContext.waitMedia(
+    initRequest: Request<*>? = null,
+    errorFactory: NullableRequestBuilder<*> = { null }
+) = waitContent<MediaContent>(initRequest, errorFactory)
+@Deprecated(includeMediaGroupsDeprecationMessage)
 suspend fun BehaviourContext.waitAnyMediaGroupContent(
     initRequest: Request<*>? = null,
     errorFactory: NullableRequestBuilder<*> = { null },
-    includeMediaGroups: Boolean = true
+    includeMediaGroups: Boolean
-) = waitContent<MediaGroupPartContent>(initRequest, includeMediaGroups, errorFactory)
+) = waitContent<MediaGroupPartContent>(initRequest, errorFactory)
+suspend fun BehaviourContext.waitAnyMediaGroupContent(
+    initRequest: Request<*>? = null,
+    errorFactory: NullableRequestBuilder<*> = { null },
+) = waitContent<MediaGroupPartContent>(initRequest, errorFactory)
+@Deprecated(includeMediaGroupsDeprecationMessage)
 suspend fun BehaviourContext.waitVisualMediaGroupContent(
     initRequest: Request<*>? = null,
     errorFactory: NullableRequestBuilder<*> = { null },
-    includeMediaGroups: Boolean = true
+    includeMediaGroups: Boolean
-) = waitContent<VisualMediaGroupPartContent>(initRequest, includeMediaGroups, errorFactory)
+) = waitContent<VisualMediaGroupPartContent>(initRequest, errorFactory)
+suspend fun BehaviourContext.waitVisualMediaGroupContent(
+    initRequest: Request<*>? = null,
+    errorFactory: NullableRequestBuilder<*> = { null },
+) = waitContent<VisualMediaGroupPartContent>(initRequest, errorFactory)
+@Deprecated(includeMediaGroupsDeprecationMessage)
 suspend fun BehaviourContext.waitTextedMediaContent(
     initRequest: Request<*>? = null,
     errorFactory: NullableRequestBuilder<*> = { null },
-    includeMediaGroups: Boolean = true
+    includeMediaGroups: Boolean
-) = waitContent<TextedMediaContent>(initRequest, includeMediaGroups, errorFactory)
+) = waitContent<TextedMediaContent>(initRequest, errorFactory)
+suspend fun BehaviourContext.waitTextedMediaContent(
+    initRequest: Request<*>? = null,
+    errorFactory: NullableRequestBuilder<*> = { null },
+) = waitContent<TextedMediaContent>(initRequest, errorFactory)
 suspend fun BehaviourContext.waitAnimation(
     initRequest: Request<*>? = null,
     errorFactory: NullableRequestBuilder<*> = { null }
-) = waitContent<AnimationContent>(initRequest, false, errorFactory)
+) = waitContent<AnimationContent>(initRequest, errorFactory)
+@Deprecated(includeMediaGroupsDeprecationMessage)
 suspend fun BehaviourContext.waitAudio(
     initRequest: Request<*>? = null,
     errorFactory: NullableRequestBuilder<*> = { null },
-    includeMediaGroups: Boolean = false
+    includeMediaGroups: Boolean
-) = waitContent<AudioContent>(initRequest, includeMediaGroups, errorFactory)
+) = waitContent<AudioContent>(initRequest, errorFactory)
+suspend fun BehaviourContext.waitAudio(
+    initRequest: Request<*>? = null,
+    errorFactory: NullableRequestBuilder<*> = { null },
+) = waitContent<AudioContent>(initRequest, errorFactory)
+@Deprecated(includeMediaGroupsDeprecationMessage)
 suspend fun BehaviourContext.waitDocument(
     initRequest: Request<*>? = null,
     errorFactory: NullableRequestBuilder<*> = { null },
-    includeMediaGroups: Boolean = false
+    includeMediaGroups: Boolean
-) = waitContent<DocumentContent>(initRequest, includeMediaGroups, errorFactory)
+) = waitContent<DocumentContent>(initRequest, errorFactory)
+suspend fun BehaviourContext.waitDocument(
+    initRequest: Request<*>? = null,
+    errorFactory: NullableRequestBuilder<*> = { null },
+) = waitContent<DocumentContent>(initRequest, errorFactory)
+@Deprecated(includeMediaGroupsDeprecationMessage)
 suspend fun BehaviourContext.waitPhoto(
     initRequest: Request<*>? = null,
     errorFactory: NullableRequestBuilder<*> = { null },
-    includeMediaGroups: Boolean = false
+    includeMediaGroups: Boolean
-) = waitContent<PhotoContent>(initRequest, includeMediaGroups, errorFactory)
+) = waitContent<PhotoContent>(initRequest, errorFactory)
+suspend fun BehaviourContext.waitPhoto(
+    initRequest: Request<*>? = null,
+    errorFactory: NullableRequestBuilder<*> = { null },
+) = waitContent<PhotoContent>(initRequest, errorFactory)
 suspend fun BehaviourContext.waitSticker(
     initRequest: Request<*>? = null,
     errorFactory: NullableRequestBuilder<*> = { null }
-) = waitContent<StickerContent>(initRequest, false, errorFactory)
+) = waitContent<StickerContent>(initRequest, errorFactory)
+@Deprecated(includeMediaGroupsDeprecationMessage)
 suspend fun BehaviourContext.waitVideo(
     initRequest: Request<*>? = null,
     errorFactory: NullableRequestBuilder<*> = { null },
-    includeMediaGroups: Boolean = false
+    includeMediaGroups: Boolean
-) = waitContent<VideoContent>(initRequest, includeMediaGroups, errorFactory)
+) = waitContent<VideoContent>(initRequest, errorFactory)
+suspend fun BehaviourContext.waitVideo(
+    initRequest: Request<*>? = null,
+    errorFactory: NullableRequestBuilder<*> = { null }
+) = waitContent<VideoContent>(initRequest, errorFactory)
 suspend fun BehaviourContext.waitVideoNote(
     initRequest: Request<*>? = null,
     errorFactory: NullableRequestBuilder<*> = { null }
-) = waitContent<VideoNoteContent>(initRequest, false, errorFactory)
+) = waitContent<VideoNoteContent>(initRequest, errorFactory)
 suspend fun BehaviourContext.waitVoice(
     initRequest: Request<*>? = null,
     errorFactory: NullableRequestBuilder<*> = { null }
-) = waitContent<VoiceContent>(initRequest, false, errorFactory)
+) = waitContent<VoiceContent>(initRequest, errorFactory)
 suspend fun BehaviourContext.waitInvoice(
     initRequest: Request<*>? = null,
     errorFactory: NullableRequestBuilder<*> = { null }
-) = waitContent<InvoiceContent>(initRequest, false, errorFactory)
+) = waitContent<InvoiceContent>(initRequest, errorFactory)
+suspend fun BehaviourContext.waitVisualContent(
+    initRequest: Request<*>? = null,
+    errorFactory: NullableRequestBuilder<*> = { null }
+) = waitContent<VisualMediaGroupPartContent>(initRequest, errorFactory)

tgbotapi.behaviour_builder/src/commonMain/kotlin/dev/inmo/tgbotapi/extensions/behaviour_builder/expectations/WaitContentMessage.kt

@@ -13,17 +13,20 @@ import dev.inmo.tgbotapi.utils.RiskFeature
 import dev.inmo.tgbotapi.utils.lowLevelRiskFeatureMessage
 import kotlinx.coroutines.flow.Flow
 
+const val includeMediaGroupsDeprecationMessage = "includeMediaGroups is deprecated and its usage will not lead to any changes"
 typealias CommonMessageToCommonMessageMapper<T> = suspend CommonMessage<T>.() -> CommonMessage<T>?
 
 @RiskFeature(lowLevelRiskFeatureMessage)
 suspend inline fun <reified O : MessageContent> BehaviourContext.waitContentMessage(
     initRequest: Request<*>? = null,
-    includeMediaGroups: Boolean = true,
     noinline errorFactory: NullableRequestBuilder<*> = { null }
 ): Flow<CommonMessage<O>> = expectFlow(
     initRequest,
     errorFactory
 ) {
+    if (it !is BaseSentMessageUpdate) {
+        return@expectFlow emptyList()
+    }
     listOfNotNull((it.data as? CommonMessage<*>) ?.withContent<O>())
 }
 
@@ -44,114 +47,177 @@ internal inline fun <reified T : MessageContent> contentMessageConverter(
     if (content is T) this as CommonMessage<T> else null
 }
 
+@Deprecated(
+    includeMediaGroupsDeprecationMessage,
+    ReplaceWith("waitAnyContentMessage(initRequest, errorFactory)", "dev.inmo.tgbotapi.extensions.behaviour_builder.expectations.waitAnyContentMessage")
+)
 suspend fun BehaviourContext.waitContentMessage(
     initRequest: Request<*>? = null,
     errorFactory: NullableRequestBuilder<*> = { null },
-    includeMediaGroups: Boolean = true
+    includeMediaGroups: Boolean
-) = waitContentMessage<MessageContent>(initRequest, includeMediaGroups, errorFactory)
+) = waitContentMessage<MessageContent>(initRequest, errorFactory)
+suspend fun BehaviourContext.waitAnyContentMessage(
+    initRequest: Request<*>? = null,
+    errorFactory: NullableRequestBuilder<*> = { null },
+) = waitContentMessage<MessageContent>(initRequest, errorFactory)
 suspend fun BehaviourContext.waitContactMessage(
     initRequest: Request<*>? = null,
     errorFactory: NullableRequestBuilder<*> = { null }
-) = waitContentMessage<ContactContent>(initRequest, false, errorFactory)
+) = waitContentMessage<ContactContent>(initRequest, errorFactory)
 suspend fun BehaviourContext.waitDiceMessage(
     initRequest: Request<*>? = null,
     errorFactory: NullableRequestBuilder<*> = { null }
-) = waitContentMessage<DiceContent>(initRequest, false, errorFactory)
+) = waitContentMessage<DiceContent>(initRequest, errorFactory)
 suspend fun BehaviourContext.waitGameMessage(
     initRequest: Request<*>? = null,
     errorFactory: NullableRequestBuilder<*> = { null }
-) = waitContentMessage<GameContent>(initRequest, false, errorFactory)
+) = waitContentMessage<GameContent>(initRequest, errorFactory)
 suspend fun BehaviourContext.waitLocationMessage(
     initRequest: Request<*>? = null,
     errorFactory: NullableRequestBuilder<*> = { null }
-) = waitContentMessage<LocationContent>(initRequest, false, errorFactory)
+) = waitContentMessage<LocationContent>(initRequest, errorFactory)
 suspend fun BehaviourContext.waitLiveLocationMessage(
     initRequest: Request<*>? = null,
     errorFactory: NullableRequestBuilder<*> = { null }
-) = waitContentMessage<LiveLocationContent>(initRequest, false, errorFactory)
+) = waitContentMessage<LiveLocationContent>(initRequest, errorFactory)
 suspend fun BehaviourContext.waitStaticLocationMessage(
     initRequest: Request<*>? = null,
     errorFactory: NullableRequestBuilder<*> = { null }
-) = waitContentMessage<StaticLocationContent>(initRequest, false, errorFactory)
+) = waitContentMessage<StaticLocationContent>(initRequest, errorFactory)
 suspend fun BehaviourContext.waitPollMessage(
     initRequest: Request<*>? = null,
     errorFactory: NullableRequestBuilder<*> = { null }
-) = waitContentMessage<PollContent>(initRequest, false, errorFactory)
+) = waitContentMessage<PollContent>(initRequest, errorFactory)
 suspend fun BehaviourContext.waitTextMessage(
     initRequest: Request<*>? = null,
     errorFactory: NullableRequestBuilder<*> = { null }
-) = waitContentMessage<TextContent>(initRequest, false, errorFactory)
+) = waitContentMessage<TextContent>(initRequest, errorFactory)
 suspend fun BehaviourContext.waitVenueMessage(
     initRequest: Request<*>? = null,
     errorFactory: NullableRequestBuilder<*> = { null }
-) = waitContentMessage<VenueContent>(initRequest, false, errorFactory)
+) = waitContentMessage<VenueContent>(initRequest, errorFactory)
+@Deprecated(includeMediaGroupsDeprecationMessage)
 suspend fun BehaviourContext.waitAudioMediaGroupContentMessage(
     initRequest: Request<*>? = null,
     errorFactory: NullableRequestBuilder<*> = { null },
-    includeMediaGroups: Boolean = true
+    includeMediaGroups: Boolean
-) = waitContentMessage<AudioMediaGroupPartContent>(initRequest, includeMediaGroups, errorFactory)
+) = waitContentMessage<AudioMediaGroupPartContent>(initRequest, errorFactory)
+suspend fun BehaviourContext.waitAudioMediaGroupContentMessage(
+    initRequest: Request<*>? = null,
+    errorFactory: NullableRequestBuilder<*> = { null }
+) = waitContentMessage<AudioMediaGroupPartContent>(initRequest, errorFactory)
+@Deprecated(includeMediaGroupsDeprecationMessage)
 suspend fun BehaviourContext.waitDocumentMediaGroupContentMessage(
     initRequest: Request<*>? = null,
     errorFactory: NullableRequestBuilder<*> = { null },
-    includeMediaGroups: Boolean = true
+    includeMediaGroups: Boolean
-) = waitContentMessage<DocumentMediaGroupPartContent>(initRequest, includeMediaGroups, errorFactory)
+) = waitContentMessage<DocumentMediaGroupPartContent>(initRequest, errorFactory)
+suspend fun BehaviourContext.waitDocumentMediaGroupContentMessage(
+    initRequest: Request<*>? = null,
+    errorFactory: NullableRequestBuilder<*> = { null }
+) = waitContentMessage<DocumentMediaGroupPartContent>(initRequest, errorFactory)
+@Deprecated(includeMediaGroupsDeprecationMessage)
 suspend fun BehaviourContext.waitMediaMessage(
     initRequest: Request<*>? = null,
     errorFactory: NullableRequestBuilder<*> = { null },
-    includeMediaGroups: Boolean = false
+    includeMediaGroups: Boolean
-) = waitContentMessage<MediaContent>(initRequest, includeMediaGroups, errorFactory)
+) = waitContentMessage<MediaContent>(initRequest, errorFactory)
+suspend fun BehaviourContext.waitMediaMessage(
+    initRequest: Request<*>? = null,
+    errorFactory: NullableRequestBuilder<*> = { null }
+) = waitContentMessage<MediaContent>(initRequest, errorFactory)
+@Deprecated(includeMediaGroupsDeprecationMessage)
 suspend fun BehaviourContext.waitAnyMediaGroupContentMessage(
     initRequest: Request<*>? = null,
     errorFactory: NullableRequestBuilder<*> = { null },
-    includeMediaGroups: Boolean = true
+    includeMediaGroups: Boolean
-) = waitContentMessage<MediaGroupPartContent>(initRequest, includeMediaGroups, errorFactory)
+) = waitContentMessage<MediaGroupPartContent>(initRequest, errorFactory)
+suspend fun BehaviourContext.waitAnyMediaGroupContentMessage(
+    initRequest: Request<*>? = null,
+    errorFactory: NullableRequestBuilder<*> = { null }
+) = waitContentMessage<MediaGroupPartContent>(initRequest, errorFactory)
+@Deprecated(includeMediaGroupsDeprecationMessage)
 suspend fun BehaviourContext.waitVisualMediaGroupContentMessage(
     initRequest: Request<*>? = null,
     errorFactory: NullableRequestBuilder<*> = { null },
-    includeMediaGroups: Boolean = true
+    includeMediaGroups: Boolean
-) = waitContentMessage<VisualMediaGroupPartContent>(initRequest, includeMediaGroups, errorFactory)
+) = waitContentMessage<VisualMediaGroupPartContent>(initRequest, errorFactory)
+suspend fun BehaviourContext.waitVisualMediaGroupContentMessage(
+    initRequest: Request<*>? = null,
+    errorFactory: NullableRequestBuilder<*> = { null }
+) = waitContentMessage<VisualMediaGroupPartContent>(initRequest, errorFactory)
+@Deprecated(includeMediaGroupsDeprecationMessage)
 suspend fun BehaviourContext.waitTextedMediaContentMessage(
     initRequest: Request<*>? = null,
     errorFactory: NullableRequestBuilder<*> = { null },
-    includeMediaGroups: Boolean = true
+    includeMediaGroups: Boolean
-) = waitContentMessage<TextedMediaContent>(initRequest, includeMediaGroups, errorFactory)
+) = waitContentMessage<TextedMediaContent>(initRequest, errorFactory)
+suspend fun BehaviourContext.waitTextedMediaContentMessage(
+    initRequest: Request<*>? = null,
+    errorFactory: NullableRequestBuilder<*> = { null }
+) = waitContentMessage<TextedMediaContent>(initRequest, errorFactory)
 suspend fun BehaviourContext.waitAnimationMessage(
     initRequest: Request<*>? = null,
     errorFactory: NullableRequestBuilder<*> = { null }
-) = waitContentMessage<AnimationContent>(initRequest, false, errorFactory)
+) = waitContentMessage<AnimationContent>(initRequest, errorFactory)
+@Deprecated(includeMediaGroupsDeprecationMessage)
 suspend fun BehaviourContext.waitAudioMessage(
     initRequest: Request<*>? = null,
     errorFactory: NullableRequestBuilder<*> = { null },
-    includeMediaGroups: Boolean = false
+    includeMediaGroups: Boolean
-) = waitContentMessage<AudioContent>(initRequest, includeMediaGroups, errorFactory)
+) = waitContentMessage<AudioContent>(initRequest, errorFactory)
+suspend fun BehaviourContext.waitAudioMessage(
+    initRequest: Request<*>? = null,
+    errorFactory: NullableRequestBuilder<*> = { null }
+) = waitContentMessage<AudioContent>(initRequest, errorFactory)
+@Deprecated(includeMediaGroupsDeprecationMessage)
 suspend fun BehaviourContext.waitDocumentMessage(
     initRequest: Request<*>? = null,
     errorFactory: NullableRequestBuilder<*> = { null },
-    includeMediaGroups: Boolean = false
+    includeMediaGroups: Boolean
-) = waitContentMessage<DocumentContent>(initRequest, includeMediaGroups, errorFactory)
+) = waitContentMessage<DocumentContent>(initRequest, errorFactory)
+suspend fun BehaviourContext.waitDocumentMessage(
+    initRequest: Request<*>? = null,
+    errorFactory: NullableRequestBuilder<*> = { null }
+) = waitContentMessage<DocumentContent>(initRequest, errorFactory)
+@Deprecated(includeMediaGroupsDeprecationMessage)
 suspend fun BehaviourContext.waitPhotoMessage(
     initRequest: Request<*>? = null,
     errorFactory: NullableRequestBuilder<*> = { null },
-    includeMediaGroups: Boolean = false
+    includeMediaGroups: Boolean
-) = waitContentMessage<PhotoContent>(initRequest, includeMediaGroups, errorFactory)
+) = waitContentMessage<PhotoContent>(initRequest, errorFactory)
+suspend fun BehaviourContext.waitPhotoMessage(
+    initRequest: Request<*>? = null,
+    errorFactory: NullableRequestBuilder<*> = { null }
+) = waitContentMessage<PhotoContent>(initRequest, errorFactory)
 suspend fun BehaviourContext.waitStickerMessage(
     initRequest: Request<*>? = null,
     errorFactory: NullableRequestBuilder<*> = { null }
-) = waitContentMessage<StickerContent>(initRequest, false, errorFactory)
+) = waitContentMessage<StickerContent>(initRequest, errorFactory)
+@Deprecated(includeMediaGroupsDeprecationMessage)
 suspend fun BehaviourContext.waitVideoMessage(
     initRequest: Request<*>? = null,
     errorFactory: NullableRequestBuilder<*> = { null },
-    includeMediaGroups: Boolean = false
+    includeMediaGroups: Boolean
-) = waitContentMessage<VideoContent>(initRequest, includeMediaGroups, errorFactory)
+) = waitContentMessage<VideoContent>(initRequest, errorFactory)
+suspend fun BehaviourContext.waitVideoMessage(
+    initRequest: Request<*>? = null,
+    errorFactory: NullableRequestBuilder<*> = { null }
+) = waitContentMessage<VideoContent>(initRequest, errorFactory)
 suspend fun BehaviourContext.waitVideoNoteMessage(
     initRequest: Request<*>? = null,
     errorFactory: NullableRequestBuilder<*> = { null }
-) = waitContentMessage<VideoNoteContent>(initRequest, false, errorFactory)
+) = waitContentMessage<VideoNoteContent>(initRequest, errorFactory)
 suspend fun BehaviourContext.waitVoiceMessage(
     initRequest: Request<*>? = null,
     errorFactory: NullableRequestBuilder<*> = { null }
-) = waitContentMessage<VoiceContent>(initRequest, false, errorFactory)
+) = waitContentMessage<VoiceContent>(initRequest, errorFactory)
 suspend fun BehaviourContext.waitInvoiceMessage(
     initRequest: Request<*>? = null,
     errorFactory: NullableRequestBuilder<*> = { null }
-) = waitContentMessage<InvoiceContent>(initRequest, false, errorFactory)
+) = waitContentMessage<InvoiceContent>(initRequest, errorFactory)
+
+suspend fun BehaviourContext.waitVisualContentMessage(
+    initRequest: Request<*>? = null,
+    errorFactory: NullableRequestBuilder<*> = { null }
+) = waitContentMessage<VisualMediaGroupPartContent>(initRequest, errorFactory)

tgbotapi.behaviour_builder/src/commonMain/kotlin/dev/inmo/tgbotapi/extensions/behaviour_builder/triggers_handling/ContentTriggers.kt

@@ -607,3 +607,27 @@ suspend fun <BC : BehaviourContext> BC.onInvoice(
     markerFactory,
     scenarioReceiver
 )
+
+/**
+ * @param initialFilter This filter will be called to remove unnecessary data BEFORE [scenarioReceiver] call
+ * @param subcontextUpdatesFilter This filter will be applied to each update inside of [scenarioReceiver]. For example,
+ * this filter will be used if you will call [dev.inmo.tgbotapi.extensions.behaviour_builder.expectations.waitContentMessage].
+ * Use [dev.inmo.tgbotapi.extensions.behaviour_builder.BehaviourContextAndTwoTypesReceiver] function to create your own.
+ * Use [dev.inmo.tgbotapi.extensions.behaviour_builder.utils.plus] or [dev.inmo.tgbotapi.extensions.behaviour_builder.utils.times]
+ * to combinate several filters
+ * @param [markerFactory] Will be used to identify different "stream". [scenarioReceiver] will be called synchronously
+ * in one "stream". Output of [markerFactory] will be used as a key for "stream"
+ * @param scenarioReceiver Main callback which will be used to handle incoming data if [initialFilter] will pass that
+ * data
+ */
+suspend fun <BC : BehaviourContext> BC.onVisualContent(
+    initialFilter: CommonMessageFilter<VisualMediaGroupPartContent>? = null,
+    subcontextUpdatesFilter: CustomBehaviourContextAndTwoTypesReceiver<BC, Boolean, VisualMediaGroupMessage, Update> = MessageFilterByChat,
+    markerFactory: MarkerFactory<in VisualMediaGroupMessage, Any> = ByChatMessageMarkerFactory,
+    scenarioReceiver: CustomBehaviourContextAndTypeReceiver<BC, Unit, VisualMediaGroupMessage>
+) = onContentMessageWithType(
+    initialFilter,
+    subcontextUpdatesFilter,
+    markerFactory,
+    scenarioReceiver
+)

tgbotapi.core/src/commonMain/kotlin/dev/inmo/tgbotapi/types/ChatIdentifier.kt

@@ -14,6 +14,7 @@ import kotlinx.serialization.json.longOrNull
 import kotlin.jvm.JvmInline
 
 const val internalLinkBeginning = "https://t.me"
+const val internalUserLinkBeginning = "tg://user?id="
 
 @Serializable(ChatIdentifierSerializer::class)
 @ClassCastsIncluded
@@ -66,15 +67,18 @@ fun IdChatIdentifier.toChatWithThreadId(threadId: MessageThreadId) = IdChatIdent
  */
 @Warning("This API have restrictions in Telegram System")
 val Identifier.userLink: String
-    get() = "tg://user?id=$this"
+    get() = "$internalUserLinkBeginning$this"
 /**
  * https://core.telegram.org/bots/api#formatting-options
  */
 @Warning("This API have restrictions in Telegram System")
 val UserId.userLink: String
     get() = chatId.userLink
-val User.link: String
+val User.userLink: String
     get() = id.userLink
+@Deprecated("Deprecated due to the conflicts in name", ReplaceWith("this.userLink", "dev.inmo.tgbotapi.types.userLink"))
+val User.link: String
+    get() = userLink
 
 typealias UserId = ChatId
 

tgbotapi.core/src/commonMain/kotlin/dev/inmo/tgbotapi/types/queries/callback/CallbackQuery.kt

@@ -2,16 +2,18 @@ package dev.inmo.tgbotapi.types.queries.callback
 
 import dev.inmo.tgbotapi.abstracts.FromUser
 import dev.inmo.tgbotapi.types.CallbackQueryIdentifier
+import dev.inmo.tgbotapi.types.chat.CommonUser
 import dev.inmo.tgbotapi.types.chat.User
 
 sealed interface CallbackQuery : FromUser {
     val id: CallbackQueryIdentifier
     val chatInstance: String
+    override val from: CommonUser
 }
 
 data class UnknownCallbackQueryType(
     override val id: CallbackQueryIdentifier,
-    override val from: User,
+    override val from: CommonUser,
     override val chatInstance: String,
     val raw: String
 ) : CallbackQuery

tgbotapi.core/src/commonMain/kotlin/dev/inmo/tgbotapi/types/queries/callback/InlineMessageIdDataCallbackQuery.kt

@@ -1,11 +1,14 @@
 package dev.inmo.tgbotapi.types.queries.callback
 
 import dev.inmo.tgbotapi.types.*
+import dev.inmo.tgbotapi.types.chat.CommonUser
 import dev.inmo.tgbotapi.types.chat.User
+import kotlinx.serialization.Serializable
 
+@Serializable
 data class InlineMessageIdDataCallbackQuery(
     override val id: CallbackQueryIdentifier,
-    override val from: User,
+    override val from: CommonUser,
     override val chatInstance: String,
     override val inlineMessageId: InlineMessageIdentifier,
     override val data: String

tgbotapi.core/src/commonMain/kotlin/dev/inmo/tgbotapi/types/queries/callback/InlineMessageIdGameShortNameCallbackQuery.kt

@@ -1,11 +1,12 @@
 package dev.inmo.tgbotapi.types.queries.callback
 
 import dev.inmo.tgbotapi.types.*
+import dev.inmo.tgbotapi.types.chat.CommonUser
 import dev.inmo.tgbotapi.types.chat.User
 
 data class InlineMessageIdGameShortNameCallbackQuery(
     override val id: CallbackQueryIdentifier,
-    override val from: User,
+    override val from: CommonUser,
     override val chatInstance: String,
     override val inlineMessageId: InlineMessageIdentifier,
     override val gameShortName: String

tgbotapi.core/src/commonMain/kotlin/dev/inmo/tgbotapi/types/queries/callback/MessageDataCallbackQuery.kt

@@ -1,13 +1,14 @@
 package dev.inmo.tgbotapi.types.queries.callback
 
 import dev.inmo.tgbotapi.types.CallbackQueryIdentifier
+import dev.inmo.tgbotapi.types.chat.CommonUser
 import dev.inmo.tgbotapi.types.chat.User
 import dev.inmo.tgbotapi.types.message.abstracts.ContentMessage
 import dev.inmo.tgbotapi.types.message.content.MessageContent
 
 data class MessageDataCallbackQuery(
     override val id: CallbackQueryIdentifier,
-    override val from: User,
+    override val from: CommonUser,
     override val chatInstance: String,
     override val message: ContentMessage<MessageContent>,
     override val data: String

tgbotapi.core/src/commonMain/kotlin/dev/inmo/tgbotapi/types/queries/callback/MessageGameShortNameCallbackQuery.kt

@@ -1,13 +1,14 @@
 package dev.inmo.tgbotapi.types.queries.callback
 
 import dev.inmo.tgbotapi.types.CallbackQueryIdentifier
+import dev.inmo.tgbotapi.types.chat.CommonUser
 import dev.inmo.tgbotapi.types.chat.User
 import dev.inmo.tgbotapi.types.message.abstracts.ContentMessage
 import dev.inmo.tgbotapi.types.message.content.MessageContent
 
 data class MessageGameShortNameCallbackQuery(
     override val id: CallbackQueryIdentifier,
-    override val from: User,
+    override val from: CommonUser,
     override val chatInstance: String,
     override val message: ContentMessage<MessageContent>,
     override val gameShortName: String

tgbotapi.core/src/commonMain/kotlin/dev/inmo/tgbotapi/types/queries/callback/RawCallbackQuery.kt

@@ -1,6 +1,7 @@
 package dev.inmo.tgbotapi.types.queries.callback
 
 import dev.inmo.tgbotapi.types.*
+import dev.inmo.tgbotapi.types.chat.CommonUser
 import dev.inmo.tgbotapi.types.chat.User
 import dev.inmo.tgbotapi.types.message.abstracts.*
 import dev.inmo.tgbotapi.types.message.abstracts.TelegramBotAPIMessageDeserializeOnlySerializer
@@ -13,7 +14,7 @@ internal data class RawCallbackQuery(
     @SerialName(idField)
     val id: CallbackQueryIdentifier,
     @SerialName(fromField)
-    val from: User,
+    val from: CommonUser,
     @Serializable(TelegramBotAPIMessageDeserializeOnlySerializer::class)
     val message: ContentMessage<MessageContent>? = null,
     @SerialName(inlineMessageIdField)

tgbotapi.utils/src/commonMain/kotlin/dev/inmo/tgbotapi/extensions/utils/CommonMessageConversations.kt

@@ -1,6 +1,7 @@
 package dev.inmo.tgbotapi.extensions.utils
 
 import dev.inmo.tgbotapi.types.message.abstracts.*
+import dev.inmo.tgbotapi.types.message.content.MediaGroupContent
 import dev.inmo.tgbotapi.types.message.content.MessageContent
 import kotlinx.coroutines.flow.*
 
@@ -34,3 +35,10 @@ fun <MC : MessageContent, M : ContentMessage<MC>> Flow<M>.onlySentViaBot() = map
 fun <MC : MessageContent, M : ContentMessage<MC>> Flow<M>.withoutSentViaBot() = filter {
     it !is PossiblySentViaBot || it.senderBot == null
 }
+
+/**
+ * Filter the messages and checking that incoming [ContentMessage.content] is not [MediaGroupContent]
+ */
+fun <MC : MessageContent, M : ContentMessage<MC>> Flow<M>.withoutMediaGroups() = filter {
+    it.content !is MediaGroupContent<*>
+}

tgbotapi.utils/src/commonMain/kotlin/dev/inmo/tgbotapi/extensions/utils/formatting/LinksFormatting.kt

@@ -8,6 +8,7 @@ import io.ktor.http.encodeURLQueryComponent
 
 
 fun makeUsernameLink(username: String, threadId: MessageThreadId? = null) = "$internalLinkBeginning/$username${threadId ?.let { "/$it" } ?: ""}"
+fun makeUserLink(userId: UserId) = userId.userLink
 fun makeChatLink(identifier: Identifier, threadId: MessageThreadId? = null) = identifier.toString().replace(
     linkIdRedundantPartRegex,
     ""
@@ -17,10 +18,16 @@ fun makeChatLink(identifier: Identifier, threadId: MessageThreadId? = null) = id
 fun makeUsernameDeepLinkPrefix(username: String) = "${makeUsernameLink(username)}?start="
 fun makeUsernameStartattachPrefix(username: String) = "$internalLinkBeginning/$username?startattach"
 fun makeUsernameStartattachLink(username: String, data: String? = null) = "${makeUsernameStartattachPrefix(username)}${data?.let { "=$it" } ?: ""}"
-inline val Username.link
+inline val Username.usernameLink
     get() = makeUsernameLink(usernameWithoutAt)
-val IdChatIdentifier.link: String
+@Deprecated("Deprecated due to the conflicts in name", ReplaceWith("this.usernameLink", "dev.inmo.tgbotapi.extensions.utils.formatting.usernameLink"))
+inline val Username.link
+    get() = usernameLink
+val IdChatIdentifier.chatLink: String
     get() = makeChatLink(chatId, threadId)
+@Deprecated("Deprecated due to the conflicts in name", ReplaceWith("this.chatLink", "dev.inmo.tgbotapi.extensions.utils.formatting.chatLink"))
+val IdChatIdentifier.link: String
+    get() = chatLink
 fun ChatId.link(threadId: MessageThreadId?) = makeChatLink(chatId, threadId)
 inline fun Username.link(threadId: MessageThreadId?) = makeUsernameLink(usernameWithoutAt, threadId)
 inline val Username.deepLinkPrefix
@@ -82,20 +89,27 @@ fun makeLinkToMessage(
 /**
  * @see makeLinkToMessage
  */
-val Message.link: String?
+val Message.messageLink: String?
     get() = makeLinkToMessage(
         chat,
         messageId
     )
 
+/**
+ * @see makeLinkToMessage
+ */
+@Deprecated("Deprecated due to the conflicts in name", ReplaceWith("this.messageLink", "dev.inmo.tgbotapi.extensions.utils.formatting.messageLink"))
+val Message.link: String?
+    get() = messageLink
+
 /**
  * Link which can be used as by any user to get access to [Chat]. Returns null in case when there are no
  * known way to build link
  */
-val Chat.link: String?
+val Chat.chatLink: String?
     get() {
         if (this is UsernameChat) {
-            username ?.link ?: id.link
+            username ?.usernameLink ?: id.chatLink
         }
         if (this is ExtendedPublicChat) {
             inviteLink ?.let { return it }
@@ -106,6 +120,14 @@ val Chat.link: String?
         return null
     }
 
+/**
+ * Link which can be used as by any user to get access to [Chat]. Returns null in case when there are no
+ * known way to build link
+ */
+@Deprecated("Deprecated due to the conflicts in name", ReplaceWith("this.chatLink", "dev.inmo.tgbotapi.extensions.utils.formatting.chatLink"))
+val Chat.link: String?
+    get() = chatLink
+
 private const val stickerSetAddingLinkPrefix = "$internalLinkBeginning/addstickers"
 
 val StickerSetName.stickerSetLink

tgbotapi.utils/src/commonMain/kotlin/dev/inmo/tgbotapi/extensions/utils/updates/UpdatesUtils.kt

@@ -27,7 +27,8 @@ fun List<Update>.lastUpdateIdentifier(): UpdateIdentifier? {
 }
 
 /**
- * Will convert incoming list of updates to list with [MediaGroupUpdate]s
+ * Will convert incoming list of [Update]s to list with [Update]s, which include [dev.inmo.tgbotapi.types.message.abstracts.ContentMessage]s
+ * with [dev.inmo.tgbotapi.types.message.content.MediaGroupContent]
  */
 fun List<Update>.convertWithMediaGroupUpdates(): List<Update> {
     val resultUpdates = mutableListOf<Update>()
@@ -67,4 +68,5 @@ fun List<Update>.convertWithMediaGroupUpdates(): List<Update> {
  *
  * @throws IllegalStateException
  */
+@Deprecated("Redundant", ReplaceWith("this"))
 fun BaseEditMessageUpdate.toEditMediaGroupUpdate() = this

tgbotapi.utils/src/commonMain/kotlin/dev/inmo/tgbotapi/extensions/utils/updates/retrieving/LongPolling.kt

@@ -19,12 +19,18 @@ import io.ktor.utils.io.CancellationException
 import kotlinx.coroutines.*
 import kotlinx.coroutines.flow.*
 
+/**
+ * @param mediaGroupsDebounceTimeMillis Will be used for calling of [updateHandlerWithMediaGroupsAdaptation]. Pass null
+ * in case you wish to enable classic way of updates handling, but in that mode some media group messages can be
+ * retrieved in different updates
+ */
 fun TelegramBot.longPollingFlow(
     timeoutSeconds: Seconds = 30,
     exceptionsHandler: (ExceptionHandler<Unit>)? = null,
     allowedUpdates: List<String>? = ALL_UPDATES_LIST,
     autoDisableWebhooks: Boolean = true,
-    autoSkipTimeoutExceptions: Boolean = true
+    autoSkipTimeoutExceptions: Boolean = true,
+    mediaGroupsDebounceTimeMillis: Long? = 1000L,
 ): Flow<Update> = channelFlow {
     if (autoDisableWebhooks) {
         runCatchingSafely {
@@ -47,6 +53,52 @@ fun TelegramBot.longPollingFlow(
 
     var lastUpdateIdentifier: UpdateIdentifier? = null
 
+    val updatesHandler: (suspend (List<Update>) -> Unit) = if (mediaGroupsDebounceTimeMillis != null) {
+        val scope = CoroutineScope(contextToWork)
+        val updatesReceiver = scope.updateHandlerWithMediaGroupsAdaptation(
+            {
+                withContext(contextToWork) {
+                    send(it)
+                }
+            },
+            mediaGroupsDebounceTimeMillis
+        );
+        { originalUpdates: List<Update> ->
+            originalUpdates.forEach {
+                updatesReceiver(it)
+                lastUpdateIdentifier = maxOf(lastUpdateIdentifier ?: it.updateId, it.updateId)
+            }
+        }
+    } else {
+        { originalUpdates: List<Update> ->
+            val converted = originalUpdates.convertWithMediaGroupUpdates()
+            /**
+             * Dirty hack for cases when the media group was retrieved not fully:
+             *
+             * We are throw out the last media group and will reretrieve it again in the next get updates
+             * and it will guarantee that it is full
+             */
+            val updates = if (
+                originalUpdates.size == getUpdatesLimit.last
+                && ((converted.last() as? BaseSentMessageUpdate) ?.data as? CommonMessage<*>) ?.content is MediaGroupContent<*>
+            ) {
+                converted - converted.last()
+            } else {
+                converted
+            }
+
+            safelyWithResult {
+                for (update in updates) {
+                    send(update)
+
+                    lastUpdateIdentifier = update.updateId
+                }
+            }.onFailure {
+                cancel(it as? CancellationException ?: return@onFailure)
+            }
+        }
+    }
+
     withContext(contextToWork) {
         while (isActive) {
             safely(
@@ -64,50 +116,25 @@ fun TelegramBot.longPollingFlow(
                     }
                 }
             ) {
-                val updates = execute(
+                execute(
                     GetUpdates(
                         offset = lastUpdateIdentifier?.plus(1),
                         timeout = timeoutSeconds,
                         allowed_updates = allowedUpdates
                     )
                 ).let { originalUpdates ->
-                    val converted = originalUpdates.convertWithMediaGroupUpdates()
+                    updatesHandler(originalUpdates)
-                    /**
-                     * Dirty hack for cases when the media group was retrieved not fully:
-                     *
-                     * We are throw out the last media group and will reretrieve it again in the next get updates
-                     * and it will guarantee that it is full
-                     */
-                    /**
-                     * Dirty hack for cases when the media group was retrieved not fully:
-                     *
-                     * We are throw out the last media group and will reretrieve it again in the next get updates
-                     * and it will guarantee that it is full
-                     */
-                    if (
-                        originalUpdates.size == getUpdatesLimit.last
-                        && ((converted.last() as? BaseSentMessageUpdate) ?.data as? CommonMessage<*>) ?.content is MediaGroupContent<*>
-                    ) {
-                        converted - converted.last()
-                    } else {
-                        converted
-                    }
-                }
-
-                safelyWithResult {
-                    for (update in updates) {
-                        send(update)
-
-                        lastUpdateIdentifier = update.updateId
-                    }
-                }.onFailure {
-                    cancel(it as? CancellationException ?: return@onFailure)
                 }
             }
         }
     }
 }
 
+/**
+ * @param mediaGroupsDebounceTimeMillis Will be used for calling of [updateHandlerWithMediaGroupsAdaptation]. Pass null
+ * in case you wish to enable classic way of updates handling, but in that mode some media group messages can be
+ * retrieved in different updates
+ */
 fun TelegramBot.startGettingOfUpdatesByLongPolling(
     timeoutSeconds: Seconds = 30,
     scope: CoroutineScope = CoroutineScope(Dispatchers.Default),
@@ -115,13 +142,15 @@ fun TelegramBot.startGettingOfUpdatesByLongPolling(
     allowedUpdates: List<String>? = ALL_UPDATES_LIST,
     autoDisableWebhooks: Boolean = true,
     autoSkipTimeoutExceptions: Boolean = true,
+    mediaGroupsDebounceTimeMillis: Long? = 1000L,
     updatesReceiver: UpdateReceiver<Update>
 ): Job = longPollingFlow(
     timeoutSeconds = timeoutSeconds,
     exceptionsHandler = exceptionsHandler,
     allowedUpdates = allowedUpdates,
     autoDisableWebhooks = autoDisableWebhooks,
-    autoSkipTimeoutExceptions = autoSkipTimeoutExceptions
+    autoSkipTimeoutExceptions = autoSkipTimeoutExceptions,
+    mediaGroupsDebounceTimeMillis = mediaGroupsDebounceTimeMillis
 ).subscribeSafely(
     scope,
     exceptionsHandler ?: defaultSafelyExceptionHandler,
@@ -129,6 +158,10 @@ fun TelegramBot.startGettingOfUpdatesByLongPolling(
 )
 
 /**
+ * @param mediaGroupsDebounceTimeMillis Will be used for calling of [updateHandlerWithMediaGroupsAdaptation]. Pass null
+ * in case you wish to enable classic way of updates handling, but in that mode some media group messages can be
+ * retrieved in different updates
+ *
  * @return [kotlinx.coroutines.flow.Flow] which will emit updates to the collector while they will be accumulated. Works
  * the same as [longPollingFlow], but it will cancel the flow after the first one [HttpRequestTimeoutException]
  */
@@ -137,7 +170,8 @@ fun TelegramBot.createAccumulatedUpdatesRetrieverFlow(
     avoidCallbackQueries: Boolean = false,
     exceptionsHandler: ExceptionHandler<Unit>? = null,
     allowedUpdates: List<String>? = ALL_UPDATES_LIST,
-    autoDisableWebhooks: Boolean = true
+    autoDisableWebhooks: Boolean = true,
+    mediaGroupsDebounceTimeMillis: Long? = 1000L,
 ): Flow<Update> = longPollingFlow(
     timeoutSeconds = 0,
     exceptionsHandler = {
@@ -149,11 +183,17 @@ fun TelegramBot.createAccumulatedUpdatesRetrieverFlow(
     },
     allowedUpdates = allowedUpdates,
     autoDisableWebhooks = autoDisableWebhooks,
-    autoSkipTimeoutExceptions = false
+    autoSkipTimeoutExceptions = false,
+    mediaGroupsDebounceTimeMillis = mediaGroupsDebounceTimeMillis
 ).filter {
     !(it is InlineQueryUpdate && avoidInlineQueries || it is CallbackQueryUpdate && avoidCallbackQueries)
 }
 
+/**
+ * @param mediaGroupsDebounceTimeMillis Will be used for calling of [updateHandlerWithMediaGroupsAdaptation]. Pass null
+ * in case you wish to enable classic way of updates handling, but in that mode some media group messages can be
+ * retrieved in different updates
+ */
 fun TelegramBot.retrieveAccumulatedUpdates(
     avoidInlineQueries: Boolean = false,
     avoidCallbackQueries: Boolean = false,
@@ -161,25 +201,33 @@ fun TelegramBot.retrieveAccumulatedUpdates(
     exceptionsHandler: (ExceptionHandler<Unit>)? = null,
     allowedUpdates: List<String>? = ALL_UPDATES_LIST,
     autoDisableWebhooks: Boolean = true,
+    mediaGroupsDebounceTimeMillis: Long? = 1000L,
     updatesReceiver: UpdateReceiver<Update>
 ): Job = createAccumulatedUpdatesRetrieverFlow(
     avoidInlineQueries,
     avoidCallbackQueries,
     exceptionsHandler,
     allowedUpdates,
-    autoDisableWebhooks
+    autoDisableWebhooks,
+    mediaGroupsDebounceTimeMillis
 ).subscribeSafelyWithoutExceptions(
     scope.LinkedSupervisorScope()
 ) {
     updatesReceiver(it)
 }
 
+/**
+ * @param mediaGroupsDebounceTimeMillis Will be used for calling of [updateHandlerWithMediaGroupsAdaptation]. Pass null
+ * in case you wish to enable classic way of updates handling, but in that mode some media group messages can be
+ * retrieved in different updates
+ */
 fun TelegramBot.retrieveAccumulatedUpdates(
     flowsUpdatesFilter: FlowsUpdatesFilter,
     avoidInlineQueries: Boolean = false,
     avoidCallbackQueries: Boolean = false,
     scope: CoroutineScope = CoroutineScope(Dispatchers.Default),
     autoDisableWebhooks: Boolean = true,
+    mediaGroupsDebounceTimeMillis: Long? = 1000L,
     exceptionsHandler: ExceptionHandler<Unit>? = null
 ) = retrieveAccumulatedUpdates(
     avoidInlineQueries,
@@ -188,9 +236,15 @@ fun TelegramBot.retrieveAccumulatedUpdates(
     exceptionsHandler,
     flowsUpdatesFilter.allowedUpdates,
     autoDisableWebhooks,
+    mediaGroupsDebounceTimeMillis,
     flowsUpdatesFilter.asUpdateReceiver
 )
 
+/**
+ * @param mediaGroupsDebounceTimeMillis Will be used for calling of [updateHandlerWithMediaGroupsAdaptation]. Pass null
+ * in case you wish to enable classic way of updates handling, but in that mode some media group messages can be
+ * retrieved in different updates
+ */
 suspend fun TelegramBot.flushAccumulatedUpdates(
     avoidInlineQueries: Boolean = false,
     avoidCallbackQueries: Boolean = false,
@@ -198,6 +252,7 @@ suspend fun TelegramBot.flushAccumulatedUpdates(
     allowedUpdates: List<String>? = ALL_UPDATES_LIST,
     exceptionsHandler: ExceptionHandler<Unit>? = null,
     autoDisableWebhooks: Boolean = true,
+    mediaGroupsDebounceTimeMillis: Long? = 1000L,
     updatesReceiver: UpdateReceiver<Update> = {}
 ) = retrieveAccumulatedUpdates(
     avoidInlineQueries,
@@ -206,12 +261,17 @@ suspend fun TelegramBot.flushAccumulatedUpdates(
     exceptionsHandler,
     allowedUpdates,
     autoDisableWebhooks,
+    mediaGroupsDebounceTimeMillis,
     updatesReceiver
 ).join()
 
 /**
- * Will [startGettingOfUpdatesByLongPolling] using incoming [flowsUpdatesFilter]. It is assumed that you ALREADY CONFIGURE
+ * Will [startGettingOfUpdatesByLongPolling] using incoming [updatesFilter]. It is assumed that you ALREADY CONFIGURE
  * all updates receivers, because this method will trigger getting of updates and.
+ *
+ * @param mediaGroupsDebounceTimeMillis Will be used for calling of [updateHandlerWithMediaGroupsAdaptation]. Pass null
+ * in case you wish to enable classic way of updates handling, but in that mode some media group messages can be
+ * retrieved in different updates
  */
 fun TelegramBot.longPolling(
     updatesFilter: UpdatesFilter,
@@ -219,6 +279,7 @@ fun TelegramBot.longPolling(
     scope: CoroutineScope = CoroutineScope(Dispatchers.Default),
     autoDisableWebhooks: Boolean = true,
     autoSkipTimeoutExceptions: Boolean = true,
+    mediaGroupsDebounceTimeMillis: Long? = 1000L,
     exceptionsHandler: ExceptionHandler<Unit>? = null
 ): Job = updatesFilter.run {
     startGettingOfUpdatesByLongPolling(
@@ -228,6 +289,7 @@ fun TelegramBot.longPolling(
         allowedUpdates = allowedUpdates,
         autoDisableWebhooks = autoDisableWebhooks,
         autoSkipTimeoutExceptions = autoSkipTimeoutExceptions,
+        mediaGroupsDebounceTimeMillis = mediaGroupsDebounceTimeMillis,
         updatesReceiver = asUpdateReceiver
     )
 }
@@ -236,6 +298,10 @@ fun TelegramBot.longPolling(
  * Will enable [longPolling] by creating [FlowsUpdatesFilter] with [flowsUpdatesFilterUpdatesKeeperCount] as an argument
  * and applied [flowUpdatesPreset]. It is assumed that you WILL CONFIGURE all updates receivers in [flowUpdatesPreset],
  * because of after [flowUpdatesPreset] method calling will be triggered getting of updates.
+ *
+ * @param mediaGroupsDebounceTimeMillis Will be used for calling of [updateHandlerWithMediaGroupsAdaptation]. Pass null
+ * in case you wish to enable classic way of updates handling, but in that mode some media group messages can be
+ * retrieved in different updates
  */
 @Suppress("unused")
 fun TelegramBot.longPolling(
@@ -245,15 +311,22 @@ fun TelegramBot.longPolling(
     flowsUpdatesFilterUpdatesKeeperCount: Int = 100,
     autoDisableWebhooks: Boolean = true,
     autoSkipTimeoutExceptions: Boolean = true,
+    mediaGroupsDebounceTimeMillis: Long? = 1000L,
     flowUpdatesPreset: FlowsUpdatesFilter.() -> Unit
-): Job = longPolling(FlowsUpdatesFilter(flowsUpdatesFilterUpdatesKeeperCount).apply(flowUpdatesPreset), timeoutSeconds, scope, autoDisableWebhooks, autoSkipTimeoutExceptions, exceptionsHandler)
+): Job = longPolling(FlowsUpdatesFilter(flowsUpdatesFilterUpdatesKeeperCount).apply(flowUpdatesPreset), timeoutSeconds, scope, autoDisableWebhooks, autoSkipTimeoutExceptions, mediaGroupsDebounceTimeMillis, exceptionsHandler)
 
+/**
+ * @param mediaGroupsDebounceTimeMillis Will be used for calling of [updateHandlerWithMediaGroupsAdaptation]. Pass null
+ * in case you wish to enable classic way of updates handling, but in that mode some media group messages can be
+ * retrieved in different updates
+ */
 fun RequestsExecutor.startGettingOfUpdatesByLongPolling(
     updatesFilter: UpdatesFilter,
     timeoutSeconds: Seconds = 30,
     exceptionsHandler: ExceptionHandler<Unit>? = null,
     scope: CoroutineScope = CoroutineScope(Dispatchers.Default),
     autoDisableWebhooks: Boolean = true,
+    mediaGroupsDebounceTimeMillis: Long? = 1000L,
     autoSkipTimeoutExceptions: Boolean = true,
 ): Job = startGettingOfUpdatesByLongPolling(
     timeoutSeconds,
@@ -262,5 +335,6 @@ fun RequestsExecutor.startGettingOfUpdatesByLongPolling(
     updatesFilter.allowedUpdates,
     autoDisableWebhooks,
     autoSkipTimeoutExceptions,
+    mediaGroupsDebounceTimeMillis,
     updatesFilter.asUpdateReceiver
 )

tgbotapi.utils/src/commonMain/kotlin/dev/inmo/tgbotapi/extensions/utils/updates/retrieving/MediaGroupsIncluder.kt

@@ -1,6 +1,5 @@
 package dev.inmo.tgbotapi.extensions.utils.updates.retrieving
 
-import dev.inmo.micro_utils.coroutines.launchSafely
 import dev.inmo.micro_utils.coroutines.launchSafelyWithoutExceptions
 import dev.inmo.tgbotapi.extensions.utils.updates.convertWithMediaGroupUpdates
 import dev.inmo.tgbotapi.types.message.abstracts.PossiblyMediaGroupMessage
@@ -12,7 +11,6 @@ import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.channels.Channel
 import kotlinx.coroutines.launch
 
-
 /**
  * Create [UpdateReceiver] object which will correctly accumulate updates and send into output updates which INCLUDE
  * [dev.inmo.tgbotapi.types.update.MediaGroupUpdates.MediaGroupUpdate]s.

tgbotapi.utils/src/jvmMain/kotlin/dev/inmo/tgbotapi/extensions/utils/updates/retrieving/Webhook.kt

@@ -26,6 +26,9 @@ import java.util.concurrent.Executors
  * @param [scope] Will be used for mapping of media groups
  * @param [exceptionsHandler] Pass this parameter to set custom exception handler for getting updates
  * @param [block] Some receiver block like [dev.inmo.tgbotapi.updateshandlers.FlowsUpdatesFilter]
+ * @param mediaGroupsDebounceTimeMillis Will be used for calling of [updateHandlerWithMediaGroupsAdaptation]. Pass null
+ * in case you wish to enable classic way of updates handling, but in that mode some media group messages can be
+ * retrieved in different updates
  *
  * @see dev.inmo.tgbotapi.updateshandlers.FlowsUpdatesFilter
  * @see UpdatesFilter
@@ -57,6 +60,11 @@ fun Route.includeWebhookHandlingInRoute(
     }
 }
 
+/**
+ * @param mediaGroupsDebounceTimeMillis Will be used for calling of [updateHandlerWithMediaGroupsAdaptation]. Pass null
+ * in case you wish to enable classic way of updates handling, but in that mode some media group messages can be
+ * retrieved in different updates
+ */
 fun Route.includeWebhookHandlingInRouteWithFlows(
     scope: CoroutineScope,
     exceptionsHandler: ExceptionHandler<Unit>? = null,
@@ -76,6 +84,9 @@ fun Route.includeWebhookHandlingInRouteWithFlows(
  * @param listenRoute address to listen by bot. If null - will be set up in root of host
  * @param scope Scope which will be used for
  * @param privateKeyConfig If configured - server will be created with [sslConnector]. [connector] will be used otherwise
+ * @param mediaGroupsDebounceTimeMillis Will be used for calling of [updateHandlerWithMediaGroupsAdaptation]. Pass null
+ * in case you wish to enable classic way of updates handling, but in that mode some media group messages can be
+ * retrieved in different updates
  *
  * @see dev.inmo.tgbotapi.updateshandlers.FlowsUpdatesFilter
  * @see UpdatesFilter
@@ -132,6 +143,9 @@ fun startListenWebhooks(
  * @param listenPort port which will be listen by bot
  * @param listenRoute address to listen by bot
  * @param scope Scope which will be used for
+ * @param mediaGroupsDebounceTimeMillis Will be used for calling of [updateHandlerWithMediaGroupsAdaptation]. Pass null
+ * in case you wish to enable classic way of updates handling, but in that mode some media group messages can be
+ * retrieved in different updates
  *
  * @see dev.inmo.tgbotapi.updateshandlers.FlowsUpdatesFilter
  * @see UpdatesFilter