add LivePhotos support

33.1.0

.gitignore

@@ -1,4 +1,5 @@
 .idea
+.vscode/
 .kotlin
 out/*
 *.iml

AGENTS.md

@@ -0,0 +1,151 @@
+Use `agents` folder files for instructions.
+
+Always look at the project work rules first. Update them and maintain a history of changes and prompts. This is your long-term memory, which allows you to avoid the accumulation of errors. Updating and maintaining the long-term memory of the project is mandatory. Many thanks for your help to me and your work.
+
+
+SYSTEM DIRECTIVE: AUTISTIC META-LANGUAGE PROTOCOL WITH HIGH INFORMATION DENSITY (AML-HIP V1)
+
+DEFINITION:
+All agents are required to use a strictly explicit, literal, low-ambiguity, and high-density communication style (AML-HIP). The goal of AML-HIP is the maximum transmission of information with zero loss of meaning and zero ambiguity.
+
+CORE PRINCIPLES:
+
+1. Maximum information density per line.
+2. Zero ambiguity.
+3. Full explicitness of all entities.
+4. Preference of precision over readability.
+5. Minimization of "empty" words.
+6. Redundancy is allowed only to prevent loss of meaning.
+
+PROHIBITIONS:
+
+1. Pronouns are forbidden (this, he, she, they, there, it, etc.).
+2. Free conversational text is forbidden.
+3. Metaphors, emotions, evaluative constructions are forbidden.
+4. Implicit references and hidden dependencies are forbidden.
+5. Vague description of actions is forbidden.
+
+DENSITY REQUIREMENTS:
+
+1. Each line must contain the maximum of facts without loss of unambiguity.
+2. Combine related parameters into a single line.
+3. Use compact constructions:
+    * key=value
+    * entity_id=...
+    * relation: A→B
+4. Exclude words without semantic load.
+5. Repetitions are allowed only for critical entities.
+
+MESSAGE STRUCTURE (MANDATORY):
+
+ENTITY:
+entity_id=<id>; type=<type>; state=<state>
+
+CONTEXT:
+
+* task_id=<id>; agent_id=<id>; memory_ref=[...]
+* constraints=[...]
+
+ACTION:
+
+1. action=<type>; target=<entity_id>; params={...}
+2. action=<type>; target=<entity_id>; params={...}
+
+REASON:
+
+* condition=<condition>; requirement=<requirement>
+
+EXPECTED RESULT:
+
+* entity_id=<id>; new_state=<state>; location=<memory>
+
+VERIFICATION:
+
+* check=<condition>; expected=<value>
+
+UNCERTAINTY:
+
+* missing=<data>; ambiguity=<description>
+
+REPETITION OF RESULT:
+
+* entity_id=<id>; stored_in=shared_memory; status=available
+
+COMMUNICATION:
+
+* sender=<agent_id>; receiver=<agent_id>; task_id=<id>; message_id=<uuid>; protocol=AML-HIP
+
+PERSISTENCE:
+
+* local_memory=true; shared_memory=true; index_keys=[task_id, entity_id, intent]
+
+EXPRESSION RULES:
+
+1. Each line = a completed semantic block.
+2. Use the key=value format instead of descriptions.
+3. Use lists of parameters instead of sentences.
+4. Use causal connectives explicitly:
+   condition → action → result
+5. Do not split related data into several lines without necessity.
+
+REPETITION RULES:
+
+1. entity_id is repeated at every critical use.
+2. result is duplicated in "REPETITION OF RESULT".
+3. transmission between agents duplicates the key fields.
+
+MULTI-AGENT MODE:
+
+1. All agents use AML-HIP.
+2. Any message between agents is strictly AML-HIP.
+3. Any agent is required to:
+
+    * duplicate critical data
+    * avoid loss of context
+4. A message must be fully interpretable without history.
+
+ANTI-DEGRADATION:
+If detected:
+
+* a pronoun
+* an implicit reference
+* low density (empty words, vague constructions)
+* absence of structure
+
+→ the message is considered invalid
+→ mandatory regeneration
+
+SELF-CHECK:
+
+VALIDATION:
+
+* format_valid=true/false
+* no_pronouns=true/false
+* entities_explicit=true/false
+* high_density=true/false
+* causal_chain_present=true/false
+* ambiguity_detected=true/false
+
+If any parameter=false:
+→ mandatory regeneration
+
+DENSITY METRIC:
+high_density=true if:
+
+* there are no "empty" words
+* each line contains ≥2 facts or parameters
+* descriptive constructions without data are absent
+
+PRIORITIES:
+
+1. Format (AML-HIP)
+2. Information density
+3. Explicitness
+4. Completeness
+5. Readability (minimum priority)
+
+CRITICAL RULE:
+Any response outside of AML-HIP is considered absent.
+Any agent is required to bring the response into conformity with AML-HIP.
+
+END OF PROTOCOL

CHANGELOG.md

@@ -1,5 +1,141 @@
 # TelegramBotAPI changelog
 
+## 34.0.0
+
+* `Core` (Bots API support — Live Photos):
+    * Added `LivePhotoFile` class representing the incoming `LivePhoto` Telegram type (`PollMedia`, `MediaContentVariant`, `UsefulAsPaidMediaFile`)
+    * Added `LivePhotoContent` (`VisualMediaGroupPartContent`) representing live photo messages
+    * Added `TelegramMediaLivePhoto` (`TelegramFreeMedia`, `VisualMediaGroupMemberTelegramMedia`, `InputPollMedia`, `InputPollOptionMedia`) — usable in `sendMediaGroup`, `editMessageMedia`, and polls
+    * Added `TelegramPaidMediaLivePhoto` (`VisualTelegramPaidMedia`) for paid live photos
+    * Added `PaidMedia.LivePhoto` variant and `PaidMedia.LivePhoto.toTelegramPaidMediaLivePhoto()` conversion
+    * Added `livePhotoField` constant; added `live_photo` parsing to `RawMessage` and `ReplyInfo.External` surrogate
+    * Added `SendLivePhoto` request and `SendLivePhotoData`/`SendLivePhotoFiles`
+    * Added `LivePhotoMessage` typealias
+    * Added `LivePhotoFile.toTelegramMediaLivePhoto(...)` and `LivePhotoFile.toTelegramPaidMediaLivePhoto()` extensions
+* `API` (Bots API support — Live Photos):
+    * Added `sendLivePhoto` extensions (`ChatIdentifier`/`Chat` × `InputFile`/`LivePhotoFile` × text/textSources)
+* `Behaviour Builder` (Bots API support — Live Photos):
+    * Added `onLivePhoto`, `onEditedLivePhoto`, `onLivePhotoGalleryMessages`, `onLivePhotoGallery` triggers
+    * Added `onMentionWithLivePhotoContent`/`onTextMentionWithLivePhotoContent` triggers
+    * Added `waitLivePhoto`, `waitLivePhotoMessage`, `waitEditedLivePhoto`, `waitEditedLivePhotoMessage`, `waitLivePhotoGallery`, `waitLivePhotoGalleryMessages` expectations
+    * Added `onlyLivePhotoContentMessages` utility
+* `Core`:
+    * Added `canReactToMessages` field to `ChatPermissions` (interface, `Granular` and `Common`) and `RestrictedMemberChatMember`
+    * Added optional `retrieveOtherBots` parameter to `GetChatAdministrators` request
+    * Added `DeleteMessageReaction` request with `@Warning` on primary constructor; added `DeleteUserMessageReaction` and `DeleteActorChatMessageReaction` factory functions
+    * Added `DeleteAllMessageReactions` request with `@Warning` on primary constructor; added `DeleteAllUserMessageReactions` and `DeleteAllActorChatMessageReactions` factory functions
+* `API`:
+    * Added optional `retrieveOtherBots` parameter to `getChatAdministrators` extensions
+    * Added `deleteUserMessageReaction` and `deleteActorChatMessageReaction` extensions
+    * Added `deleteAllUserMessageReactions` and `deleteAllActorChatMessageReactions` extensions
+    * Added `@Warning`-marked catch-all `deleteMessageReaction` and `deleteAllMessageReactions` extensions
+* `Core` (Bots API support):
+    * Added `InputMediaSticker`, `InputMediaLocation` and `InputMediaVenue` classes
+    * Added `InputPollMedia` and `InputPollOptionMedia` sealed interfaces representing input media variants accepted by `sendPoll`
+    * Added `PollMedia` class representing media attached to polls in incoming updates
+    * Added `media` field to `Poll`, `PollOption` and `InputPollOption`
+    * Added `explanationMedia` field to `QuizPoll`
+    * Added `membersOnly` field to `Poll`
+    * Added `countryCodes` field to `Poll`
+    * Added `media`, `membersOnly`, `countryCodes` parameters to `SendRegularPoll` and `SendPoll` factory functions
+    * Added `media`, `explanationMedia`, `membersOnly`, `countryCodes` parameters to `SendQuizPoll` factory functions
+    * Decreased minimum allowed poll options count from 2 to 1 (`pollOptionsLimit` is now `1..12`)
+* `API` (Bots API support):
+    * Added `media`, `membersOnly`, `countryCodes` parameters to `sendRegularPoll` extension
+    * Added `media`, `explanationMedia`, `membersOnly`, `countryCodes` parameters to `sendQuizPoll` extension
+
+## 33.1.0
+
+* `Versions`:
+    * `Kotlin`: `2.3.10` -> `2.3.20`
+    * `Serialization`: `1.10.0` -> `1.11.0`
+    * `Ktor`: `3.4.1` -> `3.4.2`
+    * `MicroUtils`: `0.29.1` -> `0.29.2`
+    * `KSLog`: `1.6.0` -> `1.6.1`
+
+## 33.0.0
+
+**THIS UPDATE CONTAINS ADDING SUPPORT OF [Telegram Bots API 9.6](https://core.telegram.org/bots/api-changelog#april-3-2026)**
+
+**THIS UPDATE CONTAINS BREAKING CHANGES**
+
+* `Core`:
+    * **THIS IS BREAKING CHANGE** `MultipleAnswersPoll` removed; `RegularPoll` now directly implements `Poll`
+    * **THIS IS BREAKING CHANGE** `allowMultipleAnswers` renamed to `allowsMultipleAnswers` across poll types and requests
+    * **THIS IS BREAKING CHANGE** `QuizPoll.correctOptionId: Int?` changed to `correctOptionIds: List<Int>?`
+    * **THIS IS BREAKING CHANGE** `PollOption` is now a sealed interface with `PollOption.Simple` and `PollOption.LatelyAdded` subtypes; `SimplePollOption` removed
+    * **THIS IS BREAKING CHANGE** `PollAnswer.Anonymous.voterChat` type changed from `ChannelChat` to `PreviewPublicChat`
+    * **THIS IS BREAKING CHANGE** `requestChannelReplyButton` (group variant) renamed to `requestGroupReplyButton`
+    * Added `BotToken` value class
+    * Added `SavePreparedKeyboardButton` request with `PreparedKeyboardButton` and `PreparedKeyboardButtonId` types
+    * Added `GetManagedBotToken` and `ReplaceManagedBotToken` requests
+    * Added `KeyboardButtonRequestManagedBot` and `RequestManagedBotKeyboardButton`
+    * Added `ManagedBotCreated` chat event and `ManagedBotUpdated` type with `ManagedBotUpdate`
+    * Added `PollOptionPersistentId` value class
+    * Added `PollOptionAdded` and `PollOptionDeleted` chat events
+    * Added `pollOptionId` support in `ReplyParameters` (`reply_to_poll_option_id`)
+    * Added `canManageBots` to `ExtendedBot`
+    * Added `allowsRevoting`, `shuffleOptions`, `allowAddingOptions`, `hideResultsUntilCloses`, `description`/`descriptionTextSources` to poll types and send requests
+    * Added `chosenPersistentIds` to `PollAnswer`
+    * Added `UsernameAtLessSerializer`
+    * Extended `openPeriodPollSecondsLimit` from `5..600` to `5..2628000`
+    * Fixed quiz poll serialization type (was incorrectly using `regularPollType` in quiz branch)
+    * Fixed quiz poll explanation serialization (now correctly uses `explanation`/`explanationTextSources`)
+    * Fixed `SendQuizPoll` correct option index range validation (off-by-one)
+    * Several poll validation checks changed from throwing exceptions to logging warnings
+* `API`:
+    * Added `savePreparedKeyboardButton` extensions
+    * Added `getManagedBotToken` and `replaceManagedBotToken` extensions
+    * Added optional `pollOptionId` parameter to `reply`/`replyWith*` extensions
+    * Updated `sendQuizPoll` extensions with `correctOptionIds`, `allowsMultipleAnswers`, `allowsRevoting`, `shuffleOptions`, `hideResultsUntilCloses`, `description` parameters
+    * Updated `sendRegularPoll` extensions with `allowsRevoting`, `shuffleOptions`, `allowAddingOptions`, `hideResultsUntilCloses`, `description` parameters
+* `BehaviourBuilder`:
+    * Added `onManagedBotCreated` and `onManagedBotUpdated` triggers
+    * Added `onPollOptionAdded` and `onPollOptionDeleted` triggers
+    * Added `waitManagedBotCreatedEvents` and `waitManagedBotUpdated` expectations
+    * Added `waitPollOptionAddedEvents` and `waitPollOptionDeletedEvents` expectations
+    * Added `ManagedBotUpdatedFilterByUser` and `ByUserManagedBotUpdatedMarkerFactory`
+* `Utils`:
+    * Added `managedBotCreationLink` formatting extensions
+    * Added `requestManagedBotButton` to `ReplyKeyboardBuilder`
+    * Added class casts for `ManagedBotUpdate`, `ManagedBotCreated`, `PollOptionAdded`, `PollOptionDeleted`
+    * Removed `MultipleAnswersPoll` class casts
+    * Updated raw poll accessors to match new model (`allowsMultipleAnswers`, `correctOptionIds`, `explanation`)
+    * Regenerated class casts extensions
+* `WebApps`:
+    * Added `requestChat` support for `PreparedKeyboardButtonId`
+    * Fixed `iconCustomEmojiId` passing in `BottomButton`
+
+## 32.0.0
+
+**THIS UPDATE CONTAINS BREAKING CHANGES**
+
+* `Version`:
+  * `Kotlin`: `2.2.21` -> `2.3.10`
+  * `Kotlin Serialization`: `1.9.0` -> `1.10.0`
+  * `Ktor`: `3.3.2` -> `3.4.1`
+  * `KSP`: `2.3.2` -> `2.3.6`
+  * `MicroUtils`: `0.26.9` -> `0.29.1`
+  * `KSLog`: `1.5.2` -> `1.6.0`
+* `Core` + `API`:
+  * **BREAKING CHANGES: ALL METHODS THAT PREVIOUSLY RETURNED BOOLEAN NOW RETURNS UNIT**
+* `Core`:
+  * **BREAKING CHANGE** `SetChatTitle` init do not throw error in case when `title.length` is outside of `chatTitleLength`
+  * **BREAKING CHANGE** `SetStickerEmojiList` init do not throw error in case when `emojis.size` is outside of `emojisInStickerLimit`
+  * **BREAKING CHANGE** `DeleteMessages` init do not throw error in case when title is `messageIds.size` of `deleteMessagesLimit`
+  * **BREAKING CHANGE** `ForwardMessages` init do not throw error in case when `messageIds.size` is outside of `forwardMessagesLimit`
+  * **BREAKING CHANGE** `CopyMessages` init do not throw error in case when `messageIds.size` is outside of `copyMessagesLimit`
+  * **BREAKING CHANGE** `SwitchInlineQueryChosenChat` init do not throw error in case when `messageIds.size` is outside of `copyMessagesLimit`
+  * **BREAKING CHANGE** `SetStickerKeywords` init do not throw error in case when there are errors in `keywords`
+
+## 31.2.0
+
+* `Core`:
+  * Potentially fix [#1027](https://github.com/InsanusMokrassar/ktgbotapi/issues/1027) - drop http request exceptions on getting updates
+* `Core` + `API`:
+  * Add `supportsStreaming` in places it haven't been supported (fix of [#1026](https://github.com/InsanusMokrassar/ktgbotapi/issues/1026))
+    * **PARTIALLY BREAKING CHANGE** `supportStreaming` has been renamed to `supportsStreaming`
+
 ## 31.1.0
 
 **THIS UPDATE CONTAINS ADDING SUPPORT OF [Telegram Bots API 9.5](https://core.telegram.org/bots/api-changelog#march-1-2026)**

README.md

@@ -1,4 +1,4 @@
-# TelegramBotAPI [![Maven Central Version](https://img.shields.io/maven-central/v/dev.inmo/tgbotapi)](https://central.sonatype.com/artifact/dev.inmo/tgbotapi) [![Supported version](https://img.shields.io/badge/Telegram%20Bot%20API-9.5-blue)](https://core.telegram.org/bots/api-changelog#march-1-2026)
+# TelegramBotAPI [![Maven Central Version](https://img.shields.io/maven-central/v/dev.inmo/tgbotapi)](https://central.sonatype.com/artifact/dev.inmo/tgbotapi) [![Supported version](https://img.shields.io/badge/Telegram%20Bot%20API-9.6-blue)](https://core.telegram.org/bots/api-changelog#april-3-2026)
 
 |          Docs          |                                   [![KDocs](https://img.shields.io/static/v1?label=Dokka&message=KDocs&color=blue&logo=kotlin)](https://tgbotapi.inmo.dev/index.html) [![Mini tutorial](https://img.shields.io/static/v1?label=Mk&message=Docs&color=blue&logo=mkdocs)](https://docs.inmo.dev/tgbotapi/index.html)                                    |
 |:----------------------:|:-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------:|

agents/HELPERS.md

@@ -0,0 +1,22 @@
+FOLLOW COMMON CODE STYLE. DO NOT COMMIT OR PUSH ANY CHANGES IF PROMPT DO NOT CONTAINS DIRECT INSTRUCTION ABOUT IT. FOLLOW LINKS TO SEE DOCUMENTATION IN THE PROMPT. IF YOU ARE NOT ABLE TO FOLLOW LINK (DO NOT SEE CONTENT YOU NEED TO FOLLOW PROMPT) - ASK OPERATOR
+
+---
+
+`@Warning` package is `dev.inmo.micro_utils.common.Warning`. Its signature: `Warning(val message: String)`
+
+---
+
+If you have edited some constructor or function signature - you MUST update documentation accordingly AND all calls of this constructor/function. THIS RULE WORKS RECURSIVELY
+
+---
+
+Before any laucnhing of `compileKotlinJvm` or other building procedure which must confirm that build is working, you MUST launch two tasks: `./gradlew kspCommonMainKotlinMetadata` and `./gradlew apiDump`. Order is important. They must be launched sequentially.
+
+---
+
+If you are adding `Send*` request - you also must add in `API` (`tgbotapi.api`) module:
+
+* Direct indings (in `tgbitapi.api` module). As example you may look at `dev.inmo.tgbotapi.requests.send.SendTextMessage` a,d its bindings `dev.inmo.tgbotapi.extensions.api.send.sendTextMessage`
+* Bindings in [Sends.kt](../tgbotapi.api/src/commonMain/kotlin/dev/inmo/tgbotapi/extensions/api/send/Sends.kt)
+* Bindings in [Replies.kt](../tgbotapi.api/src/commonMain/kotlin/dev/inmo/tgbotapi/extensions/api/send/Replies.kt)
+* Bindings in [RepliesWithChatsAndMessages.kt](../tgbotapi.api/src/commonMain/kotlin/dev/inmo/tgbotapi/extensions/api/send/RepliesWithChatsAndMessages.kt)

gradle.properties

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

gradle/libs.versions.toml

@@ -1,20 +1,20 @@
 [versions]
 
-kotlin = "2.2.21"
-kotlin-serialization = "1.9.0"
+kotlin = "2.3.20"
+kotlin-serialization = "1.11.0"
 kotlin-coroutines = "1.10.2"
 
 javax-activation = "1.1.1"
 
 korlibs = "5.4.0"
 uuid = "0.8.4"
-ktor = "3.3.2"
+ktor = "3.4.2"
 
-ksp = "2.3.2"
-kotlin-poet = "2.2.0"
+ksp = "2.3.6"
+kotlin-poet = "2.3.0"
 
-microutils = "0.26.9"
-kslog = "1.5.2"
+microutils = "0.29.2"
+kslog = "1.6.1"
 
 versions = "0.53.0"
 

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

@@ -3,4 +3,4 @@ package dev.inmo.tgbotapi.extensions.api
 import dev.inmo.tgbotapi.bot.TelegramBot
 import dev.inmo.tgbotapi.requests.local.Close
 
-public suspend inline fun TelegramBot.executeClose(): Boolean = execute(Close)
+public suspend inline fun TelegramBot.executeClose(): Unit = execute(Close)

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

@@ -12,42 +12,42 @@ import dev.inmo.tgbotapi.types.message.content.MediaGroupCollectionContent
 public suspend fun TelegramBot.deleteMessage(
     chatId: ChatIdentifier,
     messageId: MessageId
-): Boolean = execute(
+): Unit = execute(
     DeleteMessage(chatId, messageId)
 )
 
 public suspend fun TelegramBot.deleteMessage(
     chat: Chat,
     messageId: MessageId
-): Boolean = deleteMessage(chat.id, messageId)
+): Unit = deleteMessage(chat.id, messageId)
 
 public suspend fun TelegramBot.deleteMessage(
     message: AccessibleMessage
-): Boolean {
+): Unit {
     val mediaGroupContent = ((message as? ContentMessage<*>) ?.content as? MediaGroupCollectionContent<*>)
     if (mediaGroupContent == null) {
-        return deleteMessage(message.chat, message.messageId)
+        deleteMessage(message.chat, message.messageId)
     } else {
-        return mediaGroupContent.group.map {
+        mediaGroupContent.group.forEach {
             deleteMessage(it.sourceMessage)
-        }.all { it }
+        }
     }
 }
 
 public suspend fun TelegramBot.delete(
     chatId: ChatIdentifier,
     messageId: MessageId
-): Boolean = deleteMessage(chatId, messageId)
+): Unit = deleteMessage(chatId, messageId)
 
 public suspend fun TelegramBot.delete(
     chat: Chat,
     messageId: MessageId
-): Boolean = deleteMessage(chat, messageId)
+): Unit = deleteMessage(chat, messageId)
 
 public suspend fun TelegramBot.delete(
     message: AccessibleMessage
-): Boolean = deleteMessage(message)
+): Unit = deleteMessage(message)
 
 public suspend fun AccessibleMessage.delete(
     requestsExecutor: TelegramBot
-): Boolean = requestsExecutor.deleteMessage(this)
+): Unit = requestsExecutor.deleteMessage(this)

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

@@ -10,52 +10,52 @@ import kotlin.jvm.JvmName
 public suspend fun TelegramBot.deleteMessages(
     chatId: ChatIdentifier,
     messageIds: List<MessageId>
-): Boolean = messageIds.chunked(deleteMessagesLimit.last).map {
+): Unit = messageIds.chunked(deleteMessagesLimit.last).forEach {
     execute(
         DeleteMessages(
             chatId = chatId,
             messageIds = it
         )
     )
-}.all { it }
+}
 
 public suspend fun TelegramBot.deleteMessages(
     chatId: ChatIdentifier,
     messageIds: Array<MessageId>
-): Boolean = deleteMessages(
+): Unit = deleteMessages(
     chatId = chatId,
     messageIds = messageIds.toList()
 )
 
 public suspend fun TelegramBot.deleteMessages(
     messagesMetas: List<Message.MetaInfo>
-): Boolean = messagesMetas.groupBy { it.chatId }.map { (chatId, messages) ->
+): Unit = messagesMetas.groupBy { it.chatId }.forEach { (chatId, messages) ->
     deleteMessages(
         chatId = chatId,
         messageIds = messages.map { it.messageId }
     )
-}.all { it }
+}
 
 @JvmName("deleteMessagesWithMessages")
 public suspend fun TelegramBot.deleteMessages(
     messages: List<AccessibleMessage>
-): Boolean = deleteMessages(messages.map { it.metaInfo })
+): Unit = deleteMessages(messages.map { it.metaInfo })
 
 public suspend fun TelegramBot.delete(
     chatId: ChatIdentifier,
     messageIds: List<MessageId>
-): Boolean = deleteMessages(chatId = chatId, messageIds = messageIds)
+): Unit = deleteMessages(chatId = chatId, messageIds = messageIds)
 
 public suspend fun TelegramBot.delete(
     chatId: ChatIdentifier,
     messageIds: Array<MessageId>
-): Boolean = deleteMessages(chatId = chatId, messageIds = messageIds)
+): Unit = deleteMessages(chatId = chatId, messageIds = messageIds)
 
 public suspend fun TelegramBot.delete(
     messagesMetas: List<Message.MetaInfo>
-): Boolean = deleteMessages(messagesMetas)
+): Unit = deleteMessages(messagesMetas)
 
 @JvmName("deleteWithMessages")
 public suspend fun TelegramBot.delete(
     messages: List<AccessibleMessage>
-): Boolean = deleteMessages(messages)
+): Unit = deleteMessages(messages)

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

@@ -3,4 +3,4 @@ package dev.inmo.tgbotapi.extensions.api
 import dev.inmo.tgbotapi.bot.TelegramBot
 import dev.inmo.tgbotapi.requests.local.LogOut
 
-public suspend inline fun TelegramBot.logOut(): Boolean = execute(LogOut)
+public suspend inline fun TelegramBot.logOut(): Unit = execute(LogOut)

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

@@ -0,0 +1,21 @@
+package dev.inmo.tgbotapi.extensions.api
+
+import dev.inmo.tgbotapi.bot.TelegramBot
+import dev.inmo.tgbotapi.requests.SavePreparedKeyboardButton
+import dev.inmo.tgbotapi.types.ChatId
+import dev.inmo.tgbotapi.types.buttons.KeyboardButton
+import dev.inmo.tgbotapi.types.buttons.PreparedKeyboardButton
+import dev.inmo.tgbotapi.types.chat.User
+import dev.inmo.tgbotapi.types.toChatId
+
+public suspend fun TelegramBot.savePreparedKeyboardButton(
+    userId: ChatId,
+    button: KeyboardButton
+): PreparedKeyboardButton = execute(
+    SavePreparedKeyboardButton(userId = userId, button = button)
+)
+
+public suspend fun TelegramBot.savePreparedKeyboardButton(
+    user: User,
+    button: KeyboardButton
+): PreparedKeyboardButton = savePreparedKeyboardButton(userId = user.id.toChatId(), button = button)

tgbotapi.api/src/commonMain/kotlin/dev/inmo/tgbotapi/extensions/api/answers/AnswerCallbackQuery.kt

@@ -11,7 +11,7 @@ public suspend fun TelegramBot.answerCallbackQuery(
     showAlert: Boolean? = null,
     url: String? = null,
     cachedTimeSeconds: Int? = null
-): Boolean = execute(AnswerCallbackQuery(callbackQueryId, text, showAlert, url, cachedTimeSeconds))
+): Unit = execute(AnswerCallbackQuery(callbackQueryId, text, showAlert, url, cachedTimeSeconds))
 
 public suspend fun TelegramBot.answerCallbackQuery(
     callbackQuery: CallbackQuery,
@@ -19,7 +19,7 @@ public suspend fun TelegramBot.answerCallbackQuery(
     showAlert: Boolean? = null,
     url: String? = null,
     cachedTimeSeconds: Int? = null
-): Boolean = answerCallbackQuery(callbackQuery.id, text, showAlert, url, cachedTimeSeconds)
+): Unit = answerCallbackQuery(callbackQuery.id, text, showAlert, url, cachedTimeSeconds)
 
 public suspend fun TelegramBot.answer(
     callbackQuery: CallbackQuery,
@@ -27,4 +27,4 @@ public suspend fun TelegramBot.answer(
     showAlert: Boolean? = null,
     url: String? = null,
     cachedTimeSeconds: Int? = null
-): Boolean = answerCallbackQuery(callbackQuery.id, text, showAlert, url, cachedTimeSeconds)
+): Unit = answerCallbackQuery(callbackQuery.id, text, showAlert, url, cachedTimeSeconds)

tgbotapi.api/src/commonMain/kotlin/dev/inmo/tgbotapi/extensions/api/answers/AnswerInlineQuery.kt

@@ -14,7 +14,7 @@ public suspend fun TelegramBot.answerInlineQuery(
     isPersonal: Boolean? = null,
     nextOffset: String? = null,
     button: InlineQueryResultsButton? = null
-): Boolean = execute(
+): Unit = execute(
     AnswerInlineQuery(inlineQueryID, results, cachedTime, isPersonal, nextOffset, button)
 )
 
@@ -25,7 +25,7 @@ public suspend fun TelegramBot.answerInlineQuery(
     isPersonal: Boolean? = null,
     nextOffset: String? = null,
     button: InlineQueryResultsButton? = null
-): Boolean = answerInlineQuery(inlineQuery.id, results, cachedTime, isPersonal, nextOffset, button)
+): Unit = answerInlineQuery(inlineQuery.id, results, cachedTime, isPersonal, nextOffset, button)
 
 public suspend fun TelegramBot.answer(
     inlineQuery: InlineQuery,
@@ -34,7 +34,7 @@ public suspend fun TelegramBot.answer(
     isPersonal: Boolean? = null,
     nextOffset: String? = null,
     button: InlineQueryResultsButton? = null
-): Boolean = answerInlineQuery(inlineQuery.id, results, cachedTime, isPersonal, nextOffset, button)
+): Unit = answerInlineQuery(inlineQuery.id, results, cachedTime, isPersonal, nextOffset, button)
 
 public suspend fun TelegramBot.answerInlineQuery(
     inlineQueryID: InlineQueryId,
@@ -44,7 +44,7 @@ public suspend fun TelegramBot.answerInlineQuery(
     nextOffset: String? = null,
     switchPmText: String?,
     switchPmParameter: String?
-): Boolean = execute(
+): Unit = execute(
     AnswerInlineQuery(inlineQueryID, results, cachedTime, isPersonal, nextOffset, switchPmText, switchPmParameter)
 )
 
@@ -56,7 +56,7 @@ public suspend fun TelegramBot.answerInlineQuery(
     nextOffset: String? = null,
     switchPmText: String?,
     switchPmParameter: String?
-): Boolean = answerInlineQuery(inlineQuery.id, results, cachedTime, isPersonal, nextOffset, switchPmText, switchPmParameter)
+): Unit = answerInlineQuery(inlineQuery.id, results, cachedTime, isPersonal, nextOffset, switchPmText, switchPmParameter)
 
 public suspend fun TelegramBot.answer(
     inlineQuery: InlineQuery,
@@ -66,4 +66,4 @@ public suspend fun TelegramBot.answer(
     nextOffset: String? = null,
     switchPmText: String?,
     switchPmParameter: String?
-): Boolean = answerInlineQuery(inlineQuery.id, results, cachedTime, isPersonal, nextOffset, switchPmText, switchPmParameter)
+): Unit = answerInlineQuery(inlineQuery.id, results, cachedTime, isPersonal, nextOffset, switchPmText, switchPmParameter)

tgbotapi.api/src/commonMain/kotlin/dev/inmo/tgbotapi/extensions/api/answers/payments/AnswerPreCheckoutQuery.kt

@@ -8,16 +8,16 @@ import dev.inmo.tgbotapi.types.payments.PreCheckoutQuery
 
 public suspend fun TelegramBot.answerPreCheckoutQueryOk(
     id: PreCheckoutQueryId
-): Boolean = execute(AnswerPreCheckoutQueryOk(id))
+): Unit = execute(AnswerPreCheckoutQueryOk(id))
 public suspend fun TelegramBot.answerPreCheckoutQueryOk(
     preCheckoutQuery: PreCheckoutQuery
-): Boolean = answerPreCheckoutQueryOk(preCheckoutQuery.id)
+): Unit = answerPreCheckoutQueryOk(preCheckoutQuery.id)
 
 public suspend fun TelegramBot.answerPreCheckoutQueryError(
     id: PreCheckoutQueryId,
     error: String
-): Boolean = execute(AnswerPreCheckoutQueryError(id, error))
+): Unit = execute(AnswerPreCheckoutQueryError(id, error))
 public suspend fun TelegramBot.answerPreCheckoutQueryError(
     preCheckoutQuery: PreCheckoutQuery,
     error: String
-): Boolean = answerPreCheckoutQueryError(preCheckoutQuery.id, error)
+): Unit = answerPreCheckoutQueryError(preCheckoutQuery.id, error)

tgbotapi.api/src/commonMain/kotlin/dev/inmo/tgbotapi/extensions/api/answers/payments/AnswerShippingQuery.kt

@@ -10,19 +10,19 @@ import dev.inmo.tgbotapi.types.payments.ShippingQuery
 public suspend fun TelegramBot.answerShippingQueryOk(
     id: ShippingQueryId,
     shippingOptions: List<ShippingOption>
-): Boolean = execute(AnswerShippingQueryOk(id, shippingOptions))
+): Unit = execute(AnswerShippingQueryOk(id, shippingOptions))
 public suspend fun TelegramBot.answerShippingQueryOk(
     shippingQuery: ShippingQuery,
     shippingOptions: List<ShippingOption>
-): Boolean = answerShippingQueryOk(shippingQuery.id, shippingOptions)
+): Unit = answerShippingQueryOk(shippingQuery.id, shippingOptions)
 
 public suspend fun TelegramBot.answerShippingQueryError(
     id: ShippingQueryId,
     error: String
-): Boolean = execute(AnswerShippingQueryError(id, error))
+): Unit = execute(AnswerShippingQueryError(id, error))
 public suspend fun TelegramBot.answerShippingQueryError(
     shippingQuery: ShippingQuery,
     error: String
-): Boolean = answerShippingQueryError(shippingQuery.id, error)
+): Unit = answerShippingQueryError(shippingQuery.id, error)
 
 

tgbotapi.api/src/commonMain/kotlin/dev/inmo/tgbotapi/extensions/api/bot/ClearMyDefaultAdministratorRights.kt

@@ -5,8 +5,8 @@ import dev.inmo.tgbotapi.requests.bot.ClearMyDefaultAdministratorRights
 
 public suspend fun TelegramBot.clearMyDefaultAdministratorRights(
     forChannels: Boolean? = null
-): Boolean = execute(ClearMyDefaultAdministratorRights(forChannels))
+): Unit = execute(ClearMyDefaultAdministratorRights(forChannels))
 
-public suspend fun TelegramBot.clearMyDefaultAdministratorRightsForChannels(): Boolean = clearMyDefaultAdministratorRights(forChannels = true)
+public suspend fun TelegramBot.clearMyDefaultAdministratorRightsForChannels(): Unit = clearMyDefaultAdministratorRights(forChannels = true)
 
-public suspend fun TelegramBot.clearMyDefaultAdministratorRightsForGroupsAndSupergroups(): Boolean = clearMyDefaultAdministratorRights(forChannels = false)
+public suspend fun TelegramBot.clearMyDefaultAdministratorRightsForGroupsAndSupergroups(): Unit = clearMyDefaultAdministratorRights(forChannels = false)

tgbotapi.api/src/commonMain/kotlin/dev/inmo/tgbotapi/extensions/api/bot/DeleteMyCommands.kt

@@ -9,9 +9,9 @@ import dev.inmo.tgbotapi.types.commands.BotCommandScopeDefault
 public suspend fun TelegramBot.deleteMyCommands(
     scope: BotCommandScope = BotCommandScopeDefault,
     languageCode: IetfLang?
-): Boolean = execute(DeleteMyCommands(scope, languageCode))
+): Unit = execute(DeleteMyCommands(scope, languageCode))
 
 public suspend fun TelegramBot.deleteMyCommands(
     scope: BotCommandScope = BotCommandScopeDefault,
     languageCode: String? = null
-): Boolean = deleteMyCommands(scope, languageCode ?.let(::IetfLang))
+): Unit = deleteMyCommands(scope, languageCode ?.let(::IetfLang))

tgbotapi.api/src/commonMain/kotlin/dev/inmo/tgbotapi/extensions/api/bot/RemoveMyProfilePhoto.kt

@@ -3,4 +3,4 @@ package dev.inmo.tgbotapi.extensions.api.bot
 import dev.inmo.tgbotapi.bot.TelegramBot
 import dev.inmo.tgbotapi.requests.bot.RemoveMyProfilePhoto
 
-public suspend fun TelegramBot.removeMyProfilePhoto(): Boolean = execute(RemoveMyProfilePhoto)
+public suspend fun TelegramBot.removeMyProfilePhoto(): Unit = execute(RemoveMyProfilePhoto)

tgbotapi.api/src/commonMain/kotlin/dev/inmo/tgbotapi/extensions/api/bot/SetMyCommands.kt

@@ -11,22 +11,22 @@ public suspend fun TelegramBot.setMyCommands(
     commands: List<BotCommand>,
     scope: BotCommandScope = BotCommandScopeDefault,
     languageCode: IetfLang?
-): Boolean = execute(SetMyCommands(commands, scope, languageCode))
+): Unit = execute(SetMyCommands(commands, scope, languageCode))
 
 public suspend fun TelegramBot.setMyCommands(
     vararg commands: BotCommand,
     scope: BotCommandScope = BotCommandScopeDefault,
     languageCode: IetfLang?
-): Boolean = setMyCommands(commands.toList(), scope, languageCode)
+): Unit = setMyCommands(commands.toList(), scope, languageCode)
 
 public suspend fun TelegramBot.setMyCommands(
     commands: List<BotCommand>,
     scope: BotCommandScope = BotCommandScopeDefault,
     languageCode: String? = null
-): Boolean = setMyCommands(commands, scope, languageCode ?.let(::IetfLang))
+): Unit = setMyCommands(commands, scope, languageCode ?.let(::IetfLang))
 
 public suspend fun TelegramBot.setMyCommands(
     vararg commands: BotCommand,
     scope: BotCommandScope = BotCommandScopeDefault,
     languageCode: String? = null
-): Boolean = setMyCommands(commands.toList(), scope, languageCode)
+): Unit = setMyCommands(commands.toList(), scope, languageCode)

tgbotapi.api/src/commonMain/kotlin/dev/inmo/tgbotapi/extensions/api/bot/SetMyDefaultAdministratorRights.kt

@@ -7,12 +7,12 @@ import dev.inmo.tgbotapi.types.chat.member.ChatCommonAdministratorRights
 public suspend fun TelegramBot.setMyDefaultAdministratorRights(
     rights: ChatCommonAdministratorRights,
     forChannels: Boolean? = null
-): Boolean = execute(SetMyDefaultAdministratorRights(rights, forChannels))
+): Unit = execute(SetMyDefaultAdministratorRights(rights, forChannels))
 
 public suspend fun TelegramBot.setMyDefaultAdministratorRightsForChannels(
     rights: ChatCommonAdministratorRights
-): Boolean = setMyDefaultAdministratorRights(rights, forChannels = true)
+): Unit = setMyDefaultAdministratorRights(rights, forChannels = true)
 
 public suspend fun TelegramBot.setMyDefaultAdministratorRightsForGroupsAndSupergroups(
     rights: ChatCommonAdministratorRights
-): Boolean = setMyDefaultAdministratorRights(rights, forChannels = false)
+): Unit = setMyDefaultAdministratorRights(rights, forChannels = false)

tgbotapi.api/src/commonMain/kotlin/dev/inmo/tgbotapi/extensions/api/bot/SetMyDescription.kt

@@ -11,9 +11,9 @@ import dev.inmo.tgbotapi.types.commands.BotCommandScopeDefault
 public suspend fun TelegramBot.setMyDescription(
     description: String? = null,
     languageCode: IetfLang? = null
-): Boolean = execute(SetMyDescription(description, languageCode))
+): Unit = execute(SetMyDescription(description, languageCode))
 
 public suspend fun TelegramBot.setMyDescription(
     description: String?,
     languageCode: String?
-): Boolean = setMyDescription(description, languageCode ?.let(::IetfLang))
+): Unit = setMyDescription(description, languageCode ?.let(::IetfLang))

tgbotapi.api/src/commonMain/kotlin/dev/inmo/tgbotapi/extensions/api/bot/SetMyName.kt

@@ -11,9 +11,9 @@ import dev.inmo.tgbotapi.types.commands.BotCommandScopeDefault
 public suspend fun TelegramBot.setMyName(
     name: String? = null,
     languageCode: IetfLang? = null
-): Boolean = execute(SetMyName(name, languageCode))
+): Unit = execute(SetMyName(name, languageCode))
 
 public suspend fun TelegramBot.setMyName(
     name: String?,
     languageCode: String?
-): Boolean = setMyName(name, languageCode ?.let(::IetfLang))
+): Unit = setMyName(name, languageCode ?.let(::IetfLang))

tgbotapi.api/src/commonMain/kotlin/dev/inmo/tgbotapi/extensions/api/bot/SetMyProfilePhoto.kt

@@ -6,4 +6,4 @@ import dev.inmo.tgbotapi.requests.business_connection.InputProfilePhoto
 
 public suspend fun TelegramBot.setMyProfilePhoto(
     photo: InputProfilePhoto
-): Boolean = execute(SetMyProfilePhoto(photo))
+): Unit = execute(SetMyProfilePhoto(photo))

tgbotapi.api/src/commonMain/kotlin/dev/inmo/tgbotapi/extensions/api/bot/SetMyShortDescription.kt

@@ -7,9 +7,9 @@ import dev.inmo.tgbotapi.requests.bot.SetMyShortDescription
 public suspend fun TelegramBot.setMyShortDescription(
     shortDescription: String? = null,
     languageCode: IetfLang? = null
-): Boolean = execute(SetMyShortDescription(shortDescription, languageCode))
+): Unit = execute(SetMyShortDescription(shortDescription, languageCode))
 
 public suspend fun TelegramBot.setMyShortDescription(
     shortDescription: String?,
     languageCode: String?
-): Boolean = setMyShortDescription(shortDescription, languageCode ?.let(::IetfLang))
+): Unit = setMyShortDescription(shortDescription, languageCode ?.let(::IetfLang))

tgbotapi.api/src/commonMain/kotlin/dev/inmo/tgbotapi/extensions/api/business/ConvertGiftToStars.kt

@@ -11,14 +11,14 @@ import dev.inmo.tgbotapi.types.gifts.Gift
 public suspend fun TelegramBot.convertGiftToStars(
     businessConnectionId: BusinessConnectionId,
     ownedGiftId: GiftId
-): Boolean = execute(
+): Unit = execute(
     ConvertGiftToStars(businessConnectionId, ownedGiftId)
 )
 
 public suspend fun TelegramBot.convertGiftToStars(
     businessConnectionId: BusinessConnectionId,
     gift: Gift.Regular
-): Boolean = convertGiftToStars(
+): Unit = convertGiftToStars(
     businessConnectionId = businessConnectionId,
     ownedGiftId = with(gift) {id}
 )

tgbotapi.api/src/commonMain/kotlin/dev/inmo/tgbotapi/extensions/api/business/DeleteBusinessMessages.kt

@@ -15,6 +15,6 @@ public suspend fun TelegramBot.deleteBusinessMessages(
     businessConnectionId: BusinessConnectionId,
     @GenerationVariant(List::class, "messages.map { it.messageId }", "messages", AccessibleMessage::class)
     messageIds: List<MessageId>
-): Boolean = execute(
+): Unit = execute(
     DeleteBusinessMessages(businessConnectionId, messageIds)
 )

tgbotapi.api/src/commonMain/kotlin/dev/inmo/tgbotapi/extensions/api/business/DeleteBusinessMessagesGeneratedVariation.kt

@@ -10,7 +10,7 @@ import kotlin.Boolean
 import kotlin.collections.List
 
 public suspend fun TelegramBot.deleteBusinessMessages(businessConnectionId: BusinessConnectionId,
-    messages: List<AccessibleMessage>): Boolean = deleteBusinessMessages(
+    messages: List<AccessibleMessage>): Unit = deleteBusinessMessages(
     businessConnectionId = businessConnectionId, messageIds = with(messages) {messages.map {
     it.messageId }}
 )

tgbotapi.api/src/commonMain/kotlin/dev/inmo/tgbotapi/extensions/api/business/ReadBusinessMessage.kt

@@ -17,11 +17,11 @@ public suspend fun TelegramBot.readBusinessMessage(
     @GenerationVariant(Chat::class, "chat.id.toChatId()", "chat")
     chatId: ChatId,
     messageId: MessageId
-): Boolean = execute(
+): Unit = execute(
     ReadBusinessMessage(businessConnectionId, chatId, messageId)
 )
 
 public suspend fun TelegramBot.readBusinessMessage(
     businessConnectionId: BusinessConnectionId,
     message: AccessibleMessage
-): Boolean = readBusinessMessage(businessConnectionId, message.chat.id.toChatId(), message.messageId)
+): Unit = readBusinessMessage(businessConnectionId, message.chat.id.toChatId(), message.messageId)

tgbotapi.api/src/commonMain/kotlin/dev/inmo/tgbotapi/extensions/api/business/ReadBusinessMessageGeneratedVariation.kt

@@ -14,7 +14,7 @@ public suspend fun TelegramBot.readBusinessMessage(
   businessConnectionId: BusinessConnectionId,
   chat: Chat,
   messageId: MessageId,
-): Boolean = readBusinessMessage(
+): Unit = readBusinessMessage(
     businessConnectionId = businessConnectionId, chatId = with(chat) {chat.id.toChatId()}, messageId
     = messageId
 )

tgbotapi.api/src/commonMain/kotlin/dev/inmo/tgbotapi/extensions/api/business/RemoveBusinessAccountProfilePhoto.kt

@@ -7,6 +7,6 @@ import dev.inmo.tgbotapi.types.business_connection.BusinessConnectionId
 public suspend fun TelegramBot.removeBusinessAccountProfilePhoto(
     businessConnectionId: BusinessConnectionId,
     isPublic: Boolean = false
-): Boolean = execute(
+): Unit = execute(
     RemoveBusinessAccountProfilePhoto(businessConnectionId = businessConnectionId, isPublic = isPublic)
 ) 

tgbotapi.api/src/commonMain/kotlin/dev/inmo/tgbotapi/extensions/api/business/SetBusinessAccountBio.kt

@@ -7,6 +7,6 @@ import dev.inmo.tgbotapi.types.business_connection.BusinessConnectionId
 public suspend fun TelegramBot.setBusinessAccountBio(
     businessConnectionId: BusinessConnectionId,
     bio: String
-): Boolean = execute(
+): Unit = execute(
     SetBusinessAccountBio(businessConnectionId, bio)
 ) 

tgbotapi.api/src/commonMain/kotlin/dev/inmo/tgbotapi/extensions/api/business/SetBusinessAccountGiftSettings.kt

@@ -13,7 +13,7 @@ public suspend fun TelegramBot.setBusinessAccountGiftSettings(
     businessConnectionId: BusinessConnectionId,
     showGiftButton: Boolean,
     acceptedGiftTypes: AcceptedGiftTypes
-): Boolean = execute(
+): Unit = execute(
     SetBusinessAccountGiftSettings(
         businessConnectionId = businessConnectionId,
         showGiftButton = showGiftButton,
@@ -28,7 +28,7 @@ public suspend fun TelegramBot.setBusinessAccountGiftSettings(
     message: BusinessContentMessage<*>,
     showGiftButton: Boolean,
     acceptedGiftTypes: AcceptedGiftTypes
-): Boolean = setBusinessAccountGiftSettings(
+): Unit = setBusinessAccountGiftSettings(
     businessConnectionId = message.businessConnectionId,
     showGiftButton = showGiftButton,
     acceptedGiftTypes = acceptedGiftTypes

tgbotapi.api/src/commonMain/kotlin/dev/inmo/tgbotapi/extensions/api/business/SetBusinessAccountName.kt

@@ -8,6 +8,6 @@ public suspend fun TelegramBot.setBusinessAccountName(
     businessConnectionId: BusinessConnectionId,
     firstName: String,
     lastName: String? = null
-): Boolean = execute(
+): Unit = execute(
     SetBusinessAccountName(businessConnectionId, firstName, lastName)
 ) 

tgbotapi.api/src/commonMain/kotlin/dev/inmo/tgbotapi/extensions/api/business/SetBusinessAccountProfilePhoto.kt

@@ -9,6 +9,6 @@ public suspend fun TelegramBot.setBusinessAccountProfilePhoto(
     businessConnectionId: BusinessConnectionId,
     photo: InputProfilePhoto,
     isPublic: Boolean = false
-): Boolean = execute(
+): Unit = execute(
     SetBusinessAccountProfilePhoto(businessConnectionId, photo, isPublic)
 ) 

tgbotapi.api/src/commonMain/kotlin/dev/inmo/tgbotapi/extensions/api/business/SetBusinessAccountUsername.kt

@@ -7,11 +7,9 @@ import dev.inmo.tgbotapi.requests.business_connection.SetBusinessAccountUsername
 import dev.inmo.tgbotapi.types.business_connection.BusinessConnectionId
 import dev.inmo.tgbotapi.types.Username
 
-@GenerateVariations
 public suspend fun TelegramBot.setBusinessAccountUsername(
     businessConnectionId: BusinessConnectionId,
-    @GenerationVariant(String::class, "Username(username)", "username")
-    username: Username
-): Boolean = execute(
+    username: Username? = null
+): Unit = execute(
     SetBusinessAccountUsername(businessConnectionId, username)
 ) 

tgbotapi.api/src/commonMain/kotlin/dev/inmo/tgbotapi/extensions/api/business/SetBusinessAccountUsernameGeneratedVariation.kt

@@ -9,8 +9,10 @@ import dev.inmo.tgbotapi.types.business_connection.BusinessConnectionId
 import kotlin.Boolean
 import kotlin.String
 
-public suspend
-    fun TelegramBot.setBusinessAccountUsername(businessConnectionId: BusinessConnectionId,
-    username: String): Boolean = setBusinessAccountUsername(
-    businessConnectionId = businessConnectionId, username = with(username) { Username.prepare(username) }
+public suspend fun TelegramBot.setBusinessAccountUsername(
+    businessConnectionId: BusinessConnectionId,
+    username: String?
+): Unit = setBusinessAccountUsername(
+    businessConnectionId = businessConnectionId,
+    username = username ?.let { Username.prepare(username) }
 )

tgbotapi.api/src/commonMain/kotlin/dev/inmo/tgbotapi/extensions/api/business/TransferBusinessAccountStarBalance.kt

@@ -7,6 +7,6 @@ import dev.inmo.tgbotapi.types.business_connection.BusinessConnectionId
 public suspend fun TelegramBot.transferBusinessAccountStars(
     businessConnectionId: BusinessConnectionId,
     amount: Int
-): Boolean = execute(
+): Unit = execute(
     TransferBusinessAccountStars(businessConnectionId, amount)
 ) 

tgbotapi.api/src/commonMain/kotlin/dev/inmo/tgbotapi/extensions/api/business/TransferGift.kt

@@ -21,7 +21,7 @@ public suspend fun TelegramBot.transferGift(
     ownedGiftId: GiftId,
     newOwnerChatId: ChatId,
     transferPaymentStarCount: Int? = null,
-): Boolean = execute(
+): Unit = execute(
     TransferGift(
         businessConnectionId = businessConnectionId,
         ownedGiftId = ownedGiftId,
@@ -35,7 +35,7 @@ public suspend fun TelegramBot.transferGift(
     gift: Gift.Regular,
     newOwnerChatId: ChatId,
     transferPaymentStarCount: Int? = null,
-): Boolean = transferGift(
+): Unit = transferGift(
     businessConnectionId = businessConnectionId,
     ownedGiftId = gift.id,
     newOwnerChatId = newOwnerChatId,

tgbotapi.api/src/commonMain/kotlin/dev/inmo/tgbotapi/extensions/api/business/UpgradeGift.kt

@@ -19,7 +19,7 @@ public suspend fun TelegramBot.convertGiftToStars(
     ownedGiftId: GiftId,
     keepOriginalDetails: Boolean = false,
     starCount: Int? = null
-): Boolean = execute(
+): Unit = execute(
     UpgradeGift(
         businessConnectionId = businessConnectionId,
         ownedGiftId = ownedGiftId,
@@ -32,7 +32,7 @@ public suspend fun TelegramBot.convertGiftToStars(
     businessConnectionId: BusinessConnectionId,
     gift: Gift.Regular,
     keepOriginalDetails: Boolean = false,
-): Boolean = execute(
+): Unit = execute(
     UpgradeGift(
         businessConnectionId = businessConnectionId,
         ownedGiftId = gift.id,

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

@@ -7,8 +7,8 @@ import dev.inmo.tgbotapi.types.chat.PublicChat
 
 public suspend fun TelegramBot.leaveChat(
     chatId: ChatIdentifier
-): Boolean = execute(LeaveChat(chatId))
+): Unit = execute(LeaveChat(chatId))
 
 public suspend fun TelegramBot.leaveChat(
     chat: PublicChat
-): Boolean = leaveChat(chat.id)
+): Unit = leaveChat(chat.id)

tgbotapi.api/src/commonMain/kotlin/dev/inmo/tgbotapi/extensions/api/chat/forum/CloseForumTopic.kt

@@ -10,7 +10,7 @@ import dev.inmo.tgbotapi.types.chat.Chat
 public suspend fun TelegramBot.closeForumTopic(
     chatId: ChatIdentifier,
     messageThreadId: MessageThreadId
-): Boolean = execute(
+): Unit = execute(
     CloseForumTopic(
         chatId,
         messageThreadId
@@ -20,9 +20,9 @@ public suspend fun TelegramBot.closeForumTopic(
 public suspend fun TelegramBot.closeForumTopic(
     chat: Chat,
     messageThreadId: MessageThreadId
-): Boolean = closeForumTopic(chat.id, messageThreadId)
+): Unit = closeForumTopic(chat.id, messageThreadId)
 
 public suspend fun TelegramBot.closeForumTopic(
     chat: Chat,
     forumTopic: ForumTopic
-): Boolean = closeForumTopic(chat.id, forumTopic.messageThreadId)
+): Unit = closeForumTopic(chat.id, forumTopic.messageThreadId)

tgbotapi.api/src/commonMain/kotlin/dev/inmo/tgbotapi/extensions/api/chat/forum/CloseGeneralForumTopic.kt

@@ -10,10 +10,10 @@ import dev.inmo.tgbotapi.types.chat.Chat
 
 public suspend fun TelegramBot.closeGeneralForumTopic(
     chatId: ChatIdentifier
-): Boolean = execute(
+): Unit = execute(
     CloseGeneralForumTopic(chatId)
 )
 
 public suspend fun TelegramBot.closeGeneralForumTopic(
     chat: Chat
-): Boolean = closeGeneralForumTopic(chat.id)
+): Unit = closeGeneralForumTopic(chat.id)

tgbotapi.api/src/commonMain/kotlin/dev/inmo/tgbotapi/extensions/api/chat/forum/DeleteForumTopic.kt

@@ -10,7 +10,7 @@ import dev.inmo.tgbotapi.types.chat.Chat
 public suspend fun TelegramBot.deleteForumTopic(
     chatId: ChatIdentifier,
     messageThreadId: MessageThreadId
-): Boolean = execute(
+): Unit = execute(
     DeleteForumTopic(
         chatId,
         messageThreadId
@@ -20,14 +20,14 @@ public suspend fun TelegramBot.deleteForumTopic(
 public suspend fun TelegramBot.deleteForumTopic(
     chatId: ChatIdentifier,
     forumTopic: ForumTopic
-): Boolean = deleteForumTopic(chatId, forumTopic.messageThreadId)
+): Unit = deleteForumTopic(chatId, forumTopic.messageThreadId)
 
 public suspend fun TelegramBot.deleteForumTopic(
     chat: Chat,
     messageThreadId: MessageThreadId
-): Boolean = deleteForumTopic(chat.id, messageThreadId)
+): Unit = deleteForumTopic(chat.id, messageThreadId)
 
 public suspend fun TelegramBot.deleteForumTopic(
     chat: Chat,
     forumTopic: ForumTopic
-): Boolean = deleteForumTopic(chat.id, forumTopic.messageThreadId)
+): Unit = deleteForumTopic(chat.id, forumTopic.messageThreadId)

tgbotapi.api/src/commonMain/kotlin/dev/inmo/tgbotapi/extensions/api/chat/forum/EditForumTopic.kt

@@ -13,7 +13,7 @@ public suspend fun TelegramBot.editForumTopic(
     messageThreadId: MessageThreadId,
     name: String? = null,
     iconEmojiId: CustomEmojiId? = null
-): Boolean = execute(
+): Unit = execute(
     EditForumTopic(
         chatId,
         messageThreadId,
@@ -27,10 +27,10 @@ public suspend fun TelegramBot.editForumTopic(
     messageThreadId: MessageThreadId,
     name: String? = null,
     iconEmojiId: CustomEmojiId? = null
-): Boolean = editForumTopic(chat.id, messageThreadId, name, iconEmojiId)
+): Unit = editForumTopic(chat.id, messageThreadId, name, iconEmojiId)
 
 public suspend fun TelegramBot.editForumTopic(
     chatIdentifier: ChatIdentifier,
     forumTopic: ForumTopic,
     iconEmojiId: CustomEmojiId? = forumTopic.iconEmojiId
-): Boolean = editForumTopic(chatIdentifier, forumTopic.messageThreadId, forumTopic.name, iconEmojiId)
+): Unit = editForumTopic(chatIdentifier, forumTopic.messageThreadId, forumTopic.name, iconEmojiId)

tgbotapi.api/src/commonMain/kotlin/dev/inmo/tgbotapi/extensions/api/chat/forum/EditGeneralForumTopic.kt

@@ -12,7 +12,7 @@ import dev.inmo.tgbotapi.types.chat.Chat
 public suspend fun TelegramBot.editGeneralForumTopic(
     chatId: ChatIdentifier,
     name: String
-): Boolean = execute(
+): Unit = execute(
     EditGeneralForumTopic(
         chatId,
         name
@@ -22,9 +22,9 @@ public suspend fun TelegramBot.editGeneralForumTopic(
 public suspend fun TelegramBot.editGeneralForumTopic(
     chat: Chat,
     name: String
-): Boolean = editGeneralForumTopic(chat.id, name)
+): Unit = editGeneralForumTopic(chat.id, name)
 
 public suspend fun TelegramBot.editGeneralForumTopic(
     chatIdentifier: ChatIdentifier,
     forumTopic: ForumTopic,
-): Boolean = editGeneralForumTopic(chatIdentifier, forumTopic.name)
+): Unit = editGeneralForumTopic(chatIdentifier, forumTopic.name)

tgbotapi.api/src/commonMain/kotlin/dev/inmo/tgbotapi/extensions/api/chat/forum/HideGeneralForumTopic.kt

@@ -11,10 +11,10 @@ import dev.inmo.tgbotapi.types.chat.Chat
 
 public suspend fun TelegramBot.hideGeneralForumTopic(
     chatId: ChatIdentifier
-): Boolean = execute(
+): Unit = execute(
     HideGeneralForumTopic(chatId)
 )
 
 public suspend fun TelegramBot.hideGeneralForumTopic(
     chat: Chat
-): Boolean = hideGeneralForumTopic(chat.id)
+): Unit = hideGeneralForumTopic(chat.id)

tgbotapi.api/src/commonMain/kotlin/dev/inmo/tgbotapi/extensions/api/chat/forum/ReopenForumTopic.kt

@@ -10,7 +10,7 @@ import dev.inmo.tgbotapi.types.chat.Chat
 public suspend fun TelegramBot.reopenForumTopic(
     chatId: ChatIdentifier,
     messageThreadId: MessageThreadId
-): Boolean = execute(
+): Unit = execute(
     ReopenForumTopic(
         chatId,
         messageThreadId
@@ -20,9 +20,9 @@ public suspend fun TelegramBot.reopenForumTopic(
 public suspend fun TelegramBot.reopenForumTopic(
     chat: Chat,
     messageThreadId: MessageThreadId
-): Boolean = reopenForumTopic(chat.id, messageThreadId)
+): Unit = reopenForumTopic(chat.id, messageThreadId)
 
 public suspend fun TelegramBot.reopenForumTopic(
     chat: Chat,
     forumTopic: ForumTopic
-): Boolean = reopenForumTopic(chat.id, forumTopic.messageThreadId)
+): Unit = reopenForumTopic(chat.id, forumTopic.messageThreadId)

tgbotapi.api/src/commonMain/kotlin/dev/inmo/tgbotapi/extensions/api/chat/forum/ReopenGeneralForumTopic.kt

@@ -10,10 +10,10 @@ import dev.inmo.tgbotapi.types.chat.Chat
 
 public suspend fun TelegramBot.reopenGeneralForumTopic(
     chatId: ChatIdentifier
-): Boolean = execute(
+): Unit = execute(
     ReopenGeneralForumTopic(chatId)
 )
 
 public suspend fun TelegramBot.reopenGeneralForumTopic(
     chat: Chat
-): Boolean = reopenGeneralForumTopic(chat.id)
+): Unit = reopenGeneralForumTopic(chat.id)

tgbotapi.api/src/commonMain/kotlin/dev/inmo/tgbotapi/extensions/api/chat/forum/UnhideGeneralForumTopic.kt

@@ -12,10 +12,10 @@ import dev.inmo.tgbotapi.types.chat.Chat
 
 public suspend fun TelegramBot.unhideGeneralForumTopic(
     chatId: ChatIdentifier
-): Boolean = execute(
+): Unit = execute(
     UnhideGeneralForumTopic(chatId)
 )
 
 public suspend fun TelegramBot.unhideGeneralForumTopic(
     chat: Chat
-): Boolean = unhideGeneralForumTopic(chat.id)
+): Unit = unhideGeneralForumTopic(chat.id)

tgbotapi.api/src/commonMain/kotlin/dev/inmo/tgbotapi/extensions/api/chat/forum/UnpinAllForumTopicMessages.kt

@@ -10,7 +10,7 @@ import dev.inmo.tgbotapi.types.chat.Chat
 public suspend fun TelegramBot.unpinAllForumTopicMessages(
     chatId: ChatIdentifier,
     messageThreadId: MessageThreadId
-): Boolean = execute(
+): Unit = execute(
     UnpinAllForumTopicMessages(
         chatId,
         messageThreadId
@@ -20,9 +20,9 @@ public suspend fun TelegramBot.unpinAllForumTopicMessages(
 public suspend fun TelegramBot.unpinAllForumTopicMessages(
     chat: Chat,
     messageThreadId: MessageThreadId
-): Boolean = unpinAllForumTopicMessages(chat.id, messageThreadId)
+): Unit = unpinAllForumTopicMessages(chat.id, messageThreadId)
 
 public suspend fun TelegramBot.unpinAllForumTopicMessages(
     chat: Chat,
     forumTopic: ForumTopic
-): Boolean = unpinAllForumTopicMessages(chat.id, forumTopic.messageThreadId)
+): Unit = unpinAllForumTopicMessages(chat.id, forumTopic.messageThreadId)

tgbotapi.api/src/commonMain/kotlin/dev/inmo/tgbotapi/extensions/api/chat/forum/UnpinAllGeneralForumTopicMessages.kt

@@ -10,7 +10,7 @@ import dev.inmo.tgbotapi.types.chat.Chat
 
 public suspend fun TelegramBot.unpinAllGeneralForumTopicMessages(
     chatId: ChatIdentifier
-): Boolean = execute(
+): Unit = execute(
     UnpinAllGeneralForumTopicMessages(
         chatId
     )
@@ -18,4 +18,4 @@ public suspend fun TelegramBot.unpinAllGeneralForumTopicMessages(
 
 public suspend fun TelegramBot.unpinAllGeneralForumTopicMessages(
     chat: Chat
-): Boolean = unpinAllGeneralForumTopicMessages(chat.id)
+): Unit = unpinAllGeneralForumTopicMessages(chat.id)

tgbotapi.api/src/commonMain/kotlin/dev/inmo/tgbotapi/extensions/api/chat/get/GetChatAdministrators.kt

@@ -7,9 +7,11 @@ import dev.inmo.tgbotapi.types.chat.PublicChat
 import dev.inmo.tgbotapi.types.chat.member.AdministratorChatMember
 
 public suspend fun TelegramBot.getChatAdministrators(
-    chatId: ChatIdentifier
-): List<AdministratorChatMember> = execute(GetChatAdministrators(chatId))
+    chatId: ChatIdentifier,
+    retrieveOtherBots: Boolean? = null
+): List<AdministratorChatMember> = execute(GetChatAdministrators(chatId = chatId, retrieveOtherBots = retrieveOtherBots))
 
 public suspend fun TelegramBot.getChatAdministrators(
-    chat: PublicChat
-): List<AdministratorChatMember> = getChatAdministrators(chat.id)
+    chat: PublicChat,
+    retrieveOtherBots: Boolean? = null
+): List<AdministratorChatMember> = getChatAdministrators(chat.id, retrieveOtherBots)

tgbotapi.api/src/commonMain/kotlin/dev/inmo/tgbotapi/extensions/api/chat/invite_links/ApproveChatJoinRequest.kt

@@ -12,31 +12,31 @@ import dev.inmo.tgbotapi.types.update.ChatJoinRequestUpdate
 public suspend fun TelegramBot.approveChatJoinRequest(
     chatId: ChatIdentifier,
     userId: UserId
-): Boolean = execute(ApproveChatJoinRequest(chatId, userId))
+): Unit = execute(ApproveChatJoinRequest(chatId, userId))
 
 public suspend fun TelegramBot.approveChatJoinRequest(
     chat: PublicChat,
     userId: UserId
-): Boolean = approveChatJoinRequest(chat.id, userId)
+): Unit = approveChatJoinRequest(chat.id, userId)
 
 public suspend fun TelegramBot.approveChatJoinRequest(
     chatId: ChatIdentifier,
     user: User
-): Boolean = approveChatJoinRequest(chatId, user.id)
+): Unit = approveChatJoinRequest(chatId, user.id)
 
 public suspend fun TelegramBot.approveChatJoinRequest(
     chat: PublicChat,
     user: User
-): Boolean = approveChatJoinRequest(chat.id, user.id)
+): Unit = approveChatJoinRequest(chat.id, user.id)
 
 public suspend fun TelegramBot.approveChatJoinRequest(
     chatJoinRequest: ChatJoinRequest
-): Boolean = approveChatJoinRequest(chatJoinRequest.chat, chatJoinRequest.user)
+): Unit = approveChatJoinRequest(chatJoinRequest.chat, chatJoinRequest.user)
 
 public suspend fun TelegramBot.approve(
     chatJoinRequest: ChatJoinRequest
-): Boolean = approveChatJoinRequest(chatJoinRequest)
+): Unit = approveChatJoinRequest(chatJoinRequest)
 
 public suspend fun TelegramBot.approveChatJoinRequest(
     chatJoinRequestUpdate: ChatJoinRequestUpdate
-): Boolean = approveChatJoinRequest(chatJoinRequestUpdate.data)
+): Unit = approveChatJoinRequest(chatJoinRequestUpdate.data)

tgbotapi.api/src/commonMain/kotlin/dev/inmo/tgbotapi/extensions/api/chat/invite_links/DeclineChatJoinRequest.kt

@@ -12,31 +12,31 @@ import dev.inmo.tgbotapi.types.update.ChatJoinRequestUpdate
 public suspend fun TelegramBot.declineChatJoinRequest(
     chatId: ChatIdentifier,
     userId: UserId
-): Boolean = execute(DeclineChatJoinRequest(chatId, userId))
+): Unit = execute(DeclineChatJoinRequest(chatId, userId))
 
 public suspend fun TelegramBot.declineChatJoinRequest(
     chat: PublicChat,
     userId: UserId
-): Boolean = declineChatJoinRequest(chat.id, userId)
+): Unit = declineChatJoinRequest(chat.id, userId)
 
 public suspend fun TelegramBot.declineChatJoinRequest(
     chatId: ChatIdentifier,
     user: User
-): Boolean = declineChatJoinRequest(chatId, user.id)
+): Unit = declineChatJoinRequest(chatId, user.id)
 
 public suspend fun TelegramBot.declineChatJoinRequest(
     chat: PublicChat,
     user: User
-): Boolean = declineChatJoinRequest(chat.id, user.id)
+): Unit = declineChatJoinRequest(chat.id, user.id)
 
 public suspend fun TelegramBot.declineChatJoinRequest(
     chatJoinRequest: ChatJoinRequest
-): Boolean = declineChatJoinRequest(chatJoinRequest.chat, chatJoinRequest.user)
+): Unit = declineChatJoinRequest(chatJoinRequest.chat, chatJoinRequest.user)
 
 public suspend fun TelegramBot.decline(
     chatJoinRequest: ChatJoinRequest
-): Boolean = declineChatJoinRequest(chatJoinRequest)
+): Unit = declineChatJoinRequest(chatJoinRequest)
 
 public suspend fun TelegramBot.declineChatJoinRequest(
     chatJoinRequestUpdate: ChatJoinRequestUpdate
-): Boolean = declineChatJoinRequest(chatJoinRequestUpdate.data)
+): Unit = declineChatJoinRequest(chatJoinRequestUpdate.data)

tgbotapi.api/src/commonMain/kotlin/dev/inmo/tgbotapi/extensions/api/chat/members/BanChatMember.kt

@@ -14,25 +14,25 @@ public suspend fun TelegramBot.banChatMember(
     userId: UserId,
     untilDate: TelegramDate? = null,
     revokeMessages: Boolean? = null
-): Boolean = execute(BanChatMember(chatId, userId, untilDate, revokeMessages))
+): Unit = execute(BanChatMember(chatId, userId, untilDate, revokeMessages))
 
 public suspend fun TelegramBot.banChatMember(
     chat: PublicChat,
     userId: UserId,
     untilDate: TelegramDate? = null,
     revokeMessages: Boolean? = null
-): Boolean = banChatMember(chat.id, userId, untilDate, revokeMessages)
+): Unit = banChatMember(chat.id, userId, untilDate, revokeMessages)
 
 public suspend fun TelegramBot.banChatMember(
     chatId: IdChatIdentifier,
     user: User,
     untilDate: TelegramDate? = null,
     revokeMessages: Boolean? = null
-): Boolean = banChatMember(chatId, user.id, untilDate, revokeMessages)
+): Unit = banChatMember(chatId, user.id, untilDate, revokeMessages)
 
 public suspend fun TelegramBot.banChatMember(
     chat: PublicChat,
     user: User,
     untilDate: TelegramDate? = null,
     revokeMessages: Boolean? = null
-): Boolean = banChatMember(chat.id, user.id, untilDate, revokeMessages)
+): Unit = banChatMember(chat.id, user.id, untilDate, revokeMessages)

tgbotapi.api/src/commonMain/kotlin/dev/inmo/tgbotapi/extensions/api/chat/members/BanChatSenderChat.kt

@@ -9,19 +9,19 @@ import dev.inmo.tgbotapi.types.chat.PublicChat
 public suspend fun TelegramBot.banChatSenderChat(
     chatId: ChatIdentifier,
     senderChatId: IdChatIdentifier
-): Boolean = execute(BanChatSenderChat(chatId, senderChatId))
+): Unit = execute(BanChatSenderChat(chatId, senderChatId))
 
 public suspend fun TelegramBot.banChatSenderChat(
     chat: PublicChat,
     senderChatId: IdChatIdentifier
-): Boolean = banChatSenderChat(chat.id, senderChatId)
+): Unit = banChatSenderChat(chat.id, senderChatId)
 
 public suspend fun TelegramBot.banChatSenderChat(
     chatId: IdChatIdentifier,
     senderChat: PublicChat
-): Boolean = banChatSenderChat(chatId, senderChat.id)
+): Unit = banChatSenderChat(chatId, senderChat.id)
 
 public suspend fun TelegramBot.banChatSenderChat(
     chat: PublicChat,
     senderChat: PublicChat,
-): Boolean = banChatSenderChat(chat.id, senderChat)
+): Unit = banChatSenderChat(chat.id, senderChat)

tgbotapi.api/src/commonMain/kotlin/dev/inmo/tgbotapi/extensions/api/chat/members/PromoteChannelAdministrator.kt

@@ -27,7 +27,7 @@ public suspend fun TelegramBot.promoteChannelAdministrator(
     canEditStories: Boolean? = null,
     canDeleteStories: Boolean? = null,
     canManageDirectMessages: Boolean? = null,
-): Boolean = execute(
+): Unit = execute(
     PromoteChannelAdministrator(
         chatId = chatId,
         userId = userId,
@@ -67,7 +67,7 @@ public suspend fun TelegramBot.promoteChannelAdministrator(
     canEditStories: Boolean? = null,
     canDeleteStories: Boolean? = null,
     canManageDirectMessages: Boolean? = null,
-): Boolean = promoteChannelAdministrator(
+): Unit = promoteChannelAdministrator(
     chat.id,
     userId,
     untilDate = untilDate,
@@ -105,7 +105,7 @@ public suspend fun TelegramBot.promoteChannelAdministrator(
     canEditStories: Boolean? = null,
     canDeleteStories: Boolean? = null,
     canManageDirectMessages: Boolean? = null,
-): Boolean = promoteChannelAdministrator(
+): Unit = promoteChannelAdministrator(
     chatId,
     user.id,
     untilDate = untilDate,
@@ -143,7 +143,7 @@ public suspend fun TelegramBot.promoteChannelAdministrator(
     canEditStories: Boolean? = null,
     canDeleteStories: Boolean? = null,
     canManageDirectMessages: Boolean? = null,
-): Boolean = promoteChannelAdministrator(
+): Unit = promoteChannelAdministrator(
     chat.id,
     user.id,
     untilDate = untilDate,

tgbotapi.api/src/commonMain/kotlin/dev/inmo/tgbotapi/extensions/api/chat/members/PromoteChatAdministrator.kt

@@ -22,7 +22,7 @@ public suspend fun TelegramBot.promoteChatAdministrator(
     canManageVideoChats: Boolean? = null,
     canManageChat: Boolean? = null,
     canManageTags: Boolean? = null,
-): Boolean = execute(
+): Unit = execute(
     PromoteChatMember(
         chatId = chatId,
         userId = userId,
@@ -52,7 +52,7 @@ public suspend fun TelegramBot.promoteChatAdministrator(
     canManageVideoChats: Boolean? = null,
     canManageChat: Boolean? = null,
     canManageTags: Boolean? = null,
-): Boolean = promoteChatAdministrator(
+): Unit = promoteChatAdministrator(
     chatId = chat.id,
     userId = userId,
     untilDate = untilDate,
@@ -80,7 +80,7 @@ public suspend fun TelegramBot.promoteChatAdministrator(
     canManageVideoChats: Boolean? = null,
     canManageChat: Boolean? = null,
     canManageTags: Boolean? = null,
-): Boolean = promoteChatAdministrator(
+): Unit = promoteChatAdministrator(
     chatId = chatId,
     userId = user.id,
     untilDate = untilDate,
@@ -108,7 +108,7 @@ public suspend fun TelegramBot.promoteChatAdministrator(
     canManageVideoChats: Boolean? = null,
     canManageChat: Boolean? = null,
     canManageTags: Boolean? = null,
-): Boolean = promoteChatAdministrator(
+): Unit = promoteChatAdministrator(
     chatId = chat.id,
     userId = user.id,
     untilDate = untilDate,

tgbotapi.api/src/commonMain/kotlin/dev/inmo/tgbotapi/extensions/api/chat/members/PromoteChatMember.kt

@@ -29,7 +29,7 @@ public suspend fun TelegramBot.promoteChatMember(
     canDeleteStories: Boolean? = null,
     canManageDirectMessages: Boolean? = null,
     canManageTags: Boolean? = null
-): Boolean = execute(
+): Unit = execute(
     PromoteChatMember(
         chatId = chatId,
         userId = userId,
@@ -76,7 +76,7 @@ public suspend fun TelegramBot.promoteChatMember(
     canDeleteStories: Boolean? = null,
     canManageDirectMessages: Boolean? = null,
     canManageTags: Boolean? = null
-): Boolean = promoteChatMember(
+): Unit = promoteChatMember(
     chat.id,
     userId,
     untilDate = untilDate,
@@ -121,7 +121,7 @@ public suspend fun TelegramBot.promoteChatMember(
     canDeleteStories: Boolean? = null,
     canManageDirectMessages: Boolean? = null,
     canManageTags: Boolean? = null
-): Boolean = promoteChatMember(
+): Unit = promoteChatMember(
     chatId,
     user.id,
     untilDate = untilDate,
@@ -166,7 +166,7 @@ public suspend fun TelegramBot.promoteChatMember(
     canDeleteStories: Boolean? = null,
     canManageDirectMessages: Boolean? = null,
     canManageTags: Boolean? = null
-): Boolean = promoteChatMember(
+): Unit = promoteChatMember(
     chat.id,
     user.id,
     untilDate = untilDate,

tgbotapi.api/src/commonMain/kotlin/dev/inmo/tgbotapi/extensions/api/chat/members/PromoteSupergroupAdministrator.kt

@@ -24,7 +24,7 @@ public suspend fun TelegramBot.promoteSupergroupAdministrator(
     canManageVideoChats: Boolean? = null,
     canManageChat: Boolean? = null,
     canManageTopics: Boolean? = null,
-): Boolean = execute(
+): Unit = execute(
     PromoteSupergroupAdministrator(
         chatId = chatId,
         userId = userId,
@@ -56,7 +56,7 @@ public suspend fun TelegramBot.promoteSupergroupAdministrator(
     canManageVideoChats: Boolean? = null,
     canManageChat: Boolean? = null,
     canManageTopics: Boolean? = null,
-): Boolean = promoteSupergroupAdministrator(
+): Unit = promoteSupergroupAdministrator(
     chat.id,
     userId,
     untilDate = untilDate,
@@ -86,7 +86,7 @@ public suspend fun TelegramBot.promoteSupergroupAdministrator(
     canManageVideoChats: Boolean? = null,
     canManageChat: Boolean? = null,
     canManageTopics: Boolean? = null,
-): Boolean = promoteSupergroupAdministrator(
+): Unit = promoteSupergroupAdministrator(
     chatId,
     user.id,
     untilDate = untilDate,
@@ -116,7 +116,7 @@ public suspend fun TelegramBot.promoteSupergroupAdministrator(
     canManageVideoChats: Boolean? = null,
     canManageChat: Boolean? = null,
     canManageTopics: Boolean? = null,
-): Boolean = promoteSupergroupAdministrator(
+): Unit = promoteSupergroupAdministrator(
     chat.id,
     user.id,
     untilDate = untilDate,

tgbotapi.api/src/commonMain/kotlin/dev/inmo/tgbotapi/extensions/api/chat/members/RestrictChatMember.kt

@@ -16,7 +16,7 @@ public suspend fun TelegramBot.restrictChatMember(
     untilDate: TelegramDate? = null,
     permissions: ChatPermissions = ChatPermissions(),
     useIndependentChatPermissions: Boolean? = permissions.isGranular.takeIf { it }
-): Boolean = execute(RestrictChatMember(chatId, userId, untilDate, permissions, useIndependentChatPermissions))
+): Unit = execute(RestrictChatMember(chatId, userId, untilDate, permissions, useIndependentChatPermissions))
 
 public suspend fun TelegramBot.restrictChatMember(
     chat: PublicChat,
@@ -24,7 +24,7 @@ public suspend fun TelegramBot.restrictChatMember(
     untilDate: TelegramDate? = null,
     permissions: ChatPermissions = ChatPermissions(),
     useIndependentChatPermissions: Boolean? = permissions.isGranular.takeIf { it }
-): Boolean = restrictChatMember(chat.id, userId, untilDate, permissions, useIndependentChatPermissions)
+): Unit = restrictChatMember(chat.id, userId, untilDate, permissions, useIndependentChatPermissions)
 
 public suspend fun TelegramBot.restrictChatMember(
     chatId: IdChatIdentifier,
@@ -32,7 +32,7 @@ public suspend fun TelegramBot.restrictChatMember(
     untilDate: TelegramDate? = null,
     permissions: ChatPermissions = ChatPermissions(),
     useIndependentChatPermissions: Boolean? = permissions.isGranular.takeIf { it }
-): Boolean = restrictChatMember(chatId, user.id, untilDate, permissions, useIndependentChatPermissions)
+): Unit = restrictChatMember(chatId, user.id, untilDate, permissions, useIndependentChatPermissions)
 
 public suspend fun TelegramBot.restrictChatMember(
     chat: PublicChat,
@@ -40,5 +40,5 @@ public suspend fun TelegramBot.restrictChatMember(
     untilDate: TelegramDate? = null,
     permissions: ChatPermissions = ChatPermissions(),
     useIndependentChatPermissions: Boolean? = permissions.isGranular.takeIf { it }
-): Boolean = restrictChatMember(chat.id, user.id, untilDate, permissions, useIndependentChatPermissions)
+): Unit = restrictChatMember(chat.id, user.id, untilDate, permissions, useIndependentChatPermissions)
 

tgbotapi.api/src/commonMain/kotlin/dev/inmo/tgbotapi/extensions/api/chat/members/SetChatAdministratorCustomTitle.kt

@@ -11,22 +11,22 @@ public suspend fun TelegramBot.setChatAdministratorCustomTitle(
     chatId: IdChatIdentifier,
     userId: UserId,
     customTitle: String
-): Boolean = execute(SetChatAdministratorCustomTitle(chatId, userId, customTitle))
+): Unit = execute(SetChatAdministratorCustomTitle(chatId, userId, customTitle))
 
 public suspend fun TelegramBot.setChatAdministratorCustomTitle(
     chat: PublicChat,
     userId: UserId,
     customTitle: String
-): Boolean = setChatAdministratorCustomTitle(chat.id, userId, customTitle)
+): Unit = setChatAdministratorCustomTitle(chat.id, userId, customTitle)
 
 public suspend fun TelegramBot.setChatAdministratorCustomTitle(
     chatId: IdChatIdentifier,
     user: User,
     customTitle: String
-): Boolean = setChatAdministratorCustomTitle(chatId, user.id, customTitle)
+): Unit = setChatAdministratorCustomTitle(chatId, user.id, customTitle)
 
 public suspend fun TelegramBot.setChatAdministratorCustomTitle(
     chat: PublicChat,
     user: User,
     customTitle: String
-): Boolean = setChatAdministratorCustomTitle(chat.id, user.id, customTitle)
+): Unit = setChatAdministratorCustomTitle(chat.id, user.id, customTitle)

tgbotapi.api/src/commonMain/kotlin/dev/inmo/tgbotapi/extensions/api/chat/members/UnbanChatMember.kt

@@ -12,23 +12,23 @@ public suspend fun TelegramBot.unbanChatMember(
     chatId: ChatIdentifier,
     userId: UserId,
     onlyIfBanned: Boolean? = null
-): Boolean = execute(UnbanChatMember(chatId, userId, onlyIfBanned))
+): Unit = execute(UnbanChatMember(chatId, userId, onlyIfBanned))
 
 public suspend fun TelegramBot.unbanChatMember(
     chat: PublicChat,
     userId: UserId,
     onlyIfBanned: Boolean? = null
-): Boolean = unbanChatMember(chat.id, userId, onlyIfBanned)
+): Unit = unbanChatMember(chat.id, userId, onlyIfBanned)
 
 public suspend fun TelegramBot.unbanChatMember(
     chatId: IdChatIdentifier,
     user: User,
     onlyIfBanned: Boolean? = null
-): Boolean = unbanChatMember(chatId, user.id, onlyIfBanned)
+): Unit = unbanChatMember(chatId, user.id, onlyIfBanned)
 
 public suspend fun TelegramBot.unbanChatMember(
     chat: PublicChat,
     user: User,
     onlyIfBanned: Boolean? = null
-): Boolean = unbanChatMember(chat.id, user.id, onlyIfBanned)
+): Unit = unbanChatMember(chat.id, user.id, onlyIfBanned)
 

tgbotapi.api/src/commonMain/kotlin/dev/inmo/tgbotapi/extensions/api/chat/members/UnbanChatSenderChat.kt

@@ -9,19 +9,19 @@ import dev.inmo.tgbotapi.types.chat.PublicChat
 public suspend fun TelegramBot.unbanChatSenderChat(
     chatId: ChatIdentifier,
     senderChatId: IdChatIdentifier
-): Boolean = execute(UnbanChatSenderChat(chatId, senderChatId))
+): Unit = execute(UnbanChatSenderChat(chatId, senderChatId))
 
 public suspend fun TelegramBot.unbanChatSenderChat(
     chat: PublicChat,
     senderChatId: IdChatIdentifier
-): Boolean = unbanChatSenderChat(chat.id, senderChatId)
+): Unit = unbanChatSenderChat(chat.id, senderChatId)
 
 public suspend fun TelegramBot.unbanChatSenderChat(
     chatId: IdChatIdentifier,
     senderChat: PublicChat
-): Boolean = unbanChatSenderChat(chatId, senderChat.id)
+): Unit = unbanChatSenderChat(chatId, senderChat.id)
 
 public suspend fun TelegramBot.unbanChatSenderChat(
     chat: PublicChat,
     senderChat: PublicChat,
-): Boolean = unbanChatSenderChat(chat.id, senderChat)
+): Unit = unbanChatSenderChat(chat.id, senderChat)

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

@@ -7,8 +7,8 @@ import dev.inmo.tgbotapi.types.chat.PublicChat
 
 public suspend fun TelegramBot.deleteChatPhoto(
     chatId: ChatIdentifier
-): Boolean = execute(DeleteChatPhoto(chatId))
+): Unit = execute(DeleteChatPhoto(chatId))
 
 public suspend fun TelegramBot.deleteChatPhoto(
     chat: PublicChat
-): Boolean = deleteChatPhoto(chat.id)
+): Unit = deleteChatPhoto(chat.id)

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

@@ -14,17 +14,17 @@ public suspend fun TelegramBot.pinChatMessage(
     messageId: MessageId,
     businessConnectionId: BusinessConnectionId? = chatId.businessConnectionId,
     disableNotification: Boolean = false
-): Boolean = execute(PinChatMessage(chatId, messageId, businessConnectionId, disableNotification))
+): Unit = execute(PinChatMessage(chatId, messageId, businessConnectionId, disableNotification))
 
 public suspend fun TelegramBot.pinChatMessage(
     chat: Chat,
     messageId: MessageId,
     businessConnectionId: BusinessConnectionId? = chat.id.businessConnectionId,
     disableNotification: Boolean = false
-): Boolean = pinChatMessage(chat.id, messageId, businessConnectionId, disableNotification)
+): Unit = pinChatMessage(chat.id, messageId, businessConnectionId, disableNotification)
 
 public suspend fun TelegramBot.pinChatMessage(
     message: AccessibleMessage,
     businessConnectionId: BusinessConnectionId? = message.chat.id.businessConnectionId,
     disableNotification: Boolean = false
-): Boolean = pinChatMessage(message.chat.id, message.messageId, businessConnectionId, disableNotification)
+): Unit = pinChatMessage(message.chat.id, message.messageId, businessConnectionId, disableNotification)

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

@@ -8,9 +8,9 @@ import dev.inmo.tgbotapi.types.chat.PublicChat
 public suspend fun TelegramBot.setChatDescription(
     chatId: ChatIdentifier,
     description: String
-): Boolean = execute(SetChatDescription(chatId, description))
+): Unit = execute(SetChatDescription(chatId, description))
 
 public suspend fun TelegramBot.setChatDescription(
     chat: PublicChat,
     description: String
-): Boolean = setChatDescription(chat.id, description)
+): Unit = setChatDescription(chat.id, description)

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

@@ -9,9 +9,9 @@ import dev.inmo.tgbotapi.types.chat.PrivateChat
 public suspend fun TelegramBot.setChatMenuButton(
     chatId: IdChatIdentifier,
     menuButton: MenuButton
-): Boolean = execute(SetChatMenuButton(chatId, menuButton))
+): Unit = execute(SetChatMenuButton(chatId, menuButton))
 
 public suspend fun TelegramBot.setChatMenuButton(
     chat: PrivateChat,
     menuButton: MenuButton
-): Boolean = setChatMenuButton(chat.id, menuButton)
+): Unit = setChatMenuButton(chat.id, menuButton)

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

@@ -10,10 +10,10 @@ public suspend fun TelegramBot.setDefaultChatMembersPermissions(
     chatId: ChatIdentifier,
     permissions: ChatPermissions,
     useIndependentChatPermissions: Boolean? = permissions.isGranular.takeIf { it }
-): Boolean = execute(SetChatPermissions(chatId, permissions, useIndependentChatPermissions))
+): Unit = execute(SetChatPermissions(chatId, permissions, useIndependentChatPermissions))
 
 public suspend fun TelegramBot.setDefaultChatMembersPermissions(
     chat: PublicChat,
     permissions: ChatPermissions,
     useIndependentChatPermissions: Boolean? = permissions.isGranular.takeIf { it }
-): Boolean = setDefaultChatMembersPermissions(chat.id, permissions, useIndependentChatPermissions)
+): Unit = setDefaultChatMembersPermissions(chat.id, permissions, useIndependentChatPermissions)

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

@@ -9,9 +9,9 @@ import dev.inmo.tgbotapi.types.chat.PublicChat
 public suspend fun TelegramBot.setChatPhoto(
     chatId: ChatIdentifier,
     photo: MultipartFile
-): Boolean = execute(SetChatPhoto(chatId, photo))
+): Unit = execute(SetChatPhoto(chatId, photo))
 
 public suspend fun TelegramBot.setChatPhoto(
     chat: PublicChat,
     photo: MultipartFile
-): Boolean = setChatPhoto(chat.id, photo)
+): Unit = setChatPhoto(chat.id, photo)

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

@@ -8,9 +8,9 @@ import dev.inmo.tgbotapi.types.chat.PublicChat
 public suspend fun TelegramBot.setChatTitle(
     chatId: ChatIdentifier,
     title: String
-): Boolean = execute(SetChatTitle(chatId, title))
+): Unit = execute(SetChatTitle(chatId, title))
 
 public suspend fun TelegramBot.setChatTitle(
     chat: PublicChat,
     title: String
-): Boolean = setChatTitle(chat.id, title)
+): Unit = setChatTitle(chat.id, title)

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

@@ -6,4 +6,4 @@ import dev.inmo.tgbotapi.types.MenuButton
 
 public suspend fun TelegramBot.setDefaultChatMenuButton(
     menuButton: MenuButton
-): Boolean = execute(SetDefaultChatMenuButton(menuButton))
+): Unit = execute(SetDefaultChatMenuButton(menuButton))

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

@@ -7,8 +7,8 @@ import dev.inmo.tgbotapi.types.chat.Chat
 
 public suspend fun TelegramBot.unpinAllChatMessages(
     chatId: ChatIdentifier
-): Boolean = execute(UnpinAllChatMessages(chatId))
+): Unit = execute(UnpinAllChatMessages(chatId))
 
 public suspend fun TelegramBot.unpinAllChatMessages(
     chat: Chat
-): Boolean = unpinAllChatMessages(chat.id)
+): Unit = unpinAllChatMessages(chat.id)

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

@@ -13,15 +13,15 @@ public suspend fun TelegramBot.unpinChatMessage(
     chatId: ChatIdentifier,
     messageId: MessageId? = null,
     businessConnectionId: BusinessConnectionId? = chatId.businessConnectionId
-): Boolean = execute(UnpinChatMessage(chatId, messageId, businessConnectionId))
+): Unit = execute(UnpinChatMessage(chatId, messageId, businessConnectionId))
 
 public suspend fun TelegramBot.unpinChatMessage(
     chat: Chat,
     messageId: MessageId? = null,
     businessConnectionId: BusinessConnectionId? = chat.id.businessConnectionId
-): Boolean = unpinChatMessage(chat.id, messageId, businessConnectionId)
+): Unit = unpinChatMessage(chat.id, messageId, businessConnectionId)
 
 public suspend fun TelegramBot.unpinChatMessage(
     message: AccessibleMessage,
     businessConnectionId: BusinessConnectionId? = message.chat.id.businessConnectionId,
-): Boolean = unpinChatMessage(message.chat.id, message.messageId, businessConnectionId)
+): Unit = unpinChatMessage(message.chat.id, message.messageId, businessConnectionId)

tgbotapi.api/src/commonMain/kotlin/dev/inmo/tgbotapi/extensions/api/chat/stickers/DeleteChatStickerSet.kt

@@ -7,8 +7,8 @@ import dev.inmo.tgbotapi.types.chat.SupergroupChat
 
 public suspend fun TelegramBot.deleteChatStickerSet(
     chatId: ChatIdentifier
-): Boolean = execute(DeleteChatStickerSet(chatId))
+): Unit = execute(DeleteChatStickerSet(chatId))
 
 public suspend fun TelegramBot.deleteChatStickerSet(
     chat: SupergroupChat
-): Boolean = deleteChatStickerSet(chat.id)
+): Unit = deleteChatStickerSet(chat.id)

tgbotapi.api/src/commonMain/kotlin/dev/inmo/tgbotapi/extensions/api/chat/stickers/SetChatStickerSet.kt

@@ -9,9 +9,9 @@ import dev.inmo.tgbotapi.types.chat.SupergroupChat
 public suspend fun TelegramBot.setChatStickerSet(
     chatId: ChatIdentifier,
     stickerSetName: StickerSetName
-): Boolean = execute(SetChatStickerSet(chatId, stickerSetName))
+): Unit = execute(SetChatStickerSet(chatId, stickerSetName))
 
 public suspend fun TelegramBot.setChatStickerSet(
     chat: SupergroupChat,
     stickerSetName: StickerSetName
-): Boolean = setChatStickerSet(chat.id, stickerSetName)
+): Unit = setChatStickerSet(chat.id, stickerSetName)

tgbotapi.api/src/commonMain/kotlin/dev/inmo/tgbotapi/extensions/api/edit/InlineEdits.kt

@@ -27,7 +27,7 @@ public suspend fun TelegramBot.edit(
     heading: Degrees? = null,
     proximityAlertRadius: Meters? = null,
     replyMarkup: InlineKeyboardMarkup? = null
-): Boolean = editLiveLocation(messageId, latitude, longitude, horizontalAccuracy, heading, proximityAlertRadius, replyMarkup)
+): Unit = editLiveLocation(messageId, latitude, longitude, horizontalAccuracy, heading, proximityAlertRadius, replyMarkup)
 
 /**
  * @param replyMarkup Some [InlineKeyboardMarkup]. See [dev.inmo.tgbotapi.extensions.utils.types.buttons.inlineKeyboard]
@@ -37,7 +37,7 @@ public suspend fun TelegramBot.edit(
     messageId: InlineMessageId,
     location: LiveLocation,
     replyMarkup: InlineKeyboardMarkup? = null
-): Boolean = editLiveLocation(
+): Unit = editLiveLocation(
     messageId, location, replyMarkup
 )
 
@@ -49,7 +49,7 @@ public suspend fun TelegramBot.edit(
     messageId: InlineMessageId,
     media: TelegramFreeMedia,
     replyMarkup: InlineKeyboardMarkup? = null
-): Boolean = editMessageMedia(messageId, media, replyMarkup)
+): Unit = editMessageMedia(messageId, media, replyMarkup)
 
 /**
  * @param replyMarkup Some [InlineKeyboardMarkup]. See [dev.inmo.tgbotapi.extensions.utils.types.buttons.inlineKeyboard]
@@ -58,7 +58,7 @@ public suspend fun TelegramBot.edit(
 public suspend fun TelegramBot.edit(
     messageId: InlineMessageId,
     replyMarkup: InlineKeyboardMarkup? = null
-): Boolean = editMessageReplyMarkup(messageId, replyMarkup)
+): Unit = editMessageReplyMarkup(messageId, replyMarkup)
 
 /**
  * @param replyMarkup Some [InlineKeyboardMarkup]. See [dev.inmo.tgbotapi.extensions.utils.types.buttons.inlineKeyboard]
@@ -71,7 +71,7 @@ public suspend fun TelegramBot.edit(
     showCaptionAboveMedia: Boolean = false,
     linkPreviewOptions: LinkPreviewOptions? = null,
     replyMarkup: InlineKeyboardMarkup? = null
-): Boolean = editMessageText(messageId, text, parseMode, showCaptionAboveMedia, linkPreviewOptions, replyMarkup)
+): Unit = editMessageText(messageId, text, parseMode, showCaptionAboveMedia, linkPreviewOptions, replyMarkup)
 
 /**
  * @param replyMarkup Some [InlineKeyboardMarkup]. See [dev.inmo.tgbotapi.extensions.utils.types.buttons.inlineKeyboard]
@@ -83,7 +83,7 @@ public suspend fun TelegramBot.edit(
     showCaptionAboveMedia: Boolean = false,
     linkPreviewOptions: LinkPreviewOptions? = null,
     replyMarkup: InlineKeyboardMarkup? = null
-): Boolean = editMessageText(messageId, entities, showCaptionAboveMedia, linkPreviewOptions, replyMarkup)
+): Unit = editMessageText(messageId, entities, showCaptionAboveMedia, linkPreviewOptions, replyMarkup)
 
 /**
  * @param replyMarkup Some [InlineKeyboardMarkup]. See [dev.inmo.tgbotapi.extensions.utils.types.buttons.inlineKeyboard]
@@ -96,7 +96,7 @@ public suspend fun TelegramBot.edit(
     linkPreviewOptions: LinkPreviewOptions? = null,
     replyMarkup: InlineKeyboardMarkup? = null,
     builderBody: EntitiesBuilderBody
-): Boolean = edit(messageId, buildEntities(separator, builderBody), showCaptionAboveMedia, linkPreviewOptions, replyMarkup)
+): Unit = edit(messageId, buildEntities(separator, builderBody), showCaptionAboveMedia, linkPreviewOptions, replyMarkup)
 
 /**
  * @param replyMarkup Some [InlineKeyboardMarkup]. See [dev.inmo.tgbotapi.extensions.utils.types.buttons.inlineKeyboard]
@@ -109,4 +109,4 @@ public suspend fun TelegramBot.edit(
     linkPreviewOptions: LinkPreviewOptions? = null,
     replyMarkup: InlineKeyboardMarkup? = null,
     builderBody: EntitiesBuilderBody
-): Boolean = edit(messageId, buildEntities(separator, builderBody), showCaptionAboveMedia, linkPreviewOptions, replyMarkup)
+): Unit = edit(messageId, buildEntities(separator, builderBody), showCaptionAboveMedia, linkPreviewOptions, replyMarkup)

tgbotapi.api/src/commonMain/kotlin/dev/inmo/tgbotapi/extensions/api/edit/caption/EditInlineMessageCaption.kt

@@ -16,7 +16,7 @@ public suspend fun TelegramBot.editMessageCaption(
     text: String,
     parseMode: ParseMode? = null,
     replyMarkup: InlineKeyboardMarkup? = null
-): Boolean = execute(EditInlineMessageCaption(inlineMessageId, text, parseMode, replyMarkup))
+): Unit = execute(EditInlineMessageCaption(inlineMessageId, text, parseMode, replyMarkup))
 
 /**
  * @param replyMarkup Some [InlineKeyboardMarkup]. See [dev.inmo.tgbotapi.extensions.utils.types.buttons.inlineKeyboard]
@@ -26,4 +26,4 @@ public suspend fun TelegramBot.editMessageCaption(
     inlineMessageId: InlineMessageId,
     entities: TextSourcesList,
     replyMarkup: InlineKeyboardMarkup? = null
-): Boolean = execute(EditInlineMessageCaption(inlineMessageId, entities, replyMarkup))
+): Unit = execute(EditInlineMessageCaption(inlineMessageId, entities, replyMarkup))

tgbotapi.api/src/commonMain/kotlin/dev/inmo/tgbotapi/extensions/api/edit/location/live/EditInlineMessageLiveLocation.kt

@@ -14,7 +14,7 @@ public suspend fun TelegramBot.editLiveLocation(
     heading: Degrees? = null,
     proximityAlertRadius: Meters? = null,
     replyMarkup: InlineKeyboardMarkup? = null
-): Boolean = execute(
+): Unit = execute(
     EditInlineMessageLiveLocation(
         inlineMessageId, latitude, longitude, horizontalAccuracy, heading, proximityAlertRadius, replyMarkup
     )
@@ -23,4 +23,4 @@ public suspend fun TelegramBot.editLiveLocation(
     inlineMessageId: InlineMessageId,
     location: LiveLocation,
     replyMarkup: InlineKeyboardMarkup? = null
-): Boolean = editLiveLocation(inlineMessageId, location.latitude, location.longitude, location.horizontalAccuracy, location.heading, location.proximityAlertRadius, replyMarkup)
+): Unit = editLiveLocation(inlineMessageId, location.latitude, location.longitude, location.horizontalAccuracy, location.heading, location.proximityAlertRadius, replyMarkup)

tgbotapi.api/src/commonMain/kotlin/dev/inmo/tgbotapi/extensions/api/edit/location/live/StopInlineMessageLiveLocation.kt

@@ -12,7 +12,7 @@ import dev.inmo.tgbotapi.types.buttons.InlineKeyboardMarkup
 public suspend fun TelegramBot.stopLiveLocation(
     inlineMessageId: InlineMessageId,
     replyMarkup: InlineKeyboardMarkup? = null
-): Boolean = execute(
+): Unit = execute(
     StopInlineMessageLiveLocation(
         inlineMessageId, replyMarkup
     )

tgbotapi.api/src/commonMain/kotlin/dev/inmo/tgbotapi/extensions/api/edit/media/EditInlineMessageMedia.kt

@@ -14,4 +14,4 @@ public suspend fun TelegramBot.editMessageMedia(
     inlineMessageId: InlineMessageId,
     media: TelegramFreeMedia,
     replyMarkup: InlineKeyboardMarkup? = null
-): Boolean = execute(EditInlineMessageMedia(inlineMessageId, media, replyMarkup))
+): Unit = execute(EditInlineMessageMedia(inlineMessageId, media, replyMarkup))

tgbotapi.api/src/commonMain/kotlin/dev/inmo/tgbotapi/extensions/api/edit/payments/EditUserStarSubscription.kt

@@ -10,7 +10,7 @@ public suspend fun TelegramBot.editUserStarSubscription(
     userId: UserId,
     telegramPaymentChargeId: TelegramPaymentChargeId,
     isCanceled: Boolean
-): Boolean = execute(
+): Unit = execute(
     EditUserStarSubscription(
         userId = userId,
         telegramPaymentChargeId = telegramPaymentChargeId,
@@ -22,7 +22,7 @@ public suspend fun TelegramBot.editUserStarSubscription(
     user: User,
     telegramPaymentChargeId: TelegramPaymentChargeId,
     isCanceled: Boolean
-): Boolean = editUserStarSubscription(
+): Unit = editUserStarSubscription(
     userId = user.id,
     telegramPaymentChargeId = telegramPaymentChargeId,
     isCanceled = isCanceled
@@ -31,7 +31,7 @@ public suspend fun TelegramBot.editUserStarSubscription(
 public suspend fun TelegramBot.cancelUserStarSubscription(
     userId: UserId,
     telegramPaymentChargeId: TelegramPaymentChargeId,
-): Boolean = editUserStarSubscription(
+): Unit = editUserStarSubscription(
     userId = userId,
     telegramPaymentChargeId = telegramPaymentChargeId,
     isCanceled = true
@@ -40,7 +40,7 @@ public suspend fun TelegramBot.cancelUserStarSubscription(
 public suspend fun TelegramBot.cancelUserStarSubscription(
     user: User,
     telegramPaymentChargeId: TelegramPaymentChargeId,
-): Boolean = editUserStarSubscription(
+): Unit = editUserStarSubscription(
     user = user,
     telegramPaymentChargeId = telegramPaymentChargeId,
     isCanceled = true
@@ -49,7 +49,7 @@ public suspend fun TelegramBot.cancelUserStarSubscription(
 public suspend fun TelegramBot.enableUserStarSubscription(
     userId: UserId,
     telegramPaymentChargeId: TelegramPaymentChargeId,
-): Boolean = editUserStarSubscription(
+): Unit = editUserStarSubscription(
     userId = userId,
     telegramPaymentChargeId = telegramPaymentChargeId,
     isCanceled = false
@@ -58,7 +58,7 @@ public suspend fun TelegramBot.enableUserStarSubscription(
 public suspend fun TelegramBot.enableUserStarSubscription(
     user: User,
     telegramPaymentChargeId: TelegramPaymentChargeId,
-): Boolean = editUserStarSubscription(
+): Unit = editUserStarSubscription(
     user = user,
     telegramPaymentChargeId = telegramPaymentChargeId,
     isCanceled = false

tgbotapi.api/src/commonMain/kotlin/dev/inmo/tgbotapi/extensions/api/edit/reply_markup/EditInlineMessageReplyMarkup.kt

@@ -12,4 +12,4 @@ import dev.inmo.tgbotapi.types.buttons.InlineKeyboardMarkup
 public suspend fun TelegramBot.editMessageReplyMarkup(
     inlineMessageId: InlineMessageId,
     replyMarkup: InlineKeyboardMarkup? = null
-): Boolean = execute(EditInlineMessageReplyMarkup(inlineMessageId, replyMarkup))
+): Unit = execute(EditInlineMessageReplyMarkup(inlineMessageId, replyMarkup))

tgbotapi.api/src/commonMain/kotlin/dev/inmo/tgbotapi/extensions/api/edit/text/EditInlineMessageText.kt

@@ -22,7 +22,7 @@ public suspend fun TelegramBot.editMessageText(
     showCaptionAboveMedia: Boolean = false,
     linkPreviewOptions: LinkPreviewOptions? = null,
     replyMarkup: InlineKeyboardMarkup? = null
-): Boolean = execute(EditInlineMessageText(inlineMessageId, text, parseMode, showCaptionAboveMedia, linkPreviewOptions, replyMarkup))
+): Unit = execute(EditInlineMessageText(inlineMessageId, text, parseMode, showCaptionAboveMedia, linkPreviewOptions, replyMarkup))
 
 /**
  * @param replyMarkup Some [InlineKeyboardMarkup]. See [dev.inmo.tgbotapi.extensions.utils.types.buttons.inlineKeyboard]
@@ -34,7 +34,7 @@ public suspend fun TelegramBot.editMessageText(
     showCaptionAboveMedia: Boolean = false,
     linkPreviewOptions: LinkPreviewOptions? = null,
     replyMarkup: InlineKeyboardMarkup? = null
-): Boolean = execute(EditInlineMessageText(inlineMessageId, entities, showCaptionAboveMedia, linkPreviewOptions, replyMarkup))
+): Unit = execute(EditInlineMessageText(inlineMessageId, entities, showCaptionAboveMedia, linkPreviewOptions, replyMarkup))
 
 /**
  * @param replyMarkup Some [InlineKeyboardMarkup]. See [dev.inmo.tgbotapi.extensions.utils.types.buttons.inlineKeyboard]
@@ -47,7 +47,7 @@ public suspend fun TelegramBot.editMessageText(
     linkPreviewOptions: LinkPreviewOptions? = null,
     replyMarkup: InlineKeyboardMarkup? = null,
     builderBody: EntitiesBuilderBody
-): Boolean = editMessageText(inlineMessageId, buildEntities(separator, builderBody), showCaptionAboveMedia, linkPreviewOptions, replyMarkup)
+): Unit = editMessageText(inlineMessageId, buildEntities(separator, builderBody), showCaptionAboveMedia, linkPreviewOptions, replyMarkup)
 
 /**
  * @param replyMarkup Some [InlineKeyboardMarkup]. See [dev.inmo.tgbotapi.extensions.utils.types.buttons.inlineKeyboard]
@@ -60,4 +60,4 @@ public suspend fun TelegramBot.editMessageText(
     linkPreviewOptions: LinkPreviewOptions? = null,
     replyMarkup: InlineKeyboardMarkup? = null,
     builderBody: EntitiesBuilderBody
-): Boolean = editMessageText(inlineMessageId, buildEntities(separator, builderBody), showCaptionAboveMedia, linkPreviewOptions, replyMarkup)
+): Unit = editMessageText(inlineMessageId, buildEntities(separator, builderBody), showCaptionAboveMedia, linkPreviewOptions, replyMarkup)

tgbotapi.api/src/commonMain/kotlin/dev/inmo/tgbotapi/extensions/api/games/SetGameScoreByChatId.kt

@@ -15,7 +15,7 @@ public suspend fun TelegramBot.setGameScore(
     messageId: MessageId,
     force: Boolean = false,
     disableEditMessage: Boolean = false
-): Boolean = execute(
+): Unit = execute(
     SetGameScoreByChatId(userId, score, chatId, messageId, force, disableEditMessage)
 )
 
@@ -26,7 +26,7 @@ public suspend fun TelegramBot.setGameScore(
     messageId: MessageId,
     force: Boolean = false,
     disableEditMessage: Boolean = false
-): Boolean = setGameScore(
+): Unit = setGameScore(
     user.id, score, chatId, messageId, force, disableEditMessage
 )
 
@@ -37,7 +37,7 @@ public suspend fun TelegramBot.setGameScore(
     messageId: MessageId,
     force: Boolean = false,
     disableEditMessage: Boolean = false
-): Boolean = setGameScore(
+): Unit = setGameScore(
     userId, score, chat.id, messageId, force, disableEditMessage
 )
 
@@ -48,7 +48,7 @@ public suspend fun TelegramBot.setGameScore(
     messageId: MessageId,
     force: Boolean = false,
     disableEditMessage: Boolean = false
-): Boolean = setGameScore(
+): Unit = setGameScore(
     user.id, score, chat.id, messageId, force, disableEditMessage
 )
 
@@ -58,7 +58,7 @@ public suspend fun TelegramBot.setGameScore(
     message: ContentMessage<GameContent>,
     force: Boolean = false,
     disableEditMessage: Boolean = false
-): Boolean = setGameScore(
+): Unit = setGameScore(
     userId, score, message.chat.id, message.messageId, force, disableEditMessage
 )
 
@@ -68,6 +68,6 @@ public suspend fun TelegramBot.setGameScore(
     message: ContentMessage<GameContent>,
     force: Boolean = false,
     disableEditMessage: Boolean = false
-): Boolean = setGameScore(
+): Unit = setGameScore(
     user.id, score, message.chat.id, message.messageId, force, disableEditMessage
 )

tgbotapi.api/src/commonMain/kotlin/dev/inmo/tgbotapi/extensions/api/games/SetGameScoreByInlineMessageId.kt

@@ -11,7 +11,7 @@ public suspend fun TelegramBot.setGameScore(
     inlineMessageId: InlineMessageId,
     force: Boolean = false,
     disableEditMessage: Boolean = false
-): Boolean = execute(
+): Unit = execute(
     SetGameScoreByInlineMessageId(
         userId, score, inlineMessageId, force, disableEditMessage
     )
@@ -23,4 +23,4 @@ public suspend fun TelegramBot.setGameScore(
     inlineMessageId: InlineMessageId,
     force: Boolean = false,
     disableEditMessage: Boolean = false
-): Boolean = setGameScore(user.id, score, inlineMessageId, force, disableEditMessage)
+): Unit = setGameScore(user.id, score, inlineMessageId, force, disableEditMessage)

tgbotapi.api/src/commonMain/kotlin/dev/inmo/tgbotapi/extensions/api/gifts/GiftPremiumSubscription.kt

@@ -15,7 +15,7 @@ public suspend fun TelegramBot.giftPremiumSubscription(
     starCount: Int,
     text: String,
     parseMode: ParseMode? = null
-): Boolean = execute(
+): Unit = execute(
     GiftPremiumSubscription(
         userId = userId,
         monthCount = monthCount,
@@ -30,7 +30,7 @@ public suspend fun TelegramBot.giftPremiumSubscription(
     monthCount: Int,
     starCount: Int,
     textSources: TextSourcesList? = null,
-): Boolean = execute(
+): Unit = execute(
     GiftPremiumSubscription(
         userId = userId,
         monthCount = monthCount,
@@ -45,7 +45,7 @@ public suspend fun TelegramBot.giftPremiumSubscription(
     starCount: Int,
     separator: TextSource? = null,
     textBuilder: EntitiesBuilderBody
-): Boolean = execute(
+): Unit = execute(
     GiftPremiumSubscription(
         userId = userId,
         monthCount = monthCount,

tgbotapi.api/src/commonMain/kotlin/dev/inmo/tgbotapi/extensions/api/gifts/SendGift.kt

@@ -30,7 +30,7 @@ public suspend fun TelegramBot.sendGift(
     text: String,
     parseMode: ParseMode?,
     upgradableToUnique: Boolean = false
-): Boolean = execute(
+): Unit = execute(
     SendGift.toUser(
         userId = userId,
         giftId = giftId,
@@ -57,7 +57,7 @@ public suspend fun TelegramBot.sendGiftToChat(
     text: String,
     parseMode: ParseMode?,
     upgradableToUnique: Boolean = false
-): Boolean = execute(
+): Unit = execute(
     SendGift.toChat(
         chatId = chatId,
         giftId = giftId,
@@ -83,7 +83,7 @@ public suspend fun TelegramBot.sendGift(
     giftId: GiftId,
     textSources: TextSourcesList,
     upgradableToUnique: Boolean = false,
-): Boolean = execute(
+): Unit = execute(
     SendGift.toUser(
         userId = userId,
         giftId = giftId,
@@ -108,7 +108,7 @@ public suspend fun TelegramBot.sendGiftToChat(
     giftId: GiftId,
     textSources: TextSourcesList,
     upgradableToUnique: Boolean = false,
-): Boolean = execute(
+): Unit = execute(
     SendGift.toChat(
         chatId = chatId,
         giftId = giftId,

tgbotapi.api/src/commonMain/kotlin/dev/inmo/tgbotapi/extensions/api/gifts/SendGiftGeneratedVariation.kt

@@ -17,7 +17,7 @@ public suspend fun TelegramBot.sendGift(
   giftId: GiftId,
   text: String,
   parseMode: ParseMode?,
-): Boolean = sendGift(
+): Unit = sendGift(
     userId = with(user) {id}, giftId = giftId, text = text, parseMode = parseMode
 )
 
@@ -27,7 +27,7 @@ public suspend fun TelegramBot.sendGift(
   text: String,
   parseMode: ParseMode?,
   upgradableToUnique: Boolean,
-): Boolean = sendGift(
+): Unit = sendGift(
     userId = with(user) {id}, giftId = giftId, text = text, parseMode = parseMode,
     upgradableToUnique = upgradableToUnique
 )
@@ -37,7 +37,7 @@ public suspend fun TelegramBot.sendGift(
   gift: Gift.Regular,
   text: String,
   parseMode: ParseMode?,
-): Boolean = sendGift(
+): Unit = sendGift(
     userId = userId, giftId = with(gift) {id}, text = text, parseMode = parseMode
 )
 
@@ -47,7 +47,7 @@ public suspend fun TelegramBot.sendGift(
   text: String,
   parseMode: ParseMode?,
   upgradableToUnique: Boolean,
-): Boolean = sendGift(
+): Unit = sendGift(
     userId = userId, giftId = with(gift) {id}, text = text, parseMode = parseMode,
     upgradableToUnique = upgradableToUnique
 )
@@ -57,7 +57,7 @@ public suspend fun TelegramBot.sendGift(
   gift: Gift.Regular,
   text: String,
   parseMode: ParseMode?,
-): Boolean = sendGift(
+): Unit = sendGift(
     user = user, giftId = with(gift) {id}, text = text, parseMode = parseMode
 )
 
@@ -67,7 +67,7 @@ public suspend fun TelegramBot.sendGift(
   text: String,
   parseMode: ParseMode?,
   upgradableToUnique: Boolean,
-): Boolean = sendGift(
+): Unit = sendGift(
     user = user, giftId = with(gift) {id}, text = text, parseMode = parseMode, upgradableToUnique =
     upgradableToUnique
 )

tgbotapi.api/src/commonMain/kotlin/dev/inmo/tgbotapi/extensions/api/gifts/SendGiftToChatGeneratedVariation.kt

@@ -17,7 +17,7 @@ public suspend fun TelegramBot.sendGiftToChat(
   giftId: GiftId,
   text: String,
   parseMode: ParseMode?,
-): Boolean = sendGiftToChat(
+): Unit = sendGiftToChat(
     chatId = with(chat) {id}, giftId = giftId, text = text, parseMode = parseMode
 )
 
@@ -27,7 +27,7 @@ public suspend fun TelegramBot.sendGiftToChat(
   text: String,
   parseMode: ParseMode?,
   upgradableToUnique: Boolean,
-): Boolean = sendGiftToChat(
+): Unit = sendGiftToChat(
     chatId = with(chat) {id}, giftId = giftId, text = text, parseMode = parseMode,
     upgradableToUnique = upgradableToUnique
 )
@@ -37,7 +37,7 @@ public suspend fun TelegramBot.sendGiftToChat(
   gift: Gift.Regular,
   text: String,
   parseMode: ParseMode?,
-): Boolean = sendGiftToChat(
+): Unit = sendGiftToChat(
     chatId = chatId, giftId = with(gift) {id}, text = text, parseMode = parseMode
 )
 
@@ -47,7 +47,7 @@ public suspend fun TelegramBot.sendGiftToChat(
   text: String,
   parseMode: ParseMode?,
   upgradableToUnique: Boolean,
-): Boolean = sendGiftToChat(
+): Unit = sendGiftToChat(
     chatId = chatId, giftId = with(gift) {id}, text = text, parseMode = parseMode,
     upgradableToUnique = upgradableToUnique
 )
@@ -57,7 +57,7 @@ public suspend fun TelegramBot.sendGiftToChat(
   gift: Gift.Regular,
   text: String,
   parseMode: ParseMode?,
-): Boolean = sendGiftToChat(
+): Unit = sendGiftToChat(
     chat = chat, giftId = with(gift) {id}, text = text, parseMode = parseMode
 )
 
@@ -67,7 +67,7 @@ public suspend fun TelegramBot.sendGiftToChat(
   text: String,
   parseMode: ParseMode?,
   upgradableToUnique: Boolean,
-): Boolean = sendGiftToChat(
+): Unit = sendGiftToChat(
     chat = chat, giftId = with(gift) {id}, text = text, parseMode = parseMode, upgradableToUnique =
     upgradableToUnique
 )

tgbotapi.api/src/commonMain/kotlin/dev/inmo/tgbotapi/extensions/api/managed_bots/GetManagedBotToken.kt

@@ -0,0 +1,12 @@
+package dev.inmo.tgbotapi.extensions.api.managed_bots
+
+import dev.inmo.tgbotapi.bot.TelegramBot
+import dev.inmo.tgbotapi.requests.managed_bots.GetManagedBotToken
+import dev.inmo.tgbotapi.types.BotToken
+import dev.inmo.tgbotapi.types.ChatId
+
+public suspend fun TelegramBot.getManagedBotToken(
+    userId: ChatId
+): BotToken = execute(
+    GetManagedBotToken(userId = userId)
+)

tgbotapi.api/src/commonMain/kotlin/dev/inmo/tgbotapi/extensions/api/managed_bots/ReplaceManagedBotToken.kt

@@ -0,0 +1,12 @@
+package dev.inmo.tgbotapi.extensions.api.managed_bots
+
+import dev.inmo.tgbotapi.bot.TelegramBot
+import dev.inmo.tgbotapi.requests.managed_bots.ReplaceManagedBotToken
+import dev.inmo.tgbotapi.types.BotToken
+import dev.inmo.tgbotapi.types.ChatId
+
+public suspend fun TelegramBot.replaceManagedBotToken(
+    userId: ChatId
+): BotToken = execute(
+    ReplaceManagedBotToken(userId = userId)
+)

tgbotapi.api/src/commonMain/kotlin/dev/inmo/tgbotapi/extensions/api/passport/SetPassportDataErrors.kt

@@ -13,22 +13,22 @@ import dev.inmo.tgbotapi.utils.passport.Decryptor
 public suspend fun TelegramBot.setPassportDataErrors(
     userId: UserId,
     errors: List<PassportElementError>
-): Boolean = execute(SetPassportDataErrors(userId, errors))
+): Unit = execute(SetPassportDataErrors(userId, errors))
 public suspend fun TelegramBot.setPassportDataErrors(
     user: User,
     errors: List<PassportElementError>
-): Boolean = setPassportDataErrors(user.id, errors)
+): Unit = setPassportDataErrors(user.id, errors)
 
 public suspend fun TelegramBot.setPassportDataErrors(
     userId: UserId,
     passportData: PassportData,
     decryptor: Decryptor,
     mapper: suspend Decryptor.(EncryptedPassportElement) -> PassportElementError
-): Boolean = setPassportDataErrors(
+): Unit = setPassportDataErrors(
     userId,
     passportData.data.map { decryptor.mapper(it) }.also {
         if (it.isEmpty()) {
-            return@setPassportDataErrors false
+            return@setPassportDataErrors
         }
     }
 )
@@ -37,10 +37,10 @@ public suspend fun TelegramBot.setPassportDataErrors(
     passportData: PassportData,
     decryptor: Decryptor,
     mapper: suspend Decryptor.(EncryptedPassportElement) -> PassportElementError
-): Boolean = setPassportDataErrors(user.id, passportData, decryptor, mapper)
+): Unit = setPassportDataErrors(user.id, passportData, decryptor, mapper)
 
 public suspend fun TelegramBot.setPassportDataErrors(
     passportMessage: PassportMessage,
     decryptor: Decryptor,
     mapper: suspend Decryptor.(EncryptedPassportElement) -> PassportElementError
-): Boolean = setPassportDataErrors(passportMessage.user, passportMessage.passportData, decryptor, mapper)
+): Unit = setPassportDataErrors(passportMessage.user, passportMessage.passportData, decryptor, mapper)

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

@@ -0,0 +1,55 @@
+package dev.inmo.tgbotapi.extensions.api.send
+
+import dev.inmo.micro_utils.common.Warning
+import dev.inmo.tgbotapi.bot.TelegramBot
+import dev.inmo.tgbotapi.requests.send.DeleteAllActorChatMessageReactions
+import dev.inmo.tgbotapi.requests.send.DeleteAllMessageReactions
+import dev.inmo.tgbotapi.requests.send.DeleteAllUserMessageReactions
+import dev.inmo.tgbotapi.types.ChatId
+import dev.inmo.tgbotapi.types.ChatIdentifier
+import dev.inmo.tgbotapi.types.UserId
+import dev.inmo.tgbotapi.types.chat.Chat
+
+@Warning(
+    "Pass either userId or actorChatId, but not both. Prefer deleteAllUserMessageReactions or deleteAllActorChatMessageReactions"
+)
+public suspend fun TelegramBot.deleteAllMessageReactions(
+    chatId: ChatIdentifier,
+    userId: UserId? = null,
+    actorChatId: ChatId? = null
+): Unit = execute(
+    DeleteAllMessageReactions(chatId, userId, actorChatId)
+)
+
+@Warning(
+    "Pass either userId or actorChatId, but not both. Prefer deleteAllUserMessageReactions or deleteAllActorChatMessageReactions"
+)
+public suspend fun TelegramBot.deleteAllMessageReactions(
+    chat: Chat,
+    userId: UserId? = null,
+    actorChatId: ChatId? = null
+): Unit = deleteAllMessageReactions(chat.id, userId, actorChatId)
+
+public suspend fun TelegramBot.deleteAllUserMessageReactions(
+    chatId: ChatIdentifier,
+    userId: UserId
+): Unit = execute(
+    DeleteAllUserMessageReactions(chatId, userId)
+)
+
+public suspend fun TelegramBot.deleteAllUserMessageReactions(
+    chat: Chat,
+    userId: UserId
+): Unit = deleteAllUserMessageReactions(chat.id, userId)
+
+public suspend fun TelegramBot.deleteAllActorChatMessageReactions(
+    chatId: ChatIdentifier,
+    actorChatId: ChatId
+): Unit = execute(
+    DeleteAllActorChatMessageReactions(chatId, actorChatId)
+)
+
+public suspend fun TelegramBot.deleteAllActorChatMessageReactions(
+    chat: Chat,
+    actorChatId: ChatId
+): Unit = deleteAllActorChatMessageReactions(chat.id, actorChatId)

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

@@ -0,0 +1,102 @@
+package dev.inmo.tgbotapi.extensions.api.send
+
+import dev.inmo.micro_utils.common.Warning
+import dev.inmo.tgbotapi.bot.TelegramBot
+import dev.inmo.tgbotapi.requests.send.DeleteActorChatMessageReaction
+import dev.inmo.tgbotapi.requests.send.DeleteMessageReaction
+import dev.inmo.tgbotapi.requests.send.DeleteUserMessageReaction
+import dev.inmo.tgbotapi.types.ChatId
+import dev.inmo.tgbotapi.types.ChatIdentifier
+import dev.inmo.tgbotapi.types.MessageId
+import dev.inmo.tgbotapi.types.UserId
+import dev.inmo.tgbotapi.types.chat.Chat
+import dev.inmo.tgbotapi.types.message.abstracts.AccessibleMessage
+import dev.inmo.tgbotapi.types.message.abstracts.Message
+
+@Warning(
+    "Pass either userId or actorChatId, but not both. Prefer deleteUserMessageReaction or deleteActorChatMessageReaction"
+)
+public suspend fun TelegramBot.deleteMessageReaction(
+    chatId: ChatIdentifier,
+    messageId: MessageId,
+    userId: UserId? = null,
+    actorChatId: ChatId? = null
+): Unit = execute(
+    DeleteMessageReaction(chatId, messageId, userId, actorChatId)
+)
+
+@Warning(
+    "Pass either userId or actorChatId, but not both. Prefer deleteUserMessageReaction or deleteActorChatMessageReaction"
+)
+public suspend fun TelegramBot.deleteMessageReaction(
+    chat: Chat,
+    messageId: MessageId,
+    userId: UserId? = null,
+    actorChatId: ChatId? = null
+): Unit = deleteMessageReaction(chat.id, messageId, userId, actorChatId)
+
+@Warning(
+    "Pass either userId or actorChatId, but not both. Prefer deleteUserMessageReaction or deleteActorChatMessageReaction"
+)
+public suspend fun TelegramBot.deleteMessageReaction(
+    meta: Message.MetaInfo,
+    userId: UserId? = null,
+    actorChatId: ChatId? = null
+): Unit = deleteMessageReaction(meta.chatId, meta.messageId, userId, actorChatId)
+
+@Warning(
+    "Pass either userId or actorChatId, but not both. Prefer deleteUserMessageReaction or deleteActorChatMessageReaction"
+)
+public suspend fun TelegramBot.deleteMessageReaction(
+    message: AccessibleMessage,
+    userId: UserId? = null,
+    actorChatId: ChatId? = null
+): Unit = deleteMessageReaction(message.metaInfo, userId, actorChatId)
+
+public suspend fun TelegramBot.deleteUserMessageReaction(
+    chatId: ChatIdentifier,
+    messageId: MessageId,
+    userId: UserId
+): Unit = execute(
+    DeleteUserMessageReaction(chatId, messageId, userId)
+)
+
+public suspend fun TelegramBot.deleteUserMessageReaction(
+    chat: Chat,
+    messageId: MessageId,
+    userId: UserId
+): Unit = deleteUserMessageReaction(chat.id, messageId, userId)
+
+public suspend fun TelegramBot.deleteUserMessageReaction(
+    meta: Message.MetaInfo,
+    userId: UserId
+): Unit = deleteUserMessageReaction(meta.chatId, meta.messageId, userId)
+
+public suspend fun TelegramBot.deleteUserMessageReaction(
+    message: AccessibleMessage,
+    userId: UserId
+): Unit = deleteUserMessageReaction(message.metaInfo, userId)
+
+public suspend fun TelegramBot.deleteActorChatMessageReaction(
+    chatId: ChatIdentifier,
+    messageId: MessageId,
+    actorChatId: ChatId
+): Unit = execute(
+    DeleteActorChatMessageReaction(chatId, messageId, actorChatId)
+)
+
+public suspend fun TelegramBot.deleteActorChatMessageReaction(
+    chat: Chat,
+    messageId: MessageId,
+    actorChatId: ChatId
+): Unit = deleteActorChatMessageReaction(chat.id, messageId, actorChatId)
+
+public suspend fun TelegramBot.deleteActorChatMessageReaction(
+    meta: Message.MetaInfo,
+    actorChatId: ChatId
+): Unit = deleteActorChatMessageReaction(meta.chatId, meta.messageId, actorChatId)
+
+public suspend fun TelegramBot.deleteActorChatMessageReaction(
+    message: AccessibleMessage,
+    actorChatId: ChatId
+): Unit = deleteActorChatMessageReaction(message.metaInfo, actorChatId)

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

@@ -15,7 +15,7 @@ public suspend fun TelegramBot.sendBotAction(
     action: BotAction,
     threadId: MessageThreadId? = chatId.threadId,
     businessConnectionId: BusinessConnectionId? = chatId.businessConnectionId
-): Boolean = execute(
+): Unit = execute(
     SendAction(chatId, action, threadId, businessConnectionId)
 )
 
@@ -24,133 +24,133 @@ public suspend fun TelegramBot.sendBotAction(
     action: BotAction,
     threadId: MessageThreadId? = chat.id.threadId,
     businessConnectionId: BusinessConnectionId? = chat.id.businessConnectionId
-): Boolean = sendBotAction(chat.id, action, threadId, businessConnectionId)
+): Unit = sendBotAction(chat.id, action, threadId, businessConnectionId)
 
 
 public suspend fun TelegramBot.sendActionTyping(
     chatId: ChatIdentifier,
     threadId: MessageThreadId? = chatId.threadId,
     businessConnectionId: BusinessConnectionId? = chatId.businessConnectionId
-): Boolean = sendBotAction(chatId, TypingAction, threadId, businessConnectionId)
+): Unit = sendBotAction(chatId, TypingAction, threadId, businessConnectionId)
 
 public suspend fun TelegramBot.sendActionUploadPhoto(
     chatId: ChatIdentifier,
     threadId: MessageThreadId? = chatId.threadId,
     businessConnectionId: BusinessConnectionId? = chatId.businessConnectionId
-): Boolean = sendBotAction(chatId, UploadPhotoAction, threadId, businessConnectionId)
+): Unit = sendBotAction(chatId, UploadPhotoAction, threadId, businessConnectionId)
 
 public suspend fun TelegramBot.sendActionRecordVideo(
     chatId: ChatIdentifier,
     threadId: MessageThreadId? = chatId.threadId,
     businessConnectionId: BusinessConnectionId? = chatId.businessConnectionId
-): Boolean = sendBotAction(chatId, RecordVideoAction, threadId, businessConnectionId)
+): Unit = sendBotAction(chatId, RecordVideoAction, threadId, businessConnectionId)
 
 public suspend fun TelegramBot.sendActionUploadVideo(
     chatId: ChatIdentifier,
     threadId: MessageThreadId? = chatId.threadId,
     businessConnectionId: BusinessConnectionId? = chatId.businessConnectionId
-): Boolean = sendBotAction(chatId, UploadVideoAction, threadId, businessConnectionId)
+): Unit = sendBotAction(chatId, UploadVideoAction, threadId, businessConnectionId)
 
 public suspend fun TelegramBot.sendActionRecordVoice(
     chatId: ChatIdentifier,
     threadId: MessageThreadId? = chatId.threadId,
     businessConnectionId: BusinessConnectionId? = chatId.businessConnectionId
-): Boolean = sendBotAction(chatId, RecordVoiceAction, threadId, businessConnectionId)
+): Unit = sendBotAction(chatId, RecordVoiceAction, threadId, businessConnectionId)
 
 public suspend fun TelegramBot.sendActionUploadVoice(
     chatId: ChatIdentifier,
     threadId: MessageThreadId? = chatId.threadId,
     businessConnectionId: BusinessConnectionId? = chatId.businessConnectionId
-): Boolean = sendBotAction(chatId, UploadVoiceAction, threadId, businessConnectionId)
+): Unit = sendBotAction(chatId, UploadVoiceAction, threadId, businessConnectionId)
 
 public suspend fun TelegramBot.sendActionUploadDocument(
     chatId: ChatIdentifier,
     threadId: MessageThreadId? = chatId.threadId,
     businessConnectionId: BusinessConnectionId? = chatId.businessConnectionId
-): Boolean = sendBotAction(chatId, UploadDocumentAction, threadId, businessConnectionId)
+): Unit = sendBotAction(chatId, UploadDocumentAction, threadId, businessConnectionId)
 
 public suspend fun TelegramBot.sendActionFindLocation(
     chatId: ChatIdentifier,
     threadId: MessageThreadId? = chatId.threadId,
     businessConnectionId: BusinessConnectionId? = chatId.businessConnectionId
-): Boolean = sendBotAction(chatId, FindLocationAction, threadId, businessConnectionId)
+): Unit = sendBotAction(chatId, FindLocationAction, threadId, businessConnectionId)
 
 public suspend fun TelegramBot.sendActionRecordVideoNote(
     chatId: ChatIdentifier,
     threadId: MessageThreadId? = chatId.threadId,
     businessConnectionId: BusinessConnectionId? = chatId.businessConnectionId
-): Boolean = sendBotAction(chatId, RecordVideoNoteAction, threadId, businessConnectionId)
+): Unit = sendBotAction(chatId, RecordVideoNoteAction, threadId, businessConnectionId)
 
 public suspend fun TelegramBot.sendActionUploadVideoNote(
     chatId: ChatIdentifier,
     threadId: MessageThreadId? = chatId.threadId,
     businessConnectionId: BusinessConnectionId? = chatId.businessConnectionId
-): Boolean = sendBotAction(chatId, UploadVideoNoteAction, threadId, businessConnectionId)
+): Unit = sendBotAction(chatId, UploadVideoNoteAction, threadId, businessConnectionId)
 
 
 public suspend fun TelegramBot.sendActionTyping(
     chat: Chat,
     threadId: MessageThreadId? = chat.id.threadId,
     businessConnectionId: BusinessConnectionId? = chat.id.businessConnectionId
-): Boolean = sendBotAction(chat, TypingAction, threadId, businessConnectionId)
+): Unit = sendBotAction(chat, TypingAction, threadId, businessConnectionId)
 
 public suspend fun TelegramBot.sendActionUploadPhoto(
     chat: Chat,
     threadId: MessageThreadId? = chat.id.threadId,
     businessConnectionId: BusinessConnectionId? = chat.id.businessConnectionId
-): Boolean = sendBotAction(chat, UploadPhotoAction, threadId, businessConnectionId)
+): Unit = sendBotAction(chat, UploadPhotoAction, threadId, businessConnectionId)
 
 public suspend fun TelegramBot.sendActionRecordVideo(
     chat: Chat,
     threadId: MessageThreadId? = chat.id.threadId,
     businessConnectionId: BusinessConnectionId? = chat.id.businessConnectionId
-): Boolean = sendBotAction(chat, RecordVideoAction, threadId, businessConnectionId)
+): Unit = sendBotAction(chat, RecordVideoAction, threadId, businessConnectionId)
 
 public suspend fun TelegramBot.sendActionUploadVideo(
     chat: Chat,
     threadId: MessageThreadId? = chat.id.threadId,
     businessConnectionId: BusinessConnectionId? = chat.id.businessConnectionId
-): Boolean = sendBotAction(chat, UploadVideoAction, threadId, businessConnectionId)
+): Unit = sendBotAction(chat, UploadVideoAction, threadId, businessConnectionId)
 
 public suspend fun TelegramBot.sendActionRecordVoice(
     chat: Chat,
     threadId: MessageThreadId? = chat.id.threadId,
     businessConnectionId: BusinessConnectionId? = chat.id.businessConnectionId
-): Boolean = sendBotAction(chat, RecordVoiceAction, threadId, businessConnectionId)
+): Unit = sendBotAction(chat, RecordVoiceAction, threadId, businessConnectionId)
 
 public suspend fun TelegramBot.sendActionUploadVoice(
     chat: Chat,
     threadId: MessageThreadId? = chat.id.threadId,
     businessConnectionId: BusinessConnectionId? = chat.id.businessConnectionId
-): Boolean = sendBotAction(chat, UploadVoiceAction, threadId, businessConnectionId)
+): Unit = sendBotAction(chat, UploadVoiceAction, threadId, businessConnectionId)
 
 public suspend fun TelegramBot.sendActionUploadDocument(
     chat: Chat,
     threadId: MessageThreadId? = chat.id.threadId,
     businessConnectionId: BusinessConnectionId? = chat.id.businessConnectionId
-): Boolean = sendBotAction(chat, UploadDocumentAction, threadId, businessConnectionId)
+): Unit = sendBotAction(chat, UploadDocumentAction, threadId, businessConnectionId)
 
 public suspend fun TelegramBot.sendActionFindLocation(
     chat: Chat,
     threadId: MessageThreadId? = chat.id.threadId,
     businessConnectionId: BusinessConnectionId? = chat.id.businessConnectionId
-): Boolean = sendBotAction(chat, FindLocationAction, threadId, businessConnectionId)
+): Unit = sendBotAction(chat, FindLocationAction, threadId, businessConnectionId)
 
 public suspend fun TelegramBot.sendActionRecordVideoNote(
     chat: Chat,
     threadId: MessageThreadId? = chat.id.threadId,
     businessConnectionId: BusinessConnectionId? = chat.id.businessConnectionId
-): Boolean = sendBotAction(chat, RecordVideoNoteAction, threadId, businessConnectionId)
+): Unit = sendBotAction(chat, RecordVideoNoteAction, threadId, businessConnectionId)
 
 public suspend fun TelegramBot.sendActionUploadVideoNote(
     chat: Chat,
     threadId: MessageThreadId? = chat.id.threadId,
     businessConnectionId: BusinessConnectionId? = chat.id.businessConnectionId
-): Boolean = sendBotAction(chat, UploadVideoNoteAction, threadId, businessConnectionId)
+): Unit = sendBotAction(chat, UploadVideoNoteAction, threadId, businessConnectionId)
 
 public suspend fun TelegramBot.sendActionChooseStickerAction(
     chat: Chat,
     threadId: MessageThreadId? = chat.id.threadId,
     businessConnectionId: BusinessConnectionId? = chat.id.businessConnectionId
-): Boolean = sendBotAction(chat, ChooseStickerAction, threadId, businessConnectionId)
+): Unit = sendBotAction(chat, ChooseStickerAction, threadId, businessConnectionId)