changelog fill and callback query improvements

hotfix in LiveFlowLocation (5.2.0)

CHANGELOG.md

@@ -1,7 +1,61 @@
 # TelegramBotAPI changelog
 
+## 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
+
+* `Core`:
+    * `ChatPermissions` now is interface and have two main realizations: `ChatPermissions.Granular` and
+      `ChatPermissions.Common`
+    * `RestrictedChatMember` now implements `ChatPermissions` too
+* `API`:
+    * Now it is possible to pass all long polling parameters in all places used it
+* `Issues`:
+    * Fix of [#697](https://github.com/InsanusMokrassar/TelegramBotAPI/issues/697)
+
+## 5.0.2
+
+* `Versions`:
+    * `MicroUtils`: `0.16.6` -> `0.16.8`
+    * `Ktor`: `2.2.2` -> `2.2.3`
+* `BehaviourBuilder`:
+    * Fixes in `BehaviourContext.onEditedContentMessage` - now it will trigger callback on channel post edits too
+
+## 5.0.1
+
+* `Versions`:
+    * `MicroUtils`: `0.16.4` -> `0.16.6`
+    * `Ktor`: `2.2.1` -> `2.2.2`
+* `Core`:
+    * Fixes in `SendMediaGroup` request
+    * Fixes in `SetChatAdministratorCustomTitle` request (thanks to [@madhead](https://github.com/madhead))
+
 ## 5.0.0
 
+[Bot API 6.4](https://core.telegram.org/bots/api-changelog#december-30-2022) support!
+
+* Long-polling improvements
+
 ## 4.2.4
 
 * `Core`:

README.md

@@ -1,4 +1,4 @@
-# TelegramBotAPI [![Maven Central](https://maven-badges.herokuapp.com/maven-central/dev.inmo/tgbotapi/badge.svg)](https://maven-badges.herokuapp.com/maven-central/dev.inmo/tgbotapi) [![Supported version](https://img.shields.io/badge/Telegram%20Bot%20API-6.3-blue)](https://core.telegram.org/bots/api-changelog#november-5-2022)
+# TelegramBotAPI [![Maven Central](https://maven-badges.herokuapp.com/maven-central/dev.inmo/tgbotapi/badge.svg)](https://maven-badges.herokuapp.com/maven-central/dev.inmo/tgbotapi) [![Supported version](https://img.shields.io/badge/Telegram%20Bot%20API-6.5-blue)](https://core.telegram.org/bots/api-changelog#february-3-2023)
 
 | Docs | [![KDocs](https://img.shields.io/static/v1?label=Dokka&message=KDocs&color=blue&logo=kotlin)](https://tgbotapi.inmo.dev/index.html) [![Mini tutorial](https://img.shields.io/static/v1?label=Bookstack&message=Tutorial&color=blue&logo=bookstack)](https://bookstack.inmo.dev/books/telegrambotapi/chapter/introduction-tutorial) |
 |:---:|:---:|

gradle.properties

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

gradle/libs.versions.toml

@@ -8,12 +8,12 @@ javax-activation = "1.1.1"
 
 korlibs = "3.4.0"
 uuid = "0.6.0"
-ktor = "2.2.1"
+ktor = "2.2.3"
 
 ksp = "1.7.22-1.0.8"
 kotlin-poet = "1.12.0"
 
-microutils = "0.16.4"
+microutils = "0.16.10"
 
 github-release-plugin = "2.4.1"
 dokka = "1.7.20"

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/chat/members/RestrictChatMember.kt

@@ -14,27 +14,31 @@ suspend fun TelegramBot.restrictChatMember(
     chatId: ChatIdentifier,
     userId: UserId,
     untilDate: TelegramDate? = null,
-    permissions: ChatPermissions = ChatPermissions()
+    permissions: ChatPermissions = ChatPermissions(),
-) = execute(RestrictChatMember(chatId, userId, untilDate, permissions))
+    useIndependentChatPermissions: Boolean? = permissions.isGranular.takeIf { it }
+) = execute(RestrictChatMember(chatId, userId, untilDate, permissions, useIndependentChatPermissions))
 
 suspend fun TelegramBot.restrictChatMember(
     chat: PublicChat,
     userId: UserId,
     untilDate: TelegramDate? = null,
-    permissions: ChatPermissions = ChatPermissions()
+    permissions: ChatPermissions = ChatPermissions(),
-) = restrictChatMember(chat.id, userId, untilDate, permissions)
+    useIndependentChatPermissions: Boolean? = permissions.isGranular.takeIf { it }
+) = restrictChatMember(chat.id, userId, untilDate, permissions, useIndependentChatPermissions)
 
 suspend fun TelegramBot.restrictChatMember(
     chatId: IdChatIdentifier,
     user: User,
     untilDate: TelegramDate? = null,
-    permissions: ChatPermissions = ChatPermissions()
+    permissions: ChatPermissions = ChatPermissions(),
-) = restrictChatMember(chatId, user.id, untilDate, permissions)
+    useIndependentChatPermissions: Boolean? = permissions.isGranular.takeIf { it }
+) = restrictChatMember(chatId, user.id, untilDate, permissions, useIndependentChatPermissions)
 
 suspend fun TelegramBot.restrictChatMember(
     chat: PublicChat,
     user: User,
     untilDate: TelegramDate? = null,
-    permissions: ChatPermissions = ChatPermissions()
+    permissions: ChatPermissions = ChatPermissions(),
-) = restrictChatMember(chat.id, user.id, untilDate, permissions)
+    useIndependentChatPermissions: Boolean? = permissions.isGranular.takeIf { it }
+) = restrictChatMember(chat.id, user.id, untilDate, permissions, useIndependentChatPermissions)
 

tgbotapi.api/src/commonMain/kotlin/dev/inmo/tgbotapi/extensions/api/chat/modify/SetChatPermissions.kt

@@ -8,10 +8,12 @@ import dev.inmo.tgbotapi.types.chat.PublicChat
 
 suspend fun TelegramBot.setDefaultChatMembersPermissions(
     chatId: ChatIdentifier,
-    permissions: ChatPermissions
+    permissions: ChatPermissions,
-) = execute(SetChatPermissions(chatId, permissions))
+    useIndependentChatPermissions: Boolean? = permissions.isGranular.takeIf { it }
+) = execute(SetChatPermissions(chatId, permissions, useIndependentChatPermissions))
 
 suspend fun TelegramBot.setDefaultChatMembersPermissions(
     chat: PublicChat,
-    permissions: ChatPermissions
+    permissions: ChatPermissions,
-) = setDefaultChatMembersPermissions(chat.id, permissions)
+    useIndependentChatPermissions: Boolean? = permissions.isGranular.takeIf { it }
+) = setDefaultChatMembersPermissions(chat.id, permissions, useIndependentChatPermissions)

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.types.Seconds
 import dev.inmo.tgbotapi.types.update.abstracts.Update
 import dev.inmo.tgbotapi.updateshandlers.FlowsUpdatesFilter
 import kotlinx.coroutines.*
@@ -54,6 +55,9 @@ suspend fun <T : State> TelegramBot.buildBehaviourWithFSMAndStartLongPolling(
     statesManager: StatesManager<T> = DefaultStatesManager(InMemoryDefaultStatesManagerRepo()),
     presetHandlers: List<BehaviourWithFSMStateHandlerHolder<*, T>> = listOf(),
     onStateHandlingErrorHandler: StateHandlingErrorHandler<T> = defaultStateHandlingErrorHandler(),
+    timeoutSeconds: Seconds = 30,
+    autoDisableWebhooks: Boolean = true,
+    autoSkipTimeoutExceptions: Boolean = true,
     block: CustomBehaviourContextReceiver<DefaultBehaviourContextWithFSM<T>, Unit>
 ): Pair<DefaultBehaviourContextWithFSM<T>, Job> = buildBehaviourWithFSM(
     upstreamUpdatesFlow,
@@ -66,7 +70,7 @@ suspend fun <T : State> TelegramBot.buildBehaviourWithFSMAndStartLongPolling(
 ).run {
     this to scope.launch {
         start()
-        longPolling(flowsUpdatesFilter, scope = scope)
+        longPolling(flowsUpdatesFilter, timeoutSeconds, scope, autoDisableWebhooks, autoSkipTimeoutExceptions, defaultExceptionsHandler)
     }
 }
 
@@ -124,6 +128,9 @@ suspend fun <T : State> TelegramBot.buildBehaviourWithFSMAndStartLongPolling(
     statesManager: StatesManager<T> = DefaultStatesManager(InMemoryDefaultStatesManagerRepo()),
     presetHandlers: List<BehaviourWithFSMStateHandlerHolder<*, T>> = listOf(),
     onStateHandlingErrorHandler: StateHandlingErrorHandler<T> = defaultStateHandlingErrorHandler(),
+    timeoutSeconds: Seconds = 30,
+    autoDisableWebhooks: Boolean = true,
+    autoSkipTimeoutExceptions: Boolean = true,
     block: CustomBehaviourContextReceiver<DefaultBehaviourContextWithFSM<T>, Unit>
 ) = FlowsUpdatesFilter().let {
     buildBehaviourWithFSM(
@@ -138,7 +145,11 @@ suspend fun <T : State> TelegramBot.buildBehaviourWithFSMAndStartLongPolling(
         start()
         longPolling(
             flowsUpdatesFilter,
-            scope = scope
+            timeoutSeconds,
+            scope,
+            autoDisableWebhooks,
+            autoSkipTimeoutExceptions,
+            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.types.Seconds
 import dev.inmo.tgbotapi.updateshandlers.FlowsUpdatesFilter
 import dev.inmo.tgbotapi.utils.telegramBotAPIDefaultUrl
 import kotlinx.coroutines.CoroutineScope
@@ -42,6 +43,9 @@ suspend fun <T : State> telegramBotWithBehaviourAndFSM(
     presetHandlers: List<BehaviourWithFSMStateHandlerHolder<*, T>> = listOf(),
     testServer: Boolean = false,
     onStateHandlingErrorHandler: StateHandlingErrorHandler<T> = defaultStateHandlingErrorHandler(),
+    timeoutSeconds: Seconds = 30,
+    autoDisableWebhooks: Boolean = true,
+    autoSkipTimeoutExceptions: Boolean = true,
     block: CustomBehaviourContextReceiver<DefaultBehaviourContextWithFSM<T>, Unit>
 ): TelegramBot = telegramBot(
     token,
@@ -56,6 +60,9 @@ suspend fun <T : State> telegramBotWithBehaviourAndFSM(
         statesManager,
         presetHandlers,
         onStateHandlingErrorHandler,
+        timeoutSeconds,
+        autoDisableWebhooks,
+        autoSkipTimeoutExceptions,
         block
     )
 }
@@ -81,6 +88,9 @@ suspend fun <T : State> telegramBotWithBehaviourAndFSMAndStartLongPolling(
     presetHandlers: List<BehaviourWithFSMStateHandlerHolder<*, T>> = listOf(),
     testServer: Boolean = false,
     onStateHandlingErrorHandler: StateHandlingErrorHandler<T> = defaultStateHandlingErrorHandler(),
+    timeoutSeconds: Seconds = 30,
+    autoDisableWebhooks: Boolean = true,
+    autoSkipTimeoutExceptions: Boolean = true,
     block: CustomBehaviourContextReceiver<DefaultBehaviourContextWithFSM<T>, Unit>
 ): Pair<TelegramBot, Job> {
     return telegramBot(
@@ -95,6 +105,9 @@ suspend fun <T : State> telegramBotWithBehaviourAndFSMAndStartLongPolling(
             statesManager,
             presetHandlers,
             onStateHandlingErrorHandler,
+            timeoutSeconds,
+            autoDisableWebhooks,
+            autoSkipTimeoutExceptions,
             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.types.Seconds
 import dev.inmo.tgbotapi.updateshandlers.FlowsUpdatesFilter
 import kotlinx.coroutines.*
 
@@ -53,6 +54,9 @@ suspend fun TelegramBot.buildBehaviour(
 suspend fun TelegramBot.buildBehaviourWithLongPolling(
     scope: CoroutineScope = defaultCoroutineScopeProvider(),
     defaultExceptionsHandler: ExceptionHandler<Unit>? = null,
+    timeoutSeconds: Seconds = 30,
+    autoDisableWebhooks: Boolean = true,
+    autoSkipTimeoutExceptions: Boolean = true,
     block: BehaviourContextReceiver<Unit>
 ): Job {
     val behaviourContext = buildBehaviour(
@@ -62,6 +66,9 @@ suspend fun TelegramBot.buildBehaviourWithLongPolling(
     )
     return longPolling(
         behaviourContext,
-        scope = behaviourContext
+        scope = behaviourContext,
+        timeoutSeconds = timeoutSeconds,
+        autoDisableWebhooks = autoDisableWebhooks,
+        autoSkipTimeoutExceptions = autoSkipTimeoutExceptions
     )
 }

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.types.Seconds
 import dev.inmo.tgbotapi.updateshandlers.FlowsUpdatesFilter
 import dev.inmo.tgbotapi.utils.telegramBotAPIDefaultUrl
 import kotlinx.coroutines.*
@@ -66,6 +67,9 @@ suspend fun telegramBotWithBehaviourAndLongPolling(
     builder: KtorRequestsExecutorBuilder.() -> Unit = {},
     defaultExceptionsHandler: ExceptionHandler<Unit>? = null,
     testServer: Boolean = false,
+    timeoutSeconds: Seconds = 30,
+    autoDisableWebhooks: Boolean = true,
+    autoSkipTimeoutExceptions: Boolean = true,
     block: BehaviourContextReceiver<Unit>
 ): Pair<TelegramBot, Job> {
     return telegramBot(
@@ -77,6 +81,9 @@ suspend fun telegramBotWithBehaviourAndLongPolling(
         it to it.buildBehaviourWithLongPolling(
             scope ?: CoroutineScope(coroutineContext),
             defaultExceptionsHandler,
+            timeoutSeconds,
+            autoDisableWebhooks,
+            autoSkipTimeoutExceptions,
             block
         )
     }

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

@@ -16,119 +16,176 @@ 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)

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,172 @@ 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)

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

@@ -17,6 +17,9 @@ import dev.inmo.tgbotapi.types.message.ChatEvents.forum.WriteAccessAllowed
 import dev.inmo.tgbotapi.types.message.ChatEvents.voice.*
 import dev.inmo.tgbotapi.types.message.abstracts.ChatEventMessage
 import dev.inmo.tgbotapi.types.message.payments.SuccessfulPaymentEvent
+import dev.inmo.tgbotapi.types.request.ChatShared
+import dev.inmo.tgbotapi.types.request.ChatSharedRequest
+import dev.inmo.tgbotapi.types.request.UserShared
 import dev.inmo.tgbotapi.utils.RiskFeature
 import dev.inmo.tgbotapi.utils.lowLevelRiskFeatureMessage
 import kotlinx.coroutines.flow.Flow
@@ -171,3 +174,18 @@ suspend fun BehaviourContext.waitWriteAccessAllowed(
     initRequest: Request<*>? = null,
     errorFactory: NullableRequestBuilder<*> = { null }
 ) = waitEvents<WriteAccessAllowed>(initRequest, errorFactory)
+
+suspend fun BehaviourContext.waitChatSharedRequest(
+    initRequest: Request<*>? = null,
+    errorFactory: NullableRequestBuilder<*> = { null }
+) = waitEvents<ChatSharedRequest>(initRequest, errorFactory)
+
+suspend fun BehaviourContext.waitUserShared(
+    initRequest: Request<*>? = null,
+    errorFactory: NullableRequestBuilder<*> = { null }
+) = waitEvents<UserShared>(initRequest, errorFactory)
+
+suspend fun BehaviourContext.waitChatShared(
+    initRequest: Request<*>? = null,
+    errorFactory: NullableRequestBuilder<*> = { null }
+) = waitEvents<ChatShared>(initRequest, errorFactory)

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

@@ -9,10 +9,17 @@ import dev.inmo.tgbotapi.types.message.ChatEvents.*
 import dev.inmo.tgbotapi.types.message.ChatEvents.abstracts.*
 import dev.inmo.tgbotapi.types.message.ChatEvents.forum.ForumTopicClosed
 import dev.inmo.tgbotapi.types.message.ChatEvents.forum.ForumTopicCreated
+import dev.inmo.tgbotapi.types.message.ChatEvents.forum.ForumTopicEdited
 import dev.inmo.tgbotapi.types.message.ChatEvents.forum.ForumTopicReopened
+import dev.inmo.tgbotapi.types.message.ChatEvents.forum.GeneralForumTopicHidden
+import dev.inmo.tgbotapi.types.message.ChatEvents.forum.GeneralForumTopicUnhidden
+import dev.inmo.tgbotapi.types.message.ChatEvents.forum.WriteAccessAllowed
 import dev.inmo.tgbotapi.types.message.ChatEvents.voice.*
 import dev.inmo.tgbotapi.types.message.abstracts.ChatEventMessage
 import dev.inmo.tgbotapi.types.message.payments.SuccessfulPaymentEvent
+import dev.inmo.tgbotapi.types.request.ChatShared
+import dev.inmo.tgbotapi.types.request.ChatSharedRequest
+import dev.inmo.tgbotapi.types.request.UserShared
 import dev.inmo.tgbotapi.utils.RiskFeature
 import dev.inmo.tgbotapi.utils.lowLevelRiskFeatureMessage
 import kotlinx.coroutines.flow.Flow
@@ -148,3 +155,34 @@ suspend fun BehaviourContext.waitForumTopicReopenedEventsMessages(
     initRequest: Request<*>? = null,
     errorFactory: NullableRequestBuilder<*> = { null }
 ) = waitEventsMessages<ForumTopicReopened>(initRequest, errorFactory)
+suspend fun BehaviourContext.waitForumTopicEditedEventsMessages(
+    initRequest: Request<*>? = null,
+    errorFactory: NullableRequestBuilder<*> = { null }
+) = waitEventsMessages<ForumTopicEdited>(initRequest, errorFactory)
+suspend fun BehaviourContext.waitGeneralForumTopicHiddenEventsMessages(
+    initRequest: Request<*>? = null,
+    errorFactory: NullableRequestBuilder<*> = { null }
+) = waitEventsMessages<GeneralForumTopicHidden>(initRequest, errorFactory)
+suspend fun BehaviourContext.waitGeneralForumTopicUnhiddenEventsMessages(
+    initRequest: Request<*>? = null,
+    errorFactory: NullableRequestBuilder<*> = { null }
+) = waitEventsMessages<GeneralForumTopicUnhidden>(initRequest, errorFactory)
+suspend fun BehaviourContext.waitWriteAccessAllowedEventsMessages(
+    initRequest: Request<*>? = null,
+    errorFactory: NullableRequestBuilder<*> = { null }
+) = waitEventsMessages<WriteAccessAllowed>(initRequest, errorFactory)
+
+suspend fun BehaviourContext.waitChatSharedRequestEventsMessages(
+    initRequest: Request<*>? = null,
+    errorFactory: NullableRequestBuilder<*> = { null }
+) = waitEventsMessages<ChatSharedRequest>(initRequest, errorFactory)
+
+suspend fun BehaviourContext.waitUserSharedEventsMessages(
+    initRequest: Request<*>? = null,
+    errorFactory: NullableRequestBuilder<*> = { null }
+) = waitEventsMessages<UserShared>(initRequest, errorFactory)
+
+suspend fun BehaviourContext.waitChatSharedEventsMessages(
+    initRequest: Request<*>? = null,
+    errorFactory: NullableRequestBuilder<*> = { null }
+) = waitEventsMessages<ChatShared>(initRequest, errorFactory)

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

@@ -1,18 +1,3 @@
-
-
-/**
- * @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
- */@file:Suppress("unused", "UNCHECKED_CAST")
-
 package dev.inmo.tgbotapi.extensions.behaviour_builder.triggers_handling
 
 import dev.inmo.tgbotapi.extensions.behaviour_builder.*
@@ -35,7 +20,7 @@ internal suspend inline fun <BC : BehaviourContext, reified T : MessageContent>
     noinline scenarioReceiver: CustomBehaviourContextAndTypeReceiver<BC, Unit, CommonMessage<T>>
 ) = on(markerFactory, initialFilter, subcontextUpdatesFilter, scenarioReceiver) {
     when (it) {
-        is BaseEditMessageUpdate -> (it.editMessageUpdateOrNull() ?.data ?.withContent<T>())
+        is BaseEditMessageUpdate -> (it.data.withContent<T>())
         else -> null
     } ?.let(::listOfNotNull)
 }

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

@@ -23,6 +23,9 @@ import dev.inmo.tgbotapi.types.message.PrivateEventMessage
 import dev.inmo.tgbotapi.types.message.abstracts.ChatEventMessage
 import dev.inmo.tgbotapi.types.message.abstracts.SupergroupEventMessage
 import dev.inmo.tgbotapi.types.message.payments.SuccessfulPaymentEvent
+import dev.inmo.tgbotapi.types.request.ChatShared
+import dev.inmo.tgbotapi.types.request.ChatSharedRequest
+import dev.inmo.tgbotapi.types.request.UserShared
 import dev.inmo.tgbotapi.types.update.abstracts.Update
 
 internal suspend inline fun <BC : BehaviourContext, reified T : ChatEvent> BC.onEvent(
@@ -657,3 +660,65 @@ suspend fun <BC : BehaviourContext> BC.onWriteAccessAllowed(
     markerFactory: MarkerFactory<in ChatEventMessage<WriteAccessAllowed>, Any> = ByChatMessageMarkerFactory,
     scenarioReceiver: CustomBehaviourContextAndTypeReceiver<BC, Unit, SupergroupEventMessage<WriteAccessAllowed>>
 ) = onEventWithCustomChatEventMessage(initialFilter, subcontextUpdatesFilter, 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.onChatSharedRequest(
+    initialFilter: SimpleFilter<PrivateEventMessage<ChatSharedRequest>>? = null,
+    subcontextUpdatesFilter: CustomBehaviourContextAndTwoTypesReceiver<BC, Boolean, PrivateEventMessage<ChatSharedRequest>, Update>? = MessageFilterByChat,
+    markerFactory: MarkerFactory<in ChatEventMessage<ChatSharedRequest>, Any> = ByChatMessageMarkerFactory,
+    scenarioReceiver: CustomBehaviourContextAndTypeReceiver<BC, Unit, PrivateEventMessage<ChatSharedRequest>>
+) = onEventWithCustomChatEventMessage(initialFilter, subcontextUpdatesFilter, 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.onUserShared(
+    initialFilter: SimpleFilter<PrivateEventMessage<UserShared>>? = null,
+    subcontextUpdatesFilter: CustomBehaviourContextAndTwoTypesReceiver<BC, Boolean, PrivateEventMessage<UserShared>, Update>? = MessageFilterByChat,
+    markerFactory: MarkerFactory<in ChatEventMessage<UserShared>, Any> = ByChatMessageMarkerFactory,
+    scenarioReceiver: CustomBehaviourContextAndTypeReceiver<BC, Unit, PrivateEventMessage<UserShared>>
+) = onEventWithCustomChatEventMessage(initialFilter, subcontextUpdatesFilter, 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.onChatShared(
+    initialFilter: SimpleFilter<PrivateEventMessage<ChatShared>>? = null,
+    subcontextUpdatesFilter: CustomBehaviourContextAndTwoTypesReceiver<BC, Boolean, PrivateEventMessage<ChatShared>, Update>? = MessageFilterByChat,
+    markerFactory: MarkerFactory<in ChatEventMessage<ChatShared>, Any> = ByChatMessageMarkerFactory,
+    scenarioReceiver: CustomBehaviourContextAndTypeReceiver<BC, Unit, PrivateEventMessage<ChatShared>>
+) = onEventWithCustomChatEventMessage(initialFilter, subcontextUpdatesFilter, markerFactory, scenarioReceiver)

tgbotapi.core/src/commonMain/kotlin/dev/inmo/tgbotapi/requests/chat/members/RestrictChatMember.kt

@@ -16,7 +16,9 @@ data class RestrictChatMember(
     @SerialName(untilDateField)
     override val untilDate: TelegramDate? = null,
     @SerialName(permissionsField)
-    val permissions: ChatPermissions = ChatPermissions()
+    val permissions: ChatPermissions = ChatPermissions(),
+    @SerialName(useIndependentChatPermissionsField)
+    val useIndependentChatPermissions: Boolean? = permissions.isGranular.takeIf { it }
 ) : ChatMemberRequest<Boolean>, UntilDate {
     override fun method(): String = "restrictChatMember"
     override val resultDeserializer: DeserializationStrategy<Boolean>

tgbotapi.core/src/commonMain/kotlin/dev/inmo/tgbotapi/requests/chat/members/SetChatAdministratorCustomTitle.kt

@@ -18,7 +18,7 @@ data class SetChatAdministratorCustomTitle(
     override val resultDeserializer: DeserializationStrategy<Boolean>
         get() = Boolean.serializer()
     override val requestSerializer: SerializationStrategy<*>
-        get() = RestrictChatMember.serializer()
+        get() = serializer()
 
     init {
         if (customTitle.length !in customTitleLength) {

tgbotapi.core/src/commonMain/kotlin/dev/inmo/tgbotapi/requests/chat/modify/SetChatPermissions.kt

@@ -12,7 +12,9 @@ data class SetChatPermissions (
     @SerialName(chatIdField)
     override val chatId: ChatIdentifier,
     @SerialName(permissionsField)
-    val permissions: ChatPermissions
+    val permissions: ChatPermissions,
+    @SerialName(useIndependentChatPermissionsField)
+    val useIndependentChatPermissions: Boolean? = permissions.isGranular.takeIf { it }
 ): ChatRequest, SimpleRequest<Boolean> {
     override fun method(): String = "setChatPermissions"
     override val resultDeserializer: DeserializationStrategy<Boolean>

tgbotapi.core/src/commonMain/kotlin/dev/inmo/tgbotapi/requests/send/media/SendMediaGroup.kt

@@ -37,7 +37,7 @@ fun <T : MediaGroupPartContent> SendMediaGroup(
     protectContent: Boolean = false,
     replyToMessageId: MessageId? = null,
     allowSendingWithoutReply: Boolean? = null
-): Request<PossiblySentViaBotCommonMessage<T>> {
+): Request<PossiblySentViaBotCommonMessage<MediaGroupContent<T>>> {
     if (media.size !in mediaCountInMediaGroup) {
         throwRangeError("Count of members in media group", mediaCountInMediaGroup, media.size)
     }
@@ -70,7 +70,7 @@ fun <T : MediaGroupPartContent> SendMediaGroup(
             data,
             SendMediaGroupFiles(files)
         )
-    }) as Request<PossiblySentViaBotCommonMessage<T>>
+    }) as Request<PossiblySentViaBotCommonMessage<MediaGroupContent<T>>>
 }
 
 /**

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,7 +67,7 @@ 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
  */

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

@@ -261,6 +261,19 @@ const val iconColorField = "icon_color"
 const val requestContactField = "request_contact"
 const val requestLocationField = "request_location"
 const val requestPollField = "request_poll"
+const val requestUserField = "request_user"
+const val requestChatField = "request_chat"
+const val requestIdField = "request_id"
+
+const val userIsBotField = "user_is_bot"
+const val userIsPremiumField = "user_is_premium"
+const val chatIsChannelField = "chat_is_channel"
+const val chatIsForumField = "chat_is_forum"
+const val chatHasUsernameField = "chat_has_username"
+const val chatIsCreatedField = "chat_is_created"
+const val userAdministratorRightsField = "user_administrator_rights"
+const val botAdministratorRightsField = "bot_administrator_rights"
+const val botIsMemberField = "bot_is_member"
 
 const val fileNameField = "file_name"
 const val mimeTypeField = "mime_type"
@@ -327,7 +340,12 @@ const val scopeField = "scope"
 const val isMemberField = "is_member"
 const val isForumField = "is_forum"
 const val canSendMessagesField = "can_send_messages"
-const val canSendMediaMessagesField = "can_send_media_messages"
+const val canSendAudiosField = "can_send_audios"
+const val canSendDocumentsField = "can_send_documents"
+const val canSendPhotosField = "can_send_photos"
+const val canSendVideosField = "can_send_videos"
+const val canSendVideoNotesField = "can_send_video_notes"
+const val canSendVoiceNotesField = "can_send_voice_notes"
 const val canSendOtherMessagesField = "can_send_other_messages"
 const val canSendPollsField = "can_send_polls"
 const val canAddWebPagePreviewsField = "can_add_web_page_previews"
@@ -345,6 +363,7 @@ const val canPinMessagesField = "can_pin_messages"
 const val canPromoteMembersField = "can_promote_members"
 const val canManageVoiceChatsField = "can_manage_voice_chats"
 const val canManageVideoChatsField = "can_manage_video_chats"
+const val useIndependentChatPermissionsField = "use_independent_chat_permissions"
 const val rightsField = "rights"
 const val forChannelsField = "for_channels"
 const val canManageChatField = "can_manage_chat"
@@ -375,6 +394,7 @@ const val latitudeField = "latitude"
 const val longitudeField = "longitude"
 const val headingField = "heading"
 const val fromField = "from"
+const val userChatIdField = "user_chat_id"
 const val userField = "user"
 const val dateField = "date"
 const val chatField = "chat"

tgbotapi.core/src/commonMain/kotlin/dev/inmo/tgbotapi/types/buttons/KeyboardButton.kt

@@ -94,6 +94,42 @@ data class RequestPollKeyboardButton(
     val requestPoll: KeyboardButtonPollType
 ) : KeyboardButton
 
+/**
+ * Private chats only. When user will tap on this button, he will be asked for the chat with [requestChat] options. You
+ * will be able to catch this [ChatId] in updates and data using
+ * [dev.inmo.tgbotapi.extensions.behaviour_builder.triggers_handling.onUserShared] in case you are using Behaviour
+ * Builder OR with [dev.inmo.tgbotapi.updateshandlers.FlowsUpdatesFilter.messagesFlow]
+ * and [kotlinx.coroutines.flow.filterIsInstance].
+ *
+ * In case you will use [dev.inmo.tgbotapi.extensions.behaviour_builder.triggers_handling.onUserShared] it is
+ * recommended to use [kotlinx.coroutines.flow.Flow] [kotlinx.coroutines.flow.filter] with checking of incoming
+ * [dev.inmo.tgbotapi.types.request.UserShared.requestId]
+ */
+@Serializable
+data class RequestUserKeyboardButton(
+    override val text: String,
+    @SerialName(requestUserField)
+    val requestUser: KeyboardButtonRequestUser
+) : KeyboardButton
+
+/**
+ * Private chats only. When user will tap on this button, he will be asked for the chat with [requestChat] options. You
+ * will be able to catch this [ChatId] in updates and data using
+ * [dev.inmo.tgbotapi.extensions.behaviour_builder.triggers_handling.onChatShared] in case you are using Behaviour
+ * Builder OR with [dev.inmo.tgbotapi.updateshandlers.FlowsUpdatesFilter.messagesFlow]
+ * and [kotlinx.coroutines.flow.filterIsInstance].
+ *
+ * In case you will use [dev.inmo.tgbotapi.extensions.behaviour_builder.triggers_handling.onChatShared] it is
+ * recommended to use [kotlinx.coroutines.flow.Flow] [kotlinx.coroutines.flow.filter] with checking of incoming
+ * [dev.inmo.tgbotapi.types.request.ChatShared.requestId]
+ */
+@Serializable
+data class RequestChatKeyboardButton(
+    override val text: String,
+    @SerialName(requestChatField)
+    val requestChat: KeyboardButtonRequestChat
+) : KeyboardButton
+
 @RiskFeature
 object KeyboardButtonSerializer : KSerializer<KeyboardButton> {
     private val internalSerializer = JsonElement.serializer()
@@ -124,6 +160,20 @@ object KeyboardButtonSerializer : KSerializer<KeyboardButton> {
                     asJson[requestPollField] ?.jsonObject ?: buildJsonObject {  }
                 )
             )
+            asJson is JsonObject && asJson[requestUserField] != null -> RequestUserKeyboardButton(
+                asJson[textField]!!.jsonPrimitive.content,
+                nonstrictJsonFormat.decodeFromJsonElement(
+                    KeyboardButtonRequestUser.serializer(),
+                    asJson[requestUserField] ?.jsonObject ?: buildJsonObject {  }
+                )
+            )
+            asJson is JsonObject && asJson[requestChatField] != null -> RequestChatKeyboardButton(
+                asJson[textField]!!.jsonPrimitive.content,
+                nonstrictJsonFormat.decodeFromJsonElement(
+                    KeyboardButtonRequestChat.serializer(),
+                    asJson[requestChatField] ?.jsonObject ?: buildJsonObject {  }
+                )
+            )
             else -> UnknownKeyboardButton(
                 when (asJson) {
                     is JsonObject -> asJson[textField]!!.jsonPrimitive.content
@@ -142,6 +192,8 @@ object KeyboardButtonSerializer : KSerializer<KeyboardButton> {
             is WebAppKeyboardButton -> WebAppKeyboardButton.serializer().serialize(encoder, value)
             is RequestPollKeyboardButton -> RequestPollKeyboardButton.serializer().serialize(encoder, value)
             is SimpleKeyboardButton -> encoder.encodeString(value.text)
+            is RequestUserKeyboardButton -> RequestUserKeyboardButton.serializer().serialize(encoder, value)
+            is RequestChatKeyboardButton -> RequestChatKeyboardButton.serializer().serialize(encoder, value)
             is UnknownKeyboardButton -> JsonElement.serializer().serialize(encoder, nonstrictJsonFormat.parseToJsonElement(value.raw))
         }
     }

tgbotapi.core/src/commonMain/kotlin/dev/inmo/tgbotapi/types/buttons/KeyboardButtonRequestChat.kt

@@ -0,0 +1,78 @@
+package dev.inmo.tgbotapi.types.buttons
+
+import dev.inmo.tgbotapi.types.botAdministratorRightsField
+import dev.inmo.tgbotapi.types.botIsMemberField
+import dev.inmo.tgbotapi.types.chat.member.ChatAdministratorRights
+import dev.inmo.tgbotapi.types.chatHasUsernameField
+import dev.inmo.tgbotapi.types.chatIsChannelField
+import dev.inmo.tgbotapi.types.chatIsCreatedField
+import dev.inmo.tgbotapi.types.chatIsForumField
+import dev.inmo.tgbotapi.types.request.RequestId
+import dev.inmo.tgbotapi.types.requestIdField
+import dev.inmo.tgbotapi.types.userAdministratorRightsField
+import kotlinx.serialization.SerialName
+import kotlinx.serialization.Serializable
+
+/**
+ * @see Channel
+ * @see Group
+ */
+@Serializable
+data class KeyboardButtonRequestChat(
+    @SerialName(requestIdField)
+    val requestId: RequestId,
+    @SerialName(chatIsChannelField)
+    val isChannel: Boolean? = null,
+    @SerialName(chatIsForumField)
+    val isForum: Boolean? = null,
+    @SerialName(chatHasUsernameField)
+    val isPublic: Boolean? = null,
+    @SerialName(chatIsCreatedField)
+    val isOwnedBy: Boolean? = null,
+    @SerialName(userAdministratorRightsField)
+    val userRightsInChat: ChatAdministratorRights? = null,
+    @SerialName(botAdministratorRightsField)
+    val botRightsInChat: ChatAdministratorRights? = null,
+    @SerialName(botIsMemberField)
+    val botIsMember: Boolean? = null
+) {
+    companion object {
+        fun Channel(
+            requestId: RequestId,
+            isPublic: Boolean? = null,
+            isOwnedBy: Boolean? = null,
+            userRightsInChat: ChatAdministratorRights? = null,
+            botRightsInChat: ChatAdministratorRights? = null,
+            botIsMember: Boolean? = null
+        ) = KeyboardButtonRequestChat(
+            requestId = requestId,
+            isChannel = true,
+            isForum = null,
+            isPublic = isPublic,
+            isOwnedBy = isOwnedBy,
+            userRightsInChat = userRightsInChat,
+            botRightsInChat = botRightsInChat,
+            botIsMember = botIsMember
+        )
+
+        fun Group(
+            requestId: RequestId,
+            isForum: Boolean? = null,
+            isPublic: Boolean? = null,
+            isOwnedBy: Boolean? = null,
+            userRightsInChat: ChatAdministratorRights? = null,
+            botRightsInChat: ChatAdministratorRights? = null,
+            botIsMember: Boolean? = null
+        ) = KeyboardButtonRequestChat(
+            requestId = requestId,
+            isChannel = false,
+            isForum = isForum,
+            isPublic = isPublic,
+            isOwnedBy = isOwnedBy,
+            userRightsInChat = userRightsInChat,
+            botRightsInChat = botRightsInChat,
+            botIsMember = botIsMember
+        )
+    }
+}
+

tgbotapi.core/src/commonMain/kotlin/dev/inmo/tgbotapi/types/buttons/KeyboardButtonRequestUser.kt

@@ -0,0 +1,91 @@
+package dev.inmo.tgbotapi.types.buttons
+
+import dev.inmo.tgbotapi.types.request.RequestId
+import dev.inmo.tgbotapi.types.requestIdField
+import dev.inmo.tgbotapi.types.userIsBotField
+import dev.inmo.tgbotapi.types.userIsPremiumField
+import dev.inmo.tgbotapi.utils.internal.ClassCastsIncluded
+import kotlinx.serialization.EncodeDefault
+import kotlinx.serialization.KSerializer
+import kotlinx.serialization.SerialName
+import kotlinx.serialization.Serializable
+import kotlinx.serialization.Serializer
+import kotlinx.serialization.descriptors.SerialDescriptor
+import kotlinx.serialization.encoding.Decoder
+import kotlinx.serialization.encoding.Encoder
+
+@Serializable(KeyboardButtonRequestUser.Companion::class)
+@ClassCastsIncluded
+sealed interface KeyboardButtonRequestUser {
+    val requestId: RequestId
+    val isBot: Boolean?
+
+    @Serializable
+    data class Any(
+        @SerialName(requestIdField)
+        override val requestId: RequestId
+    ) : KeyboardButtonRequestUser {
+        @SerialName(userIsBotField)
+        @EncodeDefault
+        override val isBot: Boolean? = null
+    }
+
+    @Serializable
+    data class Common(
+        @SerialName(requestIdField)
+        override val requestId: RequestId,
+        @SerialName(userIsPremiumField)
+        val isPremium: Boolean? = null
+    ) : KeyboardButtonRequestUser {
+        @SerialName(userIsBotField)
+        @EncodeDefault
+        override val isBot: Boolean = false
+    }
+
+    @Serializable
+    data class Bot(
+        @SerialName(requestIdField)
+        override val requestId: RequestId
+    ) : KeyboardButtonRequestUser {
+        @SerialName(userIsBotField)
+        @EncodeDefault
+        override val isBot: Boolean = true
+    }
+
+    @Serializer(KeyboardButtonRequestUser::class)
+    companion object : KSerializer<KeyboardButtonRequestUser> {
+        @Serializable
+        private data class Surrogate(
+            @SerialName(requestIdField)
+            val requestId: RequestId,
+            @SerialName(userIsBotField)
+            val userIsBot: Boolean? = null,
+            @SerialName(userIsPremiumField)
+            val userIsPremium: Boolean? = null
+        )
+        private val realSerializer = Surrogate.serializer()
+
+        override val descriptor: SerialDescriptor = realSerializer.descriptor
+
+        override fun deserialize(decoder: Decoder): KeyboardButtonRequestUser {
+            val surrogate = realSerializer.deserialize(decoder)
+
+            return when (surrogate.userIsBot) {
+                true -> Bot(surrogate.requestId)
+                false -> Common(surrogate.requestId, surrogate.userIsPremium)
+                null -> Any(surrogate.requestId)
+            }
+        }
+
+        override fun serialize(encoder: Encoder, value: KeyboardButtonRequestUser) {
+            realSerializer.serialize(
+                encoder,
+                Surrogate(
+                    value.requestId,
+                    value.isBot,
+                    (value as? Common) ?.isPremium
+                )
+            )
+        }
+    }
+}

tgbotapi.core/src/commonMain/kotlin/dev/inmo/tgbotapi/types/buttons/reply/ReplyKeyboardButtonsShortcuts.kt

@@ -2,6 +2,8 @@ package dev.inmo.tgbotapi.types.buttons.reply
 
 import dev.inmo.tgbotapi.types.buttons.*
 import dev.inmo.tgbotapi.types.buttons.InlineKeyboardButtons.*
+import dev.inmo.tgbotapi.types.chat.member.ChatAdministratorRights
+import dev.inmo.tgbotapi.types.request.RequestId
 import dev.inmo.tgbotapi.types.webapps.WebAppInfo
 
 
@@ -67,3 +69,161 @@ inline fun webAppReplyButton(
     text: String,
     url: String
 ) = webAppReplyButton(text, WebAppInfo(url))
+
+
+/**
+ * Creates and put [RequestUserKeyboardButton]
+ *
+ * @see replyKeyboard
+ * @see ReplyKeyboardBuilder.row
+ */
+inline fun requestUserReplyButton(
+    text: String,
+    requestUser: KeyboardButtonRequestUser
+) = RequestUserKeyboardButton(
+    text,
+    requestUser
+)
+
+/**
+ * Creates and put [RequestUserKeyboardButton] with [KeyboardButtonRequestUser.Bot]
+ *
+ * @see replyKeyboard
+ * @see ReplyKeyboardBuilder.row
+ */
+inline fun requestBotReplyButton(
+    text: String,
+    requestId: RequestId
+) = requestUserReplyButton(
+    text,
+    KeyboardButtonRequestUser.Bot(requestId)
+)
+
+/**
+ * Creates and put [RequestUserKeyboardButton] with [KeyboardButtonRequestUser.Common]
+ *
+ * @see replyKeyboard
+ * @see ReplyKeyboardBuilder.row
+ */
+inline fun requestUserReplyButton(
+    text: String,
+    requestId: RequestId,
+    premiumUser: Boolean? = null
+) = requestUserReplyButton(
+    text,
+    KeyboardButtonRequestUser.Common(requestId, premiumUser)
+)
+
+/**
+ * Creates and put [RequestUserKeyboardButton] with [KeyboardButtonRequestUser.Any]
+ *
+ * @see replyKeyboard
+ * @see ReplyKeyboardBuilder.row
+ */
+inline fun requestUserOrBotReplyButton(
+    text: String,
+    requestId: RequestId
+) = requestUserReplyButton(
+    text,
+    KeyboardButtonRequestUser.Any(requestId)
+)
+
+
+/**
+ * Creates and put [RequestChatKeyboardButton]
+ *
+ * @see replyKeyboard
+ * @see ReplyKeyboardBuilder.row
+ */
+inline fun requestChatReplyButton(
+    text: String,
+    requestChat: KeyboardButtonRequestChat
+) = RequestChatKeyboardButton(
+    text,
+    requestChat
+)
+
+/**
+ * Creates and put [RequestChatKeyboardButton] with [KeyboardButtonRequestChat]
+ *
+ * @see replyKeyboard
+ * @see ReplyKeyboardBuilder.row
+ */
+inline fun requestChatReplyButton(
+    text: String,
+    requestId: RequestId,
+    isChannel: Boolean? = null,
+    isForum: Boolean? = null,
+    isPublic: Boolean? = null,
+    isOwnedBy: Boolean? = null,
+    userRightsInChat: ChatAdministratorRights? = null,
+    botRightsInChat: ChatAdministratorRights? = null,
+    botIsMember: Boolean = false
+) = requestChatReplyButton(
+    text,
+    KeyboardButtonRequestChat(
+        requestId = requestId,
+        isChannel = isChannel,
+        isForum = isForum,
+        isPublic = isPublic,
+        isOwnedBy = isOwnedBy,
+        userRightsInChat = userRightsInChat,
+        botRightsInChat = botRightsInChat,
+        botIsMember = botIsMember
+    )
+)
+
+/**
+ * Creates and put [RequestChatKeyboardButton] with [KeyboardButtonRequestChat.Channel]
+ *
+ * @see replyKeyboard
+ * @see ReplyKeyboardBuilder.row
+ */
+inline fun requestChannelReplyButton(
+    text: String,
+    requestId: RequestId,
+    isPublic: Boolean? = null,
+    isOwnedBy: Boolean? = null,
+    userRightsInChat: ChatAdministratorRights? = null,
+    botRightsInChat: ChatAdministratorRights? = null,
+    botIsMember: Boolean = false
+) = requestChatReplyButton(
+    text,
+    KeyboardButtonRequestChat.Channel(
+        requestId = requestId,
+        isPublic = isPublic,
+        isOwnedBy = isOwnedBy,
+        userRightsInChat = userRightsInChat,
+        botRightsInChat = botRightsInChat,
+        botIsMember = botIsMember
+    )
+)
+
+
+/**
+ * Creates and put [RequestChatKeyboardButton] with [KeyboardButtonRequestChat.Group]
+ *
+ * @see replyKeyboard
+ * @see ReplyKeyboardBuilder.row
+ */
+inline fun requestChannelReplyButton(
+    text: String,
+    requestId: RequestId,
+    isForum: Boolean? = null,
+    isPublic: Boolean? = null,
+    isOwnedBy: Boolean? = null,
+    userRightsInChat: ChatAdministratorRights? = null,
+    botRightsInChat: ChatAdministratorRights? = null,
+    botIsMember: Boolean? = null
+) = requestChatReplyButton(
+    text,
+    KeyboardButtonRequestChat.Group(
+        requestId = requestId,
+        isForum = isForum,
+        isPublic = isPublic,
+        isOwnedBy = isOwnedBy,
+        userRightsInChat = userRightsInChat,
+        botRightsInChat = botRightsInChat,
+        botIsMember = botIsMember
+    )
+)

tgbotapi.core/src/commonMain/kotlin/dev/inmo/tgbotapi/types/chat/ChatJoinRequest.kt

@@ -15,6 +15,8 @@ data class ChatJoinRequest(
     val chat: PublicChat,
     @SerialName(fromField)
     override val from: User,
+    @SerialName(userChatIdField)
+    val userChatId: UserId,
     @SerialName(dateField)
     val date: TelegramDate,
     @SerialName(inviteLinkField)

tgbotapi.core/src/commonMain/kotlin/dev/inmo/tgbotapi/types/chat/ChatPermissions.kt

@@ -1,32 +1,259 @@
 package dev.inmo.tgbotapi.types.chat
 
 import dev.inmo.tgbotapi.types.*
+import kotlinx.serialization.KSerializer
 import kotlinx.serialization.SerialName
 import kotlinx.serialization.Serializable
+import kotlinx.serialization.Transient
+import kotlinx.serialization.descriptors.SerialDescriptor
+import kotlinx.serialization.encoding.Decoder
+import kotlinx.serialization.encoding.Encoder
 
-@Serializable
+/**
-data class ChatPermissions(
+ * Represents any type with common permissions list
-    @SerialName(canSendMessagesField)
+ *
-    val canSendMessages: Boolean = false,
+ * !!WARNING!! Default serializer of this interface is using [Granular] as surrogate and in fact serialized
-    @SerialName(canSendMediaMessagesField)
+ * and deserialized as [Granular]. In case you wish some custom behaviour you must implement your own
-    val canSendMediaMessages: Boolean = false,
+ * [KSerializer] or pass another serializer
-    @SerialName(canSendPollsField)
+ */
-    val canSendPolls: Boolean = false,
+@Serializable(ChatPermissions.Companion::class)
-    @SerialName(canSendOtherMessagesField)
+interface ChatPermissions {
-    val canSendOtherMessages: Boolean = false,
+    val canSendMessages: Boolean?
-    @SerialName(canAddWebPagePreviewsField)
+    val canSendAudios: Boolean?
-    val canAddWebPagePreviews: Boolean = false,
+    val canSendDocuments: Boolean?
-    @SerialName(canChangeInfoField)
+    val canSendPhotos: Boolean?
-    val canChangeInfo: Boolean = false,
+    val canSendVideos: Boolean?
-    @SerialName(canInviteUsersField)
+    val canSendVideoNotes: Boolean?
-    val canInviteUsers: Boolean = false,
+    val canSendVoiceNotes: Boolean?
-    @SerialName(canPinMessagesField)
+    val canSendPolls: Boolean?
-    val canPinMessages: Boolean = false
+    val canSendOtherMessages: Boolean?
-)
+    val canAddWebPagePreviews: Boolean?
+    val canChangeInfo: Boolean?
+    val canInviteUsers: Boolean?
+    val canPinMessages: Boolean?
+    @Transient
+    val isGranular
+        get() = canSendAudios != null ||
+            canSendDocuments != null ||
+            canSendVideoNotes != null ||
+            canSendPhotos != null ||
+            canSendVideos != null ||
+            canSendVoiceNotes != null
+    val canSendStickers: Boolean?
+        get() = canSendOtherMessages
+    val canSendGifs: Boolean?
+        get() = canSendStickers
+
+    @Serializable
+    data class Granular(
+        @SerialName(canSendMessagesField)
+        override val canSendMessages: Boolean? = null,
+        @SerialName(canSendAudiosField)
+        override val canSendAudios: Boolean? = null,
+        @SerialName(canSendDocumentsField)
+        override val canSendDocuments: Boolean? = null,
+        @SerialName(canSendPhotosField)
+        override val canSendPhotos: Boolean? = null,
+        @SerialName(canSendVideosField)
+        override val canSendVideos: Boolean? = null,
+        @SerialName(canSendVideoNotesField)
+        override val canSendVideoNotes: Boolean? = null,
+        @SerialName(canSendVoiceNotesField)
+        override val canSendVoiceNotes: Boolean? = null,
+        @SerialName(canSendPollsField)
+        override val canSendPolls: Boolean? = null,
+        @SerialName(canSendOtherMessagesField)
+        override val canSendOtherMessages: Boolean? = null,
+        @SerialName(canAddWebPagePreviewsField)
+        override val canAddWebPagePreviews: Boolean? = null,
+        @SerialName(canChangeInfoField)
+        override val canChangeInfo: Boolean? = null,
+        @SerialName(canInviteUsersField)
+        override val canInviteUsers: Boolean? = null,
+        @SerialName(canPinMessagesField)
+        override val canPinMessages: Boolean? = null
+    ) : ChatPermissions {
+        @Transient
+        override val isGranular: Boolean
+            get() = true
+    }
+
+    @Serializable
+    data class Common(
+        @SerialName(canSendPollsField)
+        override val canSendPolls: Boolean? = null,
+        @SerialName(canSendOtherMessagesField)
+        override val canSendOtherMessages: Boolean? = null,
+        @SerialName(canAddWebPagePreviewsField)
+        override val canAddWebPagePreviews: Boolean? = null,
+        @SerialName(canChangeInfoField)
+        override val canChangeInfo: Boolean? = null,
+        @SerialName(canInviteUsersField)
+        override val canInviteUsers: Boolean? = null,
+        @SerialName(canPinMessagesField)
+        override val canPinMessages: Boolean? = null
+    ) : ChatPermissions {
+        @Transient
+        override val isGranular: Boolean
+            get() = false
+        @Transient
+        override val canSendMessages: Boolean? = canSendOtherMessages ?.let {
+            it && (canAddWebPagePreviews ?: return@let null)
+        }
+        @Transient
+        override val canSendAudios: Boolean?
+            get() = canSendMessages
+        @Transient
+        override val canSendDocuments: Boolean?
+            get() = canSendMessages
+        @Transient
+        override val canSendPhotos: Boolean?
+            get() = canSendMessages
+        @Transient
+        override val canSendVideos: Boolean?
+            get() = canSendMessages
+        @Transient
+        override val canSendVideoNotes: Boolean?
+            get() = canSendMessages
+        @Transient
+        override val canSendVoiceNotes: Boolean?
+            get() = canSendMessages
+    }
+
+    companion object : KSerializer<ChatPermissions> {
+        operator fun invoke(
+            canSendMessages: Boolean? = null,
+            canSendAudios: Boolean? = null,
+            canSendDocuments: Boolean? = null,
+            canSendPhotos: Boolean? = null,
+            canSendVideos: Boolean? = null,
+            canSendVideoNotes: Boolean? = null,
+            canSendVoiceNotes: Boolean? = null,
+            canSendPolls: Boolean? = null,
+            canSendOtherMessages: Boolean? = null,
+            canAddWebPagePreviews: Boolean? = null,
+            canChangeInfo: Boolean? = null,
+            canInviteUsers: Boolean? = null,
+            canPinMessages: Boolean? = null
+        ) = Granular(
+            canSendMessages = canSendMessages,
+            canSendAudios = canSendAudios,
+            canSendDocuments = canSendDocuments,
+            canSendPhotos = canSendPhotos,
+            canSendVideos = canSendVideos,
+            canSendVideoNotes = canSendVideoNotes,
+            canSendVoiceNotes = canSendVoiceNotes,
+            canSendPolls = canSendPolls,
+            canSendOtherMessages = canSendOtherMessages,
+            canAddWebPagePreviews = canAddWebPagePreviews,
+            canChangeInfo = canChangeInfo,
+            canInviteUsers = canInviteUsers,
+            canPinMessages = canPinMessages
+        )
+
+        private val realSerializer = Granular.serializer()
+        private val commonSerializer = Common.serializer()
+        override val descriptor: SerialDescriptor
+            get() = realSerializer.descriptor
+
+        override fun deserialize(decoder: Decoder): ChatPermissions {
+            return realSerializer.deserialize(decoder)
+        }
+
+        override fun serialize(encoder: Encoder, value: ChatPermissions) {
+            realSerializer.serialize(
+                encoder,
+                (value as? Granular) ?: value.run {
+                    Granular(
+                        canSendMessages = canSendMessages,
+                        canSendAudios = canSendAudios,
+                        canSendDocuments = canSendDocuments,
+                        canSendPhotos = canSendPhotos,
+                        canSendVideos = canSendVideos,
+                        canSendVideoNotes = canSendVideoNotes,
+                        canSendVoiceNotes = canSendVoiceNotes,
+                        canSendPolls = canSendPolls,
+                        canSendOtherMessages = canSendOtherMessages,
+                        canAddWebPagePreviews = canAddWebPagePreviews,
+                        canChangeInfo = canChangeInfo,
+                        canInviteUsers = canInviteUsers,
+                        canPinMessages = canPinMessages
+                    )
+                }
+            )
+        }
+    }
+
+    /**
+     * Copying current instance as [ChatPermissions], but realizations of this interface may differently override this
+     * method
+     */
+    fun copyGranular(
+        canSendMessages: Boolean? = this.canSendMessages,
+        canSendAudios: Boolean? = this.canSendAudios,
+        canSendDocuments: Boolean? = this.canSendDocuments,
+        canSendPhotos: Boolean? = this.canSendPhotos,
+        canSendVideos: Boolean? = this.canSendVideos,
+        canSendVideoNotes: Boolean? = this.canSendVideoNotes,
+        canSendVoiceNotes: Boolean? = this.canSendVoiceNotes,
+        canSendPolls: Boolean? = this.canSendPolls,
+        canSendOtherMessages: Boolean? = this.canSendOtherMessages,
+        canAddWebPagePreviews: Boolean? = this.canAddWebPagePreviews,
+        canChangeInfo: Boolean? = this.canChangeInfo,
+        canInviteUsers: Boolean? = this.canInviteUsers,
+        canPinMessages: Boolean? = this.canPinMessages
+    ): ChatPermissions = ChatPermissions(
+        canSendMessages = canSendMessages,
+        canSendAudios = canSendAudios,
+        canSendDocuments = canSendDocuments,
+        canSendPhotos = canSendPhotos,
+        canSendVideos = canSendVideos,
+        canSendVideoNotes = canSendVideoNotes,
+        canSendVoiceNotes = canSendVoiceNotes,
+        canSendPolls = canSendPolls,
+        canSendOtherMessages = canSendOtherMessages,
+        canAddWebPagePreviews = canAddWebPagePreviews,
+        canChangeInfo = canChangeInfo,
+        canInviteUsers = canInviteUsers,
+        canPinMessages = canPinMessages
+    )
+
+    /**
+     * Copying current instance as [ChatPermissions], but realizations of this interface may differently override this
+     * method
+     */
+    fun copyCommon(
+        canSendPolls: Boolean? = this.canSendPolls,
+        canSendOtherMessages: Boolean? = this.canSendOtherMessages,
+        canAddWebPagePreviews: Boolean? = this.canAddWebPagePreviews,
+        canChangeInfo: Boolean? = this.canChangeInfo,
+        canInviteUsers: Boolean? = this.canInviteUsers,
+        canPinMessages: Boolean? = this.canPinMessages
+    ): ChatPermissions = ChatPermissions(
+        canSendMessages = null,
+        canSendAudios = null,
+        canSendDocuments = null,
+        canSendPhotos = null,
+        canSendVideos = null,
+        canSendVideoNotes = null,
+        canSendVoiceNotes = null,
+        canSendPolls = canSendPolls,
+        canSendOtherMessages = canSendOtherMessages,
+        canAddWebPagePreviews = canAddWebPagePreviews,
+        canChangeInfo = canChangeInfo,
+        canInviteUsers = canInviteUsers,
+        canPinMessages = canPinMessages
+    )
+}
 
 val LeftRestrictionsChatPermissions = ChatPermissions(
     canSendMessages = true,
-    canSendMediaMessages = true,
+    canSendAudios = true,
+    canSendDocuments = true,
+    canSendPhotos = true,
+    canSendVideos = true,
+    canSendVideoNotes = true,
+    canSendVoiceNotes = true,
     canSendPolls = true,
     canSendOtherMessages = true,
     canAddWebPagePreviews = true,
@@ -37,7 +264,12 @@ val LeftRestrictionsChatPermissions = ChatPermissions(
 
 val RestrictionsChatPermissions = ChatPermissions(
     canSendMessages = false,
-    canSendMediaMessages = false,
+    canSendAudios = false,
+    canSendDocuments = false,
+    canSendPhotos = false,
+    canSendVideos = false,
+    canSendVideoNotes = false,
+    canSendVoiceNotes = false,
     canSendPolls = false,
     canSendOtherMessages = false,
     canAddWebPagePreviews = false,

tgbotapi.core/src/commonMain/kotlin/dev/inmo/tgbotapi/types/chat/member/RestrictedChatMember.kt

@@ -1,6 +1,7 @@
 package dev.inmo.tgbotapi.types.chat.member
 
 import dev.inmo.tgbotapi.types.*
+import dev.inmo.tgbotapi.types.chat.ChatPermissions
 import dev.inmo.tgbotapi.types.chat.User
 import kotlinx.serialization.*
 
@@ -13,15 +14,25 @@ data class RestrictedChatMember(
     @SerialName(isMemberField)
     val isMember: Boolean = false,
     @SerialName(canSendMessagesField)
-    val canSendMessages: Boolean = false,
+    override val canSendMessages: Boolean = false,
-    @SerialName(canSendMediaMessagesField)
+    @SerialName(canSendAudiosField)
-    val canSendMediaMessages: Boolean = false,
+    override val canSendAudios: Boolean = false,
+    @SerialName(canSendDocumentsField)
+    override val canSendDocuments: Boolean = false,
+    @SerialName(canSendPhotosField)
+    override val canSendPhotos: Boolean = false,
+    @SerialName(canSendVideosField)
+    override val canSendVideos: Boolean = false,
+    @SerialName(canSendVideoNotesField)
+    override val canSendVideoNotes: Boolean = false,
+    @SerialName(canSendVoiceNotesField)
+    override val canSendVoiceNotes: Boolean = false,
     @SerialName(canSendPollsField)
-    val canSendPolls: Boolean = false,
+    override val canSendPolls: Boolean = false,
     @SerialName(canSendOtherMessagesField)
-    val canSendOtherMessages: Boolean = false,
+    override val canSendOtherMessages: Boolean = false,
     @SerialName(canAddWebPagePreviewsField)
-    val canAddWebpagePreviews: Boolean = false,
+    override val canAddWebPagePreviews: Boolean = false,
     @SerialName(canChangeInfoField)
     override val canChangeInfo: Boolean = false,
     @SerialName(canInviteUsersField)
@@ -30,7 +41,7 @@ data class RestrictedChatMember(
     override val canPinMessages: Boolean = false,
     @SerialName(canManageTopicsField)
     override val canManageTopics: Boolean = false
-) : BannedChatMember, SpecialRightsChatMember {
+) : BannedChatMember, SpecialRightsChatMember, ChatPermissions {
     @SerialName(statusField)
     @Required
     private val type: String = "restricted"

tgbotapi.core/src/commonMain/kotlin/dev/inmo/tgbotapi/types/message/RawMessage.kt

@@ -29,6 +29,8 @@ import dev.inmo.tgbotapi.types.passport.PassportData
 import dev.inmo.tgbotapi.types.payments.Invoice
 import dev.inmo.tgbotapi.types.payments.SuccessfulPayment
 import dev.inmo.tgbotapi.types.polls.Poll
+import dev.inmo.tgbotapi.types.request.ChatShared
+import dev.inmo.tgbotapi.types.request.UserShared
 import dev.inmo.tgbotapi.types.venue.Venue
 import kotlinx.serialization.SerialName
 import kotlinx.serialization.Serializable
@@ -93,6 +95,9 @@ internal data class RawMessage(
     private val dice: Dice? = null,
     private val successful_payment: SuccessfulPayment? = null,
 
+    private val user_shared: UserShared? = null,
+    private val chat_shared: ChatShared? = null,
+
     // Voice Chat Service Messages
     private val video_chat_scheduled: VideoChatScheduled? = null,
     private val video_chat_started: VideoChatStarted? = null,
@@ -249,6 +254,8 @@ internal data class RawMessage(
             successful_payment != null -> SuccessfulPaymentEvent(successful_payment)
             connected_website != null -> UserLoggedIn(connected_website)
             web_app_data != null -> web_app_data
+            user_shared != null -> user_shared
+            chat_shared != null -> chat_shared
             else -> null
         }
     }

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.core/src/commonMain/kotlin/dev/inmo/tgbotapi/types/request/ChatShared.kt

@@ -0,0 +1,17 @@
+package dev.inmo.tgbotapi.types.request
+
+import dev.inmo.tgbotapi.types.ChatId
+import dev.inmo.tgbotapi.types.ChatIdentifier
+import dev.inmo.tgbotapi.types.UserId
+import dev.inmo.tgbotapi.types.chatIdField
+import dev.inmo.tgbotapi.types.requestIdField
+import kotlinx.serialization.SerialName
+import kotlinx.serialization.Serializable
+
+@Serializable
+data class ChatShared(
+    @SerialName(requestIdField)
+    override val requestId: RequestId,
+    @SerialName(chatIdField)
+    override val chatId: ChatId
+) : ChatSharedRequest

tgbotapi.core/src/commonMain/kotlin/dev/inmo/tgbotapi/types/request/ChatSharedRequest.kt

@@ -0,0 +1,8 @@
+package dev.inmo.tgbotapi.types.request
+
+import dev.inmo.tgbotapi.types.ChatIdentifier
+import dev.inmo.tgbotapi.types.message.ChatEvents.abstracts.PrivateEvent
+
+sealed interface ChatSharedRequest : RequestResponse, PrivateEvent {
+    val chatId: ChatIdentifier
+}

tgbotapi.core/src/commonMain/kotlin/dev/inmo/tgbotapi/types/request/RequestId.kt

@@ -0,0 +1,15 @@
+package dev.inmo.tgbotapi.types.request
+
+import kotlinx.serialization.Serializable
+import kotlin.jvm.JvmInline
+import kotlin.random.Random
+
+@Serializable
+@JvmInline
+value class RequestId(
+    val int: Int
+) {
+    companion object {
+        fun random() = RequestId(Random.nextInt())
+    }
+}

tgbotapi.core/src/commonMain/kotlin/dev/inmo/tgbotapi/types/request/RequestResponse.kt

@@ -0,0 +1,8 @@
+package dev.inmo.tgbotapi.types.request
+
+import dev.inmo.tgbotapi.utils.internal.ClassCastsIncluded
+
+@ClassCastsIncluded
+sealed interface RequestResponse {
+    val requestId: RequestId
+}

tgbotapi.core/src/commonMain/kotlin/dev/inmo/tgbotapi/types/request/UserShared.kt

@@ -0,0 +1,19 @@
+package dev.inmo.tgbotapi.types.request
+
+import dev.inmo.tgbotapi.types.ChatId
+import dev.inmo.tgbotapi.types.UserId
+import dev.inmo.tgbotapi.types.requestIdField
+import dev.inmo.tgbotapi.types.userIdField
+import kotlinx.serialization.SerialName
+import kotlinx.serialization.Serializable
+
+@Serializable
+data class UserShared(
+    @SerialName(requestIdField)
+    override val requestId: RequestId,
+    @SerialName(userIdField)
+    val userId: UserId
+) : ChatSharedRequest {
+    override val chatId: ChatId
+        get() = userId
+}

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

@@ -113,6 +113,7 @@ import dev.inmo.tgbotapi.types.buttons.InlineKeyboardButtons.URLInlineKeyboardBu
 import dev.inmo.tgbotapi.types.buttons.InlineKeyboardButtons.UnknownInlineKeyboardButton
 import dev.inmo.tgbotapi.types.buttons.InlineKeyboardButtons.WebAppInlineKeyboardButton
 import dev.inmo.tgbotapi.types.buttons.InlineKeyboardMarkup
+import dev.inmo.tgbotapi.types.buttons.KeyboardButtonRequestUser
 import dev.inmo.tgbotapi.types.buttons.KeyboardMarkup
 import dev.inmo.tgbotapi.types.buttons.ReplyForce
 import dev.inmo.tgbotapi.types.buttons.ReplyKeyboardMarkup
@@ -433,6 +434,10 @@ import dev.inmo.tgbotapi.types.queries.callback.MessageCallbackQuery
 import dev.inmo.tgbotapi.types.queries.callback.MessageDataCallbackQuery
 import dev.inmo.tgbotapi.types.queries.callback.MessageGameShortNameCallbackQuery
 import dev.inmo.tgbotapi.types.queries.callback.UnknownCallbackQueryType
+import dev.inmo.tgbotapi.types.request.ChatShared
+import dev.inmo.tgbotapi.types.request.ChatSharedRequest
+import dev.inmo.tgbotapi.types.request.RequestResponse
+import dev.inmo.tgbotapi.types.request.UserShared
 import dev.inmo.tgbotapi.types.update.CallbackQueryUpdate
 import dev.inmo.tgbotapi.types.update.ChannelPostUpdate
 import dev.inmo.tgbotapi.types.update.ChatJoinRequestUpdate
@@ -1879,6 +1884,34 @@ public inline fun <T>
     InlineKeyboardButton.ifWebAppInlineKeyboardButton(block: (WebAppInlineKeyboardButton) -> T): T?
     = webAppInlineKeyboardButtonOrNull() ?.let(block)
 
+public inline fun KeyboardButtonRequestUser.anyOrNull(): KeyboardButtonRequestUser.Any? = this as?
+    dev.inmo.tgbotapi.types.buttons.KeyboardButtonRequestUser.Any
+
+public inline fun KeyboardButtonRequestUser.anyOrThrow(): KeyboardButtonRequestUser.Any = this as
+    dev.inmo.tgbotapi.types.buttons.KeyboardButtonRequestUser.Any
+
+public inline fun <T> KeyboardButtonRequestUser.ifAny(block: (KeyboardButtonRequestUser.Any) -> T):
+    T? = anyOrNull() ?.let(block)
+
+public inline fun KeyboardButtonRequestUser.botOrNull(): KeyboardButtonRequestUser.Bot? = this as?
+    dev.inmo.tgbotapi.types.buttons.KeyboardButtonRequestUser.Bot
+
+public inline fun KeyboardButtonRequestUser.botOrThrow(): KeyboardButtonRequestUser.Bot = this as
+    dev.inmo.tgbotapi.types.buttons.KeyboardButtonRequestUser.Bot
+
+public inline fun <T> KeyboardButtonRequestUser.ifBot(block: (KeyboardButtonRequestUser.Bot) -> T):
+    T? = botOrNull() ?.let(block)
+
+public inline fun KeyboardButtonRequestUser.commonOrNull(): KeyboardButtonRequestUser.Common? = this
+    as? dev.inmo.tgbotapi.types.buttons.KeyboardButtonRequestUser.Common
+
+public inline fun KeyboardButtonRequestUser.commonOrThrow(): KeyboardButtonRequestUser.Common = this
+    as dev.inmo.tgbotapi.types.buttons.KeyboardButtonRequestUser.Common
+
+public inline fun <T>
+    KeyboardButtonRequestUser.ifCommon(block: (KeyboardButtonRequestUser.Common) -> T): T? =
+    commonOrNull() ?.let(block)
+
 public inline fun KeyboardMarkup.inlineKeyboardMarkupOrNull(): InlineKeyboardMarkup? = this as?
     dev.inmo.tgbotapi.types.buttons.InlineKeyboardMarkup
 
@@ -3031,6 +3064,33 @@ public inline fun ChatEvent.successfulPaymentEventOrThrow(): SuccessfulPaymentEv
 public inline fun <T> ChatEvent.ifSuccessfulPaymentEvent(block: (SuccessfulPaymentEvent) -> T): T? =
     successfulPaymentEventOrNull() ?.let(block)
 
+public inline fun ChatEvent.chatSharedOrNull(): ChatShared? = this as?
+    dev.inmo.tgbotapi.types.request.ChatShared
+
+public inline fun ChatEvent.chatSharedOrThrow(): ChatShared = this as
+    dev.inmo.tgbotapi.types.request.ChatShared
+
+public inline fun <T> ChatEvent.ifChatShared(block: (ChatShared) -> T): T? = chatSharedOrNull()
+    ?.let(block)
+
+public inline fun ChatEvent.chatSharedRequestOrNull(): ChatSharedRequest? = this as?
+    dev.inmo.tgbotapi.types.request.ChatSharedRequest
+
+public inline fun ChatEvent.chatSharedRequestOrThrow(): ChatSharedRequest = this as
+    dev.inmo.tgbotapi.types.request.ChatSharedRequest
+
+public inline fun <T> ChatEvent.ifChatSharedRequest(block: (ChatSharedRequest) -> T): T? =
+    chatSharedRequestOrNull() ?.let(block)
+
+public inline fun ChatEvent.userSharedOrNull(): UserShared? = this as?
+    dev.inmo.tgbotapi.types.request.UserShared
+
+public inline fun ChatEvent.userSharedOrThrow(): UserShared = this as
+    dev.inmo.tgbotapi.types.request.UserShared
+
+public inline fun <T> ChatEvent.ifUserShared(block: (UserShared) -> T): T? = userSharedOrNull()
+    ?.let(block)
+
 public inline fun ForwardInfo.byAnonymousOrNull(): ForwardInfo.ByAnonymous? = this as?
     dev.inmo.tgbotapi.types.message.ForwardInfo.ByAnonymous
 
@@ -4659,6 +4719,33 @@ public inline fun Poll.quizPollOrThrow(): QuizPoll = this as dev.inmo.tgbotapi.t
 
 public inline fun <T> Poll.ifQuizPoll(block: (QuizPoll) -> T): T? = quizPollOrNull() ?.let(block)
 
+public inline fun RequestResponse.chatSharedOrNull(): ChatShared? = this as?
+    dev.inmo.tgbotapi.types.request.ChatShared
+
+public inline fun RequestResponse.chatSharedOrThrow(): ChatShared = this as
+    dev.inmo.tgbotapi.types.request.ChatShared
+
+public inline fun <T> RequestResponse.ifChatShared(block: (ChatShared) -> T): T? =
+    chatSharedOrNull() ?.let(block)
+
+public inline fun RequestResponse.chatSharedRequestOrNull(): ChatSharedRequest? = this as?
+    dev.inmo.tgbotapi.types.request.ChatSharedRequest
+
+public inline fun RequestResponse.chatSharedRequestOrThrow(): ChatSharedRequest = this as
+    dev.inmo.tgbotapi.types.request.ChatSharedRequest
+
+public inline fun <T> RequestResponse.ifChatSharedRequest(block: (ChatSharedRequest) -> T): T? =
+    chatSharedRequestOrNull() ?.let(block)
+
+public inline fun RequestResponse.userSharedOrNull(): UserShared? = this as?
+    dev.inmo.tgbotapi.types.request.UserShared
+
+public inline fun RequestResponse.userSharedOrThrow(): UserShared = this as
+    dev.inmo.tgbotapi.types.request.UserShared
+
+public inline fun <T> RequestResponse.ifUserShared(block: (UserShared) -> T): T? =
+    userSharedOrNull() ?.let(block)
+
 public inline fun Update.callbackQueryUpdateOrNull(): CallbackQueryUpdate? = this as?
     dev.inmo.tgbotapi.types.update.CallbackQueryUpdate
 

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,
     ""

tgbotapi.utils/src/commonMain/kotlin/dev/inmo/tgbotapi/extensions/utils/types/buttons/ReplyKeyboardBuilder.kt

@@ -1,6 +1,10 @@
 package dev.inmo.tgbotapi.extensions.utils.types.buttons
 
 import dev.inmo.tgbotapi.types.buttons.*
+import dev.inmo.tgbotapi.types.buttons.reply.requestChatReplyButton
+import dev.inmo.tgbotapi.types.buttons.reply.requestUserReplyButton
+import dev.inmo.tgbotapi.types.chat.member.ChatAdministratorRights
+import dev.inmo.tgbotapi.types.request.RequestId
 import dev.inmo.tgbotapi.types.webapps.WebAppInfo
 import dev.inmo.tgbotapi.utils.*
 
@@ -138,3 +142,164 @@ inline fun ReplyKeyboardRowBuilder.webAppButton(
     text: String,
     url: String
 ) = webAppButton(text, WebAppInfo(url))
+
+
+/**
+ * Creates and put [RequestUserKeyboardButton]
+ *
+ * @see replyKeyboard
+ * @see ReplyKeyboardBuilder.row
+ */
+inline fun ReplyKeyboardRowBuilder.requestUserButton(
+    text: String,
+    requestUser: KeyboardButtonRequestUser
+) = add(
+    requestUserReplyButton(
+        text,
+        requestUser
+    )
+)
+
+/**
+ * Creates and put [RequestUserKeyboardButton] with [KeyboardButtonRequestUser.Bot]
+ *
+ * @see replyKeyboard
+ * @see ReplyKeyboardBuilder.row
+ */
+inline fun ReplyKeyboardRowBuilder.requestBotButton(
+    text: String,
+    requestId: RequestId
+) = requestUserButton(
+    text,
+    KeyboardButtonRequestUser.Bot(requestId)
+)
+
+/**
+ * Creates and put [RequestUserKeyboardButton] with [KeyboardButtonRequestUser.Common]
+ *
+ * @see replyKeyboard
+ * @see ReplyKeyboardBuilder.row
+ */
+inline fun ReplyKeyboardRowBuilder.requestUserButton(
+    text: String,
+    requestId: RequestId,
+    premiumUser: Boolean? = null
+) = requestUserButton(
+    text,
+    KeyboardButtonRequestUser.Common(requestId, premiumUser)
+)
+
+/**
+ * Creates and put [RequestUserKeyboardButton] with [KeyboardButtonRequestUser.Any]
+ *
+ * @see replyKeyboard
+ * @see ReplyKeyboardBuilder.row
+ */
+inline fun ReplyKeyboardRowBuilder.requestUserOrBotButton(
+    text: String,
+    requestId: RequestId
+) = requestUserButton(
+    text,
+    KeyboardButtonRequestUser.Any(requestId)
+)
+
+
+/**
+ * Creates and put [RequestChatKeyboardButton]
+ *
+ * @see replyKeyboard
+ * @see ReplyKeyboardBuilder.row
+ */
+inline fun ReplyKeyboardRowBuilder.requestChatButton(
+    text: String,
+    requestChat: KeyboardButtonRequestChat
+) = add(
+    requestChatReplyButton(
+        text,
+        requestChat
+    )
+)
+
+/**
+ * Creates and put [RequestChatKeyboardButton] with [KeyboardButtonRequestChat]
+ *
+ * @see replyKeyboard
+ * @see ReplyKeyboardBuilder.row
+ */
+inline fun ReplyKeyboardRowBuilder.requestChatButton(
+    text: String,
+    requestId: RequestId,
+    isChannel: Boolean? = null,
+    isForum: Boolean? = null,
+    isPublic: Boolean? = null,
+    isOwnedBy: Boolean? = null,
+    userRightsInChat: ChatAdministratorRights? = null,
+    botRightsInChat: ChatAdministratorRights? = null,
+    botIsMember: Boolean? = null
+) = requestChatButton(
+    text,
+    KeyboardButtonRequestChat(
+        requestId = requestId,
+        isChannel = isChannel,
+        isForum = isForum,
+        isPublic = isPublic,
+        isOwnedBy = isOwnedBy,
+        userRightsInChat = userRightsInChat,
+        botRightsInChat = botRightsInChat,
+        botIsMember = botIsMember
+    )
+)
+
+/**
+ * Creates and put [RequestChatKeyboardButton] with [KeyboardButtonRequestChat.Channel]
+ *
+ * @see replyKeyboard
+ * @see ReplyKeyboardBuilder.row
+ */
+inline fun ReplyKeyboardRowBuilder.requestChannelButton(
+    text: String,
+    requestId: RequestId,
+    isPublic: Boolean? = null,
+    isOwnedBy: Boolean? = null,
+    userRightsInChat: ChatAdministratorRights? = null,
+    botRightsInChat: ChatAdministratorRights? = null,
+    botIsMember: Boolean? = null
+) = requestChatButton(
+    text,
+    KeyboardButtonRequestChat.Channel(
+        requestId = requestId,
+        isPublic = isPublic,
+        isOwnedBy = isOwnedBy,
+        userRightsInChat = userRightsInChat,
+        botRightsInChat = botRightsInChat,
+        botIsMember = botIsMember
+    )
+)
+
+/**
+ * Creates and put [RequestChatKeyboardButton] with [KeyboardButtonRequestChat.Group]
+ *
+ * @see replyKeyboard
+ * @see ReplyKeyboardBuilder.row
+ */
+inline fun ReplyKeyboardRowBuilder.requestGroupButton(
+    text: String,
+    requestId: RequestId,
+    isForum: Boolean? = null,
+    isPublic: Boolean? = null,
+    isOwnedBy: Boolean? = null,
+    userRightsInChat: ChatAdministratorRights? = null,
+    botRightsInChat: ChatAdministratorRights? = null,
+    botIsMember: Boolean? = null
+) = requestChatButton(
+    text,
+    KeyboardButtonRequestChat.Group(
+        requestId = requestId,
+        isForum = isForum,
+        isPublic = isPublic,
+        isOwnedBy = isOwnedBy,
+        userRightsInChat = userRightsInChat,
+        botRightsInChat = botRightsInChat,
+        botIsMember = botIsMember
+    )
+)

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

@@ -5,7 +5,6 @@ import dev.inmo.tgbotapi.bot.RequestsExecutor
 import dev.inmo.tgbotapi.bot.TelegramBot
 import dev.inmo.tgbotapi.bot.exceptions.*
 import dev.inmo.tgbotapi.extensions.utils.updates.convertWithMediaGroupUpdates
-import dev.inmo.tgbotapi.extensions.utils.updates.lastUpdateIdentifier
 import dev.inmo.tgbotapi.requests.GetUpdates
 import dev.inmo.tgbotapi.requests.webhook.DeleteWebhook
 import dev.inmo.tgbotapi.types.*
@@ -24,7 +23,8 @@ fun TelegramBot.longPollingFlow(
     timeoutSeconds: Seconds = 30,
     exceptionsHandler: (ExceptionHandler<Unit>)? = null,
     allowedUpdates: List<String>? = ALL_UPDATES_LIST,
-    autoDisableWebhooks: Boolean = true
+    autoDisableWebhooks: Boolean = true,
+    autoSkipTimeoutExceptions: Boolean = true
 ): Flow<Update> = channelFlow {
     if (autoDisableWebhooks) {
         runCatchingSafely {
@@ -32,58 +32,77 @@ fun TelegramBot.longPollingFlow(
         }
     }
 
+    val contextSafelyExceptionHandler = coroutineContext[ContextSafelyExceptionHandlerKey]
+    val contextToWork = if (contextSafelyExceptionHandler == null || !autoSkipTimeoutExceptions) {
+        coroutineContext
+    } else {
+        coroutineContext + ContextSafelyExceptionHandler { e ->
+            if (e is HttpRequestTimeoutException || (e is CommonBotException && e.cause is HttpRequestTimeoutException)) {
+                return@ContextSafelyExceptionHandler
+            } else {
+                contextSafelyExceptionHandler.handler(e)
+            }
+        }
+    }
+
     var lastUpdateIdentifier: UpdateIdentifier? = null
 
-    while (isActive) {
+    withContext(contextToWork) {
-        safely(
+        while (isActive) {
-            { e ->
+            safely(
-                exceptionsHandler ?.invoke(e)
+                { e ->
-                if (e is RequestException) {
+                    val isHttpRequestTimeoutException = e is HttpRequestTimeoutException || (e is CommonBotException && e.cause is HttpRequestTimeoutException)
-                    delay(1000L)
+                    if (isHttpRequestTimeoutException && autoSkipTimeoutExceptions) {
+                        return@safely
+                    }
+                    exceptionsHandler ?.invoke(e)
+                    if (e is RequestException) {
+                        delay(1000L)
+                    }
+                    if (e is GetUpdatesConflict && (exceptionsHandler == null || exceptionsHandler == defaultSafelyExceptionHandler)) {
+                        println("Warning!!! Other bot with the same bot token requests updates with getUpdate in parallel")
+                    }
                 }
-                if (e is GetUpdatesConflict && (exceptionsHandler == null || exceptionsHandler == defaultSafelyExceptionHandler)) {
+            ) {
-                    println("Warning!!! Other bot with the same bot token requests updates with getUpdate in parallel")
+                val updates = execute(
+                    GetUpdates(
+                        offset = lastUpdateIdentifier?.plus(1),
+                        timeout = timeoutSeconds,
+                        allowed_updates = allowedUpdates
+                    )
+                ).let { originalUpdates ->
+                    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
+                     */
+                    /**
+                     * 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
+                    }
                 }
-            }
-        ) {
-            val updates = execute(
-                GetUpdates(
-                    offset = lastUpdateIdentifier?.plus(1),
-                    timeout = timeoutSeconds,
-                    allowed_updates = allowedUpdates
-                )
-            ).let { originalUpdates ->
-                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
-                 */
-                /**
-                 * 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 {
+                safelyWithResult {
-                for (update in updates) {
+                    for (update in updates) {
-                    send(update)
+                        send(update)
 
-                    lastUpdateIdentifier = update.updateId
+                        lastUpdateIdentifier = update.updateId
+                    }
+                }.onFailure {
+                    cancel(it as? CancellationException ?: return@onFailure)
                 }
-            }.onFailure {
-                cancel(it as? CancellationException ?: return@onFailure)
             }
         }
     }
@@ -95,8 +114,15 @@ fun TelegramBot.startGettingOfUpdatesByLongPolling(
     exceptionsHandler: (ExceptionHandler<Unit>)? = null,
     allowedUpdates: List<String>? = ALL_UPDATES_LIST,
     autoDisableWebhooks: Boolean = true,
+    autoSkipTimeoutExceptions: Boolean = true,
     updatesReceiver: UpdateReceiver<Update>
-): Job = longPollingFlow(timeoutSeconds, exceptionsHandler, allowedUpdates, autoDisableWebhooks).subscribeSafely(
+): Job = longPollingFlow(
+    timeoutSeconds = timeoutSeconds,
+    exceptionsHandler = exceptionsHandler,
+    allowedUpdates = allowedUpdates,
+    autoDisableWebhooks = autoDisableWebhooks,
+    autoSkipTimeoutExceptions = autoSkipTimeoutExceptions
+).subscribeSafely(
     scope,
     exceptionsHandler ?: defaultSafelyExceptionHandler,
     updatesReceiver
@@ -111,7 +137,7 @@ fun TelegramBot.createAccumulatedUpdatesRetrieverFlow(
     avoidCallbackQueries: Boolean = false,
     exceptionsHandler: ExceptionHandler<Unit>? = null,
     allowedUpdates: List<String>? = ALL_UPDATES_LIST,
-    autoDisableWebhooks: Boolean = true,
+    autoDisableWebhooks: Boolean = true
 ): Flow<Update> = longPollingFlow(
     timeoutSeconds = 0,
     exceptionsHandler = {
@@ -122,7 +148,8 @@ fun TelegramBot.createAccumulatedUpdatesRetrieverFlow(
         }
     },
     allowedUpdates = allowedUpdates,
-    autoDisableWebhooks = autoDisableWebhooks
+    autoDisableWebhooks = autoDisableWebhooks,
+    autoSkipTimeoutExceptions = false
 ).filter {
     !(it is InlineQueryUpdate && avoidInlineQueries || it is CallbackQueryUpdate && avoidCallbackQueries)
 }
@@ -191,9 +218,18 @@ fun TelegramBot.longPolling(
     timeoutSeconds: Seconds = 30,
     scope: CoroutineScope = CoroutineScope(Dispatchers.Default),
     autoDisableWebhooks: Boolean = true,
+    autoSkipTimeoutExceptions: Boolean = true,
     exceptionsHandler: ExceptionHandler<Unit>? = null
 ): Job = updatesFilter.run {
-    startGettingOfUpdatesByLongPolling(timeoutSeconds, scope, exceptionsHandler, allowedUpdates, autoDisableWebhooks, asUpdateReceiver)
+    startGettingOfUpdatesByLongPolling(
+        timeoutSeconds = timeoutSeconds,
+        scope = scope,
+        exceptionsHandler = exceptionsHandler,
+        allowedUpdates = allowedUpdates,
+        autoDisableWebhooks = autoDisableWebhooks,
+        autoSkipTimeoutExceptions = autoSkipTimeoutExceptions,
+        updatesReceiver = asUpdateReceiver
+    )
 }
 
 /**
@@ -208,8 +244,9 @@ fun TelegramBot.longPolling(
     exceptionsHandler: ExceptionHandler<Unit>? = null,
     flowsUpdatesFilterUpdatesKeeperCount: Int = 100,
     autoDisableWebhooks: Boolean = true,
+    autoSkipTimeoutExceptions: Boolean = true,
     flowUpdatesPreset: FlowsUpdatesFilter.() -> Unit
-): Job = longPolling(FlowsUpdatesFilter(flowsUpdatesFilterUpdatesKeeperCount).apply(flowUpdatesPreset), timeoutSeconds, scope, autoDisableWebhooks, exceptionsHandler)
+): Job = longPolling(FlowsUpdatesFilter(flowsUpdatesFilterUpdatesKeeperCount).apply(flowUpdatesPreset), timeoutSeconds, scope, autoDisableWebhooks, autoSkipTimeoutExceptions, exceptionsHandler)
 
 fun RequestsExecutor.startGettingOfUpdatesByLongPolling(
     updatesFilter: UpdatesFilter,
@@ -217,11 +254,13 @@ fun RequestsExecutor.startGettingOfUpdatesByLongPolling(
     exceptionsHandler: ExceptionHandler<Unit>? = null,
     scope: CoroutineScope = CoroutineScope(Dispatchers.Default),
     autoDisableWebhooks: Boolean = true,
+    autoSkipTimeoutExceptions: Boolean = true,
 ): Job = startGettingOfUpdatesByLongPolling(
     timeoutSeconds,
     scope,
     exceptionsHandler,
     updatesFilter.allowedUpdates,
     autoDisableWebhooks,
+    autoSkipTimeoutExceptions,
     updatesFilter.asUpdateReceiver
 )