start migration to non-suspend expect flow

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

@@ -29,9 +29,8 @@ typealias NullableRequestBuilder<T> = suspend (Update) -> Request<T>?
  * will be called too), [errorFactory] and then will be returned null
  */
 @RiskFeature(lowLevelRiskFeatureMessage)
-suspend fun <T> FlowsUpdatesFilter.expectFlow(
+fun <T> FlowsUpdatesFilter.expectFlow(
     bot: TelegramBot,
-    initRequest: Request<*>? = null,
     errorFactory: NullableRequestBuilder<*> = { null },
     cancelRequestFactory: NullableRequestBuilder<*> = { null },
     cancelTrigger: suspend (Update) -> Boolean = { cancelRequestFactory(it) != null },
@@ -58,11 +57,6 @@ suspend fun <T> FlowsUpdatesFilter.expectFlow(
             result.getOrThrow()
         }
     }.flatten()
-    initRequest ?.also {
-        runCatching {
-            bot.execute(initRequest)
-        }
-    }
     return flow
 }
 
@@ -77,51 +71,9 @@ suspend fun <T> FlowsUpdatesFilter.expectFlow(
  * will be called too), [errorFactory] and then will be returned null
  */
 @RiskFeature(lowLevelRiskFeatureMessage)
-suspend fun <T> BehaviourContext.expectFlow(
+fun <T> BehaviourContext.expectFlow(
-    initRequest: Request<*>? = null,
     errorFactory: NullableRequestBuilder<*> = { null },
     cancelRequestFactory: NullableRequestBuilder<*> = { null },
     cancelTrigger: suspend (Update) -> Boolean = { cancelRequestFactory(it) != null },
     filter: suspend (Update) -> List<T>
-) = flowsUpdatesFilter.expectFlow(bot, initRequest, errorFactory, cancelRequestFactory, cancelTrigger, filter)
+) = flowsUpdatesFilter.expectFlow(bot, errorFactory, cancelRequestFactory, cancelTrigger, filter)
-
-/**
- * @param initRequest If not null, this request will be sent by [bot] before returning value
- * @param errorFactory If set, this factory will be used to produce requests in case when user have sent incorrect data
- * @param cancelRequestFactory If set, this factory will be used to produce requests in case when it is required to say
- * user that chain of scenario has been cancelled
- * @param cancelTrigger When this trigger returns true, chain is cancelled
- * @param filter It is main param, which will be called on each update. When it return not null, result will be returned
- * as is, but when it returns null, then will be called [cancelTrigger] (if it will return true - [cancelRequestFactory]
- * will be called too), [errorFactory] and then will be returned null
- */
-@RiskFeature(lowLevelRiskFeatureMessage)
-suspend fun <T> FlowsUpdatesFilter.expectOne(
-    bot: TelegramBot,
-    initRequest: Request<*>? = null,
-    errorFactory: NullableRequestBuilder<*> = { null },
-    cancelRequestFactory: NullableRequestBuilder<*> = { null },
-    cancelTrigger: suspend (Update) -> Boolean = { cancelRequestFactory(it) != null },
-    filter: suspend (Update) -> T?
-): T = expectFlow(bot, initRequest, errorFactory, cancelRequestFactory, cancelTrigger) {
-    listOfNotNull(filter.invoke(it))
-}.first()
-
-/**
- * @param initRequest If not null, this request will be sent by [bot] before returning value
- * @param errorFactory If set, this factory will be used to produce requests in case when user have sent incorrect data
- * @param cancelRequestFactory If set, this factory will be used to produce requests in case when it is required to say
- * user that chain of scenario has been cancelled
- * @param cancelTrigger When this trigger returns true, chain is cancelled
- * @param filter It is main param, which will be called on each update. When it return not null, result will be returned
- * as is, but when it returns null, then will be called [cancelTrigger] (if it will return true - [cancelRequestFactory]
- * will be called too), [errorFactory] and then will be returned null
- */
-@RiskFeature(lowLevelRiskFeatureMessage)
-suspend fun <T> BehaviourContext.expectOne(
-    initRequest: Request<*>? = null,
-    errorFactory: NullableRequestBuilder<*> = { null },
-    cancelRequestFactory: NullableRequestBuilder<*> = { null },
-    cancelTrigger: suspend (Update) -> Boolean = { cancelRequestFactory(it) != null },
-    filter: suspend (Update) -> T?
-) = flowsUpdatesFilter.expectOne(bot, initRequest, errorFactory, cancelRequestFactory, cancelTrigger, filter)

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

@@ -0,0 +1,102 @@
+package dev.inmo.tgbotapi.extensions.behaviour_builder.expectations
+
+import dev.inmo.micro_utils.coroutines.safelyWithResult
+import dev.inmo.micro_utils.coroutines.safelyWithoutExceptions
+import dev.inmo.tgbotapi.bot.TelegramBot
+import dev.inmo.tgbotapi.extensions.behaviour_builder.BehaviourContext
+import dev.inmo.tgbotapi.extensions.utils.flatten
+import dev.inmo.tgbotapi.requests.abstracts.Request
+import dev.inmo.tgbotapi.types.update.abstracts.Update
+import dev.inmo.tgbotapi.updateshandlers.FlowsUpdatesFilter
+import dev.inmo.tgbotapi.utils.RiskFeature
+import dev.inmo.tgbotapi.utils.lowLevelRiskFeatureMessage
+import kotlinx.coroutines.CancellationException
+import kotlinx.coroutines.flow.*
+
+/**
+ * @param initRequest If not null, this request will be sent by [bot] before returning value
+ * @param errorFactory If set, this factory will be used to produce requests in case when user have sent incorrect data
+ * @param cancelRequestFactory If set, this factory will be used to produce requests in case when it is required to say
+ * user that chain of scenario has been cancelled
+ * @param cancelTrigger When this trigger returns true, chain is cancelled
+ * @param filter It is main param, which will be called on each update. When it return not null, result will be returned
+ * as is, but when it returns null, then will be called [cancelTrigger] (if it will return true - [cancelRequestFactory]
+ * will be called too), [errorFactory] and then will be returned null
+ */
+@RiskFeature(lowLevelRiskFeatureMessage)
+suspend fun <T> FlowsUpdatesFilter.expectFlow(
+    bot: TelegramBot,
+    initRequest: Request<*>?,
+    errorFactory: NullableRequestBuilder<*> = { null },
+    cancelRequestFactory: NullableRequestBuilder<*> = { null },
+    cancelTrigger: suspend (Update) -> Boolean = { cancelRequestFactory(it) != null },
+    filter: suspend (Update) -> List<T>
+): Flow<T> {
+    val flow = expectFlow(bot, errorFactory, cancelRequestFactory, cancelTrigger, filter)
+    initRequest ?.also {
+        runCatching {
+            bot.execute(initRequest)
+        }
+    }
+    return flow
+}
+
+/**
+ * @param initRequest If not null, this request will be sent by [bot] before returning value
+ * @param errorFactory If set, this factory will be used to produce requests in case when user have sent incorrect data
+ * @param cancelRequestFactory If set, this factory will be used to produce requests in case when it is required to say
+ * user that chain of scenario has been cancelled
+ * @param cancelTrigger When this trigger returns true, chain is cancelled
+ * @param filter It is main param, which will be called on each update. When it return not null, result will be returned
+ * as is, but when it returns null, then will be called [cancelTrigger] (if it will return true - [cancelRequestFactory]
+ * will be called too), [errorFactory] and then will be returned null
+ */
+@RiskFeature(lowLevelRiskFeatureMessage)
+suspend fun <T> BehaviourContext.expectFlow(
+    initRequest: Request<*>?,
+    errorFactory: NullableRequestBuilder<*> = { null },
+    cancelRequestFactory: NullableRequestBuilder<*> = { null },
+    cancelTrigger: suspend (Update) -> Boolean = { cancelRequestFactory(it) != null },
+    filter: suspend (Update) -> List<T>
+) = flowsUpdatesFilter.expectFlow(bot, initRequest, errorFactory, cancelRequestFactory, cancelTrigger, filter)
+
+/**
+ * @param initRequest If not null, this request will be sent by [bot] before returning value
+ * @param errorFactory If set, this factory will be used to produce requests in case when user have sent incorrect data
+ * @param cancelRequestFactory If set, this factory will be used to produce requests in case when it is required to say
+ * user that chain of scenario has been cancelled
+ * @param cancelTrigger When this trigger returns true, chain is cancelled
+ * @param filter It is main param, which will be called on each update. When it return not null, result will be returned
+ * as is, but when it returns null, then will be called [cancelTrigger] (if it will return true - [cancelRequestFactory]
+ * will be called too), [errorFactory] and then will be returned null
+ */
+@RiskFeature(lowLevelRiskFeatureMessage)
+suspend fun <T> FlowsUpdatesFilter.expectOne(
+    bot: TelegramBot,
+    initRequest: Request<*>,
+    errorFactory: NullableRequestBuilder<*> = { null },
+    cancelRequestFactory: NullableRequestBuilder<*> = { null },
+    cancelTrigger: suspend (Update) -> Boolean = { cancelRequestFactory(it) != null },
+    filter: suspend (Update) -> T?
+): T = expectFlow(bot, initRequest, errorFactory, cancelRequestFactory, cancelTrigger) {
+    listOfNotNull(filter.invoke(it))
+}.first()
+
+/**
+ * @param initRequest If not null, this request will be sent by [bot] before returning value
+ * @param errorFactory If set, this factory will be used to produce requests in case when user have sent incorrect data
+ * @param cancelRequestFactory If set, this factory will be used to produce requests in case when it is required to say
+ * user that chain of scenario has been cancelled
+ * @param cancelTrigger When this trigger returns true, chain is cancelled
+ * @param filter It is main param, which will be called on each update. When it return not null, result will be returned
+ * as is, but when it returns null, then will be called [cancelTrigger] (if it will return true - [cancelRequestFactory]
+ * will be called too), [errorFactory] and then will be returned null
+ */
+@RiskFeature(lowLevelRiskFeatureMessage)
+suspend fun <T> BehaviourContext.expectOne(
+    initRequest: Request<*>,
+    errorFactory: NullableRequestBuilder<*> = { null },
+    cancelRequestFactory: NullableRequestBuilder<*> = { null },
+    cancelTrigger: suspend (Update) -> Boolean = { cancelRequestFactory(it) != null },
+    filter: suspend (Update) -> T?
+) = flowsUpdatesFilter.expectOne(bot, initRequest, errorFactory, cancelRequestFactory, cancelTrigger, filter)

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

@@ -0,0 +1,41 @@
+package dev.inmo.tgbotapi.extensions.behaviour_builder.expectations
+
+import dev.inmo.tgbotapi.extensions.behaviour_builder.BehaviourContext
+import dev.inmo.tgbotapi.extensions.utils.businessConnectionUpdateOrNull
+import dev.inmo.tgbotapi.extensions.utils.disabledOrNull
+import dev.inmo.tgbotapi.extensions.utils.enabledOrNull
+import dev.inmo.tgbotapi.extensions.utils.shippingQueryUpdateOrNull
+import dev.inmo.tgbotapi.requests.abstracts.Request
+import dev.inmo.tgbotapi.types.business_connection.BusinessConnection
+import dev.inmo.tgbotapi.types.payments.ShippingQuery
+import kotlinx.coroutines.flow.Flow
+
+suspend fun BehaviourContext.waitBusinessConnection(
+    initRequest: Request<*>,
+    errorFactory: NullableRequestBuilder<*> = { null }
+): Flow<BusinessConnection> = expectFlow(
+    initRequest,
+    errorFactory
+) {
+    (it.businessConnectionUpdateOrNull() ?.data).let(::listOfNotNull)
+}
+
+suspend fun BehaviourContext.waitBusinessConnectionEnabled(
+    initRequest: Request<*>,
+    errorFactory: NullableRequestBuilder<*> = { null }
+): Flow<BusinessConnection> = expectFlow(
+    initRequest,
+    errorFactory
+) {
+    (it.businessConnectionUpdateOrNull() ?.data ?.enabledOrNull()).let(::listOfNotNull)
+}
+
+suspend fun BehaviourContext.waitBusinessConnectionDisabled(
+    initRequest: Request<*>,
+    errorFactory: NullableRequestBuilder<*> = { null }
+): Flow<BusinessConnection> = expectFlow(
+    initRequest,
+    errorFactory
+) {
+    (it.businessConnectionUpdateOrNull() ?.data ?.disabledOrNull()).let(::listOfNotNull)
+}

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

@@ -0,0 +1,62 @@
+@file:Suppress("unused")
+
+package dev.inmo.tgbotapi.extensions.behaviour_builder.expectations
+
+import dev.inmo.tgbotapi.extensions.behaviour_builder.BehaviourContext
+import dev.inmo.tgbotapi.extensions.utils.callbackQueryUpdateOrNull
+import dev.inmo.tgbotapi.requests.abstracts.Request
+import dev.inmo.tgbotapi.types.queries.callback.*
+import dev.inmo.tgbotapi.utils.RiskFeature
+import dev.inmo.tgbotapi.utils.lowLevelRiskFeatureMessage
+import kotlinx.coroutines.flow.Flow
+
+typealias CallbackQueryMapper<T> = suspend T.() -> T?
+
+@RiskFeature(lowLevelRiskFeatureMessage)
+suspend inline fun <reified O> BehaviourContext.waitCallbackQueries(
+    initRequest: Request<*>,
+    noinline errorFactory: NullableRequestBuilder<*> = { null }
+): Flow<O> = expectFlow(
+    initRequest,
+    errorFactory
+) {
+    (it.callbackQueryUpdateOrNull() ?.data as? O).let(::listOfNotNull)
+}
+
+
+suspend fun BehaviourContext.waitDataCallbackQuery(
+    initRequest: Request<*>,
+    errorFactory: NullableRequestBuilder<*> = { null }
+) = waitCallbackQueries<DataCallbackQuery>(initRequest, errorFactory)
+suspend fun BehaviourContext.waitGameShortNameCallbackQuery(
+    initRequest: Request<*>,
+    errorFactory: NullableRequestBuilder<*> = { null }
+) = waitCallbackQueries<GameShortNameCallbackQuery>(initRequest, errorFactory)
+suspend fun BehaviourContext.waitInlineMessageIdCallbackQuery(
+    initRequest: Request<*>,
+    errorFactory: NullableRequestBuilder<*> = { null }
+) = waitCallbackQueries<InlineMessageIdCallbackQuery>(initRequest, errorFactory)
+suspend fun BehaviourContext.waitInlineMessageIdDataCallbackQuery(
+    initRequest: Request<*>,
+    errorFactory: NullableRequestBuilder<*> = { null }
+) = waitCallbackQueries<InlineMessageIdDataCallbackQuery>(initRequest, errorFactory)
+suspend fun BehaviourContext.waitInlineMessageIdGameShortNameCallbackQuery(
+    initRequest: Request<*>,
+    errorFactory: NullableRequestBuilder<*> = { null }
+) = waitCallbackQueries<InlineMessageIdGameShortNameCallbackQuery>(initRequest, errorFactory)
+suspend fun BehaviourContext.waitMessageCallbackQuery(
+    initRequest: Request<*>,
+    errorFactory: NullableRequestBuilder<*> = { null }
+) = waitCallbackQueries<MessageCallbackQuery>(initRequest, errorFactory)
+suspend fun BehaviourContext.waitMessageDataCallbackQuery(
+    initRequest: Request<*>,
+    errorFactory: NullableRequestBuilder<*> = { null }
+) = waitCallbackQueries<MessageDataCallbackQuery>(initRequest, errorFactory)
+suspend fun BehaviourContext.waitMessageGameShortNameCallbackQuery(
+    initRequest: Request<*>,
+    errorFactory: NullableRequestBuilder<*> = { null }
+) = waitCallbackQueries<MessageGameShortNameCallbackQuery>(initRequest, errorFactory)
+suspend fun BehaviourContext.waitUnknownCallbackQuery(
+    initRequest: Request<*>,
+    errorFactory: NullableRequestBuilder<*> = { null }
+) = waitCallbackQueries<UnknownCallbackQueryType>(initRequest, errorFactory)

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

@@ -0,0 +1,17 @@
+package dev.inmo.tgbotapi.extensions.behaviour_builder.expectations
+
+import dev.inmo.tgbotapi.extensions.behaviour_builder.BehaviourContext
+import dev.inmo.tgbotapi.extensions.utils.chatBoostRemovedUpdateOrNull
+import dev.inmo.tgbotapi.requests.abstracts.Request
+import dev.inmo.tgbotapi.types.boosts.ChatBoostRemoved
+import kotlinx.coroutines.flow.Flow
+
+suspend fun BehaviourContext.waitChatBoostRemoved(
+    initRequest: Request<*>,
+    errorFactory: NullableRequestBuilder<*> = { null }
+): Flow<ChatBoostRemoved> = expectFlow(
+    initRequest,
+    errorFactory
+) {
+    it.chatBoostRemovedUpdateOrNull() ?.data.let(::listOfNotNull)
+}

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

@@ -0,0 +1,17 @@
+package dev.inmo.tgbotapi.extensions.behaviour_builder.expectations
+
+import dev.inmo.tgbotapi.extensions.behaviour_builder.BehaviourContext
+import dev.inmo.tgbotapi.extensions.utils.chatBoostUpdatedUpdateOrNull
+import dev.inmo.tgbotapi.requests.abstracts.Request
+import dev.inmo.tgbotapi.types.boosts.ChatBoostUpdated
+import kotlinx.coroutines.flow.Flow
+
+suspend fun BehaviourContext.waitChatBoostUpdated(
+    initRequest: Request<*>,
+    errorFactory: NullableRequestBuilder<*> = { null }
+): Flow<ChatBoostUpdated> = expectFlow(
+    initRequest,
+    errorFactory
+) {
+    it.chatBoostUpdatedUpdateOrNull() ?.data.let(::listOfNotNull)
+}

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

@@ -0,0 +1,31 @@
+package dev.inmo.tgbotapi.extensions.behaviour_builder.expectations
+
+import dev.inmo.tgbotapi.extensions.behaviour_builder.BehaviourContext
+import dev.inmo.tgbotapi.extensions.utils.chatJoinRequestUpdateOrNull
+import dev.inmo.tgbotapi.requests.abstracts.Request
+import dev.inmo.tgbotapi.types.chat.ChatJoinRequest
+import dev.inmo.tgbotapi.utils.RiskFeature
+import dev.inmo.tgbotapi.utils.lowLevelRiskFeatureMessage
+import kotlinx.coroutines.flow.Flow
+
+typealias ChatJoinRequestsMapper = suspend ChatJoinRequest.() -> ChatJoinRequest?
+
+@RiskFeature(lowLevelRiskFeatureMessage)
+suspend inline fun <reified O> BehaviourContext.internalWaitChatJoinRequests(
+    initRequest: Request<*>,
+    noinline errorFactory: NullableRequestBuilder<*> = { null }
+): Flow<O> = expectFlow(
+    initRequest,
+    errorFactory
+) {
+    (it.chatJoinRequestUpdateOrNull() ?.data as? O).let(::listOfNotNull)
+}
+
+
+suspend fun BehaviourContext.waitChatJoinRequests(
+    initRequest: Request<*>,
+    errorFactory: NullableRequestBuilder<*> = { null }
+) : Flow<ChatJoinRequest> = internalWaitChatJoinRequests(
+    initRequest,
+    errorFactory
+)

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

@@ -0,0 +1,257 @@
+package dev.inmo.tgbotapi.extensions.behaviour_builder.expectations
+
+import dev.inmo.tgbotapi.extensions.behaviour_builder.BehaviourContext
+import dev.inmo.tgbotapi.extensions.behaviour_builder.filters.*
+import dev.inmo.tgbotapi.extensions.behaviour_builder.triggers_handling.onChatMemberUpdatedInternal
+import dev.inmo.tgbotapi.extensions.behaviour_builder.utils.SimpleFilter
+import dev.inmo.tgbotapi.extensions.behaviour_builder.utils.marker_factories.ByChatChatMemberUpdatedMarkerFactory
+import dev.inmo.tgbotapi.extensions.behaviour_builder.utils.marker_factories.MarkerFactory
+import dev.inmo.tgbotapi.extensions.behaviour_builder.utils.times
+import dev.inmo.tgbotapi.requests.abstracts.Request
+import dev.inmo.tgbotapi.types.chat.member.ChatMemberUpdated
+import dev.inmo.tgbotapi.types.update.CommonChatMemberUpdatedUpdate
+import dev.inmo.tgbotapi.types.update.MyChatMemberUpdatedUpdate
+import dev.inmo.tgbotapi.types.update.abstracts.ChatMemberUpdatedUpdate
+import dev.inmo.tgbotapi.types.update.abstracts.Update
+import dev.inmo.tgbotapi.utils.RiskFeature
+import dev.inmo.tgbotapi.utils.lowLevelRiskFeatureMessage
+import kotlinx.coroutines.flow.Flow
+import kotlinx.coroutines.flow.filter
+
+typealias ChatMemberUpdatedMapper<T> = suspend T.() -> T?
+
+@RiskFeature(lowLevelRiskFeatureMessage)
+suspend inline fun <reified O : ChatMemberUpdatedUpdate> BehaviourContext.waitChatMemberUpdatedWithFilter(
+    initRequest: Request<*>,
+    noinline errorFactory: NullableRequestBuilder<*> = { null }
+): Flow<ChatMemberUpdated> = expectFlow(
+    initRequest,
+    errorFactory
+) {
+    (it as? O) ?.data.let(::listOfNotNull)
+}
+
+suspend fun BehaviourContext.waitChatMemberUpdated(
+    initRequest: Request<*>,
+    errorFactory: NullableRequestBuilder<*> = { null },
+) = waitChatMemberUpdatedWithFilter<ChatMemberUpdatedUpdate>(initRequest, errorFactory)
+
+suspend fun BehaviourContext.waitCommonChatMemberUpdated(
+    initRequest: Request<*>,
+    errorFactory: NullableRequestBuilder<*> = { null },
+) = waitChatMemberUpdatedWithFilter<CommonChatMemberUpdatedUpdate>(initRequest, errorFactory)
+
+suspend fun BehaviourContext.waitMyChatMemberUpdated(
+    initRequest: Request<*>,
+    errorFactory: NullableRequestBuilder<*> = { null }
+) = waitChatMemberUpdatedWithFilter<MyChatMemberUpdatedUpdate>(initRequest, errorFactory)
+
+suspend fun BehaviourContext.waitChatMemberJoined(
+    initRequest: Request<*>,
+    errorFactory: NullableRequestBuilder<*> = { null }
+) = waitChatMemberUpdated(initRequest, errorFactory).filter { chatMemberJoinedFilter(it) };
+
+suspend fun BehaviourContext.waitChatMemberLeft(
+    initRequest: Request<*>,
+    errorFactory: NullableRequestBuilder<*> = { null }
+) = waitChatMemberUpdated(initRequest, errorFactory).filter { chatMemberLeftFilter(it) };
+
+suspend fun BehaviourContext.waitChatMemberSubscribed(
+    initRequest: Request<*>,
+    errorFactory: NullableRequestBuilder<*> = { null }
+) = waitChatMemberUpdated(initRequest, errorFactory).filter { chatMemberSubscribedFilter(it) };
+
+suspend fun BehaviourContext.waitChatMemberSubscriptionChanged(
+    initRequest: Request<*>,
+    errorFactory: NullableRequestBuilder<*> = { null }
+) = waitChatMemberUpdated(initRequest, errorFactory).filter { chatMemberSubscriptionChangedFilter(it) };
+
+suspend fun BehaviourContext.waitChatMemberUnsubscribed(
+    initRequest: Request<*>,
+    errorFactory: NullableRequestBuilder<*> = { null }
+) = waitChatMemberUpdated(initRequest, errorFactory).filter { chatMemberUnsubscribedFilter(it) };
+
+suspend fun BehaviourContext.waitChatMemberGotPromoted(
+    initRequest: Request<*>,
+    errorFactory: NullableRequestBuilder<*> = { null }
+) = waitChatMemberUpdated(initRequest, errorFactory).filter { chatMemberGotPromotedFilter(it) };
+
+suspend fun BehaviourContext.waitChatMemberGotPromotionChanged(
+    initRequest: Request<*>,
+    errorFactory: NullableRequestBuilder<*> = { null }
+) = waitChatMemberUpdated(initRequest, errorFactory).filter { chatMemberGotPromotionChangedFilter(it) };
+
+suspend fun BehaviourContext.waitChatMemberGotDemoted(
+    initRequest: Request<*>,
+    errorFactory: NullableRequestBuilder<*> = { null }
+) = waitChatMemberUpdated(initRequest, errorFactory).filter { chatMemberGotDemotedFilter(it) };
+
+suspend fun BehaviourContext.waitChatMemberBecameOwner(
+    initRequest: Request<*>,
+    errorFactory: NullableRequestBuilder<*> = { null }
+) = waitChatMemberUpdated(initRequest, errorFactory).filter { chatMemberBecameOwnerFilter(it) };
+
+suspend fun BehaviourContext.waitChatMemberCeasedOwnership(
+    initRequest: Request<*>,
+    errorFactory: NullableRequestBuilder<*> = { null }
+) = waitChatMemberUpdated(initRequest, errorFactory).filter { chatMemberCeasedOwnershipFilter(it) };
+
+suspend fun BehaviourContext.waitChatMemberGotRestricted(
+    initRequest: Request<*>,
+    errorFactory: NullableRequestBuilder<*> = { null }
+) = waitChatMemberUpdated(initRequest, errorFactory).filter { chatMemberGotRestrictedFilter(it) };
+
+suspend fun BehaviourContext.waitChatMemberGotRestrictionChanged(
+    initRequest: Request<*>,
+    errorFactory: NullableRequestBuilder<*> = { null }
+) = waitChatMemberUpdated(initRequest, errorFactory).filter { chatMemberGotRestrictionsChangedFilter(it) };
+
+suspend fun BehaviourContext.waitChatMemberGotUnrestricted(
+    initRequest: Request<*>,
+    errorFactory: NullableRequestBuilder<*> = { null }
+) = waitChatMemberUpdated(initRequest, errorFactory).filter { chatMemberGotUnrestrictedFilter(it) };
+
+suspend fun BehaviourContext.waitChatMemberKicked(
+    initRequest: Request<*>,
+    errorFactory: NullableRequestBuilder<*> = { null }
+) = waitChatMemberUpdated(initRequest, errorFactory).filter { chatMemberKickedFilter(it) };
+
+suspend fun BehaviourContext.waitCommonChatMemberJoined(
+    initRequest: Request<*>,
+    errorFactory: NullableRequestBuilder<*> = { null }
+) = waitCommonChatMemberUpdated(initRequest, errorFactory).filter { chatMemberJoinedFilter(it) };
+
+suspend fun BehaviourContext.waitCommonChatMemberLeft(
+    initRequest: Request<*>,
+    errorFactory: NullableRequestBuilder<*> = { null }
+) = waitCommonChatMemberUpdated(initRequest, errorFactory).filter { chatMemberLeftFilter(it) };
+
+suspend fun BehaviourContext.waitCommonChatMemberSubscribed(
+    initRequest: Request<*>,
+    errorFactory: NullableRequestBuilder<*> = { null }
+) = waitCommonChatMemberUpdated(initRequest, errorFactory).filter { chatMemberSubscribedFilter(it) };
+
+suspend fun BehaviourContext.waitCommonChatMemberSubscriptionChanged(
+    initRequest: Request<*>,
+    errorFactory: NullableRequestBuilder<*> = { null }
+) = waitCommonChatMemberUpdated(initRequest, errorFactory).filter { chatMemberSubscriptionChangedFilter(it) };
+
+suspend fun BehaviourContext.waitCommonChatMemberUnsubscribed(
+    initRequest: Request<*>,
+    errorFactory: NullableRequestBuilder<*> = { null }
+) = waitCommonChatMemberUpdated(initRequest, errorFactory).filter { chatMemberUnsubscribedFilter(it) };
+
+suspend fun BehaviourContext.waitCommonChatMemberGotPromoted(
+    initRequest: Request<*>,
+    errorFactory: NullableRequestBuilder<*> = { null }
+) = waitCommonChatMemberUpdated(initRequest, errorFactory).filter { chatMemberGotPromotedFilter(it) };
+
+suspend fun BehaviourContext.waitCommonChatMemberGotPromotionChanged(
+    initRequest: Request<*>,
+    errorFactory: NullableRequestBuilder<*> = { null }
+) = waitCommonChatMemberUpdated(initRequest, errorFactory).filter { chatMemberGotPromotionChangedFilter(it) };
+
+suspend fun BehaviourContext.waitCommonChatMemberGotDemoted(
+    initRequest: Request<*>,
+    errorFactory: NullableRequestBuilder<*> = { null }
+) = waitCommonChatMemberUpdated(initRequest, errorFactory).filter { chatMemberGotDemotedFilter(it) };
+
+suspend fun BehaviourContext.waitCommonChatMemberBecameOwner(
+    initRequest: Request<*>,
+    errorFactory: NullableRequestBuilder<*> = { null }
+) = waitCommonChatMemberUpdated(initRequest, errorFactory).filter { chatMemberBecameOwnerFilter(it) };
+
+suspend fun BehaviourContext.waitCommonChatMemberCeasedOwnership(
+    initRequest: Request<*>,
+    errorFactory: NullableRequestBuilder<*> = { null }
+) = waitCommonChatMemberUpdated(initRequest, errorFactory).filter { chatMemberCeasedOwnershipFilter(it) };
+
+suspend fun BehaviourContext.waitCommonChatMemberGotRestricted(
+    initRequest: Request<*>,
+    errorFactory: NullableRequestBuilder<*> = { null }
+) = waitCommonChatMemberUpdated(initRequest, errorFactory).filter { chatMemberGotRestrictedFilter(it) };
+
+suspend fun BehaviourContext.waitCommonChatMemberGotRestrictionChanged(
+    initRequest: Request<*>,
+    errorFactory: NullableRequestBuilder<*> = { null }
+) = waitCommonChatMemberUpdated(initRequest, errorFactory).filter { chatMemberGotRestrictionsChangedFilter(it) };
+
+suspend fun BehaviourContext.waitCommonChatMemberGotUnrestricted(
+    initRequest: Request<*>,
+    errorFactory: NullableRequestBuilder<*> = { null }
+) = waitCommonChatMemberUpdated(initRequest, errorFactory).filter { chatMemberGotUnrestrictedFilter(it) };
+
+suspend fun BehaviourContext.waitCommonChatMemberKicked(
+    initRequest: Request<*>,
+    errorFactory: NullableRequestBuilder<*> = { null }
+) = waitCommonChatMemberUpdated(initRequest, errorFactory).filter { chatMemberKickedFilter(it) };
+
+suspend fun BehaviourContext.waitMyChatMemberJoined(
+    initRequest: Request<*>,
+    errorFactory: NullableRequestBuilder<*> = { null }
+) = waitMyChatMemberUpdated(initRequest, errorFactory).filter { chatMemberJoinedFilter(it) };
+
+suspend fun BehaviourContext.waitMyChatMemberLeft(
+    initRequest: Request<*>,
+    errorFactory: NullableRequestBuilder<*> = { null }
+) = waitMyChatMemberUpdated(initRequest, errorFactory).filter { chatMemberLeftFilter(it) };
+
+suspend fun BehaviourContext.waitMyChatMemberSubscribed(
+    initRequest: Request<*>,
+    errorFactory: NullableRequestBuilder<*> = { null }
+) = waitMyChatMemberUpdated(initRequest, errorFactory).filter { chatMemberSubscribedFilter(it) };
+
+suspend fun BehaviourContext.waitMyChatMemberSubscriptionChanged(
+    initRequest: Request<*>,
+    errorFactory: NullableRequestBuilder<*> = { null }
+) = waitMyChatMemberUpdated(initRequest, errorFactory).filter { chatMemberSubscriptionChangedFilter(it) };
+
+suspend fun BehaviourContext.waitMyChatMemberUnsubscribed(
+    initRequest: Request<*>,
+    errorFactory: NullableRequestBuilder<*> = { null }
+) = waitMyChatMemberUpdated(initRequest, errorFactory).filter { chatMemberUnsubscribedFilter(it) };
+
+suspend fun BehaviourContext.waitMyChatMemberGotPromoted(
+    initRequest: Request<*>,
+    errorFactory: NullableRequestBuilder<*> = { null }
+) = waitMyChatMemberUpdated(initRequest, errorFactory).filter { chatMemberGotPromotedFilter(it) };
+
+suspend fun BehaviourContext.waitMyChatMemberGotPromotionChanged(
+    initRequest: Request<*>,
+    errorFactory: NullableRequestBuilder<*> = { null }
+) = waitMyChatMemberUpdated(initRequest, errorFactory).filter { chatMemberGotPromotionChangedFilter(it) };
+
+suspend fun BehaviourContext.waitMyChatMemberGotDemoted(
+    initRequest: Request<*>,
+    errorFactory: NullableRequestBuilder<*> = { null }
+) = waitMyChatMemberUpdated(initRequest, errorFactory).filter { chatMemberGotDemotedFilter(it) };
+
+suspend fun BehaviourContext.waitMyChatMemberBecameOwner(
+    initRequest: Request<*>,
+    errorFactory: NullableRequestBuilder<*> = { null }
+) = waitMyChatMemberUpdated(initRequest, errorFactory).filter { chatMemberBecameOwnerFilter(it) };
+
+suspend fun BehaviourContext.waitMyChatMemberCeasedOwnership(
+    initRequest: Request<*>,
+    errorFactory: NullableRequestBuilder<*> = { null }
+) = waitMyChatMemberUpdated(initRequest, errorFactory).filter { chatMemberCeasedOwnershipFilter(it) };
+
+suspend fun BehaviourContext.waitMyChatMemberGotRestricted(
+    initRequest: Request<*>,
+    errorFactory: NullableRequestBuilder<*> = { null }
+) = waitMyChatMemberUpdated(initRequest, errorFactory).filter { chatMemberGotRestrictedFilter(it) };
+
+suspend fun BehaviourContext.waitMyChatMemberGotRestrictionChanged(
+    initRequest: Request<*>,
+    errorFactory: NullableRequestBuilder<*> = { null }
+) = waitMyChatMemberUpdated(initRequest, errorFactory).filter { chatMemberGotRestrictionsChangedFilter(it) };
+
+suspend fun BehaviourContext.waitMyChatMemberGotUnrestricted(
+    initRequest: Request<*>,
+    errorFactory: NullableRequestBuilder<*> = { null }
+) = waitMyChatMemberUpdated(initRequest, errorFactory).filter { chatMemberGotUnrestrictedFilter(it) };
+
+suspend fun BehaviourContext.waitMyChatMemberKicked(
+    initRequest: Request<*>,
+    errorFactory: NullableRequestBuilder<*> = { null }
+) = waitMyChatMemberUpdated(initRequest, errorFactory).filter { chatMemberKickedFilter(it) };

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

@@ -0,0 +1,31 @@
+package dev.inmo.tgbotapi.extensions.behaviour_builder.expectations
+
+import dev.inmo.tgbotapi.extensions.behaviour_builder.BehaviourContext
+import dev.inmo.tgbotapi.extensions.utils.chatMessageReactionUpdatedUpdateOrNull
+import dev.inmo.tgbotapi.requests.abstracts.Request
+import dev.inmo.tgbotapi.types.chat.ChatMessageReactionUpdated
+import dev.inmo.tgbotapi.utils.RiskFeature
+import dev.inmo.tgbotapi.utils.lowLevelRiskFeatureMessage
+import kotlinx.coroutines.flow.Flow
+
+@RiskFeature(lowLevelRiskFeatureMessage)
+suspend inline fun <reified O : ChatMessageReactionUpdated> BehaviourContext.waitChatMessageReactionUpdated(
+    initRequest: Request<*>,
+    noinline errorFactory: NullableRequestBuilder<*> = { null }
+): Flow<O> = expectFlow(
+    initRequest,
+    errorFactory
+) {
+    (it.chatMessageReactionUpdatedUpdateOrNull() ?.data as? O).let(::listOfNotNull)
+}
+
+suspend fun BehaviourContext.waitChatMessageReactionUpdatedByUser(
+    initRequest: Request<*>,
+    errorFactory: NullableRequestBuilder<*> = { null }
+) = waitChatMessageReactionUpdated<ChatMessageReactionUpdated.ByUser>(initRequest, errorFactory)
+
+
+suspend fun BehaviourContext.waitChatMessageReactionUpdatedByChat(
+    initRequest: Request<*>,
+    errorFactory: NullableRequestBuilder<*> = { null }
+) = waitChatMessageReactionUpdated<ChatMessageReactionUpdated.ByChat>(initRequest, errorFactory)

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

@@ -0,0 +1,21 @@
+package dev.inmo.tgbotapi.extensions.behaviour_builder.expectations
+
+import dev.inmo.tgbotapi.extensions.behaviour_builder.BehaviourContext
+import dev.inmo.tgbotapi.extensions.utils.chatMessageReactionUpdatedUpdateOrNull
+import dev.inmo.tgbotapi.extensions.utils.chatMessageReactionsCountUpdatedUpdateOrNull
+import dev.inmo.tgbotapi.requests.abstracts.Request
+import dev.inmo.tgbotapi.types.chat.ChatMessageReactionUpdated
+import dev.inmo.tgbotapi.types.chat.ChatMessageReactionsCountUpdated
+import dev.inmo.tgbotapi.utils.RiskFeature
+import dev.inmo.tgbotapi.utils.lowLevelRiskFeatureMessage
+import kotlinx.coroutines.flow.Flow
+
+suspend inline fun BehaviourContext.waitChatMessageReactionsCountUpdated(
+    initRequest: Request<*>,
+    noinline errorFactory: NullableRequestBuilder<*> = { null }
+): Flow<ChatMessageReactionsCountUpdated> = expectFlow(
+    initRequest,
+    errorFactory
+) {
+    (it.chatMessageReactionsCountUpdatedUpdateOrNull() ?.data).let(::listOfNotNull)
+}

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

@@ -0,0 +1,37 @@
+package dev.inmo.tgbotapi.extensions.behaviour_builder.expectations
+
+import dev.inmo.tgbotapi.extensions.behaviour_builder.BehaviourContext
+import dev.inmo.tgbotapi.extensions.utils.chosenInlineResultUpdateOrNull
+import dev.inmo.tgbotapi.requests.abstracts.Request
+import dev.inmo.tgbotapi.types.InlineQueries.ChosenInlineResult.*
+import dev.inmo.tgbotapi.utils.RiskFeature
+import dev.inmo.tgbotapi.utils.lowLevelRiskFeatureMessage
+import kotlinx.coroutines.flow.Flow
+
+typealias ChosenInlineResultMapper<T> = suspend T.() -> T?
+
+@RiskFeature(lowLevelRiskFeatureMessage)
+suspend inline fun <reified O> BehaviourContext.waitChosenInlineResults(
+    initRequest: Request<*>,
+    noinline errorFactory: NullableRequestBuilder<*> = { null }
+): Flow<O> = expectFlow(
+    initRequest,
+    errorFactory
+) {
+    (it.chosenInlineResultUpdateOrNull() ?.data as? O).let(::listOfNotNull)
+}
+
+suspend fun BehaviourContext.waitChosenInlineResult(
+    initRequest: Request<*>,
+    errorFactory: NullableRequestBuilder<*> = { null }
+) = waitChosenInlineResults<ChosenInlineResult>(initRequest, errorFactory)
+
+suspend fun BehaviourContext.waitLocationChosenInlineResult(
+    initRequest: Request<*>,
+    errorFactory: NullableRequestBuilder<*> = { null }
+) = waitChosenInlineResults<LocationChosenInlineResult>(initRequest, errorFactory)
+
+suspend fun BehaviourContext.waitBaseChosenInlineResult(
+    initRequest: Request<*>,
+    errorFactory: NullableRequestBuilder<*> = { null }
+) = waitChosenInlineResults<BaseChosenInlineResult>(initRequest, errorFactory)

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

@@ -0,0 +1,51 @@
+package dev.inmo.tgbotapi.extensions.behaviour_builder.expectations
+
+import dev.inmo.tgbotapi.extensions.behaviour_builder.BehaviourContext
+import dev.inmo.tgbotapi.extensions.behaviour_builder.utils.handlers_registrar.doWithRegistration
+import dev.inmo.tgbotapi.extensions.utils.*
+import dev.inmo.tgbotapi.extensions.utils.extensions.TelegramBotCommandsDefaults
+import dev.inmo.tgbotapi.extensions.utils.extensions.parseCommandsWithArgs
+import dev.inmo.tgbotapi.extensions.utils.extensions.parseCommandsWithArgsSources
+import dev.inmo.tgbotapi.extensions.utils.extensions.parseCommandsWithNamedArgs
+import dev.inmo.tgbotapi.requests.abstracts.Request
+import dev.inmo.tgbotapi.types.BotCommand
+import dev.inmo.tgbotapi.types.message.abstracts.CommonMessage
+import dev.inmo.tgbotapi.types.message.content.TextContent
+import dev.inmo.tgbotapi.types.message.textsources.BotCommandTextSource
+import dev.inmo.tgbotapi.types.message.textsources.TextSource
+import kotlinx.coroutines.flow.*
+
+/**
+ * Will filter all the messages and include required commands with [commandRegex].
+ *
+ * * In case you wish to get only the commands at the start of message, use [requireCommandAtStart]
+ * * In case you wish to exclude messages with more than one command, you may use [requireSingleCommand]
+ * * In case you wish to exclude messages with commands params, you may use [requireCommandsWithoutParams]
+ */
+suspend fun BehaviourContext.waitCommandMessage(
+    commandRegex: Regex,
+    initRequest: Request<*>,
+    errorFactory: NullableRequestBuilder<*> = { null }
+) = channelFlow {
+    triggersHolder.handleableCommandsHolder.doWithRegistration(
+        commandRegex
+    ) {
+        waitTextMessage(initRequest, errorFactory).filter {
+            it.content.textSources.any { it.botCommandTextSourceOrNull() ?.command ?.matches(commandRegex) == true }
+        }.collect {
+            send(it)
+        }
+    }
+}
+
+suspend fun BehaviourContext.waitCommandMessage(
+    command: String,
+    initRequest: Request<*>,
+    errorFactory: NullableRequestBuilder<*> = { null }
+) = waitCommandMessage(Regex(command), initRequest, errorFactory)
+
+suspend fun BehaviourContext.waitCommandMessage(
+    botCommand: BotCommand,
+    initRequest: Request<*>,
+    errorFactory: NullableRequestBuilder<*> = { null }
+) = waitCommandMessage(botCommand.command, initRequest, errorFactory)

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

@@ -0,0 +1,159 @@
+@file:Suppress("unused")
+
+package dev.inmo.tgbotapi.extensions.behaviour_builder.expectations
+
+import dev.inmo.tgbotapi.extensions.behaviour_builder.BehaviourContext
+import dev.inmo.tgbotapi.requests.abstracts.Request
+import dev.inmo.tgbotapi.types.giveaway.GiveawayPublicResults
+import dev.inmo.tgbotapi.types.message.abstracts.CommonMessage
+import dev.inmo.tgbotapi.types.message.content.*
+import dev.inmo.tgbotapi.utils.RiskFeature
+import dev.inmo.tgbotapi.utils.lowLevelRiskFeatureMessage
+import kotlinx.coroutines.flow.Flow
+import kotlinx.coroutines.flow.map
+import kotlinx.coroutines.flow.mapNotNull
+
+typealias CommonMessageToContentMapper<T> = suspend CommonMessage<T>.() -> T?
+
+@RiskFeature(lowLevelRiskFeatureMessage)
+suspend inline fun BehaviourContext.waitContent(
+    initRequest: Request<*>,
+    noinline errorFactory: NullableRequestBuilder<*> = { null }
+): Flow<MessageContent> = waitContentMessage(initRequest, errorFactory).map { it.content }
+
+suspend fun BehaviourContext.waitAnyContent(
+    initRequest: Request<*>,
+    errorFactory: NullableRequestBuilder<*> = { null }
+) = waitContent(initRequest, errorFactory)
+suspend fun BehaviourContext.waitTextedContent(
+    initRequest: Request<*>,
+    errorFactory: NullableRequestBuilder<*> = { null }
+) = waitContent(initRequest, errorFactory).mapContent<TextedContent>()
+suspend fun BehaviourContext.waitContact(
+    initRequest: Request<*>,
+    errorFactory: NullableRequestBuilder<*> = { null }
+) = waitContent(initRequest, errorFactory).mapContent<ContactContent>()
+suspend fun BehaviourContext.waitDice(
+    initRequest: Request<*>,
+    errorFactory: NullableRequestBuilder<*> = { null }
+) = waitContent(initRequest, errorFactory).mapContent<DiceContent>()
+suspend fun BehaviourContext.waitGame(
+    initRequest: Request<*>,
+    errorFactory: NullableRequestBuilder<*> = { null }
+) = waitContent(initRequest, errorFactory).mapContent<GameContent>()
+suspend fun BehaviourContext.waitLocation(
+    initRequest: Request<*>,
+    errorFactory: NullableRequestBuilder<*> = { null }
+) = waitContent(initRequest, errorFactory).mapContent<LocationContent>()
+suspend fun BehaviourContext.waitLiveLocation(
+    initRequest: Request<*>,
+    errorFactory: NullableRequestBuilder<*> = { null }
+) = waitContent(initRequest, errorFactory).mapContent<LiveLocationContent>()
+suspend fun BehaviourContext.waitStaticLocation(
+    initRequest: Request<*>,
+    errorFactory: NullableRequestBuilder<*> = { null }
+) = waitContent(initRequest, errorFactory).mapContent<StaticLocationContent>()
+suspend fun BehaviourContext.waitPoll(
+    initRequest: Request<*>,
+    errorFactory: NullableRequestBuilder<*> = { null }
+) = waitContent(initRequest, errorFactory).mapContent<PollContent>()
+suspend fun BehaviourContext.waitText(
+    initRequest: Request<*>,
+    errorFactory: NullableRequestBuilder<*> = { null }
+) = waitContent(initRequest, errorFactory).mapContent<TextContent>()
+suspend fun BehaviourContext.waitStory(
+    initRequest: Request<*>,
+    errorFactory: NullableRequestBuilder<*> = { null }
+) = waitContent(initRequest, errorFactory).mapContent<StoryContent>()
+suspend fun BehaviourContext.waitVenue(
+    initRequest: Request<*>,
+    errorFactory: NullableRequestBuilder<*> = { null }
+) = waitContent(initRequest, errorFactory).mapContent<VenueContent>()
+suspend fun BehaviourContext.waitAudioMediaGroupContent(
+    initRequest: Request<*>,
+    errorFactory: NullableRequestBuilder<*> = { null },
+) = waitContent(initRequest, errorFactory).mapContent<AudioMediaGroupPartContent>()
+suspend fun BehaviourContext.waitDocumentMediaGroupContent(
+    initRequest: Request<*>,
+    errorFactory: NullableRequestBuilder<*> = { null }
+) = waitContent(initRequest, errorFactory).mapContent<DocumentMediaGroupPartContent>()
+suspend fun BehaviourContext.waitMedia(
+    initRequest: Request<*>,
+    errorFactory: NullableRequestBuilder<*> = { null }
+) = waitContent(initRequest, errorFactory).mapContent<MediaContent>()
+suspend fun BehaviourContext.waitAnyMediaGroupContent(
+    initRequest: Request<*>,
+    errorFactory: NullableRequestBuilder<*> = { null },
+) = waitContent(initRequest, errorFactory).mapContent<MediaGroupPartContent>()
+suspend fun BehaviourContext.waitVisualMediaGroupContent(
+    initRequest: Request<*>,
+    errorFactory: NullableRequestBuilder<*> = { null },
+) = waitContent(initRequest, errorFactory).mapContent<VisualMediaGroupPartContent>()
+suspend fun BehaviourContext.waitTextedMediaContent(
+    initRequest: Request<*>,
+    errorFactory: NullableRequestBuilder<*> = { null },
+) = waitContent(initRequest, errorFactory).mapContent<TextedMediaContent>()
+suspend fun BehaviourContext.waitAnimation(
+    initRequest: Request<*>,
+    errorFactory: NullableRequestBuilder<*> = { null }
+) = waitContent(initRequest, errorFactory).mapContent<AnimationContent>()
+suspend fun BehaviourContext.waitAudio(
+    initRequest: Request<*>,
+    errorFactory: NullableRequestBuilder<*> = { null },
+) = waitContent(initRequest, errorFactory).mapContent<AudioContent>()
+suspend fun BehaviourContext.waitDocument(
+    initRequest: Request<*>,
+    errorFactory: NullableRequestBuilder<*> = { null },
+) = waitContent(initRequest, errorFactory).mapContent<DocumentContent>()
+suspend fun BehaviourContext.waitPhoto(
+    initRequest: Request<*>,
+    errorFactory: NullableRequestBuilder<*> = { null },
+) = waitContent(initRequest, errorFactory).mapContent<PhotoContent>()
+suspend fun BehaviourContext.waitSticker(
+    initRequest: Request<*>,
+    errorFactory: NullableRequestBuilder<*> = { null }
+) = waitContent(initRequest, errorFactory).mapContent<StickerContent>()
+suspend fun BehaviourContext.waitVideo(
+    initRequest: Request<*>,
+    errorFactory: NullableRequestBuilder<*> = { null }
+) = waitContent(initRequest, errorFactory).mapContent<VideoContent>()
+suspend fun BehaviourContext.waitVideoNote(
+    initRequest: Request<*>,
+    errorFactory: NullableRequestBuilder<*> = { null }
+) = waitContent(initRequest, errorFactory).mapContent<VideoNoteContent>()
+suspend fun BehaviourContext.waitVoice(
+    initRequest: Request<*>,
+    errorFactory: NullableRequestBuilder<*> = { null }
+) = waitContent(initRequest, errorFactory).mapContent<VoiceContent>()
+suspend fun BehaviourContext.waitInvoice(
+    initRequest: Request<*>,
+    errorFactory: NullableRequestBuilder<*> = { null }
+) = waitContent(initRequest, errorFactory).mapContent<InvoiceContent>()
+suspend fun BehaviourContext.waitVisualContent(
+    initRequest: Request<*>,
+    errorFactory: NullableRequestBuilder<*> = { null }
+) = waitContent(initRequest, errorFactory).mapContent<VisualMediaGroupPartContent>()
+suspend fun BehaviourContext.waitMediaContent(
+    initRequest: Request<*>,
+    errorFactory: NullableRequestBuilder<*> = { null }
+) = waitContent(initRequest, errorFactory).mapContent<MediaContent>()
+
+suspend fun BehaviourContext.waitGiveawayContent(
+    initRequest: Request<*>,
+    errorFactory: NullableRequestBuilder<*> = { null }
+) = waitContent(initRequest, errorFactory).mapContent<GiveawayContent>()
+
+suspend fun BehaviourContext.waitGiveawayPublicResultsContent(
+    initRequest: Request<*>,
+    errorFactory: NullableRequestBuilder<*> = { null }
+) = waitContent(initRequest, errorFactory).mapContent<GiveawayPublicResultsContent>()
+
+suspend fun BehaviourContext.waitGiveawayWinners(
+    initRequest: Request<*>,
+    errorFactory: NullableRequestBuilder<*> = { null }
+) = waitGiveawayPublicResultsContent(initRequest, errorFactory)
+
+suspend fun BehaviourContext.waitPaidMediaInfoContent(
+    initRequest: Request<*>,
+    errorFactory: NullableRequestBuilder<*> = { null }
+) = waitContent(initRequest, errorFactory).mapContent<PaidMediaInfoContent>()

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

@@ -0,0 +1,167 @@
+@file:Suppress("unused")
+
+package dev.inmo.tgbotapi.extensions.behaviour_builder.expectations
+
+import dev.inmo.tgbotapi.extensions.behaviour_builder.BehaviourContext
+import dev.inmo.tgbotapi.extensions.utils.withContentOrNull
+import dev.inmo.tgbotapi.requests.abstracts.Request
+import dev.inmo.tgbotapi.types.message.abstracts.CommonMessage
+import dev.inmo.tgbotapi.types.message.content.*
+import dev.inmo.tgbotapi.types.update.abstracts.BaseSentMessageUpdate
+import dev.inmo.tgbotapi.utils.RiskFeature
+import dev.inmo.tgbotapi.utils.lowLevelRiskFeatureMessage
+import kotlinx.coroutines.flow.Flow
+import kotlinx.coroutines.flow.mapNotNull
+
+@RiskFeature(lowLevelRiskFeatureMessage)
+suspend inline fun BehaviourContext.waitContentMessage(
+    initRequest: Request<*>,
+    noinline errorFactory: NullableRequestBuilder<*> = { null }
+): Flow<CommonMessage<MessageContent>> = expectFlow(
+    initRequest,
+    errorFactory
+) {
+    if (it !is BaseSentMessageUpdate) {
+        return@expectFlow emptyList()
+    }
+    listOfNotNull((it.data as? CommonMessage<*>))
+}
+
+suspend fun BehaviourContext.waitAnyContentMessage(
+    initRequest: Request<*>,
+    errorFactory: NullableRequestBuilder<*> = { null },
+) = waitContentMessage(initRequest, errorFactory)
+suspend fun BehaviourContext.waitTextedContentMessage(
+    initRequest: Request<*>,
+    errorFactory: NullableRequestBuilder<*> = { null },
+) = waitContentMessage(initRequest, errorFactory).mapWithContent<TextedContent>()
+suspend fun BehaviourContext.waitContactMessage(
+    initRequest: Request<*>,
+    errorFactory: NullableRequestBuilder<*> = { null }
+) = waitContentMessage(initRequest, errorFactory).mapWithContent<ContactContent>()
+suspend fun BehaviourContext.waitDiceMessage(
+    initRequest: Request<*>,
+    errorFactory: NullableRequestBuilder<*> = { null }
+) = waitContentMessage(initRequest, errorFactory).mapWithContent<DiceContent>()
+suspend fun BehaviourContext.waitGameMessage(
+    initRequest: Request<*>,
+    errorFactory: NullableRequestBuilder<*> = { null }
+) = waitContentMessage(initRequest, errorFactory).mapWithContent<GameContent>()
+suspend fun BehaviourContext.waitLocationMessage(
+    initRequest: Request<*>,
+    errorFactory: NullableRequestBuilder<*> = { null }
+) = waitContentMessage(initRequest, errorFactory).mapWithContent<LocationContent>()
+suspend fun BehaviourContext.waitLiveLocationMessage(
+    initRequest: Request<*>,
+    errorFactory: NullableRequestBuilder<*> = { null }
+) = waitContentMessage(initRequest, errorFactory).mapWithContent<LiveLocationContent>()
+suspend fun BehaviourContext.waitStaticLocationMessage(
+    initRequest: Request<*>,
+    errorFactory: NullableRequestBuilder<*> = { null }
+) = waitContentMessage(initRequest, errorFactory).mapWithContent<StaticLocationContent>()
+suspend fun BehaviourContext.waitPollMessage(
+    initRequest: Request<*>,
+    errorFactory: NullableRequestBuilder<*> = { null }
+) = waitContentMessage(initRequest, errorFactory).mapWithContent<PollContent>()
+suspend fun BehaviourContext.waitTextMessage(
+    initRequest: Request<*>,
+    errorFactory: NullableRequestBuilder<*> = { null }
+) = waitContentMessage(initRequest, errorFactory).mapWithContent<TextContent>()
+suspend fun BehaviourContext.waitStoryMessage(
+    initRequest: Request<*>,
+    errorFactory: NullableRequestBuilder<*> = { null }
+) = waitContentMessage(initRequest, errorFactory).mapWithContent<StoryContent>()
+suspend fun BehaviourContext.waitVenueMessage(
+    initRequest: Request<*>,
+    errorFactory: NullableRequestBuilder<*> = { null }
+) = waitContentMessage(initRequest, errorFactory).mapWithContent<VenueContent>()
+suspend fun BehaviourContext.waitAudioMediaGroupContentMessage(
+    initRequest: Request<*>,
+    errorFactory: NullableRequestBuilder<*> = { null }
+) = waitContentMessage(initRequest, errorFactory).mapWithContent<AudioMediaGroupPartContent>()
+suspend fun BehaviourContext.waitDocumentMediaGroupContentMessage(
+    initRequest: Request<*>,
+    errorFactory: NullableRequestBuilder<*> = { null }
+) = waitContentMessage(initRequest, errorFactory).mapWithContent<DocumentMediaGroupPartContent>()
+suspend fun BehaviourContext.waitMediaMessage(
+    initRequest: Request<*>,
+    errorFactory: NullableRequestBuilder<*> = { null }
+) = waitContentMessage(initRequest, errorFactory).mapWithContent<MediaContent>()
+suspend fun BehaviourContext.waitAnyMediaGroupContentMessage(
+    initRequest: Request<*>,
+    errorFactory: NullableRequestBuilder<*> = { null }
+) = waitContentMessage(initRequest, errorFactory).mapWithContent<MediaGroupPartContent>()
+suspend fun BehaviourContext.waitVisualMediaGroupContentMessage(
+    initRequest: Request<*>,
+    errorFactory: NullableRequestBuilder<*> = { null }
+) = waitContentMessage(initRequest, errorFactory).mapWithContent<VisualMediaGroupPartContent>()
+suspend fun BehaviourContext.waitTextedMediaContentMessage(
+    initRequest: Request<*>,
+    errorFactory: NullableRequestBuilder<*> = { null }
+) = waitContentMessage(initRequest, errorFactory).mapWithContent<TextedMediaContent>()
+suspend fun BehaviourContext.waitAnimationMessage(
+    initRequest: Request<*>,
+    errorFactory: NullableRequestBuilder<*> = { null }
+) = waitContentMessage(initRequest, errorFactory).mapWithContent<AnimationContent>()
+suspend fun BehaviourContext.waitAudioMessage(
+    initRequest: Request<*>,
+    errorFactory: NullableRequestBuilder<*> = { null }
+) = waitContentMessage(initRequest, errorFactory).mapWithContent<AudioContent>()
+suspend fun BehaviourContext.waitDocumentMessage(
+    initRequest: Request<*>,
+    errorFactory: NullableRequestBuilder<*> = { null }
+) = waitContentMessage(initRequest, errorFactory).mapWithContent<DocumentContent>()
+suspend fun BehaviourContext.waitPhotoMessage(
+    initRequest: Request<*>,
+    errorFactory: NullableRequestBuilder<*> = { null }
+) = waitContentMessage(initRequest, errorFactory).mapWithContent<PhotoContent>()
+suspend fun BehaviourContext.waitStickerMessage(
+    initRequest: Request<*>,
+    errorFactory: NullableRequestBuilder<*> = { null }
+) = waitContentMessage(initRequest, errorFactory).mapWithContent<StickerContent>()
+suspend fun BehaviourContext.waitVideoMessage(
+    initRequest: Request<*>,
+    errorFactory: NullableRequestBuilder<*> = { null }
+) = waitContentMessage(initRequest, errorFactory).mapWithContent<VideoContent>()
+suspend fun BehaviourContext.waitVideoNoteMessage(
+    initRequest: Request<*>,
+    errorFactory: NullableRequestBuilder<*> = { null }
+) = waitContentMessage(initRequest, errorFactory).mapWithContent<VideoNoteContent>()
+suspend fun BehaviourContext.waitVoiceMessage(
+    initRequest: Request<*>,
+    errorFactory: NullableRequestBuilder<*> = { null }
+) = waitContentMessage(initRequest, errorFactory).mapWithContent<VoiceContent>()
+suspend fun BehaviourContext.waitInvoiceMessage(
+    initRequest: Request<*>,
+    errorFactory: NullableRequestBuilder<*> = { null }
+) = waitContentMessage(initRequest, errorFactory).mapWithContent<InvoiceContent>()
+
+suspend fun BehaviourContext.waitVisualContentMessage(
+    initRequest: Request<*>,
+    errorFactory: NullableRequestBuilder<*> = { null }
+) = waitContentMessage(initRequest, errorFactory).mapWithContent<VisualMediaGroupPartContent>()
+
+suspend fun BehaviourContext.waitMediaContentMessage(
+    initRequest: Request<*>,
+    errorFactory: NullableRequestBuilder<*> = { null }
+) = waitContentMessage(initRequest, errorFactory).mapWithContent<MediaContent>()
+
+suspend fun BehaviourContext.waitGiveawayContentMessage(
+    initRequest: Request<*>,
+    errorFactory: NullableRequestBuilder<*> = { null }
+) = waitContentMessage(initRequest, errorFactory).mapWithContent<GiveawayContent>()
+
+suspend fun BehaviourContext.waitGiveawayPublicResultsContentMessage(
+    initRequest: Request<*>,
+    errorFactory: NullableRequestBuilder<*> = { null }
+) = waitContentMessage(initRequest, errorFactory).mapWithContent<GiveawayPublicResultsContent>()
+
+suspend fun BehaviourContext.waitGiveawayWinnersMessage(
+    initRequest: Request<*>,
+    errorFactory: NullableRequestBuilder<*> = { null }
+) = waitGiveawayPublicResultsContentMessage(initRequest, errorFactory)
+
+suspend fun BehaviourContext.waitPaidMediaInfoContentMessage(
+    initRequest: Request<*>,
+    errorFactory: NullableRequestBuilder<*> = { null }
+) = waitContentMessage(initRequest, errorFactory).mapWithContent<PaidMediaInfoContent>()

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

@@ -0,0 +1,37 @@
+package dev.inmo.tgbotapi.extensions.behaviour_builder.expectations
+
+import dev.inmo.tgbotapi.extensions.behaviour_builder.BehaviourContext
+import dev.inmo.tgbotapi.extensions.utils.regularTextSourceOrNull
+import dev.inmo.tgbotapi.requests.abstracts.Request
+import dev.inmo.tgbotapi.types.message.abstracts.CommonMessage
+import dev.inmo.tgbotapi.types.message.content.TextContent
+import dev.inmo.tgbotapi.types.message.textsources.RegularTextSource
+import kotlinx.coroutines.flow.*
+
+suspend fun BehaviourContext.waitDeepLinks(
+    initRequest: Request<*>,
+    errorFactory: NullableRequestBuilder<*> = { null },
+): Flow<Pair<CommonMessage<TextContent>, String>> = waitCommandMessage(
+    "start",
+    initRequest,
+    errorFactory
+)
+    .requireSingleCommand()
+    .requireCommandAtStart()
+    .flattenCommandsWithParams().mapNotNull {
+        it.first to (it.second.second.singleOrNull() ?.regularTextSourceOrNull() ?.source ?.removePrefix(" ") ?: return@mapNotNull null)
+    }
+
+suspend fun BehaviourContext.waitDeepLinks(
+    regex: Regex,
+    initRequest: Request<*>,
+    errorFactory: NullableRequestBuilder<*> = { null },
+): Flow<Pair<CommonMessage<TextContent>, String>> = waitDeepLinks(initRequest, errorFactory).filter {
+    regex.matches(it.second)
+}
+
+suspend fun BehaviourContext.waitDeepLinks(
+    deepLink: String,
+    initRequest: Request<*>,
+    errorFactory: NullableRequestBuilder<*> = { null },
+): Flow<Pair<CommonMessage<TextContent>, String>> = waitDeepLinks(Regex("^$deepLink$"), initRequest, errorFactory)

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

@@ -0,0 +1,19 @@
+package dev.inmo.tgbotapi.extensions.behaviour_builder.expectations
+
+import dev.inmo.tgbotapi.extensions.behaviour_builder.BehaviourContext
+import dev.inmo.tgbotapi.extensions.utils.*
+import dev.inmo.tgbotapi.requests.abstracts.Request
+import dev.inmo.tgbotapi.types.business_connection.BusinessConnection
+import dev.inmo.tgbotapi.types.business_connection.BusinessMessagesDeleted
+import dev.inmo.tgbotapi.types.payments.ShippingQuery
+import kotlinx.coroutines.flow.Flow
+
+suspend fun BehaviourContext.waitDeletedBusinessMessages(
+    initRequest: Request<*>,
+    errorFactory: NullableRequestBuilder<*> = { null }
+): Flow<BusinessMessagesDeleted> = expectFlow(
+    initRequest,
+    errorFactory
+) {
+    (it.deletedBusinessMessageUpdateOrNull() ?.data).let(::listOfNotNull)
+}

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

@@ -0,0 +1,130 @@
+@file:Suppress("unused")
+
+package dev.inmo.tgbotapi.extensions.behaviour_builder.expectations
+
+import dev.inmo.tgbotapi.extensions.behaviour_builder.BehaviourContext
+import dev.inmo.tgbotapi.requests.abstracts.Request
+import dev.inmo.tgbotapi.types.message.content.*
+import dev.inmo.tgbotapi.utils.RiskFeature
+import dev.inmo.tgbotapi.utils.lowLevelRiskFeatureMessage
+import kotlinx.coroutines.flow.Flow
+import kotlinx.coroutines.flow.map
+
+@RiskFeature(lowLevelRiskFeatureMessage)
+suspend inline fun <reified O : MessageContent> BehaviourContext.waitEditedContent(
+    initRequest: Request<*>,
+    noinline errorFactory: NullableRequestBuilder<*> = { null }
+): Flow<O> = waitEditedContentMessage<O>(initRequest, errorFactory).map { it.content }
+
+suspend fun BehaviourContext.waitEditedMessageContent(
+    initRequest: Request<*>,
+    errorFactory: NullableRequestBuilder<*> = { null },
+) = waitEditedContent<MessageContent>(initRequest, errorFactory)
+
+suspend fun BehaviourContext.waitEditedContentMessage(
+    initRequest: Request<*>,
+    errorFactory: NullableRequestBuilder<*> = { null },
+) = waitEditedContent<MessageContent>(initRequest, errorFactory)
+suspend fun BehaviourContext.waitEditedContact(
+    initRequest: Request<*>,
+    errorFactory: NullableRequestBuilder<*> = { null }
+) = waitEditedContent<ContactContent>(initRequest, errorFactory)
+suspend fun BehaviourContext.waitEditedDice(
+    initRequest: Request<*>,
+    errorFactory: NullableRequestBuilder<*> = { null }
+) = waitEditedContent<DiceContent>(initRequest, errorFactory)
+suspend fun BehaviourContext.waitEditedGame(
+    initRequest: Request<*>,
+    errorFactory: NullableRequestBuilder<*> = { null }
+) = waitEditedContent<GameContent>(initRequest, errorFactory)
+suspend fun BehaviourContext.waitEditedLocation(
+    initRequest: Request<*>,
+    errorFactory: NullableRequestBuilder<*> = { null }
+) = waitEditedContent<LocationContent>(initRequest, errorFactory)
+suspend fun BehaviourContext.waitEditedLiveLocation(
+    initRequest: Request<*>,
+    errorFactory: NullableRequestBuilder<*> = { null }
+) = waitEditedContent<LiveLocationContent>(initRequest, errorFactory)
+suspend fun BehaviourContext.waitEditedStaticLocation(
+    initRequest: Request<*>,
+    errorFactory: NullableRequestBuilder<*> = { null }
+) = waitEditedContent<StaticLocationContent>(initRequest, errorFactory)
+suspend fun BehaviourContext.waitEditedText(
+    initRequest: Request<*>,
+    errorFactory: NullableRequestBuilder<*> = { null }
+) = waitEditedContent<TextContent>(initRequest, errorFactory)
+suspend fun BehaviourContext.waitEditedVenue(
+    initRequest: Request<*>,
+    errorFactory: NullableRequestBuilder<*> = { null }
+) = waitEditedContent<VenueContent>(initRequest, errorFactory)
+suspend fun BehaviourContext.waitEditedAudioMediaGroupContent(
+    initRequest: Request<*>,
+    errorFactory: NullableRequestBuilder<*> = { null },
+) = waitEditedContent<AudioMediaGroupPartContent>(initRequest, errorFactory)
+suspend fun BehaviourContext.waitEditedDocumentMediaGroupContent(
+    initRequest: Request<*>,
+    errorFactory: NullableRequestBuilder<*> = { null },
+) = waitEditedContent<DocumentMediaGroupPartContent>(initRequest, errorFactory)
+suspend fun BehaviourContext.waitEditedMedia(
+    initRequest: Request<*>,
+    errorFactory: NullableRequestBuilder<*> = { null },
+) = waitEditedContent<MediaContent>(initRequest, errorFactory)
+suspend fun BehaviourContext.waitEditedAnyMediaGroupContent(
+    initRequest: Request<*>,
+    errorFactory: NullableRequestBuilder<*> = { null },
+) = waitEditedContent<MediaGroupPartContent>(initRequest, errorFactory)
+suspend fun BehaviourContext.waitEditedVisualMediaGroupContent(
+    initRequest: Request<*>,
+    errorFactory: NullableRequestBuilder<*> = { null },
+) = waitEditedContent<VisualMediaGroupPartContent>(initRequest, errorFactory)
+suspend fun BehaviourContext.waitEditedTextedMediaContent(
+    initRequest: Request<*>,
+    errorFactory: NullableRequestBuilder<*> = { null },
+) = waitEditedContent<TextedMediaContent>(initRequest, errorFactory)
+suspend fun BehaviourContext.waitEditedAnimation(
+    initRequest: Request<*>,
+    errorFactory: NullableRequestBuilder<*> = { null }
+) = waitEditedContent<AnimationContent>(initRequest, errorFactory)
+suspend fun BehaviourContext.waitEditedAudio(
+    initRequest: Request<*>,
+    errorFactory: NullableRequestBuilder<*> = { null },
+) = waitEditedContent<AudioContent>(initRequest, errorFactory)
+suspend fun BehaviourContext.waitEditedDocument(
+    initRequest: Request<*>,
+    errorFactory: NullableRequestBuilder<*> = { null },
+) = waitEditedContent<DocumentContent>(initRequest, errorFactory)
+suspend fun BehaviourContext.waitEditedPhoto(
+    initRequest: Request<*>,
+    errorFactory: NullableRequestBuilder<*> = { null },
+) = waitEditedContent<PhotoContent>(initRequest, errorFactory)
+suspend fun BehaviourContext.waitEditedSticker(
+    initRequest: Request<*>,
+    errorFactory: NullableRequestBuilder<*> = { null }
+) = waitEditedContent<StickerContent>(initRequest, errorFactory)
+suspend fun BehaviourContext.waitEditedVideo(
+    initRequest: Request<*>,
+    errorFactory: NullableRequestBuilder<*> = { null },
+) = waitEditedContent<VideoContent>(initRequest, errorFactory)
+suspend fun BehaviourContext.waitEditedVideoNote(
+    initRequest: Request<*>,
+    errorFactory: NullableRequestBuilder<*> = { null }
+) = waitEditedContent<VideoNoteContent>(initRequest, errorFactory)
+suspend fun BehaviourContext.waitEditedVoice(
+    initRequest: Request<*>,
+    errorFactory: NullableRequestBuilder<*> = { null }
+) = waitEditedContent<VoiceContent>(initRequest, errorFactory)
+suspend fun BehaviourContext.waitEditedInvoice(
+    initRequest: Request<*>,
+    errorFactory: NullableRequestBuilder<*> = { null }
+) = waitEditedContent<InvoiceContent>(initRequest, errorFactory)
+
+suspend fun BehaviourContext.waitEditedGiveawayContent(
+    initRequest: Request<*>,
+    errorFactory: NullableRequestBuilder<*> = { null }
+) = waitEditedContent<GiveawayContent>(initRequest, errorFactory)
+
+suspend fun BehaviourContext.waitEditedGiveawayPublicResultsContent(
+    initRequest: Request<*>,
+    errorFactory: NullableRequestBuilder<*> = { null }
+) = waitEditedContent<GiveawayPublicResultsContent>(initRequest, errorFactory)
+

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

@@ -0,0 +1,143 @@
+@file:Suppress("unused")
+
+package dev.inmo.tgbotapi.extensions.behaviour_builder.expectations
+
+import dev.inmo.tgbotapi.extensions.behaviour_builder.BehaviourContext
+import dev.inmo.tgbotapi.extensions.utils.commonMessageOrNull
+import dev.inmo.tgbotapi.extensions.utils.withContent
+import dev.inmo.tgbotapi.requests.abstracts.Request
+import dev.inmo.tgbotapi.types.message.abstracts.CommonMessage
+import dev.inmo.tgbotapi.types.message.content.*
+import dev.inmo.tgbotapi.types.update.abstracts.BaseEditMessageUpdate
+import dev.inmo.tgbotapi.utils.RiskFeature
+import dev.inmo.tgbotapi.utils.lowLevelRiskFeatureMessage
+import kotlinx.coroutines.flow.Flow
+
+@RiskFeature(lowLevelRiskFeatureMessage)
+suspend inline fun <reified O : MessageContent> BehaviourContext.waitEditedContentMessage(
+    initRequest: Request<*>,
+    noinline errorFactory: NullableRequestBuilder<*> = { null }
+): Flow<CommonMessage<O>> = expectFlow(
+    initRequest,
+    errorFactory
+) {
+    val messages = when (it) {
+        is BaseEditMessageUpdate -> {
+            val commonMessage = it.data.commonMessageOrNull() ?: return@expectFlow emptyList()
+            listOf(commonMessage)
+        }
+        else -> return@expectFlow emptyList()
+    }
+    messages.mapNotNull { message ->
+        (message as CommonMessage<*>).withContent<O>()
+    }
+}
+
+suspend fun BehaviourContext.waitEditedMessageContentMessage(
+    initRequest: Request<*>,
+    errorFactory: NullableRequestBuilder<*> = { null }
+) = waitEditedContentMessage<MessageContent>(initRequest, errorFactory)
+
+suspend fun BehaviourContext.waitEditedContactMessage(
+    initRequest: Request<*>,
+    errorFactory: NullableRequestBuilder<*> = { null }
+) = waitEditedContentMessage<ContactContent>(initRequest, errorFactory)
+suspend fun BehaviourContext.waitEditedDiceMessage(
+    initRequest: Request<*>,
+    errorFactory: NullableRequestBuilder<*> = { null }
+) = waitEditedContentMessage<DiceContent>(initRequest, errorFactory)
+suspend fun BehaviourContext.waitEditedGameMessage(
+    initRequest: Request<*>,
+    errorFactory: NullableRequestBuilder<*> = { null }
+) = waitEditedContentMessage<GameContent>(initRequest, errorFactory)
+suspend fun BehaviourContext.waitEditedLocationMessage(
+    initRequest: Request<*>,
+    errorFactory: NullableRequestBuilder<*> = { null }
+) = waitEditedContentMessage<LocationContent>(initRequest, errorFactory)
+suspend fun BehaviourContext.waitEditedLiveLocationMessage(
+    initRequest: Request<*>,
+    errorFactory: NullableRequestBuilder<*> = { null }
+) = waitEditedContentMessage<LiveLocationContent>(initRequest, errorFactory)
+suspend fun BehaviourContext.waitEditedStaticLocationMessage(
+    initRequest: Request<*>,
+    errorFactory: NullableRequestBuilder<*> = { null }
+) = waitEditedContentMessage<StaticLocationContent>(initRequest, errorFactory)
+suspend fun BehaviourContext.waitEditedTextMessage(
+    initRequest: Request<*>,
+    errorFactory: NullableRequestBuilder<*> = { null }
+) = waitEditedContentMessage<TextContent>(initRequest, errorFactory)
+suspend fun BehaviourContext.waitEditedVenueMessage(
+    initRequest: Request<*>,
+    errorFactory: NullableRequestBuilder<*> = { null }
+) = waitEditedContentMessage<VenueContent>(initRequest, errorFactory)
+suspend fun BehaviourContext.waitEditedAudioMediaGroupContentMessage(
+    initRequest: Request<*>,
+    errorFactory: NullableRequestBuilder<*> = { null }
+) = waitEditedContentMessage<AudioMediaGroupPartContent>(initRequest, errorFactory)
+suspend fun BehaviourContext.waitEditedDocumentMediaGroupContentMessage(
+    initRequest: Request<*>,
+    errorFactory: NullableRequestBuilder<*> = { null }
+) = waitEditedContentMessage<DocumentMediaGroupPartContent>(initRequest, errorFactory)
+suspend fun BehaviourContext.waitEditedMediaMessage(
+    initRequest: Request<*>,
+    errorFactory: NullableRequestBuilder<*> = { null },
+) = waitEditedContentMessage<MediaContent>(initRequest, errorFactory)
+suspend fun BehaviourContext.waitEditedAnyMediaGroupContentMessage(
+    initRequest: Request<*>,
+    errorFactory: NullableRequestBuilder<*> = { null }
+) = waitEditedContentMessage<MediaGroupPartContent>(initRequest, errorFactory)
+suspend fun BehaviourContext.waitEditedVisualMediaGroupContentMessage(
+    initRequest: Request<*>,
+    errorFactory: NullableRequestBuilder<*> = { null }
+) = waitEditedContentMessage<VisualMediaGroupPartContent>(initRequest, errorFactory)
+suspend fun BehaviourContext.waitEditedTextedMediaContentMessage(
+    initRequest: Request<*>,
+    errorFactory: NullableRequestBuilder<*> = { null }
+) = waitEditedContentMessage<TextedMediaContent>(initRequest, errorFactory)
+suspend fun BehaviourContext.waitEditedAnimationMessage(
+    initRequest: Request<*>,
+    errorFactory: NullableRequestBuilder<*> = { null }
+) = waitEditedContentMessage<AnimationContent>(initRequest, errorFactory)
+suspend fun BehaviourContext.waitEditedAudioMessage(
+    initRequest: Request<*>,
+    errorFactory: NullableRequestBuilder<*> = { null },
+) = waitEditedContentMessage<AudioContent>(initRequest, errorFactory)
+suspend fun BehaviourContext.waitEditedDocumentMessage(
+    initRequest: Request<*>,
+    errorFactory: NullableRequestBuilder<*> = { null },
+) = waitEditedContentMessage<DocumentContent>(initRequest, errorFactory)
+suspend fun BehaviourContext.waitEditedPhotoMessage(
+    initRequest: Request<*>,
+    errorFactory: NullableRequestBuilder<*> = { null },
+) = waitEditedContentMessage<PhotoContent>(initRequest, errorFactory)
+suspend fun BehaviourContext.waitEditedStickerMessage(
+    initRequest: Request<*>,
+    errorFactory: NullableRequestBuilder<*> = { null }
+) = waitEditedContentMessage<StickerContent>(initRequest, errorFactory)
+suspend fun BehaviourContext.waitEditedVideoMessage(
+    initRequest: Request<*>,
+    errorFactory: NullableRequestBuilder<*> = { null },
+) = waitEditedContentMessage<VideoContent>(initRequest, errorFactory)
+suspend fun BehaviourContext.waitEditedVideoNoteMessage(
+    initRequest: Request<*>,
+    errorFactory: NullableRequestBuilder<*> = { null }
+) = waitEditedContentMessage<VideoNoteContent>(initRequest, errorFactory)
+suspend fun BehaviourContext.waitEditedVoiceMessage(
+    initRequest: Request<*>,
+    errorFactory: NullableRequestBuilder<*> = { null }
+) = waitEditedContentMessage<VoiceContent>(initRequest, errorFactory)
+suspend fun BehaviourContext.waitEditedInvoiceMessage(
+    initRequest: Request<*>,
+    errorFactory: NullableRequestBuilder<*> = { null }
+) = waitEditedContentMessage<InvoiceContent>(initRequest, errorFactory)
+
+suspend fun BehaviourContext.waitEditedGiveawayContentMessage(
+    initRequest: Request<*>,
+    errorFactory: NullableRequestBuilder<*> = { null }
+) = waitEditedContentMessage<GiveawayContent>(initRequest, errorFactory)
+
+suspend fun BehaviourContext.waitEditedGiveawayPublicResultsContentMessage(
+    initRequest: Request<*>,
+    errorFactory: NullableRequestBuilder<*> = { null }
+) = waitEditedContentMessage<GiveawayPublicResultsContent>(initRequest, errorFactory)
+

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

@@ -0,0 +1,264 @@
+@file:Suppress("unused")
+
+package dev.inmo.tgbotapi.extensions.behaviour_builder.expectations
+
+import dev.inmo.tgbotapi.extensions.behaviour_builder.BehaviourContext
+import dev.inmo.tgbotapi.extensions.utils.*
+import dev.inmo.tgbotapi.requests.abstracts.Request
+import dev.inmo.tgbotapi.types.PaidMessagePriceChanged
+import dev.inmo.tgbotapi.types.chat.ChatBackground
+import dev.inmo.tgbotapi.types.gifts.GiftSentOrReceived
+import dev.inmo.tgbotapi.types.giveaway.GiveawayCreated
+import dev.inmo.tgbotapi.types.giveaway.GiveawayPrivateResults
+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.RefundedPaymentEvent
+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.UsersShared
+import dev.inmo.tgbotapi.utils.RiskFeature
+import dev.inmo.tgbotapi.utils.lowLevelRiskFeatureMessage
+import kotlinx.coroutines.flow.Flow
+import kotlinx.coroutines.flow.filter
+
+@RiskFeature(lowLevelRiskFeatureMessage)
+suspend inline fun <reified O : ChatEvent> BehaviourContext.waitEvents(
+    initRequest: Request<*>,
+    noinline errorFactory: NullableRequestBuilder<*> = { null }
+): Flow<O> = expectFlow(
+    initRequest,
+    errorFactory
+) {
+    it.baseSentMessageUpdateOrNull() ?.data ?.chatEventMessageOrNull() ?.withEvent<O>() ?.chatEvent.let(::listOfNotNull)
+}
+
+suspend fun BehaviourContext.waitChannelEvents(
+    initRequest: Request<*>,
+    errorFactory: NullableRequestBuilder<*> = { null }
+) = waitEvents<ChannelEvent>(initRequest, errorFactory)
+
+suspend fun BehaviourContext.waitPrivateEvents(
+    initRequest: Request<*>,
+    errorFactory: NullableRequestBuilder<*> = { null }
+) = waitEvents<PrivateEvent>(initRequest, errorFactory)
+
+suspend fun BehaviourContext.waitChatEvents(
+    initRequest: Request<*>,
+    errorFactory: NullableRequestBuilder<*> = { null }
+) = waitEvents<ChatEvent>(initRequest, errorFactory)
+
+
+suspend fun BehaviourContext.waitVideoChatEvents(
+    initRequest: Request<*>,
+    errorFactory: NullableRequestBuilder<*> = { null }
+) = waitEvents<VideoChatEvent>(initRequest, errorFactory)
+suspend fun BehaviourContext.waitVideoChatStartedEvents(
+    initRequest: Request<*>,
+    errorFactory: NullableRequestBuilder<*> = { null }
+) = waitEvents<VideoChatStarted>(initRequest, errorFactory)
+suspend fun BehaviourContext.waitVideoChatEndedEvents(
+    initRequest: Request<*>,
+    errorFactory: NullableRequestBuilder<*> = { null }
+) = waitEvents<VideoChatEnded>(initRequest, errorFactory)
+suspend fun BehaviourContext.waitVideoChatParticipantsInvitedEvents(
+    initRequest: Request<*>,
+    errorFactory: NullableRequestBuilder<*> = { null }
+) = waitEvents<VideoChatParticipantsInvited>(initRequest, errorFactory)
+
+suspend fun BehaviourContext.waitMessageAutoDeleteTimerChangedEvents(
+    initRequest: Request<*>,
+    errorFactory: NullableRequestBuilder<*> = { null }
+) = waitEvents<MessageAutoDeleteTimerChanged>(initRequest, errorFactory)
+
+
+suspend fun BehaviourContext.waitPublicChatEvents(
+    initRequest: Request<*>,
+    errorFactory: NullableRequestBuilder<*> = { null }
+) = waitEvents<PublicChatEvent>(initRequest, errorFactory)
+suspend fun BehaviourContext.waitCommonEvents(
+    initRequest: Request<*>,
+    errorFactory: NullableRequestBuilder<*> = { null }
+) = waitEvents<CommonEvent>(initRequest, errorFactory)
+
+suspend fun BehaviourContext.waitGroupEvents(
+    initRequest: Request<*>,
+    errorFactory: NullableRequestBuilder<*> = { null }
+) = waitEvents<GroupEvent>(initRequest, errorFactory)
+suspend fun BehaviourContext.waitSupergroupEvents(
+    initRequest: Request<*>,
+    errorFactory: NullableRequestBuilder<*> = { null }
+) = waitEvents<SupergroupEvent>(initRequest, errorFactory)
+
+suspend fun BehaviourContext.waitChannelChatCreatedEvents(
+    initRequest: Request<*>,
+    errorFactory: NullableRequestBuilder<*> = { null }
+) = waitEvents<ChannelChatCreated>(initRequest, errorFactory)
+suspend fun BehaviourContext.waitDeleteChatPhotoEvents(
+    initRequest: Request<*>,
+    errorFactory: NullableRequestBuilder<*> = { null }
+) = waitEvents<DeleteChatPhoto>(initRequest, errorFactory)
+suspend fun BehaviourContext.waitGroupChatCreatedEvents(
+    initRequest: Request<*>,
+    errorFactory: NullableRequestBuilder<*> = { null }
+) = waitEvents<GroupChatCreated>(initRequest, errorFactory)
+suspend fun BehaviourContext.waitLeftChatMemberEvents(
+    initRequest: Request<*>,
+    errorFactory: NullableRequestBuilder<*> = { null }
+) = waitEvents<LeftChatMemberEvent>(initRequest, errorFactory)
+suspend fun BehaviourContext.waitNewChatPhotoEvents(
+    initRequest: Request<*>,
+    errorFactory: NullableRequestBuilder<*> = { null }
+) = waitEvents<NewChatPhoto>(initRequest, errorFactory)
+suspend fun BehaviourContext.waitNewChatMembersEvents(
+    initRequest: Request<*>,
+    errorFactory: NullableRequestBuilder<*> = { null }
+) = waitEvents<NewChatMembers>(initRequest, errorFactory)
+suspend fun BehaviourContext.waitNewChatTitleEvents(
+    initRequest: Request<*>,
+    errorFactory: NullableRequestBuilder<*> = { null }
+) = waitEvents<NewChatTitle>(initRequest, errorFactory)
+suspend fun BehaviourContext.waitPinnedMessageEvents(
+    initRequest: Request<*>,
+    errorFactory: NullableRequestBuilder<*> = { null }
+) = waitEvents<PinnedMessage>(initRequest, errorFactory)
+suspend fun BehaviourContext.waitProximityAlertTriggeredEvents(
+    initRequest: Request<*>,
+    errorFactory: NullableRequestBuilder<*> = { null }
+) = waitEvents<ProximityAlertTriggered>(initRequest, errorFactory)
+suspend fun BehaviourContext.waitSupergroupChatCreatedEvents(
+    initRequest: Request<*>,
+    errorFactory: NullableRequestBuilder<*> = { null }
+) = waitEvents<SupergroupChatCreated>(initRequest, errorFactory)
+suspend fun BehaviourContext.waitSuccessfulPaymentEvents(
+    initRequest: Request<*>,
+    errorFactory: NullableRequestBuilder<*> = { null }
+) = waitEvents<SuccessfulPaymentEvent>(initRequest, errorFactory)
+suspend fun BehaviourContext.waitRefundedPaymentEvents(
+    initRequest: Request<*>,
+    errorFactory: NullableRequestBuilder<*> = { null }
+) = waitEvents<RefundedPaymentEvent>(initRequest, errorFactory)
+suspend fun BehaviourContext.waitUserLoggedInEvents(
+    initRequest: Request<*>,
+    errorFactory: NullableRequestBuilder<*> = { null }
+) = waitEvents<UserLoggedIn>(initRequest, errorFactory)
+suspend fun BehaviourContext.waitWebAppDataEvents(
+    initRequest: Request<*>,
+    errorFactory: NullableRequestBuilder<*> = { null }
+) = waitEvents<WebAppData>(initRequest, errorFactory)
+suspend fun BehaviourContext.waitForumTopicClosed(
+    initRequest: Request<*>,
+    errorFactory: NullableRequestBuilder<*> = { null }
+) = waitEvents<ForumTopicClosed>(initRequest, errorFactory)
+suspend fun BehaviourContext.waitForumTopicCreated(
+    initRequest: Request<*>,
+    errorFactory: NullableRequestBuilder<*> = { null }
+) = waitEvents<ForumTopicCreated>(initRequest, errorFactory)
+suspend fun BehaviourContext.waitForumTopicReopened(
+    initRequest: Request<*>,
+    errorFactory: NullableRequestBuilder<*> = { null }
+) = waitEvents<ForumTopicReopened>(initRequest, errorFactory)
+suspend fun BehaviourContext.waitForumTopicEdited(
+    initRequest: Request<*>,
+    errorFactory: NullableRequestBuilder<*> = { null }
+) = waitEvents<ForumTopicEdited>(initRequest, errorFactory)
+suspend fun BehaviourContext.waitGeneralForumTopicHidden(
+    initRequest: Request<*>,
+    errorFactory: NullableRequestBuilder<*> = { null }
+) = waitEvents<GeneralForumTopicHidden>(initRequest, errorFactory)
+suspend fun BehaviourContext.waitGeneralForumTopicUnhidden(
+    initRequest: Request<*>,
+    errorFactory: NullableRequestBuilder<*> = { null }
+) = waitEvents<GeneralForumTopicUnhidden>(initRequest, errorFactory)
+suspend fun BehaviourContext.waitWriteAccessAllowed(
+    initRequest: Request<*>,
+    errorFactory: NullableRequestBuilder<*> = { null }
+) = waitEvents<WriteAccessAllowed>(initRequest, errorFactory)
+suspend fun BehaviourContext.waitWriteAccessAllowedFromRequest(
+    initRequest: Request<*>,
+    errorFactory: NullableRequestBuilder<*> = { null }
+) = waitEvents<WriteAccessAllowed.FromRequest>(initRequest, errorFactory)
+
+suspend fun BehaviourContext.waitWriteAccessAllowedFromAttachmentMenu(
+    initRequest: Request<*>,
+    errorFactory: NullableRequestBuilder<*> = { null }
+) = waitEvents<WriteAccessAllowed.FromAttachmentMenu>(initRequest, errorFactory)
+
+suspend fun BehaviourContext.waitWriteAccessAllowedFromWebAppLink(
+    initRequest: Request<*>,
+    errorFactory: NullableRequestBuilder<*> = { null }
+) = waitEvents<WriteAccessAllowed.FromWebAppLink>(initRequest, errorFactory)
+
+suspend fun BehaviourContext.waitWriteAccessAllowedOther(
+    initRequest: Request<*>,
+    errorFactory: NullableRequestBuilder<*> = { null }
+) = waitEvents<WriteAccessAllowed.Other>(initRequest, errorFactory)
+
+suspend fun BehaviourContext.waitChatSharedRequest(
+    initRequest: Request<*>,
+    errorFactory: NullableRequestBuilder<*> = { null }
+) = waitEvents<ChatSharedRequest>(initRequest, errorFactory)
+
+suspend fun BehaviourContext.waitUsersShared(
+    initRequest: Request<*>,
+    errorFactory: NullableRequestBuilder<*> = { null }
+) = waitEvents<UsersShared>(initRequest, errorFactory)
+
+suspend fun BehaviourContext.waitUserShared(
+    initRequest: Request<*>,
+    errorFactory: NullableRequestBuilder<*> = { null }
+) = waitUsersShared(initRequest, errorFactory).filter { it.userIds.size == 1 }
+
+suspend fun BehaviourContext.waitChatShared(
+    initRequest: Request<*>,
+    errorFactory: NullableRequestBuilder<*> = { null }
+) = waitEvents<ChatShared>(initRequest, errorFactory)
+
+suspend fun BehaviourContext.waitChatBoostAdded(
+    initRequest: Request<*>,
+    errorFactory: NullableRequestBuilder<*> = { null }
+) = waitEvents<ChatBoostAdded>(initRequest, errorFactory)
+
+suspend fun BehaviourContext.waitChatBackgroundSet(
+    initRequest: Request<*>,
+    errorFactory: NullableRequestBuilder<*> = { null }
+) = waitEvents<ChatBackground>(initRequest, errorFactory)
+
+suspend fun BehaviourContext.waitGiveawayCreated(
+    initRequest: Request<*>,
+    errorFactory: NullableRequestBuilder<*> = { null }
+) = waitEvents<GiveawayCreated>(initRequest, errorFactory)
+
+suspend fun BehaviourContext.waitGiveawayCompleted(
+    initRequest: Request<*>,
+    errorFactory: NullableRequestBuilder<*> = { null }
+) = waitEvents<GiveawayPrivateResults>(initRequest, errorFactory)
+
+suspend fun BehaviourContext.waitGiveawayCompletedWithPrivateWinners(
+    initRequest: Request<*>,
+    errorFactory: NullableRequestBuilder<*> = { null }
+) = waitGiveawayCompleted(initRequest, errorFactory)
+
+suspend fun BehaviourContext.waitPaidMessagePriceChanged(
+    initRequest: Request<*>,
+    errorFactory: NullableRequestBuilder<*> = { null }
+) = waitEvents<PaidMessagePriceChanged>(initRequest, errorFactory)
+
+suspend fun BehaviourContext.waitRegularGiftSentOrReceived(
+    initRequest: Request<*>,
+    errorFactory: NullableRequestBuilder<*> = { null }
+) = waitEvents<GiftSentOrReceived.Regular>(initRequest, errorFactory)
+
+suspend fun BehaviourContext.waitUniqueGiftSentOrReceived(
+    initRequest: Request<*>,
+    errorFactory: NullableRequestBuilder<*> = { null }
+) = waitEvents<GiftSentOrReceived.Unique>(initRequest, errorFactory)

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

@@ -0,0 +1,243 @@
+@file:Suppress("unused")
+
+package dev.inmo.tgbotapi.extensions.behaviour_builder.expectations
+
+import dev.inmo.tgbotapi.extensions.behaviour_builder.BehaviourContext
+import dev.inmo.tgbotapi.extensions.utils.*
+import dev.inmo.tgbotapi.requests.abstracts.Request
+import dev.inmo.tgbotapi.types.PaidMessagePriceChanged
+import dev.inmo.tgbotapi.types.chat.ChatBackground
+import dev.inmo.tgbotapi.types.gifts.GiftSentOrReceived
+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.RefundedPaymentEvent
+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.UsersShared
+import dev.inmo.tgbotapi.utils.RiskFeature
+import dev.inmo.tgbotapi.utils.lowLevelRiskFeatureMessage
+import kotlinx.coroutines.flow.Flow
+import kotlinx.coroutines.flow.filter
+
+@RiskFeature(lowLevelRiskFeatureMessage)
+suspend inline fun <reified O : ChatEvent> BehaviourContext.waitEventsMessages(
+    initRequest: Request<*>,
+    noinline errorFactory: NullableRequestBuilder<*> = { null }
+): Flow<ChatEventMessage<O>> = expectFlow(
+    initRequest,
+    errorFactory
+) {
+    it.baseSentMessageUpdateOrNull() ?.data ?.chatEventMessageOrNull() ?.withEvent<O>().let(::listOfNotNull)
+}
+
+suspend fun BehaviourContext.waitChannelEventsMessages(
+    initRequest: Request<*>,
+    errorFactory: NullableRequestBuilder<*> = { null }
+) = waitEventsMessages<ChannelEvent>(initRequest, errorFactory)
+
+suspend fun BehaviourContext.waitPrivateEventsMessages(
+    initRequest: Request<*>,
+    errorFactory: NullableRequestBuilder<*> = { null }
+) = waitEventsMessages<PrivateEvent>(initRequest, errorFactory)
+
+suspend fun BehaviourContext.waitChatEventsMessages(
+    initRequest: Request<*>,
+    errorFactory: NullableRequestBuilder<*> = { null }
+) = waitEventsMessages<ChatEvent>(initRequest, errorFactory)
+
+suspend fun BehaviourContext.waitVideoChatEventsMessages(
+    initRequest: Request<*>,
+    errorFactory: NullableRequestBuilder<*> = { null }
+) = waitEventsMessages<VideoChatEvent>(initRequest, errorFactory)
+suspend fun BehaviourContext.waitVideoChatStartedEventsMessages(
+    initRequest: Request<*>,
+    errorFactory: NullableRequestBuilder<*> = { null }
+) = waitEventsMessages<VideoChatStarted>(initRequest, errorFactory)
+suspend fun BehaviourContext.waitVideoChatEndedEventsMessages(
+    initRequest: Request<*>,
+    errorFactory: NullableRequestBuilder<*> = { null }
+) = waitEventsMessages<VideoChatEnded>(initRequest, errorFactory)
+suspend fun BehaviourContext.waitVideoChatParticipantsInvitedEventsMessages(
+    initRequest: Request<*>,
+    errorFactory: NullableRequestBuilder<*> = { null }
+) = waitEventsMessages<VideoChatParticipantsInvited>(initRequest, errorFactory)
+
+suspend fun BehaviourContext.waitMessageAutoDeleteTimerChangedEventsMessages(
+    initRequest: Request<*>,
+    errorFactory: NullableRequestBuilder<*> = { null }
+) = waitEventsMessages<MessageAutoDeleteTimerChanged>(initRequest, errorFactory)
+
+
+suspend fun BehaviourContext.waitPublicChatEventsMessages(
+    initRequest: Request<*>,
+    errorFactory: NullableRequestBuilder<*> = { null }
+) = waitEventsMessages<PublicChatEvent>(initRequest, errorFactory)
+suspend fun BehaviourContext.waitCommonEventsMessages(
+    initRequest: Request<*>,
+    errorFactory: NullableRequestBuilder<*> = { null }
+) = waitEventsMessages<CommonEvent>(initRequest, errorFactory)
+
+suspend fun BehaviourContext.waitGroupEventsMessages(
+    initRequest: Request<*>,
+    errorFactory: NullableRequestBuilder<*> = { null }
+) = waitEventsMessages<GroupEvent>(initRequest, errorFactory)
+suspend fun BehaviourContext.waitSupergroupEventsMessages(
+    initRequest: Request<*>,
+    errorFactory: NullableRequestBuilder<*> = { null }
+) = waitEventsMessages<SupergroupEvent>(initRequest, errorFactory)
+
+suspend fun BehaviourContext.waitChannelChatCreatedEventsMessages(
+    initRequest: Request<*>,
+    errorFactory: NullableRequestBuilder<*> = { null }
+) = waitEventsMessages<ChannelChatCreated>(initRequest, errorFactory)
+suspend fun BehaviourContext.waitDeleteChatPhotoEventsMessages(
+    initRequest: Request<*>,
+    errorFactory: NullableRequestBuilder<*> = { null }
+) = waitEventsMessages<DeleteChatPhoto>(initRequest, errorFactory)
+suspend fun BehaviourContext.waitGroupChatCreatedEventsMessages(
+    initRequest: Request<*>,
+    errorFactory: NullableRequestBuilder<*> = { null }
+) = waitEventsMessages<GroupChatCreated>(initRequest, errorFactory)
+suspend fun BehaviourContext.waitLeftChatMemberEventsMessages(
+    initRequest: Request<*>,
+    errorFactory: NullableRequestBuilder<*> = { null }
+) = waitEventsMessages<LeftChatMemberEvent>(initRequest, errorFactory)
+suspend fun BehaviourContext.waitNewChatPhotoEventsMessages(
+    initRequest: Request<*>,
+    errorFactory: NullableRequestBuilder<*> = { null }
+) = waitEventsMessages<NewChatPhoto>(initRequest, errorFactory)
+suspend fun BehaviourContext.waitNewChatMembersEventsMessages(
+    initRequest: Request<*>,
+    errorFactory: NullableRequestBuilder<*> = { null }
+) = waitEventsMessages<NewChatMembers>(initRequest, errorFactory)
+suspend fun BehaviourContext.waitNewChatTitleEventsMessages(
+    initRequest: Request<*>,
+    errorFactory: NullableRequestBuilder<*> = { null }
+) = waitEventsMessages<NewChatTitle>(initRequest, errorFactory)
+suspend fun BehaviourContext.waitPinnedMessageEventsMessages(
+    initRequest: Request<*>,
+    errorFactory: NullableRequestBuilder<*> = { null }
+) = waitEventsMessages<PinnedMessage>(initRequest, errorFactory)
+suspend fun BehaviourContext.waitProximityAlertTriggeredEventsMessages(
+    initRequest: Request<*>,
+    errorFactory: NullableRequestBuilder<*> = { null }
+) = waitEventsMessages<ProximityAlertTriggered>(initRequest, errorFactory)
+suspend fun BehaviourContext.waitSupergroupChatCreatedEventsMessages(
+    initRequest: Request<*>,
+    errorFactory: NullableRequestBuilder<*> = { null }
+) = waitEventsMessages<SupergroupChatCreated>(initRequest, errorFactory)
+suspend fun BehaviourContext.waitSuccessfulPaymentEventsMessages(
+    initRequest: Request<*>,
+    errorFactory: NullableRequestBuilder<*> = { null }
+) = waitEventsMessages<SuccessfulPaymentEvent>(initRequest, errorFactory)
+suspend fun BehaviourContext.waitRefundedPaymentEventsMessages(
+    initRequest: Request<*>,
+    errorFactory: NullableRequestBuilder<*> = { null }
+) = waitEventsMessages<RefundedPaymentEvent>(initRequest, errorFactory)
+suspend fun BehaviourContext.waitUserLoggedInEventsMessages(
+    initRequest: Request<*>,
+    errorFactory: NullableRequestBuilder<*> = { null }
+) = waitEventsMessages<UserLoggedIn>(initRequest, errorFactory)
+suspend fun BehaviourContext.waitWebAppDataEventsMessages(
+    initRequest: Request<*>,
+    errorFactory: NullableRequestBuilder<*> = { null }
+) = waitEventsMessages<WebAppData>(initRequest, errorFactory)
+suspend fun BehaviourContext.waitForumTopicClosedEventsMessages(
+    initRequest: Request<*>,
+    errorFactory: NullableRequestBuilder<*> = { null }
+) = waitEventsMessages<ForumTopicClosed>(initRequest, errorFactory)
+suspend fun BehaviourContext.waitForumTopicCreatedEventsMessages(
+    initRequest: Request<*>,
+    errorFactory: NullableRequestBuilder<*> = { null }
+) = waitEventsMessages<ForumTopicCreated>(initRequest, errorFactory)
+suspend fun BehaviourContext.waitForumTopicReopenedEventsMessages(
+    initRequest: Request<*>,
+    errorFactory: NullableRequestBuilder<*> = { null }
+) = waitEventsMessages<ForumTopicReopened>(initRequest, errorFactory)
+suspend fun BehaviourContext.waitForumTopicEditedEventsMessages(
+    initRequest: Request<*>,
+    errorFactory: NullableRequestBuilder<*> = { null }
+) = waitEventsMessages<ForumTopicEdited>(initRequest, errorFactory)
+suspend fun BehaviourContext.waitGeneralForumTopicHiddenEventsMessages(
+    initRequest: Request<*>,
+    errorFactory: NullableRequestBuilder<*> = { null }
+) = waitEventsMessages<GeneralForumTopicHidden>(initRequest, errorFactory)
+suspend fun BehaviourContext.waitGeneralForumTopicUnhiddenEventsMessages(
+    initRequest: Request<*>,
+    errorFactory: NullableRequestBuilder<*> = { null }
+) = waitEventsMessages<GeneralForumTopicUnhidden>(initRequest, errorFactory)
+suspend fun BehaviourContext.waitWriteAccessAllowedEventsMessages(
+    initRequest: Request<*>,
+    errorFactory: NullableRequestBuilder<*> = { null }
+) = waitEventsMessages<WriteAccessAllowed>(initRequest, errorFactory)
+suspend fun BehaviourContext.waitWriteAccessAllowedFromRequestEventsMessages(
+    initRequest: Request<*>,
+    errorFactory: NullableRequestBuilder<*> = { null }
+) = waitEventsMessages<WriteAccessAllowed.FromRequest>(initRequest, errorFactory)
+suspend fun BehaviourContext.waitWriteAccessAllowedFromAttachmentMenuEventsMessages(
+    initRequest: Request<*>,
+    errorFactory: NullableRequestBuilder<*> = { null }
+) = waitEventsMessages<WriteAccessAllowed.FromAttachmentMenu>(initRequest, errorFactory)
+suspend fun BehaviourContext.waitWriteAccessAllowedFromWebAppLinkEventsMessages(
+    initRequest: Request<*>,
+    errorFactory: NullableRequestBuilder<*> = { null }
+) = waitEventsMessages<WriteAccessAllowed.FromWebAppLink>(initRequest, errorFactory)
+suspend fun BehaviourContext.waitWriteAccessAllowedOtherEventsMessages(
+    initRequest: Request<*>,
+    errorFactory: NullableRequestBuilder<*> = { null }
+) = waitEventsMessages<WriteAccessAllowed.Other>(initRequest, errorFactory)
+
+suspend fun BehaviourContext.waitChatSharedRequestEventsMessages(
+    initRequest: Request<*>,
+    errorFactory: NullableRequestBuilder<*> = { null }
+) = waitEventsMessages<ChatSharedRequest>(initRequest, errorFactory)
+
+suspend fun BehaviourContext.waitUsersSharedEventsMessages(
+    initRequest: Request<*>,
+    errorFactory: NullableRequestBuilder<*> = { null }
+) = waitEventsMessages<UsersShared>(initRequest, errorFactory)
+
+suspend fun BehaviourContext.waitUserSharedEventsMessages(
+    initRequest: Request<*>,
+    errorFactory: NullableRequestBuilder<*> = { null }
+) = waitUsersSharedEventsMessages(initRequest, errorFactory).filter { it.chatEvent.userIds.size == 1 }
+
+suspend fun BehaviourContext.waitChatSharedEventsMessages(
+    initRequest: Request<*>,
+    errorFactory: NullableRequestBuilder<*> = { null }
+) = waitEventsMessages<ChatShared>(initRequest, errorFactory)
+
+suspend fun BehaviourContext.waitChatBoostAddedEventsMessages(
+    initRequest: Request<*>,
+    errorFactory: NullableRequestBuilder<*> = { null }
+) = waitEventsMessages<ChatBoostAdded>(initRequest, errorFactory)
+
+suspend fun BehaviourContext.waitChatBackgroundSetEventsMessages(
+    initRequest: Request<*>,
+    errorFactory: NullableRequestBuilder<*> = { null }
+) = waitEventsMessages<ChatBackground>(initRequest, errorFactory)
+
+suspend fun BehaviourContext.waitPaidMessagePriceChangedMessages(
+    initRequest: Request<*>,
+    errorFactory: NullableRequestBuilder<*> = { null }
+) = waitEventsMessages<PaidMessagePriceChanged>(initRequest, errorFactory)
+
+suspend fun BehaviourContext.waitRegularGiftSentOrReceivedMessages(
+    initRequest: Request<*>,
+    errorFactory: NullableRequestBuilder<*> = { null }
+) = waitEventsMessages<GiftSentOrReceived.Regular>(initRequest, errorFactory)
+
+suspend fun BehaviourContext.waitUniqueGiftSentOrReceivedMessages(
+    initRequest: Request<*>,
+    errorFactory: NullableRequestBuilder<*> = { null }
+) = waitEventsMessages<GiftSentOrReceived.Unique>(initRequest, errorFactory)

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

@@ -0,0 +1,34 @@
+package dev.inmo.tgbotapi.extensions.behaviour_builder.expectations
+
+import dev.inmo.tgbotapi.extensions.behaviour_builder.BehaviourContext
+import dev.inmo.tgbotapi.extensions.utils.inlineQueryUpdateOrNull
+import dev.inmo.tgbotapi.requests.abstracts.Request
+import dev.inmo.tgbotapi.types.InlineQueries.query.*
+import dev.inmo.tgbotapi.utils.RiskFeature
+import dev.inmo.tgbotapi.utils.lowLevelRiskFeatureMessage
+import kotlinx.coroutines.flow.Flow
+
+@RiskFeature(lowLevelRiskFeatureMessage)
+suspend inline fun <reified O : InlineQuery> BehaviourContext.waitInlineQueries(
+    initRequest: Request<*>,
+    noinline errorFactory: NullableRequestBuilder<*> = { null }
+): Flow<O> = expectFlow(
+    initRequest,
+    errorFactory
+) {
+    (it.inlineQueryUpdateOrNull() ?.data as? O).let(::listOfNotNull)
+}
+
+suspend fun BehaviourContext.waitAnyInlineQuery(
+    initRequest: Request<*>,
+    errorFactory: NullableRequestBuilder<*> = { null }
+) = waitInlineQueries<InlineQuery>(initRequest, errorFactory)
+
+suspend fun BehaviourContext.waitBaseInlineQuery(
+    initRequest: Request<*>,
+    errorFactory: NullableRequestBuilder<*> = { null }
+) = waitInlineQueries<BaseInlineQuery>(initRequest, errorFactory)
+suspend fun BehaviourContext.waitLocationInlineQuery(
+    initRequest: Request<*>,
+    errorFactory: NullableRequestBuilder<*> = { null }
+) = waitInlineQueries<LocationInlineQuery>(initRequest, errorFactory)

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

@@ -0,0 +1,51 @@
+package dev.inmo.tgbotapi.extensions.behaviour_builder.expectations
+
+import dev.inmo.tgbotapi.extensions.behaviour_builder.BehaviourContext
+import dev.inmo.tgbotapi.extensions.utils.baseSentMessageUpdateOrNull
+import dev.inmo.tgbotapi.extensions.utils.commonMessageOrNull
+import dev.inmo.tgbotapi.extensions.utils.withContent
+import dev.inmo.tgbotapi.extensions.utils.withContentOrNull
+import dev.inmo.tgbotapi.requests.abstracts.Request
+import dev.inmo.tgbotapi.types.message.content.*
+import dev.inmo.tgbotapi.utils.RiskFeature
+import dev.inmo.tgbotapi.utils.lowLevelRiskFeatureMessage
+import kotlinx.coroutines.flow.Flow
+
+@RiskFeature(lowLevelRiskFeatureMessage)
+suspend inline fun <reified T : MediaGroupPartContent> BehaviourContext.buildMediaGroupWaiter(
+    initRequest: Request<*>,
+    noinline errorFactory: NullableRequestBuilder<*> = { null }
+): Flow<MediaGroupContent<T>> = flowsUpdatesFilter.expectFlow(bot, initRequest, errorFactory) { update ->
+    update.baseSentMessageUpdateOrNull() ?.data ?.commonMessageOrNull() ?.withContentOrNull<MediaGroupContent<*>>() ?.let { message ->
+        if (message.content.group.all { it is T }) {
+            listOf(message.content as MediaGroupContent<T>)
+        } else {
+            null
+        }
+    } ?: emptyList()
+}
+
+suspend fun BehaviourContext.waitMediaGroup(
+    initRequest: Request<*>,
+    errorFactory: NullableRequestBuilder<*> = { null }
+) = buildMediaGroupWaiter<MediaGroupPartContent>(initRequest, errorFactory)
+suspend fun BehaviourContext.waitPlaylist(
+    initRequest: Request<*>,
+    errorFactory: NullableRequestBuilder<*> = { null }
+) = buildMediaGroupWaiter<AudioMediaGroupPartContent>(initRequest, errorFactory)
+suspend fun BehaviourContext.waitDocumentsGroup(
+    initRequest: Request<*>,
+    errorFactory: NullableRequestBuilder<*> = { null }
+) = buildMediaGroupWaiter<DocumentMediaGroupPartContent>(initRequest, errorFactory)
+suspend fun BehaviourContext.waitVisualGallery(
+    initRequest: Request<*>,
+    errorFactory: NullableRequestBuilder<*> = { null }
+) = buildMediaGroupWaiter<VisualMediaGroupPartContent>(initRequest, errorFactory)
+suspend fun BehaviourContext.waitPhotoGallery(
+    initRequest: Request<*>,
+    errorFactory: NullableRequestBuilder<*> = { null }
+) = buildMediaGroupWaiter<PhotoContent>(initRequest, errorFactory)
+suspend fun BehaviourContext.waitVideoGallery(
+    initRequest: Request<*>,
+    errorFactory: NullableRequestBuilder<*> = { null }
+) = buildMediaGroupWaiter<VideoContent>(initRequest, errorFactory)

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

@@ -0,0 +1,51 @@
+package dev.inmo.tgbotapi.extensions.behaviour_builder.expectations
+
+import dev.inmo.tgbotapi.extensions.behaviour_builder.BehaviourContext
+import dev.inmo.tgbotapi.extensions.utils.baseSentMessageUpdateOrNull
+import dev.inmo.tgbotapi.extensions.utils.commonMessageOrNull
+import dev.inmo.tgbotapi.extensions.utils.withContent
+import dev.inmo.tgbotapi.extensions.utils.withContentOrNull
+import dev.inmo.tgbotapi.requests.abstracts.Request
+import dev.inmo.tgbotapi.types.message.content.*
+import dev.inmo.tgbotapi.utils.RiskFeature
+import dev.inmo.tgbotapi.utils.lowLevelRiskFeatureMessage
+import kotlinx.coroutines.flow.Flow
+
+@RiskFeature(lowLevelRiskFeatureMessage)
+suspend inline fun <reified T : MediaGroupPartContent> BehaviourContext.buildMediaGroupMessagesWaiter(
+    initRequest: Request<*>,
+    noinline errorFactory: NullableRequestBuilder<*> = { null }
+): Flow<MediaGroupMessage<T>> = flowsUpdatesFilter.expectFlow(bot, initRequest, errorFactory) { update ->
+    update.baseSentMessageUpdateOrNull() ?.data ?.commonMessageOrNull() ?.withContentOrNull<MediaGroupContent<*>>() ?.let { message ->
+        if (message.content.group.all { it is T }) {
+            listOf(message as MediaGroupMessage<T>)
+        } else {
+            null
+        }
+    } ?: emptyList()
+}
+
+suspend fun BehaviourContext.waitMediaGroupMessages(
+    initRequest: Request<*>,
+    errorFactory: NullableRequestBuilder<*> = { null }
+) = buildMediaGroupMessagesWaiter<MediaGroupPartContent>(initRequest, errorFactory)
+suspend fun BehaviourContext.waitPlaylistMessages(
+    initRequest: Request<*>,
+    errorFactory: NullableRequestBuilder<*> = { null }
+) = buildMediaGroupMessagesWaiter<AudioMediaGroupPartContent>(initRequest, errorFactory)
+suspend fun BehaviourContext.waitDocumentsGroupMessages(
+    initRequest: Request<*>,
+    errorFactory: NullableRequestBuilder<*> = { null }
+) = buildMediaGroupMessagesWaiter<DocumentMediaGroupPartContent>(initRequest, errorFactory)
+suspend fun BehaviourContext.waitVisualGalleryMessages(
+    initRequest: Request<*>,
+    errorFactory: NullableRequestBuilder<*> = { null }
+) = buildMediaGroupMessagesWaiter<VisualMediaGroupPartContent>(initRequest, errorFactory)
+suspend fun BehaviourContext.waitPhotoGalleryMessages(
+    initRequest: Request<*>,
+    errorFactory: NullableRequestBuilder<*> = { null }
+) = buildMediaGroupMessagesWaiter<PhotoContent>(initRequest, errorFactory)
+suspend fun BehaviourContext.waitVideoGalleryMessages(
+    initRequest: Request<*>,
+    errorFactory: NullableRequestBuilder<*> = { null }
+) = buildMediaGroupMessagesWaiter<VideoContent>(initRequest, errorFactory)

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

@@ -0,0 +1,52 @@
+package dev.inmo.tgbotapi.extensions.behaviour_builder.expectations
+
+import dev.inmo.tgbotapi.extensions.behaviour_builder.BehaviourContext
+import dev.inmo.tgbotapi.extensions.utils.whenMentionTextSource
+import dev.inmo.tgbotapi.extensions.utils.whenTextMentionTextSource
+import dev.inmo.tgbotapi.requests.abstracts.Request
+import dev.inmo.tgbotapi.types.UserId
+import dev.inmo.tgbotapi.types.Username
+import dev.inmo.tgbotapi.types.chat.User
+import dev.inmo.tgbotapi.types.message.abstracts.CommonMessage
+import dev.inmo.tgbotapi.types.message.content.MessageContent
+import dev.inmo.tgbotapi.types.message.content.TextedContent
+import kotlinx.coroutines.flow.Flow
+import kotlinx.coroutines.flow.filter
+
+/**
+ * Creates cold [Flow] with the messages with [TextedContent] where [username] has been mentioned
+ *
+ * @see filterMentions
+ * @see filterTextMentions
+ */
+suspend fun BehaviourContext.waitContentWithMentions (
+    username: Username,
+    initRequest: Request<*>,
+    errorFactory: NullableRequestBuilder<*> = { null }
+) = waitContent(initRequest, errorFactory).mapContent<TextedContent>().filterMentions(username)
+
+/**
+ * Creates cold [Flow] with the messages with [TextedContent] where [userId] has been mentioned with text
+ *
+ * @see filterTextMentions
+ * @see filterMentions
+ * @see dev.inmo.tgbotapi.types.message.textsources.TextMentionTextSource
+ */
+suspend fun BehaviourContext.waitContentWithTextMentions (
+    userId: UserId,
+    initRequest: Request<*>,
+    errorFactory: NullableRequestBuilder<*> = { null }
+) = waitTextedContent(initRequest, errorFactory).filterTextMentions(userId)
+
+/**
+ * Creates cold [Flow] with the messages with [TextedContent] where [user] has been mentioned as text or mentioned
+ * with text
+ *
+ * @see filterMentions
+ * @see filterTextMentions
+ */
+suspend fun BehaviourContext.waitContentWithMentions (
+    user: User,
+    initRequest: Request<*>,
+    errorFactory: NullableRequestBuilder<*> = { null }
+) = waitTextedContent(initRequest, errorFactory).filterMentions(user)

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

@@ -0,0 +1,51 @@
+package dev.inmo.tgbotapi.extensions.behaviour_builder.expectations
+
+import dev.inmo.tgbotapi.extensions.behaviour_builder.BehaviourContext
+import dev.inmo.tgbotapi.extensions.utils.whenMentionTextSource
+import dev.inmo.tgbotapi.extensions.utils.whenTextMentionTextSource
+import dev.inmo.tgbotapi.requests.abstracts.Request
+import dev.inmo.tgbotapi.types.UserId
+import dev.inmo.tgbotapi.types.Username
+import dev.inmo.tgbotapi.types.chat.User
+import dev.inmo.tgbotapi.types.message.abstracts.CommonMessage
+import dev.inmo.tgbotapi.types.message.content.TextedContent
+import kotlinx.coroutines.flow.Flow
+import kotlinx.coroutines.flow.filter
+
+/**
+ * Creates cold [Flow] with the messages with [TextedContent] where [username] has been mentioned
+ *
+ * @see filterMentions
+ * @see filterTextMentions
+ */
+suspend fun BehaviourContext.waitContentMessageWithMentions (
+    username: Username,
+    initRequest: Request<*>,
+    errorFactory: NullableRequestBuilder<*> = { null }
+) = waitContentMessage(initRequest, errorFactory).mapWithContent<TextedContent>().filterMentionsMessages(username)
+
+/**
+ * Creates cold [Flow] with the messages with [TextedContent] where [userId] has been mentioned with text
+ *
+ * @see filterTextMentions
+ * @see filterMentions
+ * @see dev.inmo.tgbotapi.types.message.textsources.TextMentionTextSource
+ */
+suspend fun BehaviourContext.waitContentMessageWithTextMentions (
+    userId: UserId,
+    initRequest: Request<*>,
+    errorFactory: NullableRequestBuilder<*> = { null }
+) = waitTextedContentMessage(initRequest, errorFactory).filterTextMentionsMessages(userId)
+
+/**
+ * Creates cold [Flow] with the messages with [TextedContent] where [user] has been mentioned as text or mentioned
+ * with text
+ *
+ * @see filterMentions
+ * @see filterTextMentions
+ */
+suspend fun BehaviourContext.waitContentMessageWithMentions (
+    user: User,
+    initRequest: Request<*>,
+    errorFactory: NullableRequestBuilder<*> = { null }
+) = waitTextedContentMessage(initRequest, errorFactory).filterMentionsMessages(user)

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

@@ -0,0 +1,44 @@
+package dev.inmo.tgbotapi.extensions.behaviour_builder.expectations
+
+import dev.inmo.tgbotapi.extensions.behaviour_builder.BehaviourContext
+import dev.inmo.tgbotapi.extensions.utils.businessConnectionUpdateOrNull
+import dev.inmo.tgbotapi.extensions.utils.disabledOrNull
+import dev.inmo.tgbotapi.extensions.utils.enabledOrNull
+import dev.inmo.tgbotapi.extensions.utils.paidMediaPurchasedUpdateOrNull
+import dev.inmo.tgbotapi.requests.abstracts.Request
+import dev.inmo.tgbotapi.types.PaidMediaPayload
+import dev.inmo.tgbotapi.types.business_connection.BusinessConnection
+import dev.inmo.tgbotapi.types.message.payments.PaidMediaPurchased
+import kotlinx.coroutines.flow.Flow
+
+suspend fun BehaviourContext.waitPaidMediaPurchased(
+    initRequest: Request<*>,
+    errorFactory: NullableRequestBuilder<*> = { null }
+): Flow<PaidMediaPurchased> = expectFlow(
+    initRequest,
+    errorFactory
+) {
+    (it.paidMediaPurchasedUpdateOrNull() ?.data).let(::listOfNotNull)
+}
+
+suspend fun BehaviourContext.waitPaidMediaPurchased(
+    paidMediaPayloadRegex: Regex,
+    initRequest: Request<*>,
+    errorFactory: NullableRequestBuilder<*> = { null }
+): Flow<PaidMediaPurchased> = expectFlow(
+    initRequest,
+    errorFactory
+) {
+    (it.paidMediaPurchasedUpdateOrNull() ?.data ?.takeIf { paidMediaPayloadRegex.matches(it.payload.string) }).let(::listOfNotNull)
+}
+
+suspend fun BehaviourContext.waitPaidMediaPurchased(
+    paidMediaPayload: PaidMediaPayload,
+    initRequest: Request<*>,
+    errorFactory: NullableRequestBuilder<*> = { null }
+): Flow<PaidMediaPurchased> = expectFlow(
+    initRequest,
+    errorFactory
+) {
+    (it.paidMediaPurchasedUpdateOrNull() ?.data ?.takeIf { it.payload == paidMediaPayload }).let(::listOfNotNull)
+}

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

@@ -0,0 +1,28 @@
+package dev.inmo.tgbotapi.extensions.behaviour_builder.expectations
+
+import dev.inmo.tgbotapi.extensions.behaviour_builder.BehaviourContext
+import dev.inmo.tgbotapi.extensions.utils.messageUpdateOrNull
+import dev.inmo.tgbotapi.extensions.utils.passportMessageOrNull
+import dev.inmo.tgbotapi.requests.abstracts.Request
+import dev.inmo.tgbotapi.types.message.PassportMessage
+import dev.inmo.tgbotapi.types.passport.PassportData
+import dev.inmo.tgbotapi.types.passport.encrypted.abstracts.EncryptedPassportElement
+import dev.inmo.tgbotapi.utils.RiskFeature
+import dev.inmo.tgbotapi.utils.lowLevelRiskFeatureMessage
+import kotlinx.coroutines.flow.Flow
+
+@RiskFeature(lowLevelRiskFeatureMessage)
+suspend inline fun <reified O : EncryptedPassportElement> BehaviourContext.waitPassportMessagesWith(
+    initRequest: Request<*>,
+    noinline errorFactory: NullableRequestBuilder<*> = { null }
+): Flow<O> = expectFlow(
+    initRequest,
+    errorFactory
+) {
+    it.messageUpdateOrNull() ?.data ?.passportMessageOrNull() ?.passportData ?.data ?.filterIsInstance<O>() ?: emptyList()
+}
+
+suspend fun BehaviourContext.waitAnyPassportMessages(
+    initRequest: Request<*>,
+    errorFactory: NullableRequestBuilder<*> = { null }
+) = waitPassportMessagesWith<EncryptedPassportElement>(initRequest, errorFactory)

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

@@ -0,0 +1,17 @@
+package dev.inmo.tgbotapi.extensions.behaviour_builder.expectations
+
+import dev.inmo.tgbotapi.extensions.behaviour_builder.BehaviourContext
+import dev.inmo.tgbotapi.extensions.utils.pollAnswerUpdateOrNull
+import dev.inmo.tgbotapi.requests.abstracts.Request
+import dev.inmo.tgbotapi.types.polls.PollAnswer
+import kotlinx.coroutines.flow.Flow
+
+suspend fun BehaviourContext.waitPollAnswers(
+    initRequest: Request<*>,
+    errorFactory: NullableRequestBuilder<*> = { null }
+): Flow<PollAnswer> = expectFlow(
+    initRequest,
+    errorFactory
+) {
+    it.pollAnswerUpdateOrNull() ?.data.let(::listOfNotNull)
+}

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

@@ -0,0 +1,44 @@
+package dev.inmo.tgbotapi.extensions.behaviour_builder.expectations
+
+import dev.inmo.tgbotapi.extensions.behaviour_builder.BehaviourContext
+import dev.inmo.tgbotapi.extensions.utils.pollUpdateOrNull
+import dev.inmo.tgbotapi.requests.abstracts.Request
+import dev.inmo.tgbotapi.types.polls.*
+import dev.inmo.tgbotapi.utils.RiskFeature
+import dev.inmo.tgbotapi.utils.lowLevelRiskFeatureMessage
+import kotlinx.coroutines.flow.Flow
+
+@RiskFeature(lowLevelRiskFeatureMessage)
+suspend inline fun <reified O : Poll> BehaviourContext.waitPolls(
+    initRequest: Request<*>,
+    noinline errorFactory: NullableRequestBuilder<*> = { null }
+): Flow<O> = expectFlow(
+    initRequest,
+    errorFactory
+) {
+    (it.pollUpdateOrNull() ?.data as? O).let(::listOfNotNull)
+}
+
+/**
+ * This wait will be triggered only for stopped polls and polls, which are sent by the bot
+ */
+suspend fun BehaviourContext.waitPollUpdates(
+    initRequest: Request<*>,
+    errorFactory: NullableRequestBuilder<*> = { null }
+) = waitPolls<Poll>(initRequest, errorFactory)
+
+/**
+ * This wait will be triggered only for stopped polls and polls, which are sent by the bot
+ */
+suspend fun BehaviourContext.waitQuizPollUpdates(
+    initRequest: Request<*>,
+    errorFactory: NullableRequestBuilder<*> = { null }
+) = waitPolls<QuizPoll>(initRequest, errorFactory)
+
+/**
+ * This wait will be triggered only for stopped polls and polls, which are sent by the bot
+ */
+suspend fun BehaviourContext.waitRegularPollUpdates(
+    initRequest: Request<*>,
+    errorFactory: NullableRequestBuilder<*> = { null }
+) = waitPolls<RegularPoll>(initRequest, errorFactory)

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

@@ -0,0 +1,17 @@
+package dev.inmo.tgbotapi.extensions.behaviour_builder.expectations
+
+import dev.inmo.tgbotapi.extensions.behaviour_builder.BehaviourContext
+import dev.inmo.tgbotapi.extensions.utils.preCheckoutQueryUpdateOrNull
+import dev.inmo.tgbotapi.requests.abstracts.Request
+import dev.inmo.tgbotapi.types.payments.PreCheckoutQuery
+import kotlinx.coroutines.flow.Flow
+
+suspend fun BehaviourContext.waitPreCheckoutQueries(
+    initRequest: Request<*>,
+    errorFactory: NullableRequestBuilder<*> = { null }
+): Flow<PreCheckoutQuery> = expectFlow(
+    initRequest,
+    errorFactory
+) {
+    it.preCheckoutQueryUpdateOrNull() ?.data.let(::listOfNotNull)
+}

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

@@ -0,0 +1,17 @@
+package dev.inmo.tgbotapi.extensions.behaviour_builder.expectations
+
+import dev.inmo.tgbotapi.extensions.behaviour_builder.BehaviourContext
+import dev.inmo.tgbotapi.extensions.utils.shippingQueryUpdateOrNull
+import dev.inmo.tgbotapi.requests.abstracts.Request
+import dev.inmo.tgbotapi.types.payments.ShippingQuery
+import kotlinx.coroutines.flow.Flow
+
+suspend fun BehaviourContext.waitShippingQueries(
+    initRequest: Request<*>,
+    errorFactory: NullableRequestBuilder<*> = { null }
+): Flow<ShippingQuery> = expectFlow(
+    initRequest,
+    errorFactory
+) {
+    (it.shippingQueryUpdateOrNull() ?.data).let(::listOfNotNull)
+}

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

@@ -10,31 +10,25 @@ import dev.inmo.tgbotapi.types.business_connection.BusinessConnection
 import dev.inmo.tgbotapi.types.payments.ShippingQuery
 import kotlinx.coroutines.flow.Flow
 
-suspend fun BehaviourContext.waitBusinessConnection(
+fun BehaviourContext.waitBusinessConnection(
-    initRequest: Request<*>? = null,
     errorFactory: NullableRequestBuilder<*> = { null }
 ): Flow<BusinessConnection> = expectFlow(
-    initRequest,
     errorFactory
 ) {
     (it.businessConnectionUpdateOrNull() ?.data).let(::listOfNotNull)
 }
 
-suspend fun BehaviourContext.waitBusinessConnectionEnabled(
+fun BehaviourContext.waitBusinessConnectionEnabled(
-    initRequest: Request<*>? = null,
     errorFactory: NullableRequestBuilder<*> = { null }
 ): Flow<BusinessConnection> = expectFlow(
-    initRequest,
     errorFactory
 ) {
     (it.businessConnectionUpdateOrNull() ?.data ?.enabledOrNull()).let(::listOfNotNull)
 }
 
-suspend fun BehaviourContext.waitBusinessConnectionDisabled(
+fun BehaviourContext.waitBusinessConnectionDisabled(
-    initRequest: Request<*>? = null,
     errorFactory: NullableRequestBuilder<*> = { null }
 ): Flow<BusinessConnection> = expectFlow(
-    initRequest,
     errorFactory
 ) {
     (it.businessConnectionUpdateOrNull() ?.data ?.disabledOrNull()).let(::listOfNotNull)

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

@@ -13,50 +13,39 @@ import kotlinx.coroutines.flow.Flow
 typealias CallbackQueryMapper<T> = suspend T.() -> T?
 
 @RiskFeature(lowLevelRiskFeatureMessage)
-suspend inline fun <reified O> BehaviourContext.waitCallbackQueries(
+inline fun <reified O> BehaviourContext.waitCallbackQueries(
-    initRequest: Request<*>? = null,
     noinline errorFactory: NullableRequestBuilder<*> = { null }
 ): Flow<O> = expectFlow(
-    initRequest,
     errorFactory
 ) {
     (it.callbackQueryUpdateOrNull() ?.data as? O).let(::listOfNotNull)
 }
 
 
-suspend fun BehaviourContext.waitDataCallbackQuery(
+fun BehaviourContext.waitDataCallbackQuery(
-    initRequest: Request<*>? = null,
     errorFactory: NullableRequestBuilder<*> = { null }
-) = waitCallbackQueries<DataCallbackQuery>(initRequest, errorFactory)
+) = waitCallbackQueries<DataCallbackQuery>(errorFactory)
-suspend fun BehaviourContext.waitGameShortNameCallbackQuery(
+fun BehaviourContext.waitGameShortNameCallbackQuery(
-    initRequest: Request<*>? = null,
     errorFactory: NullableRequestBuilder<*> = { null }
-) = waitCallbackQueries<GameShortNameCallbackQuery>(initRequest, errorFactory)
+) = waitCallbackQueries<GameShortNameCallbackQuery>(errorFactory)
-suspend fun BehaviourContext.waitInlineMessageIdCallbackQuery(
+fun BehaviourContext.waitInlineMessageIdCallbackQuery(
-    initRequest: Request<*>? = null,
     errorFactory: NullableRequestBuilder<*> = { null }
-) = waitCallbackQueries<InlineMessageIdCallbackQuery>(initRequest, errorFactory)
+) = waitCallbackQueries<InlineMessageIdCallbackQuery>(errorFactory)
-suspend fun BehaviourContext.waitInlineMessageIdDataCallbackQuery(
+fun BehaviourContext.waitInlineMessageIdDataCallbackQuery(
-    initRequest: Request<*>? = null,
     errorFactory: NullableRequestBuilder<*> = { null }
-) = waitCallbackQueries<InlineMessageIdDataCallbackQuery>(initRequest, errorFactory)
+) = waitCallbackQueries<InlineMessageIdDataCallbackQuery>(errorFactory)
-suspend fun BehaviourContext.waitInlineMessageIdGameShortNameCallbackQuery(
+fun BehaviourContext.waitInlineMessageIdGameShortNameCallbackQuery(
-    initRequest: Request<*>? = null,
     errorFactory: NullableRequestBuilder<*> = { null }
-) = waitCallbackQueries<InlineMessageIdGameShortNameCallbackQuery>(initRequest, errorFactory)
+) = waitCallbackQueries<InlineMessageIdGameShortNameCallbackQuery>(errorFactory)
-suspend fun BehaviourContext.waitMessageCallbackQuery(
+fun BehaviourContext.waitMessageCallbackQuery(
-    initRequest: Request<*>? = null,
     errorFactory: NullableRequestBuilder<*> = { null }
-) = waitCallbackQueries<MessageCallbackQuery>(initRequest, errorFactory)
+) = waitCallbackQueries<MessageCallbackQuery>(errorFactory)
-suspend fun BehaviourContext.waitMessageDataCallbackQuery(
+fun BehaviourContext.waitMessageDataCallbackQuery(
-    initRequest: Request<*>? = null,
     errorFactory: NullableRequestBuilder<*> = { null }
-) = waitCallbackQueries<MessageDataCallbackQuery>(initRequest, errorFactory)
+) = waitCallbackQueries<MessageDataCallbackQuery>(errorFactory)
-suspend fun BehaviourContext.waitMessageGameShortNameCallbackQuery(
+fun BehaviourContext.waitMessageGameShortNameCallbackQuery(
-    initRequest: Request<*>? = null,
     errorFactory: NullableRequestBuilder<*> = { null }
-) = waitCallbackQueries<MessageGameShortNameCallbackQuery>(initRequest, errorFactory)
+) = waitCallbackQueries<MessageGameShortNameCallbackQuery>(errorFactory)
-suspend fun BehaviourContext.waitUnknownCallbackQuery(
+fun BehaviourContext.waitUnknownCallbackQuery(
-    initRequest: Request<*>? = null,
     errorFactory: NullableRequestBuilder<*> = { null }
-) = waitCallbackQueries<UnknownCallbackQueryType>(initRequest, errorFactory)
+) = waitCallbackQueries<UnknownCallbackQueryType>(errorFactory)

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

@@ -6,11 +6,9 @@ import dev.inmo.tgbotapi.requests.abstracts.Request
 import dev.inmo.tgbotapi.types.boosts.ChatBoostRemoved
 import kotlinx.coroutines.flow.Flow
 
-suspend fun BehaviourContext.waitChatBoostRemoved(
+fun BehaviourContext.waitChatBoostRemoved(
-    initRequest: Request<*>? = null,
     errorFactory: NullableRequestBuilder<*> = { null }
 ): Flow<ChatBoostRemoved> = expectFlow(
-    initRequest,
     errorFactory
 ) {
     it.chatBoostRemovedUpdateOrNull() ?.data.let(::listOfNotNull)

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

@@ -6,11 +6,9 @@ import dev.inmo.tgbotapi.requests.abstracts.Request
 import dev.inmo.tgbotapi.types.boosts.ChatBoostUpdated
 import kotlinx.coroutines.flow.Flow
 
-suspend fun BehaviourContext.waitChatBoostUpdated(
+fun BehaviourContext.waitChatBoostUpdated(
-    initRequest: Request<*>? = null,
     errorFactory: NullableRequestBuilder<*> = { null }
 ): Flow<ChatBoostUpdated> = expectFlow(
-    initRequest,
     errorFactory
 ) {
     it.chatBoostUpdatedUpdateOrNull() ?.data.let(::listOfNotNull)

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

@@ -11,21 +11,17 @@ import kotlinx.coroutines.flow.Flow
 typealias ChatJoinRequestsMapper = suspend ChatJoinRequest.() -> ChatJoinRequest?
 
 @RiskFeature(lowLevelRiskFeatureMessage)
-suspend inline fun <reified O> BehaviourContext.internalWaitChatJoinRequests(
+inline fun <reified O> BehaviourContext.internalWaitChatJoinRequests(
-    initRequest: Request<*>? = null,
     noinline errorFactory: NullableRequestBuilder<*> = { null }
 ): Flow<O> = expectFlow(
-    initRequest,
     errorFactory
 ) {
     (it.chatJoinRequestUpdateOrNull() ?.data as? O).let(::listOfNotNull)
 }
 
 
-suspend fun BehaviourContext.waitChatJoinRequests(
+fun BehaviourContext.waitChatJoinRequests(
-    initRequest: Request<*>? = null,
     errorFactory: NullableRequestBuilder<*> = { null }
 ) : Flow<ChatJoinRequest> = internalWaitChatJoinRequests(
-    initRequest,
     errorFactory
 )

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

@@ -21,237 +21,190 @@ import kotlinx.coroutines.flow.filter
 typealias ChatMemberUpdatedMapper<T> = suspend T.() -> T?
 
 @RiskFeature(lowLevelRiskFeatureMessage)
-suspend inline fun <reified O : ChatMemberUpdatedUpdate> BehaviourContext.waitChatMemberUpdatedWithFilter(
+inline fun <reified O : ChatMemberUpdatedUpdate> BehaviourContext.waitChatMemberUpdatedWithFilter(
-    initRequest: Request<*>? = null,
     noinline errorFactory: NullableRequestBuilder<*> = { null }
 ): Flow<ChatMemberUpdated> = expectFlow(
-    initRequest,
     errorFactory
 ) {
     (it as? O) ?.data.let(::listOfNotNull)
 }
 
-suspend fun BehaviourContext.waitChatMemberUpdated(
+fun BehaviourContext.waitChatMemberUpdated(
-    initRequest: Request<*>? = null,
     errorFactory: NullableRequestBuilder<*> = { null },
-) = waitChatMemberUpdatedWithFilter<ChatMemberUpdatedUpdate>(initRequest, errorFactory)
+) = waitChatMemberUpdatedWithFilter<ChatMemberUpdatedUpdate>(errorFactory)
 
-suspend fun BehaviourContext.waitCommonChatMemberUpdated(
+fun BehaviourContext.waitCommonChatMemberUpdated(
-    initRequest: Request<*>? = null,
     errorFactory: NullableRequestBuilder<*> = { null },
-) = waitChatMemberUpdatedWithFilter<CommonChatMemberUpdatedUpdate>(initRequest, errorFactory)
+) = waitChatMemberUpdatedWithFilter<CommonChatMemberUpdatedUpdate>(errorFactory)
 
-suspend fun BehaviourContext.waitMyChatMemberUpdated(
+fun BehaviourContext.waitMyChatMemberUpdated(
-    initRequest: Request<*>? = null,
     errorFactory: NullableRequestBuilder<*> = { null }
-) = waitChatMemberUpdatedWithFilter<MyChatMemberUpdatedUpdate>(initRequest, errorFactory)
+) = waitChatMemberUpdatedWithFilter<MyChatMemberUpdatedUpdate>(errorFactory)
 
-suspend fun BehaviourContext.waitChatMemberJoined(
+fun BehaviourContext.waitChatMemberJoined(
-    initRequest: Request<*>? = null,
     errorFactory: NullableRequestBuilder<*> = { null }
-) = waitChatMemberUpdated(initRequest, errorFactory).filter { chatMemberJoinedFilter(it) };
+) = waitChatMemberUpdated(errorFactory).filter { chatMemberJoinedFilter(it) };
 
-suspend fun BehaviourContext.waitChatMemberLeft(
+fun BehaviourContext.waitChatMemberLeft(
-    initRequest: Request<*>? = null,
     errorFactory: NullableRequestBuilder<*> = { null }
-) = waitChatMemberUpdated(initRequest, errorFactory).filter { chatMemberLeftFilter(it) };
+) = waitChatMemberUpdated(errorFactory).filter { chatMemberLeftFilter(it) };
 
-suspend fun BehaviourContext.waitChatMemberSubscribed(
+fun BehaviourContext.waitChatMemberSubscribed(
-    initRequest: Request<*>? = null,
     errorFactory: NullableRequestBuilder<*> = { null }
-) = waitChatMemberUpdated(initRequest, errorFactory).filter { chatMemberSubscribedFilter(it) };
+) = waitChatMemberUpdated(errorFactory).filter { chatMemberSubscribedFilter(it) };
 
-suspend fun BehaviourContext.waitChatMemberSubscriptionChanged(
+fun BehaviourContext.waitChatMemberSubscriptionChanged(
-    initRequest: Request<*>? = null,
     errorFactory: NullableRequestBuilder<*> = { null }
-) = waitChatMemberUpdated(initRequest, errorFactory).filter { chatMemberSubscriptionChangedFilter(it) };
+) = waitChatMemberUpdated(errorFactory).filter { chatMemberSubscriptionChangedFilter(it) };
 
-suspend fun BehaviourContext.waitChatMemberUnsubscribed(
+fun BehaviourContext.waitChatMemberUnsubscribed(
-    initRequest: Request<*>? = null,
     errorFactory: NullableRequestBuilder<*> = { null }
-) = waitChatMemberUpdated(initRequest, errorFactory).filter { chatMemberUnsubscribedFilter(it) };
+) = waitChatMemberUpdated(errorFactory).filter { chatMemberUnsubscribedFilter(it) };
 
-suspend fun BehaviourContext.waitChatMemberGotPromoted(
+fun BehaviourContext.waitChatMemberGotPromoted(
-    initRequest: Request<*>? = null,
     errorFactory: NullableRequestBuilder<*> = { null }
-) = waitChatMemberUpdated(initRequest, errorFactory).filter { chatMemberGotPromotedFilter(it) };
+) = waitChatMemberUpdated(errorFactory).filter { chatMemberGotPromotedFilter(it) };
 
-suspend fun BehaviourContext.waitChatMemberGotPromotionChanged(
+fun BehaviourContext.waitChatMemberGotPromotionChanged(
-    initRequest: Request<*>? = null,
     errorFactory: NullableRequestBuilder<*> = { null }
-) = waitChatMemberUpdated(initRequest, errorFactory).filter { chatMemberGotPromotionChangedFilter(it) };
+) = waitChatMemberUpdated(errorFactory).filter { chatMemberGotPromotionChangedFilter(it) };
 
-suspend fun BehaviourContext.waitChatMemberGotDemoted(
+fun BehaviourContext.waitChatMemberGotDemoted(
-    initRequest: Request<*>? = null,
     errorFactory: NullableRequestBuilder<*> = { null }
-) = waitChatMemberUpdated(initRequest, errorFactory).filter { chatMemberGotDemotedFilter(it) };
+) = waitChatMemberUpdated(errorFactory).filter { chatMemberGotDemotedFilter(it) };
 
-suspend fun BehaviourContext.waitChatMemberBecameOwner(
+fun BehaviourContext.waitChatMemberBecameOwner(
-    initRequest: Request<*>? = null,
     errorFactory: NullableRequestBuilder<*> = { null }
-) = waitChatMemberUpdated(initRequest, errorFactory).filter { chatMemberBecameOwnerFilter(it) };
+) = waitChatMemberUpdated(errorFactory).filter { chatMemberBecameOwnerFilter(it) };
 
-suspend fun BehaviourContext.waitChatMemberCeasedOwnership(
+fun BehaviourContext.waitChatMemberCeasedOwnership(
-    initRequest: Request<*>? = null,
     errorFactory: NullableRequestBuilder<*> = { null }
-) = waitChatMemberUpdated(initRequest, errorFactory).filter { chatMemberCeasedOwnershipFilter(it) };
+) = waitChatMemberUpdated(errorFactory).filter { chatMemberCeasedOwnershipFilter(it) };
 
-suspend fun BehaviourContext.waitChatMemberGotRestricted(
+fun BehaviourContext.waitChatMemberGotRestricted(
-    initRequest: Request<*>? = null,
     errorFactory: NullableRequestBuilder<*> = { null }
-) = waitChatMemberUpdated(initRequest, errorFactory).filter { chatMemberGotRestrictedFilter(it) };
+) = waitChatMemberUpdated(errorFactory).filter { chatMemberGotRestrictedFilter(it) };
 
-suspend fun BehaviourContext.waitChatMemberGotRestrictionChanged(
+fun BehaviourContext.waitChatMemberGotRestrictionChanged(
-    initRequest: Request<*>? = null,
     errorFactory: NullableRequestBuilder<*> = { null }
-) = waitChatMemberUpdated(initRequest, errorFactory).filter { chatMemberGotRestrictionsChangedFilter(it) };
+) = waitChatMemberUpdated(errorFactory).filter { chatMemberGotRestrictionsChangedFilter(it) };
 
-suspend fun BehaviourContext.waitChatMemberGotUnrestricted(
+fun BehaviourContext.waitChatMemberGotUnrestricted(
-    initRequest: Request<*>? = null,
     errorFactory: NullableRequestBuilder<*> = { null }
-) = waitChatMemberUpdated(initRequest, errorFactory).filter { chatMemberGotUnrestrictedFilter(it) };
+) = waitChatMemberUpdated(errorFactory).filter { chatMemberGotUnrestrictedFilter(it) };
 
-suspend fun BehaviourContext.waitChatMemberKicked(
+fun BehaviourContext.waitChatMemberKicked(
-    initRequest: Request<*>? = null,
     errorFactory: NullableRequestBuilder<*> = { null }
-) = waitChatMemberUpdated(initRequest, errorFactory).filter { chatMemberKickedFilter(it) };
+) = waitChatMemberUpdated(errorFactory).filter { chatMemberKickedFilter(it) };
 
-suspend fun BehaviourContext.waitCommonChatMemberJoined(
+fun BehaviourContext.waitCommonChatMemberJoined(
-    initRequest: Request<*>? = null,
     errorFactory: NullableRequestBuilder<*> = { null }
-) = waitCommonChatMemberUpdated(initRequest, errorFactory).filter { chatMemberJoinedFilter(it) };
+) = waitCommonChatMemberUpdated(errorFactory).filter { chatMemberJoinedFilter(it) };
 
-suspend fun BehaviourContext.waitCommonChatMemberLeft(
+fun BehaviourContext.waitCommonChatMemberLeft(
-    initRequest: Request<*>? = null,
     errorFactory: NullableRequestBuilder<*> = { null }
-) = waitCommonChatMemberUpdated(initRequest, errorFactory).filter { chatMemberLeftFilter(it) };
+) = waitCommonChatMemberUpdated(errorFactory).filter { chatMemberLeftFilter(it) };
 
-suspend fun BehaviourContext.waitCommonChatMemberSubscribed(
+fun BehaviourContext.waitCommonChatMemberSubscribed(
-    initRequest: Request<*>? = null,
     errorFactory: NullableRequestBuilder<*> = { null }
-) = waitCommonChatMemberUpdated(initRequest, errorFactory).filter { chatMemberSubscribedFilter(it) };
+) = waitCommonChatMemberUpdated(errorFactory).filter { chatMemberSubscribedFilter(it) };
 
-suspend fun BehaviourContext.waitCommonChatMemberSubscriptionChanged(
+fun BehaviourContext.waitCommonChatMemberSubscriptionChanged(
-    initRequest: Request<*>? = null,
     errorFactory: NullableRequestBuilder<*> = { null }
-) = waitCommonChatMemberUpdated(initRequest, errorFactory).filter { chatMemberSubscriptionChangedFilter(it) };
+) = waitCommonChatMemberUpdated(errorFactory).filter { chatMemberSubscriptionChangedFilter(it) };
 
-suspend fun BehaviourContext.waitCommonChatMemberUnsubscribed(
+fun BehaviourContext.waitCommonChatMemberUnsubscribed(
-    initRequest: Request<*>? = null,
     errorFactory: NullableRequestBuilder<*> = { null }
-) = waitCommonChatMemberUpdated(initRequest, errorFactory).filter { chatMemberUnsubscribedFilter(it) };
+) = waitCommonChatMemberUpdated(errorFactory).filter { chatMemberUnsubscribedFilter(it) };
 
-suspend fun BehaviourContext.waitCommonChatMemberGotPromoted(
+fun BehaviourContext.waitCommonChatMemberGotPromoted(
-    initRequest: Request<*>? = null,
     errorFactory: NullableRequestBuilder<*> = { null }
-) = waitCommonChatMemberUpdated(initRequest, errorFactory).filter { chatMemberGotPromotedFilter(it) };
+) = waitCommonChatMemberUpdated(errorFactory).filter { chatMemberGotPromotedFilter(it) };
 
-suspend fun BehaviourContext.waitCommonChatMemberGotPromotionChanged(
+fun BehaviourContext.waitCommonChatMemberGotPromotionChanged(
-    initRequest: Request<*>? = null,
     errorFactory: NullableRequestBuilder<*> = { null }
-) = waitCommonChatMemberUpdated(initRequest, errorFactory).filter { chatMemberGotPromotionChangedFilter(it) };
+) = waitCommonChatMemberUpdated(errorFactory).filter { chatMemberGotPromotionChangedFilter(it) };
 
-suspend fun BehaviourContext.waitCommonChatMemberGotDemoted(
+fun BehaviourContext.waitCommonChatMemberGotDemoted(
-    initRequest: Request<*>? = null,
     errorFactory: NullableRequestBuilder<*> = { null }
-) = waitCommonChatMemberUpdated(initRequest, errorFactory).filter { chatMemberGotDemotedFilter(it) };
+) = waitCommonChatMemberUpdated(errorFactory).filter { chatMemberGotDemotedFilter(it) };
 
-suspend fun BehaviourContext.waitCommonChatMemberBecameOwner(
+fun BehaviourContext.waitCommonChatMemberBecameOwner(
-    initRequest: Request<*>? = null,
     errorFactory: NullableRequestBuilder<*> = { null }
-) = waitCommonChatMemberUpdated(initRequest, errorFactory).filter { chatMemberBecameOwnerFilter(it) };
+) = waitCommonChatMemberUpdated(errorFactory).filter { chatMemberBecameOwnerFilter(it) };
 
-suspend fun BehaviourContext.waitCommonChatMemberCeasedOwnership(
+fun BehaviourContext.waitCommonChatMemberCeasedOwnership(
-    initRequest: Request<*>? = null,
     errorFactory: NullableRequestBuilder<*> = { null }
-) = waitCommonChatMemberUpdated(initRequest, errorFactory).filter { chatMemberCeasedOwnershipFilter(it) };
+) = waitCommonChatMemberUpdated(errorFactory).filter { chatMemberCeasedOwnershipFilter(it) };
 
-suspend fun BehaviourContext.waitCommonChatMemberGotRestricted(
+fun BehaviourContext.waitCommonChatMemberGotRestricted(
-    initRequest: Request<*>? = null,
     errorFactory: NullableRequestBuilder<*> = { null }
-) = waitCommonChatMemberUpdated(initRequest, errorFactory).filter { chatMemberGotRestrictedFilter(it) };
+) = waitCommonChatMemberUpdated(errorFactory).filter { chatMemberGotRestrictedFilter(it) };
 
-suspend fun BehaviourContext.waitCommonChatMemberGotRestrictionChanged(
+fun BehaviourContext.waitCommonChatMemberGotRestrictionChanged(
-    initRequest: Request<*>? = null,
     errorFactory: NullableRequestBuilder<*> = { null }
-) = waitCommonChatMemberUpdated(initRequest, errorFactory).filter { chatMemberGotRestrictionsChangedFilter(it) };
+) = waitCommonChatMemberUpdated(errorFactory).filter { chatMemberGotRestrictionsChangedFilter(it) };
 
-suspend fun BehaviourContext.waitCommonChatMemberGotUnrestricted(
+fun BehaviourContext.waitCommonChatMemberGotUnrestricted(
-    initRequest: Request<*>? = null,
     errorFactory: NullableRequestBuilder<*> = { null }
-) = waitCommonChatMemberUpdated(initRequest, errorFactory).filter { chatMemberGotUnrestrictedFilter(it) };
+) = waitCommonChatMemberUpdated(errorFactory).filter { chatMemberGotUnrestrictedFilter(it) };
 
-suspend fun BehaviourContext.waitCommonChatMemberKicked(
+fun BehaviourContext.waitCommonChatMemberKicked(
-    initRequest: Request<*>? = null,
     errorFactory: NullableRequestBuilder<*> = { null }
-) = waitCommonChatMemberUpdated(initRequest, errorFactory).filter { chatMemberKickedFilter(it) };
+) = waitCommonChatMemberUpdated(errorFactory).filter { chatMemberKickedFilter(it) };
 
-suspend fun BehaviourContext.waitMyChatMemberJoined(
+fun BehaviourContext.waitMyChatMemberJoined(
-    initRequest: Request<*>? = null,
     errorFactory: NullableRequestBuilder<*> = { null }
-) = waitMyChatMemberUpdated(initRequest, errorFactory).filter { chatMemberJoinedFilter(it) };
+) = waitMyChatMemberUpdated(errorFactory).filter { chatMemberJoinedFilter(it) };
 
-suspend fun BehaviourContext.waitMyChatMemberLeft(
+fun BehaviourContext.waitMyChatMemberLeft(
-    initRequest: Request<*>? = null,
     errorFactory: NullableRequestBuilder<*> = { null }
-) = waitMyChatMemberUpdated(initRequest, errorFactory).filter { chatMemberLeftFilter(it) };
+) = waitMyChatMemberUpdated(errorFactory).filter { chatMemberLeftFilter(it) };
 
-suspend fun BehaviourContext.waitMyChatMemberSubscribed(
+fun BehaviourContext.waitMyChatMemberSubscribed(
-    initRequest: Request<*>? = null,
     errorFactory: NullableRequestBuilder<*> = { null }
-) = waitMyChatMemberUpdated(initRequest, errorFactory).filter { chatMemberSubscribedFilter(it) };
+) = waitMyChatMemberUpdated(errorFactory).filter { chatMemberSubscribedFilter(it) };
 
-suspend fun BehaviourContext.waitMyChatMemberSubscriptionChanged(
+fun BehaviourContext.waitMyChatMemberSubscriptionChanged(
-    initRequest: Request<*>? = null,
     errorFactory: NullableRequestBuilder<*> = { null }
-) = waitMyChatMemberUpdated(initRequest, errorFactory).filter { chatMemberSubscriptionChangedFilter(it) };
+) = waitMyChatMemberUpdated(errorFactory).filter { chatMemberSubscriptionChangedFilter(it) };
 
-suspend fun BehaviourContext.waitMyChatMemberUnsubscribed(
+fun BehaviourContext.waitMyChatMemberUnsubscribed(
-    initRequest: Request<*>? = null,
     errorFactory: NullableRequestBuilder<*> = { null }
-) = waitMyChatMemberUpdated(initRequest, errorFactory).filter { chatMemberUnsubscribedFilter(it) };
+) = waitMyChatMemberUpdated(errorFactory).filter { chatMemberUnsubscribedFilter(it) };
 
-suspend fun BehaviourContext.waitMyChatMemberGotPromoted(
+fun BehaviourContext.waitMyChatMemberGotPromoted(
-    initRequest: Request<*>? = null,
     errorFactory: NullableRequestBuilder<*> = { null }
-) = waitMyChatMemberUpdated(initRequest, errorFactory).filter { chatMemberGotPromotedFilter(it) };
+) = waitMyChatMemberUpdated(errorFactory).filter { chatMemberGotPromotedFilter(it) };
 
-suspend fun BehaviourContext.waitMyChatMemberGotPromotionChanged(
+fun BehaviourContext.waitMyChatMemberGotPromotionChanged(
-    initRequest: Request<*>? = null,
     errorFactory: NullableRequestBuilder<*> = { null }
-) = waitMyChatMemberUpdated(initRequest, errorFactory).filter { chatMemberGotPromotionChangedFilter(it) };
+) = waitMyChatMemberUpdated(errorFactory).filter { chatMemberGotPromotionChangedFilter(it) };
 
-suspend fun BehaviourContext.waitMyChatMemberGotDemoted(
+fun BehaviourContext.waitMyChatMemberGotDemoted(
-    initRequest: Request<*>? = null,
     errorFactory: NullableRequestBuilder<*> = { null }
-) = waitMyChatMemberUpdated(initRequest, errorFactory).filter { chatMemberGotDemotedFilter(it) };
+) = waitMyChatMemberUpdated(errorFactory).filter { chatMemberGotDemotedFilter(it) };
 
-suspend fun BehaviourContext.waitMyChatMemberBecameOwner(
+fun BehaviourContext.waitMyChatMemberBecameOwner(
-    initRequest: Request<*>? = null,
     errorFactory: NullableRequestBuilder<*> = { null }
-) = waitMyChatMemberUpdated(initRequest, errorFactory).filter { chatMemberBecameOwnerFilter(it) };
+) = waitMyChatMemberUpdated(errorFactory).filter { chatMemberBecameOwnerFilter(it) };
 
-suspend fun BehaviourContext.waitMyChatMemberCeasedOwnership(
+fun BehaviourContext.waitMyChatMemberCeasedOwnership(
-    initRequest: Request<*>? = null,
     errorFactory: NullableRequestBuilder<*> = { null }
-) = waitMyChatMemberUpdated(initRequest, errorFactory).filter { chatMemberCeasedOwnershipFilter(it) };
+) = waitMyChatMemberUpdated(errorFactory).filter { chatMemberCeasedOwnershipFilter(it) };
 
-suspend fun BehaviourContext.waitMyChatMemberGotRestricted(
+fun BehaviourContext.waitMyChatMemberGotRestricted(
-    initRequest: Request<*>? = null,
     errorFactory: NullableRequestBuilder<*> = { null }
-) = waitMyChatMemberUpdated(initRequest, errorFactory).filter { chatMemberGotRestrictedFilter(it) };
+) = waitMyChatMemberUpdated(errorFactory).filter { chatMemberGotRestrictedFilter(it) };
 
-suspend fun BehaviourContext.waitMyChatMemberGotRestrictionChanged(
+fun BehaviourContext.waitMyChatMemberGotRestrictionChanged(
-    initRequest: Request<*>? = null,
     errorFactory: NullableRequestBuilder<*> = { null }
-) = waitMyChatMemberUpdated(initRequest, errorFactory).filter { chatMemberGotRestrictionsChangedFilter(it) };
+) = waitMyChatMemberUpdated(errorFactory).filter { chatMemberGotRestrictionsChangedFilter(it) };
 
-suspend fun BehaviourContext.waitMyChatMemberGotUnrestricted(
+fun BehaviourContext.waitMyChatMemberGotUnrestricted(
-    initRequest: Request<*>? = null,
     errorFactory: NullableRequestBuilder<*> = { null }
-) = waitMyChatMemberUpdated(initRequest, errorFactory).filter { chatMemberGotUnrestrictedFilter(it) };
+) = waitMyChatMemberUpdated(errorFactory).filter { chatMemberGotUnrestrictedFilter(it) };
 
-suspend fun BehaviourContext.waitMyChatMemberKicked(
+fun BehaviourContext.waitMyChatMemberKicked(
-    initRequest: Request<*>? = null,
     errorFactory: NullableRequestBuilder<*> = { null }
-) = waitMyChatMemberUpdated(initRequest, errorFactory).filter { chatMemberKickedFilter(it) };
+) = waitMyChatMemberUpdated(errorFactory).filter { chatMemberKickedFilter(it) };

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

@@ -9,23 +9,19 @@ import dev.inmo.tgbotapi.utils.lowLevelRiskFeatureMessage
 import kotlinx.coroutines.flow.Flow
 
 @RiskFeature(lowLevelRiskFeatureMessage)
-suspend inline fun <reified O : ChatMessageReactionUpdated> BehaviourContext.waitChatMessageReactionUpdated(
+inline fun <reified O : ChatMessageReactionUpdated> BehaviourContext.waitChatMessageReactionUpdated(
-    initRequest: Request<*>? = null,
     noinline errorFactory: NullableRequestBuilder<*> = { null }
 ): Flow<O> = expectFlow(
-    initRequest,
     errorFactory
 ) {
     (it.chatMessageReactionUpdatedUpdateOrNull() ?.data as? O).let(::listOfNotNull)
 }
 
-suspend fun BehaviourContext.waitChatMessageReactionUpdatedByUser(
+fun BehaviourContext.waitChatMessageReactionUpdatedByUser(
-    initRequest: Request<*>? = null,
     errorFactory: NullableRequestBuilder<*> = { null }
-) = waitChatMessageReactionUpdated<ChatMessageReactionUpdated.ByUser>(initRequest, errorFactory)
+) = waitChatMessageReactionUpdated<ChatMessageReactionUpdated.ByUser>(errorFactory)
 
 
-suspend fun BehaviourContext.waitChatMessageReactionUpdatedByChat(
+fun BehaviourContext.waitChatMessageReactionUpdatedByChat(
-    initRequest: Request<*>? = null,
     errorFactory: NullableRequestBuilder<*> = { null }
-) = waitChatMessageReactionUpdated<ChatMessageReactionUpdated.ByChat>(initRequest, errorFactory)
+) = waitChatMessageReactionUpdated<ChatMessageReactionUpdated.ByChat>(errorFactory)

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

@@ -10,11 +10,9 @@ import dev.inmo.tgbotapi.utils.RiskFeature
 import dev.inmo.tgbotapi.utils.lowLevelRiskFeatureMessage
 import kotlinx.coroutines.flow.Flow
 
-suspend inline fun BehaviourContext.waitChatMessageReactionsCountUpdated(
+inline fun BehaviourContext.waitChatMessageReactionsCountUpdated(
-    initRequest: Request<*>? = null,
     noinline errorFactory: NullableRequestBuilder<*> = { null }
 ): Flow<ChatMessageReactionsCountUpdated> = expectFlow(
-    initRequest,
     errorFactory
 ) {
     (it.chatMessageReactionsCountUpdatedUpdateOrNull() ?.data).let(::listOfNotNull)

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

@@ -11,27 +11,22 @@ import kotlinx.coroutines.flow.Flow
 typealias ChosenInlineResultMapper<T> = suspend T.() -> T?
 
 @RiskFeature(lowLevelRiskFeatureMessage)
-suspend inline fun <reified O> BehaviourContext.waitChosenInlineResults(
+inline fun <reified O> BehaviourContext.waitChosenInlineResults(
-    initRequest: Request<*>? = null,
     noinline errorFactory: NullableRequestBuilder<*> = { null }
 ): Flow<O> = expectFlow(
-    initRequest,
     errorFactory
 ) {
     (it.chosenInlineResultUpdateOrNull() ?.data as? O).let(::listOfNotNull)
 }
 
-suspend fun BehaviourContext.waitChosenInlineResult(
+fun BehaviourContext.waitChosenInlineResult(
-    initRequest: Request<*>? = null,
     errorFactory: NullableRequestBuilder<*> = { null }
-) = waitChosenInlineResults<ChosenInlineResult>(initRequest, errorFactory)
+) = waitChosenInlineResults<ChosenInlineResult>(errorFactory)
 
-suspend fun BehaviourContext.waitLocationChosenInlineResult(
+fun BehaviourContext.waitLocationChosenInlineResult(
-    initRequest: Request<*>? = null,
     errorFactory: NullableRequestBuilder<*> = { null }
-) = waitChosenInlineResults<LocationChosenInlineResult>(initRequest, errorFactory)
+) = waitChosenInlineResults<LocationChosenInlineResult>(errorFactory)
 
-suspend fun BehaviourContext.waitBaseChosenInlineResult(
+fun BehaviourContext.waitBaseChosenInlineResult(
-    initRequest: Request<*>? = null,
     errorFactory: NullableRequestBuilder<*> = { null }
-) = waitChosenInlineResults<BaseChosenInlineResult>(initRequest, errorFactory)
+) = waitChosenInlineResults<BaseChosenInlineResult>(errorFactory)

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

@@ -22,15 +22,14 @@ import kotlinx.coroutines.flow.*
  * * In case you wish to exclude messages with more than one command, you may use [requireSingleCommand]
  * * In case you wish to exclude messages with commands params, you may use [requireCommandsWithoutParams]
  */
-suspend fun BehaviourContext.waitCommandMessage(
+fun BehaviourContext.waitCommandMessage(
     commandRegex: Regex,
-    initRequest: Request<*>? = null,
     errorFactory: NullableRequestBuilder<*> = { null }
 ) = channelFlow {
     triggersHolder.handleableCommandsHolder.doWithRegistration(
         commandRegex
     ) {
-        waitTextMessage(initRequest, errorFactory).filter {
+        waitTextMessage(errorFactory).filter {
             it.content.textSources.any { it.botCommandTextSourceOrNull() ?.command ?.matches(commandRegex) == true }
         }.collect {
             send(it)
@@ -38,17 +37,15 @@ suspend fun BehaviourContext.waitCommandMessage(
     }
 }
 
-suspend fun BehaviourContext.waitCommandMessage(
+fun BehaviourContext.waitCommandMessage(
     command: String,
-    initRequest: Request<*>? = null,
     errorFactory: NullableRequestBuilder<*> = { null }
-) = waitCommandMessage(Regex(command), initRequest, errorFactory)
+) = waitCommandMessage(Regex(command), errorFactory)
 
-suspend fun BehaviourContext.waitCommandMessage(
+fun BehaviourContext.waitCommandMessage(
     botCommand: BotCommand,
-    initRequest: Request<*>? = null,
     errorFactory: NullableRequestBuilder<*> = { null }
-) = waitCommandMessage(botCommand.command, initRequest, errorFactory)
+) = waitCommandMessage(botCommand.command, errorFactory)
 
 fun Flow<CommonMessage<TextContent>>.requireCommandAtStart() = filter {
     it.content.textSources.firstOrNull() is BotCommandTextSource

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

@@ -16,146 +16,112 @@ import kotlinx.coroutines.flow.mapNotNull
 typealias CommonMessageToContentMapper<T> = suspend CommonMessage<T>.() -> T?
 
 @RiskFeature(lowLevelRiskFeatureMessage)
-suspend inline fun BehaviourContext.waitContent(
+inline fun BehaviourContext.waitContent(
-    initRequest: Request<*>? = null,
     noinline errorFactory: NullableRequestBuilder<*> = { null }
-): Flow<MessageContent> = waitContentMessage(initRequest, errorFactory).map { it.content }
+): Flow<MessageContent> = waitContentMessage(errorFactory).map { it.content }
 
 inline fun <reified T : MessageContent> Flow<MessageContent>.mapContent() = mapNotNull { it as? T }
 
-suspend fun BehaviourContext.waitAnyContent(
+fun BehaviourContext.waitAnyContent(
-    initRequest: Request<*>? = null,
     errorFactory: NullableRequestBuilder<*> = { null }
-) = waitContent(initRequest, errorFactory)
+) = waitContent(errorFactory)
-suspend fun BehaviourContext.waitTextedContent(
+fun BehaviourContext.waitTextedContent(
-    initRequest: Request<*>? = null,
     errorFactory: NullableRequestBuilder<*> = { null }
-) = waitContent(initRequest, errorFactory).mapContent<TextedContent>()
+) = waitContent(errorFactory).mapContent<TextedContent>()
-suspend fun BehaviourContext.waitContact(
+fun BehaviourContext.waitContact(
-    initRequest: Request<*>? = null,
     errorFactory: NullableRequestBuilder<*> = { null }
-) = waitContent(initRequest, errorFactory).mapContent<ContactContent>()
+) = waitContent(errorFactory).mapContent<ContactContent>()
-suspend fun BehaviourContext.waitDice(
+fun BehaviourContext.waitDice(
-    initRequest: Request<*>? = null,
     errorFactory: NullableRequestBuilder<*> = { null }
-) = waitContent(initRequest, errorFactory).mapContent<DiceContent>()
+) = waitContent(errorFactory).mapContent<DiceContent>()
-suspend fun BehaviourContext.waitGame(
+fun BehaviourContext.waitGame(
-    initRequest: Request<*>? = null,
     errorFactory: NullableRequestBuilder<*> = { null }
-) = waitContent(initRequest, errorFactory).mapContent<GameContent>()
+) = waitContent(errorFactory).mapContent<GameContent>()
-suspend fun BehaviourContext.waitLocation(
+fun BehaviourContext.waitLocation(
-    initRequest: Request<*>? = null,
     errorFactory: NullableRequestBuilder<*> = { null }
-) = waitContent(initRequest, errorFactory).mapContent<LocationContent>()
+) = waitContent(errorFactory).mapContent<LocationContent>()
-suspend fun BehaviourContext.waitLiveLocation(
+fun BehaviourContext.waitLiveLocation(
-    initRequest: Request<*>? = null,
     errorFactory: NullableRequestBuilder<*> = { null }
-) = waitContent(initRequest, errorFactory).mapContent<LiveLocationContent>()
+) = waitContent(errorFactory).mapContent<LiveLocationContent>()
-suspend fun BehaviourContext.waitStaticLocation(
+fun BehaviourContext.waitStaticLocation(
-    initRequest: Request<*>? = null,
     errorFactory: NullableRequestBuilder<*> = { null }
-) = waitContent(initRequest, errorFactory).mapContent<StaticLocationContent>()
+) = waitContent(errorFactory).mapContent<StaticLocationContent>()
-suspend fun BehaviourContext.waitPoll(
+fun BehaviourContext.waitPoll(
-    initRequest: Request<*>? = null,
     errorFactory: NullableRequestBuilder<*> = { null }
-) = waitContent(initRequest, errorFactory).mapContent<PollContent>()
+) = waitContent(errorFactory).mapContent<PollContent>()
-suspend fun BehaviourContext.waitText(
+fun BehaviourContext.waitText(
-    initRequest: Request<*>? = null,
     errorFactory: NullableRequestBuilder<*> = { null }
-) = waitContent(initRequest, errorFactory).mapContent<TextContent>()
+) = waitContent(errorFactory).mapContent<TextContent>()
-suspend fun BehaviourContext.waitStory(
+fun BehaviourContext.waitStory(
-    initRequest: Request<*>? = null,
     errorFactory: NullableRequestBuilder<*> = { null }
-) = waitContent(initRequest, errorFactory).mapContent<StoryContent>()
+) = waitContent(errorFactory).mapContent<StoryContent>()
-suspend fun BehaviourContext.waitVenue(
+fun BehaviourContext.waitVenue(
-    initRequest: Request<*>? = null,
     errorFactory: NullableRequestBuilder<*> = { null }
-) = waitContent(initRequest, errorFactory).mapContent<VenueContent>()
+) = waitContent(errorFactory).mapContent<VenueContent>()
-suspend fun BehaviourContext.waitAudioMediaGroupContent(
+fun BehaviourContext.waitAudioMediaGroupContent(
-    initRequest: Request<*>? = null,
     errorFactory: NullableRequestBuilder<*> = { null },
-) = waitContent(initRequest, errorFactory).mapContent<AudioMediaGroupPartContent>()
+) = waitContent(errorFactory).mapContent<AudioMediaGroupPartContent>()
-suspend fun BehaviourContext.waitDocumentMediaGroupContent(
+fun BehaviourContext.waitDocumentMediaGroupContent(
-    initRequest: Request<*>? = null,
     errorFactory: NullableRequestBuilder<*> = { null }
-) = waitContent(initRequest, errorFactory).mapContent<DocumentMediaGroupPartContent>()
+) = waitContent(errorFactory).mapContent<DocumentMediaGroupPartContent>()
-suspend fun BehaviourContext.waitMedia(
+fun BehaviourContext.waitMedia(
-    initRequest: Request<*>? = null,
     errorFactory: NullableRequestBuilder<*> = { null }
-) = waitContent(initRequest, errorFactory).mapContent<MediaContent>()
+) = waitContent(errorFactory).mapContent<MediaContent>()
-suspend fun BehaviourContext.waitAnyMediaGroupContent(
+fun BehaviourContext.waitAnyMediaGroupContent(
-    initRequest: Request<*>? = null,
     errorFactory: NullableRequestBuilder<*> = { null },
-) = waitContent(initRequest, errorFactory).mapContent<MediaGroupPartContent>()
+) = waitContent(errorFactory).mapContent<MediaGroupPartContent>()
-suspend fun BehaviourContext.waitVisualMediaGroupContent(
+fun BehaviourContext.waitVisualMediaGroupContent(
-    initRequest: Request<*>? = null,
     errorFactory: NullableRequestBuilder<*> = { null },
-) = waitContent(initRequest, errorFactory).mapContent<VisualMediaGroupPartContent>()
+) = waitContent(errorFactory).mapContent<VisualMediaGroupPartContent>()
-suspend fun BehaviourContext.waitTextedMediaContent(
+fun BehaviourContext.waitTextedMediaContent(
-    initRequest: Request<*>? = null,
     errorFactory: NullableRequestBuilder<*> = { null },
-) = waitContent(initRequest, errorFactory).mapContent<TextedMediaContent>()
+) = waitContent(errorFactory).mapContent<TextedMediaContent>()
-suspend fun BehaviourContext.waitAnimation(
+fun BehaviourContext.waitAnimation(
-    initRequest: Request<*>? = null,
     errorFactory: NullableRequestBuilder<*> = { null }
-) = waitContent(initRequest, errorFactory).mapContent<AnimationContent>()
+) = waitContent(errorFactory).mapContent<AnimationContent>()
-suspend fun BehaviourContext.waitAudio(
+fun BehaviourContext.waitAudio(
-    initRequest: Request<*>? = null,
     errorFactory: NullableRequestBuilder<*> = { null },
-) = waitContent(initRequest, errorFactory).mapContent<AudioContent>()
+) = waitContent(errorFactory).mapContent<AudioContent>()
-suspend fun BehaviourContext.waitDocument(
+fun BehaviourContext.waitDocument(
-    initRequest: Request<*>? = null,
     errorFactory: NullableRequestBuilder<*> = { null },
-) = waitContent(initRequest, errorFactory).mapContent<DocumentContent>()
+) = waitContent(errorFactory).mapContent<DocumentContent>()
-suspend fun BehaviourContext.waitPhoto(
+fun BehaviourContext.waitPhoto(
-    initRequest: Request<*>? = null,
     errorFactory: NullableRequestBuilder<*> = { null },
-) = waitContent(initRequest, errorFactory).mapContent<PhotoContent>()
+) = waitContent(errorFactory).mapContent<PhotoContent>()
-suspend fun BehaviourContext.waitSticker(
+fun BehaviourContext.waitSticker(
-    initRequest: Request<*>? = null,
     errorFactory: NullableRequestBuilder<*> = { null }
-) = waitContent(initRequest, errorFactory).mapContent<StickerContent>()
+) = waitContent(errorFactory).mapContent<StickerContent>()
-suspend fun BehaviourContext.waitVideo(
+fun BehaviourContext.waitVideo(
-    initRequest: Request<*>? = null,
     errorFactory: NullableRequestBuilder<*> = { null }
-) = waitContent(initRequest, errorFactory).mapContent<VideoContent>()
+) = waitContent(errorFactory).mapContent<VideoContent>()
-suspend fun BehaviourContext.waitVideoNote(
+fun BehaviourContext.waitVideoNote(
-    initRequest: Request<*>? = null,
     errorFactory: NullableRequestBuilder<*> = { null }
-) = waitContent(initRequest, errorFactory).mapContent<VideoNoteContent>()
+) = waitContent(errorFactory).mapContent<VideoNoteContent>()
-suspend fun BehaviourContext.waitVoice(
+fun BehaviourContext.waitVoice(
-    initRequest: Request<*>? = null,
     errorFactory: NullableRequestBuilder<*> = { null }
-) = waitContent(initRequest, errorFactory).mapContent<VoiceContent>()
+) = waitContent(errorFactory).mapContent<VoiceContent>()
-suspend fun BehaviourContext.waitInvoice(
+fun BehaviourContext.waitInvoice(
-    initRequest: Request<*>? = null,
     errorFactory: NullableRequestBuilder<*> = { null }
-) = waitContent(initRequest, errorFactory).mapContent<InvoiceContent>()
+) = waitContent(errorFactory).mapContent<InvoiceContent>()
-suspend fun BehaviourContext.waitVisualContent(
+fun BehaviourContext.waitVisualContent(
-    initRequest: Request<*>? = null,
     errorFactory: NullableRequestBuilder<*> = { null }
-) = waitContent(initRequest, errorFactory).mapContent<VisualMediaGroupPartContent>()
+) = waitContent(errorFactory).mapContent<VisualMediaGroupPartContent>()
-suspend fun BehaviourContext.waitMediaContent(
+fun BehaviourContext.waitMediaContent(
-    initRequest: Request<*>? = null,
     errorFactory: NullableRequestBuilder<*> = { null }
-) = waitContent(initRequest, errorFactory).mapContent<MediaContent>()
+) = waitContent(errorFactory).mapContent<MediaContent>()
 
-suspend fun BehaviourContext.waitGiveawayContent(
+fun BehaviourContext.waitGiveawayContent(
-    initRequest: Request<*>? = null,
     errorFactory: NullableRequestBuilder<*> = { null }
-) = waitContent(initRequest, errorFactory).mapContent<GiveawayContent>()
+) = waitContent(errorFactory).mapContent<GiveawayContent>()
 
-suspend fun BehaviourContext.waitGiveawayPublicResultsContent(
+fun BehaviourContext.waitGiveawayPublicResultsContent(
-    initRequest: Request<*>? = null,
     errorFactory: NullableRequestBuilder<*> = { null }
-) = waitContent(initRequest, errorFactory).mapContent<GiveawayPublicResultsContent>()
+) = waitContent(errorFactory).mapContent<GiveawayPublicResultsContent>()
 
-suspend fun BehaviourContext.waitGiveawayWinners(
+fun BehaviourContext.waitGiveawayWinners(
-    initRequest: Request<*>? = null,
     errorFactory: NullableRequestBuilder<*> = { null }
-) = waitGiveawayPublicResultsContent(initRequest, errorFactory)
+) = waitGiveawayPublicResultsContent(errorFactory)
 
-suspend fun BehaviourContext.waitPaidMediaInfoContent(
+fun BehaviourContext.waitPaidMediaInfoContent(
-    initRequest: Request<*>? = null,
     errorFactory: NullableRequestBuilder<*> = { null }
-) = waitContent(initRequest, errorFactory).mapContent<PaidMediaInfoContent>()
+) = waitContent(errorFactory).mapContent<PaidMediaInfoContent>()

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

@@ -16,11 +16,9 @@ import kotlinx.coroutines.flow.mapNotNull
 typealias CommonMessageToCommonMessageMapper<T> = suspend CommonMessage<T>.() -> CommonMessage<T>?
 
 @RiskFeature(lowLevelRiskFeatureMessage)
-suspend inline fun BehaviourContext.waitContentMessage(
+fun BehaviourContext.waitContentMessage(
-    initRequest: Request<*>? = null,
+    errorFactory: NullableRequestBuilder<*> = { null }
-    noinline errorFactory: NullableRequestBuilder<*> = { null }
 ): Flow<CommonMessage<MessageContent>> = expectFlow(
-    initRequest,
     errorFactory
 ) {
     if (it !is BaseSentMessageUpdate) {
@@ -31,141 +29,108 @@ suspend inline fun BehaviourContext.waitContentMessage(
 
 inline fun <reified T : MessageContent> Flow<CommonMessage<MessageContent>>.mapWithContent() = mapNotNull { it.withContentOrNull<T>() }
 
-suspend fun BehaviourContext.waitAnyContentMessage(
+fun BehaviourContext.waitAnyContentMessage(
-    initRequest: Request<*>? = null,
     errorFactory: NullableRequestBuilder<*> = { null },
-) = waitContentMessage(initRequest, errorFactory)
+) = waitContentMessage(errorFactory)
-suspend fun BehaviourContext.waitTextedContentMessage(
+fun BehaviourContext.waitTextedContentMessage(
-    initRequest: Request<*>? = null,
     errorFactory: NullableRequestBuilder<*> = { null },
-) = waitContentMessage(initRequest, errorFactory).mapWithContent<TextedContent>()
+) = waitContentMessage(errorFactory).mapWithContent<TextedContent>()
-suspend fun BehaviourContext.waitContactMessage(
+fun BehaviourContext.waitContactMessage(
-    initRequest: Request<*>? = null,
     errorFactory: NullableRequestBuilder<*> = { null }
-) = waitContentMessage(initRequest, errorFactory).mapWithContent<ContactContent>()
+) = waitContentMessage(errorFactory).mapWithContent<ContactContent>()
-suspend fun BehaviourContext.waitDiceMessage(
+fun BehaviourContext.waitDiceMessage(
-    initRequest: Request<*>? = null,
     errorFactory: NullableRequestBuilder<*> = { null }
-) = waitContentMessage(initRequest, errorFactory).mapWithContent<DiceContent>()
+) = waitContentMessage(errorFactory).mapWithContent<DiceContent>()
-suspend fun BehaviourContext.waitGameMessage(
+fun BehaviourContext.waitGameMessage(
-    initRequest: Request<*>? = null,
     errorFactory: NullableRequestBuilder<*> = { null }
-) = waitContentMessage(initRequest, errorFactory).mapWithContent<GameContent>()
+) = waitContentMessage(errorFactory).mapWithContent<GameContent>()
-suspend fun BehaviourContext.waitLocationMessage(
+fun BehaviourContext.waitLocationMessage(
-    initRequest: Request<*>? = null,
     errorFactory: NullableRequestBuilder<*> = { null }
-) = waitContentMessage(initRequest, errorFactory).mapWithContent<LocationContent>()
+) = waitContentMessage(errorFactory).mapWithContent<LocationContent>()
-suspend fun BehaviourContext.waitLiveLocationMessage(
+fun BehaviourContext.waitLiveLocationMessage(
-    initRequest: Request<*>? = null,
     errorFactory: NullableRequestBuilder<*> = { null }
-) = waitContentMessage(initRequest, errorFactory).mapWithContent<LiveLocationContent>()
+) = waitContentMessage(errorFactory).mapWithContent<LiveLocationContent>()
-suspend fun BehaviourContext.waitStaticLocationMessage(
+fun BehaviourContext.waitStaticLocationMessage(
-    initRequest: Request<*>? = null,
     errorFactory: NullableRequestBuilder<*> = { null }
-) = waitContentMessage(initRequest, errorFactory).mapWithContent<StaticLocationContent>()
+) = waitContentMessage(errorFactory).mapWithContent<StaticLocationContent>()
-suspend fun BehaviourContext.waitPollMessage(
+fun BehaviourContext.waitPollMessage(
-    initRequest: Request<*>? = null,
     errorFactory: NullableRequestBuilder<*> = { null }
-) = waitContentMessage(initRequest, errorFactory).mapWithContent<PollContent>()
+) = waitContentMessage(errorFactory).mapWithContent<PollContent>()
-suspend fun BehaviourContext.waitTextMessage(
+fun BehaviourContext.waitTextMessage(
-    initRequest: Request<*>? = null,
     errorFactory: NullableRequestBuilder<*> = { null }
-) = waitContentMessage(initRequest, errorFactory).mapWithContent<TextContent>()
+) = waitContentMessage(errorFactory).mapWithContent<TextContent>()
-suspend fun BehaviourContext.waitStoryMessage(
+fun BehaviourContext.waitStoryMessage(
-    initRequest: Request<*>? = null,
     errorFactory: NullableRequestBuilder<*> = { null }
-) = waitContentMessage(initRequest, errorFactory).mapWithContent<StoryContent>()
+) = waitContentMessage(errorFactory).mapWithContent<StoryContent>()
-suspend fun BehaviourContext.waitVenueMessage(
+fun BehaviourContext.waitVenueMessage(
-    initRequest: Request<*>? = null,
     errorFactory: NullableRequestBuilder<*> = { null }
-) = waitContentMessage(initRequest, errorFactory).mapWithContent<VenueContent>()
+) = waitContentMessage(errorFactory).mapWithContent<VenueContent>()
-suspend fun BehaviourContext.waitAudioMediaGroupContentMessage(
+fun BehaviourContext.waitAudioMediaGroupContentMessage(
-    initRequest: Request<*>? = null,
     errorFactory: NullableRequestBuilder<*> = { null }
-) = waitContentMessage(initRequest, errorFactory).mapWithContent<AudioMediaGroupPartContent>()
+) = waitContentMessage(errorFactory).mapWithContent<AudioMediaGroupPartContent>()
-suspend fun BehaviourContext.waitDocumentMediaGroupContentMessage(
+fun BehaviourContext.waitDocumentMediaGroupContentMessage(
-    initRequest: Request<*>? = null,
     errorFactory: NullableRequestBuilder<*> = { null }
-) = waitContentMessage(initRequest, errorFactory).mapWithContent<DocumentMediaGroupPartContent>()
+) = waitContentMessage(errorFactory).mapWithContent<DocumentMediaGroupPartContent>()
-suspend fun BehaviourContext.waitMediaMessage(
+fun BehaviourContext.waitMediaMessage(
-    initRequest: Request<*>? = null,
     errorFactory: NullableRequestBuilder<*> = { null }
-) = waitContentMessage(initRequest, errorFactory).mapWithContent<MediaContent>()
+) = waitContentMessage(errorFactory).mapWithContent<MediaContent>()
-suspend fun BehaviourContext.waitAnyMediaGroupContentMessage(
+fun BehaviourContext.waitAnyMediaGroupContentMessage(
-    initRequest: Request<*>? = null,
     errorFactory: NullableRequestBuilder<*> = { null }
-) = waitContentMessage(initRequest, errorFactory).mapWithContent<MediaGroupPartContent>()
+) = waitContentMessage(errorFactory).mapWithContent<MediaGroupPartContent>()
-suspend fun BehaviourContext.waitVisualMediaGroupContentMessage(
+fun BehaviourContext.waitVisualMediaGroupContentMessage(
-    initRequest: Request<*>? = null,
     errorFactory: NullableRequestBuilder<*> = { null }
-) = waitContentMessage(initRequest, errorFactory).mapWithContent<VisualMediaGroupPartContent>()
+) = waitContentMessage(errorFactory).mapWithContent<VisualMediaGroupPartContent>()
-suspend fun BehaviourContext.waitTextedMediaContentMessage(
+fun BehaviourContext.waitTextedMediaContentMessage(
-    initRequest: Request<*>? = null,
     errorFactory: NullableRequestBuilder<*> = { null }
-) = waitContentMessage(initRequest, errorFactory).mapWithContent<TextedMediaContent>()
+) = waitContentMessage(errorFactory).mapWithContent<TextedMediaContent>()
-suspend fun BehaviourContext.waitAnimationMessage(
+fun BehaviourContext.waitAnimationMessage(
-    initRequest: Request<*>? = null,
     errorFactory: NullableRequestBuilder<*> = { null }
-) = waitContentMessage(initRequest, errorFactory).mapWithContent<AnimationContent>()
+) = waitContentMessage(errorFactory).mapWithContent<AnimationContent>()
-suspend fun BehaviourContext.waitAudioMessage(
+fun BehaviourContext.waitAudioMessage(
-    initRequest: Request<*>? = null,
     errorFactory: NullableRequestBuilder<*> = { null }
-) = waitContentMessage(initRequest, errorFactory).mapWithContent<AudioContent>()
+) = waitContentMessage(errorFactory).mapWithContent<AudioContent>()
-suspend fun BehaviourContext.waitDocumentMessage(
+fun BehaviourContext.waitDocumentMessage(
-    initRequest: Request<*>? = null,
     errorFactory: NullableRequestBuilder<*> = { null }
-) = waitContentMessage(initRequest, errorFactory).mapWithContent<DocumentContent>()
+) = waitContentMessage(errorFactory).mapWithContent<DocumentContent>()
-suspend fun BehaviourContext.waitPhotoMessage(
+fun BehaviourContext.waitPhotoMessage(
-    initRequest: Request<*>? = null,
     errorFactory: NullableRequestBuilder<*> = { null }
-) = waitContentMessage(initRequest, errorFactory).mapWithContent<PhotoContent>()
+) = waitContentMessage(errorFactory).mapWithContent<PhotoContent>()
-suspend fun BehaviourContext.waitStickerMessage(
+fun BehaviourContext.waitStickerMessage(
-    initRequest: Request<*>? = null,
     errorFactory: NullableRequestBuilder<*> = { null }
-) = waitContentMessage(initRequest, errorFactory).mapWithContent<StickerContent>()
+) = waitContentMessage(errorFactory).mapWithContent<StickerContent>()
-suspend fun BehaviourContext.waitVideoMessage(
+fun BehaviourContext.waitVideoMessage(
-    initRequest: Request<*>? = null,
     errorFactory: NullableRequestBuilder<*> = { null }
-) = waitContentMessage(initRequest, errorFactory).mapWithContent<VideoContent>()
+) = waitContentMessage(errorFactory).mapWithContent<VideoContent>()
-suspend fun BehaviourContext.waitVideoNoteMessage(
+fun BehaviourContext.waitVideoNoteMessage(
-    initRequest: Request<*>? = null,
     errorFactory: NullableRequestBuilder<*> = { null }
-) = waitContentMessage(initRequest, errorFactory).mapWithContent<VideoNoteContent>()
+) = waitContentMessage(errorFactory).mapWithContent<VideoNoteContent>()
-suspend fun BehaviourContext.waitVoiceMessage(
+fun BehaviourContext.waitVoiceMessage(
-    initRequest: Request<*>? = null,
     errorFactory: NullableRequestBuilder<*> = { null }
-) = waitContentMessage(initRequest, errorFactory).mapWithContent<VoiceContent>()
+) = waitContentMessage(errorFactory).mapWithContent<VoiceContent>()
-suspend fun BehaviourContext.waitInvoiceMessage(
+fun BehaviourContext.waitInvoiceMessage(
-    initRequest: Request<*>? = null,
     errorFactory: NullableRequestBuilder<*> = { null }
-) = waitContentMessage(initRequest, errorFactory).mapWithContent<InvoiceContent>()
+) = waitContentMessage(errorFactory).mapWithContent<InvoiceContent>()
 
-suspend fun BehaviourContext.waitVisualContentMessage(
+fun BehaviourContext.waitVisualContentMessage(
-    initRequest: Request<*>? = null,
     errorFactory: NullableRequestBuilder<*> = { null }
-) = waitContentMessage(initRequest, errorFactory).mapWithContent<VisualMediaGroupPartContent>()
+) = waitContentMessage(errorFactory).mapWithContent<VisualMediaGroupPartContent>()
 
-suspend fun BehaviourContext.waitMediaContentMessage(
+fun BehaviourContext.waitMediaContentMessage(
-    initRequest: Request<*>? = null,
     errorFactory: NullableRequestBuilder<*> = { null }
-) = waitContentMessage(initRequest, errorFactory).mapWithContent<MediaContent>()
+) = waitContentMessage(errorFactory).mapWithContent<MediaContent>()
 
-suspend fun BehaviourContext.waitGiveawayContentMessage(
+fun BehaviourContext.waitGiveawayContentMessage(
-    initRequest: Request<*>? = null,
     errorFactory: NullableRequestBuilder<*> = { null }
-) = waitContentMessage(initRequest, errorFactory).mapWithContent<GiveawayContent>()
+) = waitContentMessage(errorFactory).mapWithContent<GiveawayContent>()
 
-suspend fun BehaviourContext.waitGiveawayPublicResultsContentMessage(
+fun BehaviourContext.waitGiveawayPublicResultsContentMessage(
-    initRequest: Request<*>? = null,
     errorFactory: NullableRequestBuilder<*> = { null }
-) = waitContentMessage(initRequest, errorFactory).mapWithContent<GiveawayPublicResultsContent>()
+) = waitContentMessage(errorFactory).mapWithContent<GiveawayPublicResultsContent>()
 
-suspend fun BehaviourContext.waitGiveawayWinnersMessage(
+fun BehaviourContext.waitGiveawayWinnersMessage(
-    initRequest: Request<*>? = null,
     errorFactory: NullableRequestBuilder<*> = { null }
-) = waitGiveawayPublicResultsContentMessage(initRequest, errorFactory)
+) = waitGiveawayPublicResultsContentMessage(errorFactory)
 
-suspend fun BehaviourContext.waitPaidMediaInfoContentMessage(
+fun BehaviourContext.waitPaidMediaInfoContentMessage(
-    initRequest: Request<*>? = null,
     errorFactory: NullableRequestBuilder<*> = { null }
-) = waitContentMessage(initRequest, errorFactory).mapWithContent<PaidMediaInfoContent>()
+) = waitContentMessage(errorFactory).mapWithContent<PaidMediaInfoContent>()

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

@@ -8,12 +8,10 @@ import dev.inmo.tgbotapi.types.message.content.TextContent
 import dev.inmo.tgbotapi.types.message.textsources.RegularTextSource
 import kotlinx.coroutines.flow.*
 
-suspend fun BehaviourContext.waitDeepLinks(
+fun BehaviourContext.waitDeepLinks(
-    initRequest: Request<*>? = null,
     errorFactory: NullableRequestBuilder<*> = { null },
 ): Flow<Pair<CommonMessage<TextContent>, String>> = waitCommandMessage(
     "start",
-    initRequest,
     errorFactory
 )
     .requireSingleCommand()
@@ -22,16 +20,14 @@ suspend fun BehaviourContext.waitDeepLinks(
         it.first to (it.second.second.singleOrNull() ?.regularTextSourceOrNull() ?.source ?.removePrefix(" ") ?: return@mapNotNull null)
     }
 
-suspend fun BehaviourContext.waitDeepLinks(
+fun BehaviourContext.waitDeepLinks(
     regex: Regex,
-    initRequest: Request<*>? = null,
     errorFactory: NullableRequestBuilder<*> = { null },
-): Flow<Pair<CommonMessage<TextContent>, String>> = waitDeepLinks(initRequest, errorFactory).filter {
+): Flow<Pair<CommonMessage<TextContent>, String>> = waitDeepLinks(errorFactory).filter {
     regex.matches(it.second)
 }
 
-suspend fun BehaviourContext.waitDeepLinks(
+fun BehaviourContext.waitDeepLinks(
     deepLink: String,
-    initRequest: Request<*>? = null,
     errorFactory: NullableRequestBuilder<*> = { null },
-): Flow<Pair<CommonMessage<TextContent>, String>> = waitDeepLinks(Regex("^$deepLink$"), initRequest, errorFactory)
+): Flow<Pair<CommonMessage<TextContent>, String>> = waitDeepLinks(Regex("^$deepLink$"), errorFactory)

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

@@ -8,11 +8,9 @@ import dev.inmo.tgbotapi.types.business_connection.BusinessMessagesDeleted
 import dev.inmo.tgbotapi.types.payments.ShippingQuery
 import kotlinx.coroutines.flow.Flow
 
-suspend fun BehaviourContext.waitDeletedBusinessMessages(
+fun BehaviourContext.waitDeletedBusinessMessages(
-    initRequest: Request<*>? = null,
     errorFactory: NullableRequestBuilder<*> = { null }
 ): Flow<BusinessMessagesDeleted> = expectFlow(
-    initRequest,
     errorFactory
 ) {
     (it.deletedBusinessMessageUpdateOrNull() ?.data).let(::listOfNotNull)

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

@@ -11,120 +11,92 @@ import kotlinx.coroutines.flow.Flow
 import kotlinx.coroutines.flow.map
 
 @RiskFeature(lowLevelRiskFeatureMessage)
-suspend inline fun <reified O : MessageContent> BehaviourContext.waitEditedContent(
+inline fun <reified O : MessageContent> BehaviourContext.waitEditedContent(
-    initRequest: Request<*>? = null,
     noinline errorFactory: NullableRequestBuilder<*> = { null }
-): Flow<O> = waitEditedContentMessage<O>(initRequest, errorFactory).map { it.content }
+): Flow<O> = waitEditedContentMessage<O>(errorFactory).map { it.content }
 
-suspend fun BehaviourContext.waitEditedMessageContent(
+fun BehaviourContext.waitEditedMessageContent(
-    initRequest: Request<*>? = null,
     errorFactory: NullableRequestBuilder<*> = { null },
-) = waitEditedContent<MessageContent>(initRequest, errorFactory)
+) = waitEditedContent<MessageContent>(errorFactory)
 
-suspend fun BehaviourContext.waitEditedContentMessage(
+fun BehaviourContext.waitEditedContentMessage(
-    initRequest: Request<*>? = null,
     errorFactory: NullableRequestBuilder<*> = { null },
-) = waitEditedContent<MessageContent>(initRequest, errorFactory)
+) = waitEditedContent<MessageContent>(errorFactory)
-suspend fun BehaviourContext.waitEditedContact(
+fun BehaviourContext.waitEditedContact(
-    initRequest: Request<*>? = null,
     errorFactory: NullableRequestBuilder<*> = { null }
-) = waitEditedContent<ContactContent>(initRequest, errorFactory)
+) = waitEditedContent<ContactContent>(errorFactory)
-suspend fun BehaviourContext.waitEditedDice(
+fun BehaviourContext.waitEditedDice(
-    initRequest: Request<*>? = null,
     errorFactory: NullableRequestBuilder<*> = { null }
-) = waitEditedContent<DiceContent>(initRequest, errorFactory)
+) = waitEditedContent<DiceContent>(errorFactory)
-suspend fun BehaviourContext.waitEditedGame(
+fun BehaviourContext.waitEditedGame(
-    initRequest: Request<*>? = null,
     errorFactory: NullableRequestBuilder<*> = { null }
-) = waitEditedContent<GameContent>(initRequest, errorFactory)
+) = waitEditedContent<GameContent>(errorFactory)
-suspend fun BehaviourContext.waitEditedLocation(
+fun BehaviourContext.waitEditedLocation(
-    initRequest: Request<*>? = null,
     errorFactory: NullableRequestBuilder<*> = { null }
-) = waitEditedContent<LocationContent>(initRequest, errorFactory)
+) = waitEditedContent<LocationContent>(errorFactory)
-suspend fun BehaviourContext.waitEditedLiveLocation(
+fun BehaviourContext.waitEditedLiveLocation(
-    initRequest: Request<*>? = null,
     errorFactory: NullableRequestBuilder<*> = { null }
-) = waitEditedContent<LiveLocationContent>(initRequest, errorFactory)
+) = waitEditedContent<LiveLocationContent>(errorFactory)
-suspend fun BehaviourContext.waitEditedStaticLocation(
+fun BehaviourContext.waitEditedStaticLocation(
-    initRequest: Request<*>? = null,
     errorFactory: NullableRequestBuilder<*> = { null }
-) = waitEditedContent<StaticLocationContent>(initRequest, errorFactory)
+) = waitEditedContent<StaticLocationContent>(errorFactory)
-suspend fun BehaviourContext.waitEditedText(
+fun BehaviourContext.waitEditedText(
-    initRequest: Request<*>? = null,
     errorFactory: NullableRequestBuilder<*> = { null }
-) = waitEditedContent<TextContent>(initRequest, errorFactory)
+) = waitEditedContent<TextContent>(errorFactory)
-suspend fun BehaviourContext.waitEditedVenue(
+fun BehaviourContext.waitEditedVenue(
-    initRequest: Request<*>? = null,
     errorFactory: NullableRequestBuilder<*> = { null }
-) = waitEditedContent<VenueContent>(initRequest, errorFactory)
+) = waitEditedContent<VenueContent>(errorFactory)
-suspend fun BehaviourContext.waitEditedAudioMediaGroupContent(
+fun BehaviourContext.waitEditedAudioMediaGroupContent(
-    initRequest: Request<*>? = null,
     errorFactory: NullableRequestBuilder<*> = { null },
-) = waitEditedContent<AudioMediaGroupPartContent>(initRequest, errorFactory)
+) = waitEditedContent<AudioMediaGroupPartContent>(errorFactory)
-suspend fun BehaviourContext.waitEditedDocumentMediaGroupContent(
+fun BehaviourContext.waitEditedDocumentMediaGroupContent(
-    initRequest: Request<*>? = null,
     errorFactory: NullableRequestBuilder<*> = { null },
-) = waitEditedContent<DocumentMediaGroupPartContent>(initRequest, errorFactory)
+) = waitEditedContent<DocumentMediaGroupPartContent>(errorFactory)
-suspend fun BehaviourContext.waitEditedMedia(
+fun BehaviourContext.waitEditedMedia(
-    initRequest: Request<*>? = null,
     errorFactory: NullableRequestBuilder<*> = { null },
-) = waitEditedContent<MediaContent>(initRequest, errorFactory)
+) = waitEditedContent<MediaContent>(errorFactory)
-suspend fun BehaviourContext.waitEditedAnyMediaGroupContent(
+fun BehaviourContext.waitEditedAnyMediaGroupContent(
-    initRequest: Request<*>? = null,
     errorFactory: NullableRequestBuilder<*> = { null },
-) = waitEditedContent<MediaGroupPartContent>(initRequest, errorFactory)
+) = waitEditedContent<MediaGroupPartContent>(errorFactory)
-suspend fun BehaviourContext.waitEditedVisualMediaGroupContent(
+fun BehaviourContext.waitEditedVisualMediaGroupContent(
-    initRequest: Request<*>? = null,
     errorFactory: NullableRequestBuilder<*> = { null },
-) = waitEditedContent<VisualMediaGroupPartContent>(initRequest, errorFactory)
+) = waitEditedContent<VisualMediaGroupPartContent>(errorFactory)
-suspend fun BehaviourContext.waitEditedTextedMediaContent(
+fun BehaviourContext.waitEditedTextedMediaContent(
-    initRequest: Request<*>? = null,
     errorFactory: NullableRequestBuilder<*> = { null },
-) = waitEditedContent<TextedMediaContent>(initRequest, errorFactory)
+) = waitEditedContent<TextedMediaContent>(errorFactory)
-suspend fun BehaviourContext.waitEditedAnimation(
+fun BehaviourContext.waitEditedAnimation(
-    initRequest: Request<*>? = null,
     errorFactory: NullableRequestBuilder<*> = { null }
-) = waitEditedContent<AnimationContent>(initRequest, errorFactory)
+) = waitEditedContent<AnimationContent>(errorFactory)
-suspend fun BehaviourContext.waitEditedAudio(
+fun BehaviourContext.waitEditedAudio(
-    initRequest: Request<*>? = null,
     errorFactory: NullableRequestBuilder<*> = { null },
-) = waitEditedContent<AudioContent>(initRequest, errorFactory)
+) = waitEditedContent<AudioContent>(errorFactory)
-suspend fun BehaviourContext.waitEditedDocument(
+fun BehaviourContext.waitEditedDocument(
-    initRequest: Request<*>? = null,
     errorFactory: NullableRequestBuilder<*> = { null },
-) = waitEditedContent<DocumentContent>(initRequest, errorFactory)
+) = waitEditedContent<DocumentContent>(errorFactory)
-suspend fun BehaviourContext.waitEditedPhoto(
+fun BehaviourContext.waitEditedPhoto(
-    initRequest: Request<*>? = null,
     errorFactory: NullableRequestBuilder<*> = { null },
-) = waitEditedContent<PhotoContent>(initRequest, errorFactory)
+) = waitEditedContent<PhotoContent>(errorFactory)
-suspend fun BehaviourContext.waitEditedSticker(
+fun BehaviourContext.waitEditedSticker(
-    initRequest: Request<*>? = null,
     errorFactory: NullableRequestBuilder<*> = { null }
-) = waitEditedContent<StickerContent>(initRequest, errorFactory)
+) = waitEditedContent<StickerContent>(errorFactory)
-suspend fun BehaviourContext.waitEditedVideo(
+fun BehaviourContext.waitEditedVideo(
-    initRequest: Request<*>? = null,
     errorFactory: NullableRequestBuilder<*> = { null },
-) = waitEditedContent<VideoContent>(initRequest, errorFactory)
+) = waitEditedContent<VideoContent>(errorFactory)
-suspend fun BehaviourContext.waitEditedVideoNote(
+fun BehaviourContext.waitEditedVideoNote(
-    initRequest: Request<*>? = null,
     errorFactory: NullableRequestBuilder<*> = { null }
-) = waitEditedContent<VideoNoteContent>(initRequest, errorFactory)
+) = waitEditedContent<VideoNoteContent>(errorFactory)
-suspend fun BehaviourContext.waitEditedVoice(
+fun BehaviourContext.waitEditedVoice(
-    initRequest: Request<*>? = null,
     errorFactory: NullableRequestBuilder<*> = { null }
-) = waitEditedContent<VoiceContent>(initRequest, errorFactory)
+) = waitEditedContent<VoiceContent>(errorFactory)
-suspend fun BehaviourContext.waitEditedInvoice(
+fun BehaviourContext.waitEditedInvoice(
-    initRequest: Request<*>? = null,
     errorFactory: NullableRequestBuilder<*> = { null }
-) = waitEditedContent<InvoiceContent>(initRequest, errorFactory)
+) = waitEditedContent<InvoiceContent>(errorFactory)
 
-suspend fun BehaviourContext.waitEditedGiveawayContent(
+fun BehaviourContext.waitEditedGiveawayContent(
-    initRequest: Request<*>? = null,
     errorFactory: NullableRequestBuilder<*> = { null }
-) = waitEditedContent<GiveawayContent>(initRequest, errorFactory)
+) = waitEditedContent<GiveawayContent>(errorFactory)
 
-suspend fun BehaviourContext.waitEditedGiveawayPublicResultsContent(
+fun BehaviourContext.waitEditedGiveawayPublicResultsContent(
-    initRequest: Request<*>? = null,
     errorFactory: NullableRequestBuilder<*> = { null }
-) = waitEditedContent<GiveawayPublicResultsContent>(initRequest, errorFactory)
+) = waitEditedContent<GiveawayPublicResultsContent>(errorFactory)
 

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

@@ -14,11 +14,9 @@ import dev.inmo.tgbotapi.utils.lowLevelRiskFeatureMessage
 import kotlinx.coroutines.flow.Flow
 
 @RiskFeature(lowLevelRiskFeatureMessage)
-suspend inline fun <reified O : MessageContent> BehaviourContext.waitEditedContentMessage(
+inline fun <reified O : MessageContent> BehaviourContext.waitEditedContentMessage(
-    initRequest: Request<*>? = null,
     noinline errorFactory: NullableRequestBuilder<*> = { null }
 ): Flow<CommonMessage<O>> = expectFlow(
-    initRequest,
     errorFactory
 ) {
     val messages = when (it) {
@@ -33,111 +31,85 @@ suspend inline fun <reified O : MessageContent> BehaviourContext.waitEditedConte
     }
 }
 
-suspend fun BehaviourContext.waitEditedMessageContentMessage(
+fun BehaviourContext.waitEditedMessageContentMessage(
-    initRequest: Request<*>? = null,
     errorFactory: NullableRequestBuilder<*> = { null }
-) = waitEditedContentMessage<MessageContent>(initRequest, errorFactory)
+) = waitEditedContentMessage<MessageContent>(errorFactory)
 
-suspend fun BehaviourContext.waitEditedContactMessage(
+fun BehaviourContext.waitEditedContactMessage(
-    initRequest: Request<*>? = null,
     errorFactory: NullableRequestBuilder<*> = { null }
-) = waitEditedContentMessage<ContactContent>(initRequest, errorFactory)
+) = waitEditedContentMessage<ContactContent>(errorFactory)
-suspend fun BehaviourContext.waitEditedDiceMessage(
+fun BehaviourContext.waitEditedDiceMessage(
-    initRequest: Request<*>? = null,
     errorFactory: NullableRequestBuilder<*> = { null }
-) = waitEditedContentMessage<DiceContent>(initRequest, errorFactory)
+) = waitEditedContentMessage<DiceContent>(errorFactory)
-suspend fun BehaviourContext.waitEditedGameMessage(
+fun BehaviourContext.waitEditedGameMessage(
-    initRequest: Request<*>? = null,
     errorFactory: NullableRequestBuilder<*> = { null }
-) = waitEditedContentMessage<GameContent>(initRequest, errorFactory)
+) = waitEditedContentMessage<GameContent>(errorFactory)
-suspend fun BehaviourContext.waitEditedLocationMessage(
+fun BehaviourContext.waitEditedLocationMessage(
-    initRequest: Request<*>? = null,
     errorFactory: NullableRequestBuilder<*> = { null }
-) = waitEditedContentMessage<LocationContent>(initRequest, errorFactory)
+) = waitEditedContentMessage<LocationContent>(errorFactory)
-suspend fun BehaviourContext.waitEditedLiveLocationMessage(
+fun BehaviourContext.waitEditedLiveLocationMessage(
-    initRequest: Request<*>? = null,
     errorFactory: NullableRequestBuilder<*> = { null }
-) = waitEditedContentMessage<LiveLocationContent>(initRequest, errorFactory)
+) = waitEditedContentMessage<LiveLocationContent>(errorFactory)
-suspend fun BehaviourContext.waitEditedStaticLocationMessage(
+fun BehaviourContext.waitEditedStaticLocationMessage(
-    initRequest: Request<*>? = null,
     errorFactory: NullableRequestBuilder<*> = { null }
-) = waitEditedContentMessage<StaticLocationContent>(initRequest, errorFactory)
+) = waitEditedContentMessage<StaticLocationContent>(errorFactory)
-suspend fun BehaviourContext.waitEditedTextMessage(
+fun BehaviourContext.waitEditedTextMessage(
-    initRequest: Request<*>? = null,
     errorFactory: NullableRequestBuilder<*> = { null }
-) = waitEditedContentMessage<TextContent>(initRequest, errorFactory)
+) = waitEditedContentMessage<TextContent>(errorFactory)
-suspend fun BehaviourContext.waitEditedVenueMessage(
+fun BehaviourContext.waitEditedVenueMessage(
-    initRequest: Request<*>? = null,
     errorFactory: NullableRequestBuilder<*> = { null }
-) = waitEditedContentMessage<VenueContent>(initRequest, errorFactory)
+) = waitEditedContentMessage<VenueContent>(errorFactory)
-suspend fun BehaviourContext.waitEditedAudioMediaGroupContentMessage(
+fun BehaviourContext.waitEditedAudioMediaGroupContentMessage(
-    initRequest: Request<*>? = null,
     errorFactory: NullableRequestBuilder<*> = { null }
-) = waitEditedContentMessage<AudioMediaGroupPartContent>(initRequest, errorFactory)
+) = waitEditedContentMessage<AudioMediaGroupPartContent>(errorFactory)
-suspend fun BehaviourContext.waitEditedDocumentMediaGroupContentMessage(
+fun BehaviourContext.waitEditedDocumentMediaGroupContentMessage(
-    initRequest: Request<*>? = null,
     errorFactory: NullableRequestBuilder<*> = { null }
-) = waitEditedContentMessage<DocumentMediaGroupPartContent>(initRequest, errorFactory)
+) = waitEditedContentMessage<DocumentMediaGroupPartContent>(errorFactory)
-suspend fun BehaviourContext.waitEditedMediaMessage(
+fun BehaviourContext.waitEditedMediaMessage(
-    initRequest: Request<*>? = null,
     errorFactory: NullableRequestBuilder<*> = { null },
-) = waitEditedContentMessage<MediaContent>(initRequest, errorFactory)
+) = waitEditedContentMessage<MediaContent>(errorFactory)
-suspend fun BehaviourContext.waitEditedAnyMediaGroupContentMessage(
+fun BehaviourContext.waitEditedAnyMediaGroupContentMessage(
-    initRequest: Request<*>? = null,
     errorFactory: NullableRequestBuilder<*> = { null }
-) = waitEditedContentMessage<MediaGroupPartContent>(initRequest, errorFactory)
+) = waitEditedContentMessage<MediaGroupPartContent>(errorFactory)
-suspend fun BehaviourContext.waitEditedVisualMediaGroupContentMessage(
+fun BehaviourContext.waitEditedVisualMediaGroupContentMessage(
-    initRequest: Request<*>? = null,
     errorFactory: NullableRequestBuilder<*> = { null }
-) = waitEditedContentMessage<VisualMediaGroupPartContent>(initRequest, errorFactory)
+) = waitEditedContentMessage<VisualMediaGroupPartContent>(errorFactory)
-suspend fun BehaviourContext.waitEditedTextedMediaContentMessage(
+fun BehaviourContext.waitEditedTextedMediaContentMessage(
-    initRequest: Request<*>? = null,
     errorFactory: NullableRequestBuilder<*> = { null }
-) = waitEditedContentMessage<TextedMediaContent>(initRequest, errorFactory)
+) = waitEditedContentMessage<TextedMediaContent>(errorFactory)
-suspend fun BehaviourContext.waitEditedAnimationMessage(
+fun BehaviourContext.waitEditedAnimationMessage(
-    initRequest: Request<*>? = null,
     errorFactory: NullableRequestBuilder<*> = { null }
-) = waitEditedContentMessage<AnimationContent>(initRequest, errorFactory)
+) = waitEditedContentMessage<AnimationContent>(errorFactory)
-suspend fun BehaviourContext.waitEditedAudioMessage(
+fun BehaviourContext.waitEditedAudioMessage(
-    initRequest: Request<*>? = null,
     errorFactory: NullableRequestBuilder<*> = { null },
-) = waitEditedContentMessage<AudioContent>(initRequest, errorFactory)
+) = waitEditedContentMessage<AudioContent>(errorFactory)
-suspend fun BehaviourContext.waitEditedDocumentMessage(
+fun BehaviourContext.waitEditedDocumentMessage(
-    initRequest: Request<*>? = null,
     errorFactory: NullableRequestBuilder<*> = { null },
-) = waitEditedContentMessage<DocumentContent>(initRequest, errorFactory)
+) = waitEditedContentMessage<DocumentContent>(errorFactory)
-suspend fun BehaviourContext.waitEditedPhotoMessage(
+fun BehaviourContext.waitEditedPhotoMessage(
-    initRequest: Request<*>? = null,
     errorFactory: NullableRequestBuilder<*> = { null },
-) = waitEditedContentMessage<PhotoContent>(initRequest, errorFactory)
+) = waitEditedContentMessage<PhotoContent>(errorFactory)
-suspend fun BehaviourContext.waitEditedStickerMessage(
+fun BehaviourContext.waitEditedStickerMessage(
-    initRequest: Request<*>? = null,
     errorFactory: NullableRequestBuilder<*> = { null }
-) = waitEditedContentMessage<StickerContent>(initRequest, errorFactory)
+) = waitEditedContentMessage<StickerContent>(errorFactory)
-suspend fun BehaviourContext.waitEditedVideoMessage(
+fun BehaviourContext.waitEditedVideoMessage(
-    initRequest: Request<*>? = null,
     errorFactory: NullableRequestBuilder<*> = { null },
-) = waitEditedContentMessage<VideoContent>(initRequest, errorFactory)
+) = waitEditedContentMessage<VideoContent>(errorFactory)
-suspend fun BehaviourContext.waitEditedVideoNoteMessage(
+fun BehaviourContext.waitEditedVideoNoteMessage(
-    initRequest: Request<*>? = null,
     errorFactory: NullableRequestBuilder<*> = { null }
-) = waitEditedContentMessage<VideoNoteContent>(initRequest, errorFactory)
+) = waitEditedContentMessage<VideoNoteContent>(errorFactory)
-suspend fun BehaviourContext.waitEditedVoiceMessage(
+fun BehaviourContext.waitEditedVoiceMessage(
-    initRequest: Request<*>? = null,
     errorFactory: NullableRequestBuilder<*> = { null }
-) = waitEditedContentMessage<VoiceContent>(initRequest, errorFactory)
+) = waitEditedContentMessage<VoiceContent>(errorFactory)
-suspend fun BehaviourContext.waitEditedInvoiceMessage(
+fun BehaviourContext.waitEditedInvoiceMessage(
-    initRequest: Request<*>? = null,
     errorFactory: NullableRequestBuilder<*> = { null }
-) = waitEditedContentMessage<InvoiceContent>(initRequest, errorFactory)
+) = waitEditedContentMessage<InvoiceContent>(errorFactory)
 
-suspend fun BehaviourContext.waitEditedGiveawayContentMessage(
+fun BehaviourContext.waitEditedGiveawayContentMessage(
-    initRequest: Request<*>? = null,
     errorFactory: NullableRequestBuilder<*> = { null }
-) = waitEditedContentMessage<GiveawayContent>(initRequest, errorFactory)
+) = waitEditedContentMessage<GiveawayContent>(errorFactory)
 
-suspend fun BehaviourContext.waitEditedGiveawayPublicResultsContentMessage(
+fun BehaviourContext.waitEditedGiveawayPublicResultsContentMessage(
-    initRequest: Request<*>? = null,
     errorFactory: NullableRequestBuilder<*> = { null }
-) = waitEditedContentMessage<GiveawayPublicResultsContent>(initRequest, errorFactory)
+) = waitEditedContentMessage<GiveawayPublicResultsContent>(errorFactory)
 

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

@@ -34,233 +34,182 @@ import kotlinx.coroutines.flow.filter
 typealias EventMessageToEventMapper<T> = suspend ChatEventMessage<T>.() -> T?
 
 @RiskFeature(lowLevelRiskFeatureMessage)
-suspend inline fun <reified O : ChatEvent> BehaviourContext.waitEvents(
+inline fun <reified O : ChatEvent> BehaviourContext.waitEvents(
-    initRequest: Request<*>? = null,
     noinline errorFactory: NullableRequestBuilder<*> = { null }
 ): Flow<O> = expectFlow(
-    initRequest,
     errorFactory
 ) {
     it.baseSentMessageUpdateOrNull() ?.data ?.chatEventMessageOrNull() ?.withEvent<O>() ?.chatEvent.let(::listOfNotNull)
 }
 
-suspend fun BehaviourContext.waitChannelEvents(
+fun BehaviourContext.waitChannelEvents(
-    initRequest: Request<*>? = null,
     errorFactory: NullableRequestBuilder<*> = { null }
-) = waitEvents<ChannelEvent>(initRequest, errorFactory)
+) = waitEvents<ChannelEvent>(errorFactory)
 
-suspend fun BehaviourContext.waitPrivateEvents(
+fun BehaviourContext.waitPrivateEvents(
-    initRequest: Request<*>? = null,
     errorFactory: NullableRequestBuilder<*> = { null }
-) = waitEvents<PrivateEvent>(initRequest, errorFactory)
+) = waitEvents<PrivateEvent>(errorFactory)
 
-suspend fun BehaviourContext.waitChatEvents(
+fun BehaviourContext.waitChatEvents(
-    initRequest: Request<*>? = null,
     errorFactory: NullableRequestBuilder<*> = { null }
-) = waitEvents<ChatEvent>(initRequest, errorFactory)
+) = waitEvents<ChatEvent>(errorFactory)
 
 
-suspend fun BehaviourContext.waitVideoChatEvents(
+fun BehaviourContext.waitVideoChatEvents(
-    initRequest: Request<*>? = null,
     errorFactory: NullableRequestBuilder<*> = { null }
-) = waitEvents<VideoChatEvent>(initRequest, errorFactory)
+) = waitEvents<VideoChatEvent>(errorFactory)
-suspend fun BehaviourContext.waitVideoChatStartedEvents(
+fun BehaviourContext.waitVideoChatStartedEvents(
-    initRequest: Request<*>? = null,
     errorFactory: NullableRequestBuilder<*> = { null }
-) = waitEvents<VideoChatStarted>(initRequest, errorFactory)
+) = waitEvents<VideoChatStarted>(errorFactory)
-suspend fun BehaviourContext.waitVideoChatEndedEvents(
+fun BehaviourContext.waitVideoChatEndedEvents(
-    initRequest: Request<*>? = null,
     errorFactory: NullableRequestBuilder<*> = { null }
-) = waitEvents<VideoChatEnded>(initRequest, errorFactory)
+) = waitEvents<VideoChatEnded>(errorFactory)
-suspend fun BehaviourContext.waitVideoChatParticipantsInvitedEvents(
+fun BehaviourContext.waitVideoChatParticipantsInvitedEvents(
-    initRequest: Request<*>? = null,
     errorFactory: NullableRequestBuilder<*> = { null }
-) = waitEvents<VideoChatParticipantsInvited>(initRequest, errorFactory)
+) = waitEvents<VideoChatParticipantsInvited>(errorFactory)
 
-suspend fun BehaviourContext.waitMessageAutoDeleteTimerChangedEvents(
+fun BehaviourContext.waitMessageAutoDeleteTimerChangedEvents(
-    initRequest: Request<*>? = null,
     errorFactory: NullableRequestBuilder<*> = { null }
-) = waitEvents<MessageAutoDeleteTimerChanged>(initRequest, errorFactory)
+) = waitEvents<MessageAutoDeleteTimerChanged>(errorFactory)
 
 
-suspend fun BehaviourContext.waitPublicChatEvents(
+fun BehaviourContext.waitPublicChatEvents(
-    initRequest: Request<*>? = null,
     errorFactory: NullableRequestBuilder<*> = { null }
-) = waitEvents<PublicChatEvent>(initRequest, errorFactory)
+) = waitEvents<PublicChatEvent>(errorFactory)
-suspend fun BehaviourContext.waitCommonEvents(
+fun BehaviourContext.waitCommonEvents(
-    initRequest: Request<*>? = null,
     errorFactory: NullableRequestBuilder<*> = { null }
-) = waitEvents<CommonEvent>(initRequest, errorFactory)
+) = waitEvents<CommonEvent>(errorFactory)
 
-suspend fun BehaviourContext.waitGroupEvents(
+fun BehaviourContext.waitGroupEvents(
-    initRequest: Request<*>? = null,
     errorFactory: NullableRequestBuilder<*> = { null }
-) = waitEvents<GroupEvent>(initRequest, errorFactory)
+) = waitEvents<GroupEvent>(errorFactory)
-suspend fun BehaviourContext.waitSupergroupEvents(
+fun BehaviourContext.waitSupergroupEvents(
-    initRequest: Request<*>? = null,
     errorFactory: NullableRequestBuilder<*> = { null }
-) = waitEvents<SupergroupEvent>(initRequest, errorFactory)
+) = waitEvents<SupergroupEvent>(errorFactory)
 
-suspend fun BehaviourContext.waitChannelChatCreatedEvents(
+fun BehaviourContext.waitChannelChatCreatedEvents(
-    initRequest: Request<*>? = null,
     errorFactory: NullableRequestBuilder<*> = { null }
-) = waitEvents<ChannelChatCreated>(initRequest, errorFactory)
+) = waitEvents<ChannelChatCreated>(errorFactory)
-suspend fun BehaviourContext.waitDeleteChatPhotoEvents(
+fun BehaviourContext.waitDeleteChatPhotoEvents(
-    initRequest: Request<*>? = null,
     errorFactory: NullableRequestBuilder<*> = { null }
-) = waitEvents<DeleteChatPhoto>(initRequest, errorFactory)
+) = waitEvents<DeleteChatPhoto>(errorFactory)
-suspend fun BehaviourContext.waitGroupChatCreatedEvents(
+fun BehaviourContext.waitGroupChatCreatedEvents(
-    initRequest: Request<*>? = null,
     errorFactory: NullableRequestBuilder<*> = { null }
-) = waitEvents<GroupChatCreated>(initRequest, errorFactory)
+) = waitEvents<GroupChatCreated>(errorFactory)
-suspend fun BehaviourContext.waitLeftChatMemberEvents(
+fun BehaviourContext.waitLeftChatMemberEvents(
-    initRequest: Request<*>? = null,
     errorFactory: NullableRequestBuilder<*> = { null }
-) = waitEvents<LeftChatMemberEvent>(initRequest, errorFactory)
+) = waitEvents<LeftChatMemberEvent>(errorFactory)
-suspend fun BehaviourContext.waitNewChatPhotoEvents(
+fun BehaviourContext.waitNewChatPhotoEvents(
-    initRequest: Request<*>? = null,
     errorFactory: NullableRequestBuilder<*> = { null }
-) = waitEvents<NewChatPhoto>(initRequest, errorFactory)
+) = waitEvents<NewChatPhoto>(errorFactory)
-suspend fun BehaviourContext.waitNewChatMembersEvents(
+fun BehaviourContext.waitNewChatMembersEvents(
-    initRequest: Request<*>? = null,
     errorFactory: NullableRequestBuilder<*> = { null }
-) = waitEvents<NewChatMembers>(initRequest, errorFactory)
+) = waitEvents<NewChatMembers>(errorFactory)
-suspend fun BehaviourContext.waitNewChatTitleEvents(
+fun BehaviourContext.waitNewChatTitleEvents(
-    initRequest: Request<*>? = null,
     errorFactory: NullableRequestBuilder<*> = { null }
-) = waitEvents<NewChatTitle>(initRequest, errorFactory)
+) = waitEvents<NewChatTitle>(errorFactory)
-suspend fun BehaviourContext.waitPinnedMessageEvents(
+fun BehaviourContext.waitPinnedMessageEvents(
-    initRequest: Request<*>? = null,
     errorFactory: NullableRequestBuilder<*> = { null }
-) = waitEvents<PinnedMessage>(initRequest, errorFactory)
+) = waitEvents<PinnedMessage>(errorFactory)
-suspend fun BehaviourContext.waitProximityAlertTriggeredEvents(
+fun BehaviourContext.waitProximityAlertTriggeredEvents(
-    initRequest: Request<*>? = null,
     errorFactory: NullableRequestBuilder<*> = { null }
-) = waitEvents<ProximityAlertTriggered>(initRequest, errorFactory)
+) = waitEvents<ProximityAlertTriggered>(errorFactory)
-suspend fun BehaviourContext.waitSupergroupChatCreatedEvents(
+fun BehaviourContext.waitSupergroupChatCreatedEvents(
-    initRequest: Request<*>? = null,
     errorFactory: NullableRequestBuilder<*> = { null }
-) = waitEvents<SupergroupChatCreated>(initRequest, errorFactory)
+) = waitEvents<SupergroupChatCreated>(errorFactory)
-suspend fun BehaviourContext.waitSuccessfulPaymentEvents(
+fun BehaviourContext.waitSuccessfulPaymentEvents(
-    initRequest: Request<*>? = null,
     errorFactory: NullableRequestBuilder<*> = { null }
-) = waitEvents<SuccessfulPaymentEvent>(initRequest, errorFactory)
+) = waitEvents<SuccessfulPaymentEvent>(errorFactory)
-suspend fun BehaviourContext.waitRefundedPaymentEvents(
+fun BehaviourContext.waitRefundedPaymentEvents(
-    initRequest: Request<*>? = null,
     errorFactory: NullableRequestBuilder<*> = { null }
-) = waitEvents<RefundedPaymentEvent>(initRequest, errorFactory)
+) = waitEvents<RefundedPaymentEvent>(errorFactory)
-suspend fun BehaviourContext.waitUserLoggedInEvents(
+fun BehaviourContext.waitUserLoggedInEvents(
-    initRequest: Request<*>? = null,
     errorFactory: NullableRequestBuilder<*> = { null }
-) = waitEvents<UserLoggedIn>(initRequest, errorFactory)
+) = waitEvents<UserLoggedIn>(errorFactory)
-suspend fun BehaviourContext.waitWebAppDataEvents(
+fun BehaviourContext.waitWebAppDataEvents(
-    initRequest: Request<*>? = null,
     errorFactory: NullableRequestBuilder<*> = { null }
-) = waitEvents<WebAppData>(initRequest, errorFactory)
+) = waitEvents<WebAppData>(errorFactory)
-suspend fun BehaviourContext.waitForumTopicClosed(
+fun BehaviourContext.waitForumTopicClosed(
-    initRequest: Request<*>? = null,
     errorFactory: NullableRequestBuilder<*> = { null }
-) = waitEvents<ForumTopicClosed>(initRequest, errorFactory)
+) = waitEvents<ForumTopicClosed>(errorFactory)
-suspend fun BehaviourContext.waitForumTopicCreated(
+fun BehaviourContext.waitForumTopicCreated(
-    initRequest: Request<*>? = null,
     errorFactory: NullableRequestBuilder<*> = { null }
-) = waitEvents<ForumTopicCreated>(initRequest, errorFactory)
+) = waitEvents<ForumTopicCreated>(errorFactory)
-suspend fun BehaviourContext.waitForumTopicReopened(
+fun BehaviourContext.waitForumTopicReopened(
-    initRequest: Request<*>? = null,
     errorFactory: NullableRequestBuilder<*> = { null }
-) = waitEvents<ForumTopicReopened>(initRequest, errorFactory)
+) = waitEvents<ForumTopicReopened>(errorFactory)
-suspend fun BehaviourContext.waitForumTopicEdited(
+fun BehaviourContext.waitForumTopicEdited(
-    initRequest: Request<*>? = null,
     errorFactory: NullableRequestBuilder<*> = { null }
-) = waitEvents<ForumTopicEdited>(initRequest, errorFactory)
+) = waitEvents<ForumTopicEdited>(errorFactory)
-suspend fun BehaviourContext.waitGeneralForumTopicHidden(
+fun BehaviourContext.waitGeneralForumTopicHidden(
-    initRequest: Request<*>? = null,
     errorFactory: NullableRequestBuilder<*> = { null }
-) = waitEvents<GeneralForumTopicHidden>(initRequest, errorFactory)
+) = waitEvents<GeneralForumTopicHidden>(errorFactory)
-suspend fun BehaviourContext.waitGeneralForumTopicUnhidden(
+fun BehaviourContext.waitGeneralForumTopicUnhidden(
-    initRequest: Request<*>? = null,
     errorFactory: NullableRequestBuilder<*> = { null }
-) = waitEvents<GeneralForumTopicUnhidden>(initRequest, errorFactory)
+) = waitEvents<GeneralForumTopicUnhidden>(errorFactory)
-suspend fun BehaviourContext.waitWriteAccessAllowed(
+fun BehaviourContext.waitWriteAccessAllowed(
-    initRequest: Request<*>? = null,
     errorFactory: NullableRequestBuilder<*> = { null }
-) = waitEvents<WriteAccessAllowed>(initRequest, errorFactory)
+) = waitEvents<WriteAccessAllowed>(errorFactory)
-suspend fun BehaviourContext.waitWriteAccessAllowedFromRequest(
+fun BehaviourContext.waitWriteAccessAllowedFromRequest(
-    initRequest: Request<*>? = null,
     errorFactory: NullableRequestBuilder<*> = { null }
-) = waitEvents<WriteAccessAllowed.FromRequest>(initRequest, errorFactory)
+) = waitEvents<WriteAccessAllowed.FromRequest>(errorFactory)
 
-suspend fun BehaviourContext.waitWriteAccessAllowedFromAttachmentMenu(
+fun BehaviourContext.waitWriteAccessAllowedFromAttachmentMenu(
-    initRequest: Request<*>? = null,
     errorFactory: NullableRequestBuilder<*> = { null }
-) = waitEvents<WriteAccessAllowed.FromAttachmentMenu>(initRequest, errorFactory)
+) = waitEvents<WriteAccessAllowed.FromAttachmentMenu>(errorFactory)
 
-suspend fun BehaviourContext.waitWriteAccessAllowedFromWebAppLink(
+fun BehaviourContext.waitWriteAccessAllowedFromWebAppLink(
-    initRequest: Request<*>? = null,
     errorFactory: NullableRequestBuilder<*> = { null }
-) = waitEvents<WriteAccessAllowed.FromWebAppLink>(initRequest, errorFactory)
+) = waitEvents<WriteAccessAllowed.FromWebAppLink>(errorFactory)
 
-suspend fun BehaviourContext.waitWriteAccessAllowedOther(
+fun BehaviourContext.waitWriteAccessAllowedOther(
-    initRequest: Request<*>? = null,
     errorFactory: NullableRequestBuilder<*> = { null }
-) = waitEvents<WriteAccessAllowed.Other>(initRequest, errorFactory)
+) = waitEvents<WriteAccessAllowed.Other>(errorFactory)
 
-suspend fun BehaviourContext.waitChatSharedRequest(
+fun BehaviourContext.waitChatSharedRequest(
-    initRequest: Request<*>? = null,
     errorFactory: NullableRequestBuilder<*> = { null }
-) = waitEvents<ChatSharedRequest>(initRequest, errorFactory)
+) = waitEvents<ChatSharedRequest>(errorFactory)
 
-suspend fun BehaviourContext.waitUsersShared(
+fun BehaviourContext.waitUsersShared(
-    initRequest: Request<*>? = null,
     errorFactory: NullableRequestBuilder<*> = { null }
-) = waitEvents<UsersShared>(initRequest, errorFactory)
+) = waitEvents<UsersShared>(errorFactory)
 
-suspend fun BehaviourContext.waitUserShared(
+fun BehaviourContext.waitUserShared(
-    initRequest: Request<*>? = null,
     errorFactory: NullableRequestBuilder<*> = { null }
-) = waitUsersShared(initRequest, errorFactory).filter { it.userIds.size == 1 }
+) = waitUsersShared(errorFactory).filter { it.userIds.size == 1 }
 
-suspend fun BehaviourContext.waitChatShared(
+fun BehaviourContext.waitChatShared(
-    initRequest: Request<*>? = null,
     errorFactory: NullableRequestBuilder<*> = { null }
-) = waitEvents<ChatShared>(initRequest, errorFactory)
+) = waitEvents<ChatShared>(errorFactory)
 
-suspend fun BehaviourContext.waitChatBoostAdded(
+fun BehaviourContext.waitChatBoostAdded(
-    initRequest: Request<*>? = null,
     errorFactory: NullableRequestBuilder<*> = { null }
-) = waitEvents<ChatBoostAdded>(initRequest, errorFactory)
+) = waitEvents<ChatBoostAdded>(errorFactory)
 
-suspend fun BehaviourContext.waitChatBackgroundSet(
+fun BehaviourContext.waitChatBackgroundSet(
-    initRequest: Request<*>? = null,
     errorFactory: NullableRequestBuilder<*> = { null }
-) = waitEvents<ChatBackground>(initRequest, errorFactory)
+) = waitEvents<ChatBackground>(errorFactory)
 
-suspend fun BehaviourContext.waitGiveawayCreated(
+fun BehaviourContext.waitGiveawayCreated(
-    initRequest: Request<*>? = null,
     errorFactory: NullableRequestBuilder<*> = { null }
-) = waitEvents<GiveawayCreated>(initRequest, errorFactory)
+) = waitEvents<GiveawayCreated>(errorFactory)
 
-suspend fun BehaviourContext.waitGiveawayCompleted(
+fun BehaviourContext.waitGiveawayCompleted(
-    initRequest: Request<*>? = null,
     errorFactory: NullableRequestBuilder<*> = { null }
-) = waitEvents<GiveawayPrivateResults>(initRequest, errorFactory)
+) = waitEvents<GiveawayPrivateResults>(errorFactory)
 
-suspend fun BehaviourContext.waitGiveawayCompletedWithPrivateWinners(
+fun BehaviourContext.waitGiveawayCompletedWithPrivateWinners(
-    initRequest: Request<*>? = null,
     errorFactory: NullableRequestBuilder<*> = { null }
-) = waitGiveawayCompleted(initRequest, errorFactory)
+) = waitGiveawayCompleted(errorFactory)
 
-suspend fun BehaviourContext.waitPaidMessagePriceChanged(
+fun BehaviourContext.waitPaidMessagePriceChanged(
-    initRequest: Request<*>? = null,
     errorFactory: NullableRequestBuilder<*> = { null }
-) = waitEvents<PaidMessagePriceChanged>(initRequest, errorFactory)
+) = waitEvents<PaidMessagePriceChanged>(errorFactory)
 
-suspend fun BehaviourContext.waitRegularGiftSentOrReceived(
+fun BehaviourContext.waitRegularGiftSentOrReceived(
-    initRequest: Request<*>? = null,
     errorFactory: NullableRequestBuilder<*> = { null }
-) = waitEvents<GiftSentOrReceived.Regular>(initRequest, errorFactory)
+) = waitEvents<GiftSentOrReceived.Regular>(errorFactory)
 
-suspend fun BehaviourContext.waitUniqueGiftSentOrReceived(
+fun BehaviourContext.waitUniqueGiftSentOrReceived(
-    initRequest: Request<*>? = null,
     errorFactory: NullableRequestBuilder<*> = { null }
-) = waitEvents<GiftSentOrReceived.Unique>(initRequest, errorFactory)
+) = waitEvents<GiftSentOrReceived.Unique>(errorFactory)

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

@@ -30,214 +30,166 @@ import kotlinx.coroutines.flow.Flow
 import kotlinx.coroutines.flow.filter
 
 @RiskFeature(lowLevelRiskFeatureMessage)
-suspend inline fun <reified O : ChatEvent> BehaviourContext.waitEventsMessages(
+inline fun <reified O : ChatEvent> BehaviourContext.waitEventsMessages(
-    initRequest: Request<*>? = null,
     noinline errorFactory: NullableRequestBuilder<*> = { null }
 ): Flow<ChatEventMessage<O>> = expectFlow(
-    initRequest,
     errorFactory
 ) {
     it.baseSentMessageUpdateOrNull() ?.data ?.chatEventMessageOrNull() ?.withEvent<O>().let(::listOfNotNull)
 }
 
-suspend fun BehaviourContext.waitChannelEventsMessages(
+fun BehaviourContext.waitChannelEventsMessages(
-    initRequest: Request<*>? = null,
     errorFactory: NullableRequestBuilder<*> = { null }
-) = waitEventsMessages<ChannelEvent>(initRequest, errorFactory)
+) = waitEventsMessages<ChannelEvent>(errorFactory)
 
-suspend fun BehaviourContext.waitPrivateEventsMessages(
+fun BehaviourContext.waitPrivateEventsMessages(
-    initRequest: Request<*>? = null,
     errorFactory: NullableRequestBuilder<*> = { null }
-) = waitEventsMessages<PrivateEvent>(initRequest, errorFactory)
+) = waitEventsMessages<PrivateEvent>(errorFactory)
 
-suspend fun BehaviourContext.waitChatEventsMessages(
+fun BehaviourContext.waitChatEventsMessages(
-    initRequest: Request<*>? = null,
     errorFactory: NullableRequestBuilder<*> = { null }
-) = waitEventsMessages<ChatEvent>(initRequest, errorFactory)
+) = waitEventsMessages<ChatEvent>(errorFactory)
 
-suspend fun BehaviourContext.waitVideoChatEventsMessages(
+fun BehaviourContext.waitVideoChatEventsMessages(
-    initRequest: Request<*>? = null,
     errorFactory: NullableRequestBuilder<*> = { null }
-) = waitEventsMessages<VideoChatEvent>(initRequest, errorFactory)
+) = waitEventsMessages<VideoChatEvent>(errorFactory)
-suspend fun BehaviourContext.waitVideoChatStartedEventsMessages(
+fun BehaviourContext.waitVideoChatStartedEventsMessages(
-    initRequest: Request<*>? = null,
     errorFactory: NullableRequestBuilder<*> = { null }
-) = waitEventsMessages<VideoChatStarted>(initRequest, errorFactory)
+) = waitEventsMessages<VideoChatStarted>(errorFactory)
-suspend fun BehaviourContext.waitVideoChatEndedEventsMessages(
+fun BehaviourContext.waitVideoChatEndedEventsMessages(
-    initRequest: Request<*>? = null,
     errorFactory: NullableRequestBuilder<*> = { null }
-) = waitEventsMessages<VideoChatEnded>(initRequest, errorFactory)
+) = waitEventsMessages<VideoChatEnded>(errorFactory)
-suspend fun BehaviourContext.waitVideoChatParticipantsInvitedEventsMessages(
+fun BehaviourContext.waitVideoChatParticipantsInvitedEventsMessages(
-    initRequest: Request<*>? = null,
     errorFactory: NullableRequestBuilder<*> = { null }
-) = waitEventsMessages<VideoChatParticipantsInvited>(initRequest, errorFactory)
+) = waitEventsMessages<VideoChatParticipantsInvited>(errorFactory)
 
-suspend fun BehaviourContext.waitMessageAutoDeleteTimerChangedEventsMessages(
+fun BehaviourContext.waitMessageAutoDeleteTimerChangedEventsMessages(
-    initRequest: Request<*>? = null,
     errorFactory: NullableRequestBuilder<*> = { null }
-) = waitEventsMessages<MessageAutoDeleteTimerChanged>(initRequest, errorFactory)
+) = waitEventsMessages<MessageAutoDeleteTimerChanged>(errorFactory)
 
 
-suspend fun BehaviourContext.waitPublicChatEventsMessages(
+fun BehaviourContext.waitPublicChatEventsMessages(
-    initRequest: Request<*>? = null,
     errorFactory: NullableRequestBuilder<*> = { null }
-) = waitEventsMessages<PublicChatEvent>(initRequest, errorFactory)
+) = waitEventsMessages<PublicChatEvent>(errorFactory)
-suspend fun BehaviourContext.waitCommonEventsMessages(
+fun BehaviourContext.waitCommonEventsMessages(
-    initRequest: Request<*>? = null,
     errorFactory: NullableRequestBuilder<*> = { null }
-) = waitEventsMessages<CommonEvent>(initRequest, errorFactory)
+) = waitEventsMessages<CommonEvent>(errorFactory)
 
-suspend fun BehaviourContext.waitGroupEventsMessages(
+fun BehaviourContext.waitGroupEventsMessages(
-    initRequest: Request<*>? = null,
     errorFactory: NullableRequestBuilder<*> = { null }
-) = waitEventsMessages<GroupEvent>(initRequest, errorFactory)
+) = waitEventsMessages<GroupEvent>(errorFactory)
-suspend fun BehaviourContext.waitSupergroupEventsMessages(
+fun BehaviourContext.waitSupergroupEventsMessages(
-    initRequest: Request<*>? = null,
     errorFactory: NullableRequestBuilder<*> = { null }
-) = waitEventsMessages<SupergroupEvent>(initRequest, errorFactory)
+) = waitEventsMessages<SupergroupEvent>(errorFactory)
 
-suspend fun BehaviourContext.waitChannelChatCreatedEventsMessages(
+fun BehaviourContext.waitChannelChatCreatedEventsMessages(
-    initRequest: Request<*>? = null,
     errorFactory: NullableRequestBuilder<*> = { null }
-) = waitEventsMessages<ChannelChatCreated>(initRequest, errorFactory)
+) = waitEventsMessages<ChannelChatCreated>(errorFactory)
-suspend fun BehaviourContext.waitDeleteChatPhotoEventsMessages(
+fun BehaviourContext.waitDeleteChatPhotoEventsMessages(
-    initRequest: Request<*>? = null,
     errorFactory: NullableRequestBuilder<*> = { null }
-) = waitEventsMessages<DeleteChatPhoto>(initRequest, errorFactory)
+) = waitEventsMessages<DeleteChatPhoto>(errorFactory)
-suspend fun BehaviourContext.waitGroupChatCreatedEventsMessages(
+fun BehaviourContext.waitGroupChatCreatedEventsMessages(
-    initRequest: Request<*>? = null,
     errorFactory: NullableRequestBuilder<*> = { null }
-) = waitEventsMessages<GroupChatCreated>(initRequest, errorFactory)
+) = waitEventsMessages<GroupChatCreated>(errorFactory)
-suspend fun BehaviourContext.waitLeftChatMemberEventsMessages(
+fun BehaviourContext.waitLeftChatMemberEventsMessages(
-    initRequest: Request<*>? = null,
     errorFactory: NullableRequestBuilder<*> = { null }
-) = waitEventsMessages<LeftChatMemberEvent>(initRequest, errorFactory)
+) = waitEventsMessages<LeftChatMemberEvent>(errorFactory)
-suspend fun BehaviourContext.waitNewChatPhotoEventsMessages(
+fun BehaviourContext.waitNewChatPhotoEventsMessages(
-    initRequest: Request<*>? = null,
     errorFactory: NullableRequestBuilder<*> = { null }
-) = waitEventsMessages<NewChatPhoto>(initRequest, errorFactory)
+) = waitEventsMessages<NewChatPhoto>(errorFactory)
-suspend fun BehaviourContext.waitNewChatMembersEventsMessages(
+fun BehaviourContext.waitNewChatMembersEventsMessages(
-    initRequest: Request<*>? = null,
     errorFactory: NullableRequestBuilder<*> = { null }
-) = waitEventsMessages<NewChatMembers>(initRequest, errorFactory)
+) = waitEventsMessages<NewChatMembers>(errorFactory)
-suspend fun BehaviourContext.waitNewChatTitleEventsMessages(
+fun BehaviourContext.waitNewChatTitleEventsMessages(
-    initRequest: Request<*>? = null,
     errorFactory: NullableRequestBuilder<*> = { null }
-) = waitEventsMessages<NewChatTitle>(initRequest, errorFactory)
+) = waitEventsMessages<NewChatTitle>(errorFactory)
-suspend fun BehaviourContext.waitPinnedMessageEventsMessages(
+fun BehaviourContext.waitPinnedMessageEventsMessages(
-    initRequest: Request<*>? = null,
     errorFactory: NullableRequestBuilder<*> = { null }
-) = waitEventsMessages<PinnedMessage>(initRequest, errorFactory)
+) = waitEventsMessages<PinnedMessage>(errorFactory)
-suspend fun BehaviourContext.waitProximityAlertTriggeredEventsMessages(
+fun BehaviourContext.waitProximityAlertTriggeredEventsMessages(
-    initRequest: Request<*>? = null,
     errorFactory: NullableRequestBuilder<*> = { null }
-) = waitEventsMessages<ProximityAlertTriggered>(initRequest, errorFactory)
+) = waitEventsMessages<ProximityAlertTriggered>(errorFactory)
-suspend fun BehaviourContext.waitSupergroupChatCreatedEventsMessages(
+fun BehaviourContext.waitSupergroupChatCreatedEventsMessages(
-    initRequest: Request<*>? = null,
     errorFactory: NullableRequestBuilder<*> = { null }
-) = waitEventsMessages<SupergroupChatCreated>(initRequest, errorFactory)
+) = waitEventsMessages<SupergroupChatCreated>(errorFactory)
-suspend fun BehaviourContext.waitSuccessfulPaymentEventsMessages(
+fun BehaviourContext.waitSuccessfulPaymentEventsMessages(
-    initRequest: Request<*>? = null,
     errorFactory: NullableRequestBuilder<*> = { null }
-) = waitEventsMessages<SuccessfulPaymentEvent>(initRequest, errorFactory)
+) = waitEventsMessages<SuccessfulPaymentEvent>(errorFactory)
-suspend fun BehaviourContext.waitRefundedPaymentEventsMessages(
+fun BehaviourContext.waitRefundedPaymentEventsMessages(
-    initRequest: Request<*>? = null,
     errorFactory: NullableRequestBuilder<*> = { null }
-) = waitEventsMessages<RefundedPaymentEvent>(initRequest, errorFactory)
+) = waitEventsMessages<RefundedPaymentEvent>(errorFactory)
-suspend fun BehaviourContext.waitUserLoggedInEventsMessages(
+fun BehaviourContext.waitUserLoggedInEventsMessages(
-    initRequest: Request<*>? = null,
     errorFactory: NullableRequestBuilder<*> = { null }
-) = waitEventsMessages<UserLoggedIn>(initRequest, errorFactory)
+) = waitEventsMessages<UserLoggedIn>(errorFactory)
-suspend fun BehaviourContext.waitWebAppDataEventsMessages(
+fun BehaviourContext.waitWebAppDataEventsMessages(
-    initRequest: Request<*>? = null,
     errorFactory: NullableRequestBuilder<*> = { null }
-) = waitEventsMessages<WebAppData>(initRequest, errorFactory)
+) = waitEventsMessages<WebAppData>(errorFactory)
-suspend fun BehaviourContext.waitForumTopicClosedEventsMessages(
+fun BehaviourContext.waitForumTopicClosedEventsMessages(
-    initRequest: Request<*>? = null,
     errorFactory: NullableRequestBuilder<*> = { null }
-) = waitEventsMessages<ForumTopicClosed>(initRequest, errorFactory)
+) = waitEventsMessages<ForumTopicClosed>(errorFactory)
-suspend fun BehaviourContext.waitForumTopicCreatedEventsMessages(
+fun BehaviourContext.waitForumTopicCreatedEventsMessages(
-    initRequest: Request<*>? = null,
     errorFactory: NullableRequestBuilder<*> = { null }
-) = waitEventsMessages<ForumTopicCreated>(initRequest, errorFactory)
+) = waitEventsMessages<ForumTopicCreated>(errorFactory)
-suspend fun BehaviourContext.waitForumTopicReopenedEventsMessages(
+fun BehaviourContext.waitForumTopicReopenedEventsMessages(
-    initRequest: Request<*>? = null,
     errorFactory: NullableRequestBuilder<*> = { null }
-) = waitEventsMessages<ForumTopicReopened>(initRequest, errorFactory)
+) = waitEventsMessages<ForumTopicReopened>(errorFactory)
-suspend fun BehaviourContext.waitForumTopicEditedEventsMessages(
+fun BehaviourContext.waitForumTopicEditedEventsMessages(
-    initRequest: Request<*>? = null,
     errorFactory: NullableRequestBuilder<*> = { null }
-) = waitEventsMessages<ForumTopicEdited>(initRequest, errorFactory)
+) = waitEventsMessages<ForumTopicEdited>(errorFactory)
-suspend fun BehaviourContext.waitGeneralForumTopicHiddenEventsMessages(
+fun BehaviourContext.waitGeneralForumTopicHiddenEventsMessages(
-    initRequest: Request<*>? = null,
     errorFactory: NullableRequestBuilder<*> = { null }
-) = waitEventsMessages<GeneralForumTopicHidden>(initRequest, errorFactory)
+) = waitEventsMessages<GeneralForumTopicHidden>(errorFactory)
-suspend fun BehaviourContext.waitGeneralForumTopicUnhiddenEventsMessages(
+fun BehaviourContext.waitGeneralForumTopicUnhiddenEventsMessages(
-    initRequest: Request<*>? = null,
     errorFactory: NullableRequestBuilder<*> = { null }
-) = waitEventsMessages<GeneralForumTopicUnhidden>(initRequest, errorFactory)
+) = waitEventsMessages<GeneralForumTopicUnhidden>(errorFactory)
-suspend fun BehaviourContext.waitWriteAccessAllowedEventsMessages(
+fun BehaviourContext.waitWriteAccessAllowedEventsMessages(
-    initRequest: Request<*>? = null,
     errorFactory: NullableRequestBuilder<*> = { null }
-) = waitEventsMessages<WriteAccessAllowed>(initRequest, errorFactory)
+) = waitEventsMessages<WriteAccessAllowed>(errorFactory)
-suspend fun BehaviourContext.waitWriteAccessAllowedFromRequestEventsMessages(
+fun BehaviourContext.waitWriteAccessAllowedFromRequestEventsMessages(
-    initRequest: Request<*>? = null,
     errorFactory: NullableRequestBuilder<*> = { null }
-) = waitEventsMessages<WriteAccessAllowed.FromRequest>(initRequest, errorFactory)
+) = waitEventsMessages<WriteAccessAllowed.FromRequest>(errorFactory)
-suspend fun BehaviourContext.waitWriteAccessAllowedFromAttachmentMenuEventsMessages(
+fun BehaviourContext.waitWriteAccessAllowedFromAttachmentMenuEventsMessages(
-    initRequest: Request<*>? = null,
     errorFactory: NullableRequestBuilder<*> = { null }
-) = waitEventsMessages<WriteAccessAllowed.FromAttachmentMenu>(initRequest, errorFactory)
+) = waitEventsMessages<WriteAccessAllowed.FromAttachmentMenu>(errorFactory)
-suspend fun BehaviourContext.waitWriteAccessAllowedFromWebAppLinkEventsMessages(
+fun BehaviourContext.waitWriteAccessAllowedFromWebAppLinkEventsMessages(
-    initRequest: Request<*>? = null,
     errorFactory: NullableRequestBuilder<*> = { null }
-) = waitEventsMessages<WriteAccessAllowed.FromWebAppLink>(initRequest, errorFactory)
+) = waitEventsMessages<WriteAccessAllowed.FromWebAppLink>(errorFactory)
-suspend fun BehaviourContext.waitWriteAccessAllowedOtherEventsMessages(
+fun BehaviourContext.waitWriteAccessAllowedOtherEventsMessages(
-    initRequest: Request<*>? = null,
     errorFactory: NullableRequestBuilder<*> = { null }
-) = waitEventsMessages<WriteAccessAllowed.Other>(initRequest, errorFactory)
+) = waitEventsMessages<WriteAccessAllowed.Other>(errorFactory)
 
-suspend fun BehaviourContext.waitChatSharedRequestEventsMessages(
+fun BehaviourContext.waitChatSharedRequestEventsMessages(
-    initRequest: Request<*>? = null,
     errorFactory: NullableRequestBuilder<*> = { null }
-) = waitEventsMessages<ChatSharedRequest>(initRequest, errorFactory)
+) = waitEventsMessages<ChatSharedRequest>(errorFactory)
 
-suspend fun BehaviourContext.waitUsersSharedEventsMessages(
+fun BehaviourContext.waitUsersSharedEventsMessages(
-    initRequest: Request<*>? = null,
     errorFactory: NullableRequestBuilder<*> = { null }
-) = waitEventsMessages<UsersShared>(initRequest, errorFactory)
+) = waitEventsMessages<UsersShared>(errorFactory)
 
-suspend fun BehaviourContext.waitUserSharedEventsMessages(
+fun BehaviourContext.waitUserSharedEventsMessages(
-    initRequest: Request<*>? = null,
     errorFactory: NullableRequestBuilder<*> = { null }
-) = waitUsersSharedEventsMessages(initRequest, errorFactory).filter { it.chatEvent.userIds.size == 1 }
+) = waitUsersSharedEventsMessages(errorFactory).filter { it.chatEvent.userIds.size == 1 }
 
-suspend fun BehaviourContext.waitChatSharedEventsMessages(
+fun BehaviourContext.waitChatSharedEventsMessages(
-    initRequest: Request<*>? = null,
     errorFactory: NullableRequestBuilder<*> = { null }
-) = waitEventsMessages<ChatShared>(initRequest, errorFactory)
+) = waitEventsMessages<ChatShared>(errorFactory)
 
-suspend fun BehaviourContext.waitChatBoostAddedEventsMessages(
+fun BehaviourContext.waitChatBoostAddedEventsMessages(
-    initRequest: Request<*>? = null,
     errorFactory: NullableRequestBuilder<*> = { null }
-) = waitEventsMessages<ChatBoostAdded>(initRequest, errorFactory)
+) = waitEventsMessages<ChatBoostAdded>(errorFactory)
 
-suspend fun BehaviourContext.waitChatBackgroundSetEventsMessages(
+fun BehaviourContext.waitChatBackgroundSetEventsMessages(
-    initRequest: Request<*>? = null,
     errorFactory: NullableRequestBuilder<*> = { null }
-) = waitEventsMessages<ChatBackground>(initRequest, errorFactory)
+) = waitEventsMessages<ChatBackground>(errorFactory)
 
-suspend fun BehaviourContext.waitPaidMessagePriceChangedMessages(
+fun BehaviourContext.waitPaidMessagePriceChangedMessages(
-    initRequest: Request<*>? = null,
     errorFactory: NullableRequestBuilder<*> = { null }
-) = waitEventsMessages<PaidMessagePriceChanged>(initRequest, errorFactory)
+) = waitEventsMessages<PaidMessagePriceChanged>(errorFactory)
 
-suspend fun BehaviourContext.waitRegularGiftSentOrReceivedMessages(
+fun BehaviourContext.waitRegularGiftSentOrReceivedMessages(
-    initRequest: Request<*>? = null,
     errorFactory: NullableRequestBuilder<*> = { null }
-) = waitEventsMessages<GiftSentOrReceived.Regular>(initRequest, errorFactory)
+) = waitEventsMessages<GiftSentOrReceived.Regular>(errorFactory)
 
-suspend fun BehaviourContext.waitUniqueGiftSentOrReceivedMessages(
+fun BehaviourContext.waitUniqueGiftSentOrReceivedMessages(
-    initRequest: Request<*>? = null,
     errorFactory: NullableRequestBuilder<*> = { null }
-) = waitEventsMessages<GiftSentOrReceived.Unique>(initRequest, errorFactory)
+) = waitEventsMessages<GiftSentOrReceived.Unique>(errorFactory)

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

@@ -11,26 +11,21 @@ import kotlinx.coroutines.flow.Flow
 typealias InlineQueryMapper<T> = suspend T.() -> T?
 
 @RiskFeature(lowLevelRiskFeatureMessage)
-suspend inline fun <reified O : InlineQuery> BehaviourContext.waitInlineQueries(
+inline fun <reified O : InlineQuery> BehaviourContext.waitInlineQueries(
-    initRequest: Request<*>? = null,
     noinline errorFactory: NullableRequestBuilder<*> = { null }
 ): Flow<O> = expectFlow(
-    initRequest,
     errorFactory
 ) {
     (it.inlineQueryUpdateOrNull() ?.data as? O).let(::listOfNotNull)
 }
 
-suspend fun BehaviourContext.waitAnyInlineQuery(
+fun BehaviourContext.waitAnyInlineQuery(
-    initRequest: Request<*>? = null,
     errorFactory: NullableRequestBuilder<*> = { null }
-) = waitInlineQueries<InlineQuery>(initRequest, errorFactory)
+) = waitInlineQueries<InlineQuery>(errorFactory)
 
-suspend fun BehaviourContext.waitBaseInlineQuery(
+fun BehaviourContext.waitBaseInlineQuery(
-    initRequest: Request<*>? = null,
     errorFactory: NullableRequestBuilder<*> = { null }
-) = waitInlineQueries<BaseInlineQuery>(initRequest, errorFactory)
+) = waitInlineQueries<BaseInlineQuery>(errorFactory)
-suspend fun BehaviourContext.waitLocationInlineQuery(
+fun BehaviourContext.waitLocationInlineQuery(
-    initRequest: Request<*>? = null,
     errorFactory: NullableRequestBuilder<*> = { null }
-) = waitInlineQueries<LocationInlineQuery>(initRequest, errorFactory)
+) = waitInlineQueries<LocationInlineQuery>(errorFactory)

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

@@ -12,10 +12,9 @@ import dev.inmo.tgbotapi.utils.lowLevelRiskFeatureMessage
 import kotlinx.coroutines.flow.Flow
 
 @RiskFeature(lowLevelRiskFeatureMessage)
-suspend inline fun <reified T : MediaGroupPartContent> BehaviourContext.buildMediaGroupWaiter(
+inline fun <reified T : MediaGroupPartContent> BehaviourContext.buildMediaGroupWaiter(
-    initRequest: Request<*>? = null,
     noinline errorFactory: NullableRequestBuilder<*> = { null }
-): Flow<MediaGroupContent<T>> = flowsUpdatesFilter.expectFlow(bot, initRequest, errorFactory) { update ->
+): Flow<MediaGroupContent<T>> = flowsUpdatesFilter.expectFlow(bot, errorFactory) { update ->
     update.baseSentMessageUpdateOrNull() ?.data ?.commonMessageOrNull() ?.withContentOrNull<MediaGroupContent<*>>() ?.let { message ->
         if (message.content.group.all { it is T }) {
             listOf(message.content as MediaGroupContent<T>)
@@ -25,27 +24,21 @@ suspend inline fun <reified T : MediaGroupPartContent> BehaviourContext.buildMed
     } ?: emptyList()
 }
 
-suspend fun BehaviourContext.waitMediaGroup(
+fun BehaviourContext.waitMediaGroup(
-    initRequest: Request<*>? = null,
     errorFactory: NullableRequestBuilder<*> = { null }
-) = buildMediaGroupWaiter<MediaGroupPartContent>(initRequest, errorFactory)
+) = buildMediaGroupWaiter<MediaGroupPartContent>(errorFactory)
-suspend fun BehaviourContext.waitPlaylist(
+fun BehaviourContext.waitPlaylist(
-    initRequest: Request<*>? = null,
     errorFactory: NullableRequestBuilder<*> = { null }
-) = buildMediaGroupWaiter<AudioMediaGroupPartContent>(initRequest, errorFactory)
+) = buildMediaGroupWaiter<AudioMediaGroupPartContent>(errorFactory)
-suspend fun BehaviourContext.waitDocumentsGroup(
+fun BehaviourContext.waitDocumentsGroup(
-    initRequest: Request<*>? = null,
     errorFactory: NullableRequestBuilder<*> = { null }
-) = buildMediaGroupWaiter<DocumentMediaGroupPartContent>(initRequest, errorFactory)
+) = buildMediaGroupWaiter<DocumentMediaGroupPartContent>(errorFactory)
-suspend fun BehaviourContext.waitVisualGallery(
+fun BehaviourContext.waitVisualGallery(
-    initRequest: Request<*>? = null,
     errorFactory: NullableRequestBuilder<*> = { null }
-) = buildMediaGroupWaiter<VisualMediaGroupPartContent>(initRequest, errorFactory)
+) = buildMediaGroupWaiter<VisualMediaGroupPartContent>(errorFactory)
-suspend fun BehaviourContext.waitPhotoGallery(
+fun BehaviourContext.waitPhotoGallery(
-    initRequest: Request<*>? = null,
     errorFactory: NullableRequestBuilder<*> = { null }
-) = buildMediaGroupWaiter<PhotoContent>(initRequest, errorFactory)
+) = buildMediaGroupWaiter<PhotoContent>(errorFactory)
-suspend fun BehaviourContext.waitVideoGallery(
+fun BehaviourContext.waitVideoGallery(
-    initRequest: Request<*>? = null,
     errorFactory: NullableRequestBuilder<*> = { null }
-) = buildMediaGroupWaiter<VideoContent>(initRequest, errorFactory)
+) = buildMediaGroupWaiter<VideoContent>(errorFactory)

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

@@ -12,10 +12,9 @@ import dev.inmo.tgbotapi.utils.lowLevelRiskFeatureMessage
 import kotlinx.coroutines.flow.Flow
 
 @RiskFeature(lowLevelRiskFeatureMessage)
-suspend inline fun <reified T : MediaGroupPartContent> BehaviourContext.buildMediaGroupMessagesWaiter(
+inline fun <reified T : MediaGroupPartContent> BehaviourContext.buildMediaGroupMessagesWaiter(
-    initRequest: Request<*>? = null,
     noinline errorFactory: NullableRequestBuilder<*> = { null }
-): Flow<MediaGroupMessage<T>> = flowsUpdatesFilter.expectFlow(bot, initRequest, errorFactory) { update ->
+): Flow<MediaGroupMessage<T>> = flowsUpdatesFilter.expectFlow(bot, errorFactory) { update ->
     update.baseSentMessageUpdateOrNull() ?.data ?.commonMessageOrNull() ?.withContentOrNull<MediaGroupContent<*>>() ?.let { message ->
         if (message.content.group.all { it is T }) {
             listOf(message as MediaGroupMessage<T>)
@@ -25,27 +24,21 @@ suspend inline fun <reified T : MediaGroupPartContent> BehaviourContext.buildMed
     } ?: emptyList()
 }
 
-suspend fun BehaviourContext.waitMediaGroupMessages(
+fun BehaviourContext.waitMediaGroupMessages(
-    initRequest: Request<*>? = null,
     errorFactory: NullableRequestBuilder<*> = { null }
-) = buildMediaGroupMessagesWaiter<MediaGroupPartContent>(initRequest, errorFactory)
+) = buildMediaGroupMessagesWaiter<MediaGroupPartContent>(errorFactory)
-suspend fun BehaviourContext.waitPlaylistMessages(
+fun BehaviourContext.waitPlaylistMessages(
-    initRequest: Request<*>? = null,
     errorFactory: NullableRequestBuilder<*> = { null }
-) = buildMediaGroupMessagesWaiter<AudioMediaGroupPartContent>(initRequest, errorFactory)
+) = buildMediaGroupMessagesWaiter<AudioMediaGroupPartContent>(errorFactory)
-suspend fun BehaviourContext.waitDocumentsGroupMessages(
+fun BehaviourContext.waitDocumentsGroupMessages(
-    initRequest: Request<*>? = null,
     errorFactory: NullableRequestBuilder<*> = { null }
-) = buildMediaGroupMessagesWaiter<DocumentMediaGroupPartContent>(initRequest, errorFactory)
+) = buildMediaGroupMessagesWaiter<DocumentMediaGroupPartContent>(errorFactory)
-suspend fun BehaviourContext.waitVisualGalleryMessages(
+fun BehaviourContext.waitVisualGalleryMessages(
-    initRequest: Request<*>? = null,
     errorFactory: NullableRequestBuilder<*> = { null }
-) = buildMediaGroupMessagesWaiter<VisualMediaGroupPartContent>(initRequest, errorFactory)
+) = buildMediaGroupMessagesWaiter<VisualMediaGroupPartContent>(errorFactory)
-suspend fun BehaviourContext.waitPhotoGalleryMessages(
+fun BehaviourContext.waitPhotoGalleryMessages(
-    initRequest: Request<*>? = null,
     errorFactory: NullableRequestBuilder<*> = { null }
-) = buildMediaGroupMessagesWaiter<PhotoContent>(initRequest, errorFactory)
+) = buildMediaGroupMessagesWaiter<PhotoContent>(errorFactory)
-suspend fun BehaviourContext.waitVideoGalleryMessages(
+fun BehaviourContext.waitVideoGalleryMessages(
-    initRequest: Request<*>? = null,
     errorFactory: NullableRequestBuilder<*> = { null }
-) = buildMediaGroupMessagesWaiter<VideoContent>(initRequest, errorFactory)
+) = buildMediaGroupMessagesWaiter<VideoContent>(errorFactory)

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

@@ -74,11 +74,10 @@ fun Flow<TextedContent>.filterMentions(user: User) = filter {
  * @see filterMentions
  * @see filterTextMentions
  */
-suspend fun BehaviourContext.waitContentWithMentions (
+fun BehaviourContext.waitContentWithMentions (
     username: Username,
-    initRequest: Request<*>? = null,
     errorFactory: NullableRequestBuilder<*> = { null }
-) = waitContent(initRequest, errorFactory).mapContent<TextedContent>().filterMentions(username)
+) = waitContent(errorFactory).mapContent<TextedContent>().filterMentions(username)
 
 /**
  * Creates cold [Flow] with the messages with [TextedContent] where [userId] has been mentioned with text
@@ -87,11 +86,10 @@ suspend fun BehaviourContext.waitContentWithMentions (
  * @see filterMentions
  * @see dev.inmo.tgbotapi.types.message.textsources.TextMentionTextSource
  */
-suspend fun BehaviourContext.waitContentWithTextMentions (
+fun BehaviourContext.waitContentWithTextMentions (
     userId: UserId,
-    initRequest: Request<*>? = null,
     errorFactory: NullableRequestBuilder<*> = { null }
-) = waitTextedContent(initRequest, errorFactory).filterTextMentions(userId)
+) = waitTextedContent(errorFactory).filterTextMentions(userId)
 
 /**
  * Creates cold [Flow] with the messages with [TextedContent] where [user] has been mentioned as text or mentioned
@@ -100,8 +98,7 @@ suspend fun BehaviourContext.waitContentWithTextMentions (
  * @see filterMentions
  * @see filterTextMentions
  */
-suspend fun BehaviourContext.waitContentWithMentions (
+fun BehaviourContext.waitContentWithMentions (
     user: User,
-    initRequest: Request<*>? = null,
     errorFactory: NullableRequestBuilder<*> = { null }
-) = waitTextedContent(initRequest, errorFactory).filterMentions(user)
+) = waitTextedContent(errorFactory).filterMentions(user)

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

@@ -49,11 +49,10 @@ fun Flow<CommonMessage<TextedContent>>.filterMentionsMessages(user: User) = filt
  * @see filterMentions
  * @see filterTextMentions
  */
-suspend fun BehaviourContext.waitContentMessageWithMentions (
+fun BehaviourContext.waitContentMessageWithMentions (
     username: Username,
-    initRequest: Request<*>? = null,
     errorFactory: NullableRequestBuilder<*> = { null }
-) = waitContentMessage(initRequest, errorFactory).mapWithContent<TextedContent>().filterMentionsMessages(username)
+) = waitContentMessage(errorFactory).mapWithContent<TextedContent>().filterMentionsMessages(username)
 
 /**
  * Creates cold [Flow] with the messages with [TextedContent] where [userId] has been mentioned with text
@@ -62,11 +61,10 @@ suspend fun BehaviourContext.waitContentMessageWithMentions (
  * @see filterMentions
  * @see dev.inmo.tgbotapi.types.message.textsources.TextMentionTextSource
  */
-suspend fun BehaviourContext.waitContentMessageWithTextMentions (
+fun BehaviourContext.waitContentMessageWithTextMentions (
     userId: UserId,
-    initRequest: Request<*>? = null,
     errorFactory: NullableRequestBuilder<*> = { null }
-) = waitTextedContentMessage(initRequest, errorFactory).filterTextMentionsMessages(userId)
+) = waitTextedContentMessage(errorFactory).filterTextMentionsMessages(userId)
 
 /**
  * Creates cold [Flow] with the messages with [TextedContent] where [user] has been mentioned as text or mentioned
@@ -75,8 +73,7 @@ suspend fun BehaviourContext.waitContentMessageWithTextMentions (
  * @see filterMentions
  * @see filterTextMentions
  */
-suspend fun BehaviourContext.waitContentMessageWithMentions (
+fun BehaviourContext.waitContentMessageWithMentions (
     user: User,
-    initRequest: Request<*>? = null,
     errorFactory: NullableRequestBuilder<*> = { null }
-) = waitTextedContentMessage(initRequest, errorFactory).filterMentionsMessages(user)
+) = waitTextedContentMessage(errorFactory).filterMentionsMessages(user)

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

@@ -11,33 +11,27 @@ import dev.inmo.tgbotapi.types.business_connection.BusinessConnection
 import dev.inmo.tgbotapi.types.message.payments.PaidMediaPurchased
 import kotlinx.coroutines.flow.Flow
 
-suspend fun BehaviourContext.waitPaidMediaPurchased(
+fun BehaviourContext.waitPaidMediaPurchased(
-    initRequest: Request<*>? = null,
     errorFactory: NullableRequestBuilder<*> = { null }
 ): Flow<PaidMediaPurchased> = expectFlow(
-    initRequest,
     errorFactory
 ) {
     (it.paidMediaPurchasedUpdateOrNull() ?.data).let(::listOfNotNull)
 }
 
-suspend fun BehaviourContext.waitPaidMediaPurchased(
+fun BehaviourContext.waitPaidMediaPurchased(
     paidMediaPayloadRegex: Regex,
-    initRequest: Request<*>? = null,
     errorFactory: NullableRequestBuilder<*> = { null }
 ): Flow<PaidMediaPurchased> = expectFlow(
-    initRequest,
     errorFactory
 ) {
     (it.paidMediaPurchasedUpdateOrNull() ?.data ?.takeIf { paidMediaPayloadRegex.matches(it.payload.string) }).let(::listOfNotNull)
 }
 
-suspend fun BehaviourContext.waitPaidMediaPurchased(
+fun BehaviourContext.waitPaidMediaPurchased(
     paidMediaPayload: PaidMediaPayload,
-    initRequest: Request<*>? = null,
     errorFactory: NullableRequestBuilder<*> = { null }
 ): Flow<PaidMediaPurchased> = expectFlow(
-    initRequest,
     errorFactory
 ) {
     (it.paidMediaPurchasedUpdateOrNull() ?.data ?.takeIf { it.payload == paidMediaPayload }).let(::listOfNotNull)

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

@@ -14,17 +14,14 @@ import kotlinx.coroutines.flow.Flow
 typealias PassportMessageMapper = suspend PassportMessage.() -> PassportData
 
 @RiskFeature(lowLevelRiskFeatureMessage)
-suspend inline fun <reified O : EncryptedPassportElement> BehaviourContext.waitPassportMessagesWith(
+inline fun <reified O : EncryptedPassportElement> BehaviourContext.waitPassportMessagesWith(
-    initRequest: Request<*>? = null,
     noinline errorFactory: NullableRequestBuilder<*> = { null }
 ): Flow<O> = expectFlow(
-    initRequest,
     errorFactory
 ) {
     it.messageUpdateOrNull() ?.data ?.passportMessageOrNull() ?.passportData ?.data ?.filterIsInstance<O>() ?: emptyList()
 }
 
-suspend fun BehaviourContext.waitAnyPassportMessages(
+fun BehaviourContext.waitAnyPassportMessages(
-    initRequest: Request<*>? = null,
     errorFactory: NullableRequestBuilder<*> = { null }
-) = waitPassportMessagesWith<EncryptedPassportElement>(initRequest, errorFactory)
+) = waitPassportMessagesWith<EncryptedPassportElement>(errorFactory)

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

@@ -8,11 +8,9 @@ import kotlinx.coroutines.flow.Flow
 
 typealias PollAnswerMapper = suspend PollAnswer.() -> PollAnswer?
 
-suspend fun BehaviourContext.waitPollAnswers(
+fun BehaviourContext.waitPollAnswers(
-    initRequest: Request<*>? = null,
     errorFactory: NullableRequestBuilder<*> = { null }
 ): Flow<PollAnswer> = expectFlow(
-    initRequest,
     errorFactory
 ) {
     it.pollAnswerUpdateOrNull() ?.data.let(::listOfNotNull)

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

@@ -11,11 +11,9 @@ import kotlinx.coroutines.flow.Flow
 typealias PollMapper<T> = suspend T.() -> T?
 
 @RiskFeature(lowLevelRiskFeatureMessage)
-suspend inline fun <reified O : Poll> BehaviourContext.waitPolls(
+inline fun <reified O : Poll> BehaviourContext.waitPolls(
-    initRequest: Request<*>? = null,
     noinline errorFactory: NullableRequestBuilder<*> = { null }
 ): Flow<O> = expectFlow(
-    initRequest,
     errorFactory
 ) {
     (it.pollUpdateOrNull() ?.data as? O).let(::listOfNotNull)
@@ -24,23 +22,20 @@ suspend inline fun <reified O : Poll> BehaviourContext.waitPolls(
 /**
  * This wait will be triggered only for stopped polls and polls, which are sent by the bot
  */
-suspend fun BehaviourContext.waitPollUpdates(
+fun BehaviourContext.waitPollUpdates(
-    initRequest: Request<*>? = null,
     errorFactory: NullableRequestBuilder<*> = { null }
-) = waitPolls<Poll>(initRequest, errorFactory)
+) = waitPolls<Poll>(errorFactory)
 
 /**
  * This wait will be triggered only for stopped polls and polls, which are sent by the bot
  */
-suspend fun BehaviourContext.waitQuizPollUpdates(
+fun BehaviourContext.waitQuizPollUpdates(
-    initRequest: Request<*>? = null,
     errorFactory: NullableRequestBuilder<*> = { null }
-) = waitPolls<QuizPoll>(initRequest, errorFactory)
+) = waitPolls<QuizPoll>(errorFactory)
 
 /**
  * This wait will be triggered only for stopped polls and polls, which are sent by the bot
  */
-suspend fun BehaviourContext.waitRegularPollUpdates(
+fun BehaviourContext.waitRegularPollUpdates(
-    initRequest: Request<*>? = null,
     errorFactory: NullableRequestBuilder<*> = { null }
-) = waitPolls<RegularPoll>(initRequest, errorFactory)
+) = waitPolls<RegularPoll>(errorFactory)

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

@@ -8,11 +8,9 @@ import kotlinx.coroutines.flow.Flow
 
 typealias PreCheckoutQueryMapper = suspend PreCheckoutQuery.() -> PreCheckoutQuery?
 
-suspend fun BehaviourContext.waitPreCheckoutQueries(
+fun BehaviourContext.waitPreCheckoutQueries(
-    initRequest: Request<*>? = null,
     errorFactory: NullableRequestBuilder<*> = { null }
 ): Flow<PreCheckoutQuery> = expectFlow(
-    initRequest,
     errorFactory
 ) {
     it.preCheckoutQueryUpdateOrNull() ?.data.let(::listOfNotNull)

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

@@ -8,11 +8,9 @@ import kotlinx.coroutines.flow.Flow
 
 typealias ShippingQueryMapper = suspend ShippingQuery.() -> ShippingQuery?
 
-suspend fun BehaviourContext.waitShippingQueries(
+fun BehaviourContext.waitShippingQueries(
-    initRequest: Request<*>? = null,
     errorFactory: NullableRequestBuilder<*> = { null }
 ): Flow<ShippingQuery> = expectFlow(
-    initRequest,
     errorFactory
 ) {
     (it.shippingQueryUpdateOrNull() ?.data).let(::listOfNotNull)