Update CHANGELOG.md

9.4.2

.github/FUNDING.yml

@@ -1,3 +1,3 @@
 # These are supported funding model platforms
 
-custom: ['https://www.tinkoff.ru/rm/ovsyannikov.aleksey113/ObMJ712472']
+custom: ['https://www.tinkoff.ru/rm/ovsyannikov.aleksey113/ObMJ712472', 'https://boosty.to/insanusmokrassar']

.github/workflows/greetings.yml

@@ -5,6 +5,9 @@ on: [pull_request, issues]
 jobs:
   greeting:
     runs-on: ubuntu-latest
+    permissions:
+      issues: write
+      pull-requests: write
     steps:
     - uses: actions/first-interaction@v1
       with:

.github/workflows/kdocs.yml

@@ -10,12 +10,12 @@ jobs:
       - uses: actions/checkout@v2
       - uses: actions/setup-java@v1
         with:
-          java-version: 11
+          java-version: 17
       - name: Build
-        run: ./gradlew dokkaHtml
+        run: ./gradlew dokkaHtmlMultiModule
       - name: Publish KDocs
         uses: peaceiris/actions-gh-pages@v3
         with:
           github_token: ${{ secrets.GITHUB_TOKEN }}
-          publish_dir: ./docs/build/dokka/html
+          publish_dir: ./build/dokka/htmlMultiModule
           publish_branch: kdocs

.github/workflows/packages_publishing.yml

@@ -7,16 +7,26 @@ jobs:
       - uses: actions/checkout@v2
       - uses: actions/setup-java@v1
         with:
-          java-version: 11
+          java-version: 17
+      - name: Setup LibCurl
+        run: sudo apt update && sudo apt install -y libcurl4-openssl-dev
       - name: Rewrite version
         run: |
           branch="`echo "${{ github.ref }}" | grep -o "[^/]*$"`"
           cat gradle.properties | sed -e "s/^library_version=\([0-9\.]*\)/library_version=\1-branch_$branch-build${{ github.run_number }}/" > gradle.properties.tmp
           rm gradle.properties
           mv gradle.properties.tmp gradle.properties
+      - name: KotlinSymbolProcessing execution
+        run: ./gradlew ksp
       - name: Build
         run: ./gradlew build
-      - name: Publish
+      - name: Publish to Gitea
+        continue-on-error: true
+        run: ./gradlew publishAllPublicationsToInmoNexusRepository
+        env:
+          INMONEXUS_USER: ${{ secrets.INMONEXUS_USER }}
+          INMONEXUS_PASSWORD: ${{ secrets.INMONEXUS_PASSWORD }}
+      - name: Publish to GithubPackages
         continue-on-error: true
         run: ./gradlew publishAllPublicationsToGithubPackagesRepository --no-parallel
         env:

CHANGELOG.md

@@ -1,5 +1,611 @@
 # TelegramBotAPI changelog
 
+## 9.4.3
+
+**IetfLanguageCode has been renamed to IetfLang in MicroUtils**
+
+* `Version`:
+  * `Kotlin`: `1.9.21` -> `1.9.22`
+  * `MicroUtils`: `0.20.19` -> `0.20.23`
+
+## 9.4.2
+
+* `Version`:
+  * `Serialization`: `1.6.1` -> `1.6.2`
+  * `Ktor`: `2.3.6` -> `2.3.7`
+  * `MicroUtils`: `0.20.15` -> `0.20.19`
+  * `UUID`: `0.8.1` -> `0.8.2`
+
+## 9.4.1
+
+* Replace warning about two bots from `LongPolling` to `DefaultKtorRequestsExecutor`
+
+## 9.4.0
+
+* `Version`:
+  * `Kotlin`: `1.9.20` -> `1.9.21`
+  * `Serialization`: `1.6.0` -> `1.6.1`
+  * `Ktor`: `2.3.5` -> `2.3.6`
+  * `MicroUtils`: `0.20.12` -> `0.20.15`
+
+## 9.3.0
+
+This release become possible thanks to [Anton Lakotka](https://youtrack.jetbrains.com/users/anton.lakotka)
+
+**THIS RELEASE CONTAINS UPDATES UP TO RELEASE CANDIDATES VERSIONS**
+
+**UPDATE MAY HAVE BREAKING CHANGES**
+
+**SINCE THIS UPDATE IT WILL BE REQUIRED TO USE JDK 17+ FOR DEVELOPMENT**
+
+* `Version`:
+  * `Kotlin`: `1.8.22` -> `1.9.20`
+  * `Serialization`: `1.5.1` -> `1.6.0`
+  * `KorLibs`: `4.0.3` -> `4.0.10`
+  * `UUID`: `0.7.1` -> `0.8.1`
+  * `Ktor`: `2.3.4` -> `2.3.5`
+  * `MicroUtils`: `0.19.9` -> `0.20.12`
+
+## 9.2.4
+
+* `Utils`:
+  * New extensions `*.parseCommandsWithNamedArgs`
+* `BehaviourBuilder`:
+  * In expectaters and triggers of `commands` add `*WithNamedArgs` variants
+  * In expectaters and triggers of `commands` add opportunity to use custom separator
+
+## 9.2.3
+
+* `Core`:
+  * Fix in `VoiceContent#createResend`
+
+## 9.2.2
+
+* `Core`:
+  * Fix of [#793](https://github.com/InsanusMokrassar/ktgbotapi/issues/793): Add `PreviewChat`
+
+## 9.2.1
+
+* `Version`:
+  * `Ktor`: `2.3.3` -> `2.3.4`
+* `Core`:
+  * All `ChatMember` inheritors have fixes `status` field
+
+## 9.2.0
+
+**Add support of [Telegram Bots API 6.9](https://core.telegram.org/bots/api-changelog#september-22-2023)**
+
+* Rename `ChatAdministratorRightsImpl` -> `ChatCommonAdministratorRights`
+* All the request chat keyboards has changed their parameters `ChatAdministratorRights` to `ChatCommonAdministratorRights`
+
+## 9.1.2
+
+* `Core`:
+  * Fix of `MessageContent` serialization
+
+## 9.1.1
+
+* `Core`:
+  * Potential fix of incorrect parsing in `RawMessageEntity`
+
+## 9.1.0
+
+**This update contains adding of [Telegram Bot API 6.8](https://core.telegram.org/bots/api-changelog#august-18-2023) support**
+
+* `Version`:
+  * `Coroutines`: `1.7.2` -> `1.7.3`
+  * `Ktor`: `2.3.2` -> `2.3.3`
+  * `MicroUtils`: `0.19.7` -> `0.19.9`
+
+## 9.0.0
+
+**THIS UPDATE CONTAINS BREAKING CHANGES: USERNAMES OF BOTS NOW BECAME NULLABLE**
+
+* `Version`:
+  * `Coroutines`: `1.6.4` -> `1.7.1`
+  * `Ktor`: `2.3.1` -> `2.3.2`
+  * `MicroUtils`: `0.19.4` -> `0.19.7`
+* `Core`:
+    * **All bots now have nullable usernames just like common users ([#772](https://github.com/InsanusMokrassar/ktgbotapi/issues/772))**
+    * Decrease possible errors in updates handling by additional handling of update deserialization wrapping ([#773](https://github.com/InsanusMokrassar/ktgbotapi/issues/773))
+    * New interface `GetUpdatesRequest`. You may implement it to show default telegram bot ktor executor that this
+      request is an updates request and should be handled in a different way
+        * Now it is possible to get raw updates with `GetUpdatesRaw` request
+* `Utils`:
+    * Improve extension `Update.sourceChat` to add opportunity to select some chats by logic different with the default
+
+## 8.1.0
+
+**PARTIALLY BREAKING CHANGES: Exclude `.*Impl` classcasts from `ClassCastsNew`**
+
+* `Version`:
+  * `MicroUtils`: `0.19.2` -> `0.19.4`
+* `Utils`:
+    * Add deep links formatting for internal `tg://` prefix (thanks to [@klimatov](https://github.com/klimatov))
+    * Exclude `.*Impl` classcasts from `ClassCastsNew`
+
+## 8.0.1
+
+* `Version`:
+    * `UUID`: `0.7.0` -> `0.7.1`
+    * `Ktor`: `2.3.0` -> `2.3.1`
+    * `MicroUtils`: `0.19.1` -> `0.19.2`
+
+## 8.0.0
+
+**THIS UPDATE CONTAINS BREAKING CHANGES**
+
+**ALL PROJECT DEPRECATIONS HAVE BEEN REMOVED**
+
+**IN THIS UPDATE KORLIBS HAVE BEEN UPDATED TO VERSION `4.0.2`. SINCE THAT VERSION A LOT OF PACKAGES HAVE BEEN RENAMED.
+MIGRATIONS USED IN THIS LIB:**
+
+* `com.soywiz.klock` -> `korlibs.time`
+* `com.soywiz.krypto` -> `korlibs.crypto`
+
+* `Versions`:
+    * `Korlibs`: `3.4.0` -> `4.0.3`
+    * `MicroUtils`: `0.18.4` -> `0.19.1`
+
+## 7.1.3
+
+* `Versions`:
+    * `Serialization`: `1.5.0` -> `1.5.1`
+    * `MicroUtils`: `0.18.1` -> `0.18.4`
+* `Core`:
+    * Actualize kdocs in `InputFile`
+* `BehaviourBuilder`:
+    * Now it is possible to use `waitMediaContent`/`waitMediaContentMessage`/`onMediaContent`
+    * Add `onMention`/`waitMention` functionality
+    * Add opportunity to map content with extensions to `Flow`
+
+## 7.1.2
+
+* `Versions`:
+  * `MicroUtils`: `0.18.0` -> `0.18.1`
+* `Core`:
+    * Now it is possible to serialize `Sticker`s
+
+## 7.1.1
+
+* `Versions`:
+  * `Kotlin`: `1.8.20` -> `1.8.21`
+  * `MicroUtils`: `0.17.8` -> `0.18.0`
+* `Utils`:
+    * Fixes in `makeLinkToMessage`
+
+## 7.1.0
+
+**This update contains changes according to the [Telegram Bot API 6.7](https://core.telegram.org/bots/api-changelog#april-21-2023)**
+
+* `API`:
+    * Rename `editMessageCaption` to `editMessageMedia` due to wrong old naming
+    * Add `edit` extensions for `InlineMessageIdentifier`s
+* `BehaviourBuilder`:
+    * `BehaviourContext` extensions `onDeepLink` and `waitDeepLinks` now can be used with `Regex` or `String` as first parameters
+
+## 7.0.2
+
+_This update brings experimental support of `linuxX64` and `mingwX64` platforms_
+
+* `Versions`:
+    * `Kotlin`: `1.8.10` -> `1.8.20`
+    * `MicroUtils`: `0.17.5` -> `0.17.8`
+    * `Ktor`: `2.2.4` -> `2.3.0`
+* `Core`:
+    * New `RequestsExecutor` - `MultipleClientKtorRequestsExecutor`
+    * Old `KtorRequestsExecutor` has been renamed to `DefaultKtorRequestsExecutor`
+    * `KtorRequestsExecutor` now is `expect class`
+        * On `JS`, `JVM` and `MinGWX64` platforms it is `DefaultKtorRequestsExecutor`
+        * On `LinuxX64` platform it is `MultipleClientKtorRequestsExecutor`
+
+## 7.0.1
+
+* `Core`:
+    * New interface `WithChat` which contains `chat` field
+        * `Message` now inherits `WithChat`
+        * `ChatMemberUpdated` now inherits `WithChat`
+* `Utils`:
+    * Improvements in `same`-notations
+
+## 7.0.0
+
+This update contains support of [Telegram Bot API 6.6](https://core.telegram.org/bots/api-changelog#march-9-2023)
+
+**THIS VERSION CONTAINS BREAKING CHANGES**:
+
+* All previous deprecations have been removed
+* Fully reworked mechanism of stickers creating and adding
+    * All separations of stickers types like `Animeted` have been replaces with type `StickerFormat`
+    * New `InputSticker` type (and all subtypes) as replacements for old raw fields in methods
+* Reworked mechanism of files uploading
+
+Other changes
+
+* `Versions`:
+  * `MicroUtils`: `0.17.3` -> `0.17.5`
+
+## 6.1.0
+
+* `Versions`:
+  * `MicroUtils`: `0.17.2` -> `0.17.3`
+* `API`:
+    * Fix of [#732](https://github.com/InsanusMokrassar/TelegramBotAPI/issues/732)
+
+## 6.0.3
+
+* `Versions`:
+    * `MicroUtils`: `0.17.1` -> `0.17.2`
+* `Core`:
+    * `User` in `CallbackQuery` now is `CommonUser` as well as in `from`
+    * `User` in `InlineQuery` now is `CommonUser` as well as in `from`
+* `BehaviourBuilder`:
+    * Fixes in `DeepLink` triggers and waiters
+
+## 6.0.2
+
+* `Core`:
+    * Long polling now uses media groups debounce as in webhooks
+
+## 6.0.1
+
+* `Versions`:
+    * `Ktor`: `2.2.3` -> `2.2.4`
+    * `MicroUtils`: `0.17.0` -> `0.17.1`
+
+## 6.0.0
+
+* `Versions`:
+    * `Kotlin`: `1.7.22` -> `1.8.10`
+    * `MicroUtils`: `0.16.10` -> `0.17.0`
+    * `Serialization`: `1.4.1` -> `1.5.0`
+    * `uuid`: `0.6.0` -> `0.7.0`
+* `Core`:
+    * `*.link` extensions have been deprecated with renaming to avoid collisions with `link` methods
+* `API`:
+    * Add `TelegramBot.resend` methods
+* `BehaviourBuilder`:
+    * Add triggers and waiters for `VisualMediaGroupPartContent`
+* `Utils`:
+    * `*.link` extensions have been deprecated with renaming to avoid collisions with `link` methods
+
+## 5.2.1
+
+* `Core`:
+    * All the `CallbackQuery`es now will receive `CommonUser` instead of `User` due inability of bots to trigger any
+      inline interaction with others bots
+* `API`:
+    * Now `sentMessageFlow` will take each sent message in `handleLiveLocation`
+
+## 5.2.0
+
+* `Versions`:
+    * `MicroUtils`: `0.16.8` -> `0.16.10`
+
+## 5.1.1
+
+* `Core`:
+    * Add opportunity to get user link with `makeUserLink`
+* `BehaviourBuilder`:
+    * Fixes in content waiting expectators
+
+## 5.1.0
+
+[Bot API 6.5](https://core.telegram.org/bots/api-changelog#february-3-2023) support
+
+* `Core`:
+    * `ChatPermissions` now is interface and have two main realizations: `ChatPermissions.Granular` and
+      `ChatPermissions.Common`
+    * `RestrictedChatMember` now implements `ChatPermissions` too
+* `API`:
+    * Now it is possible to pass all long polling parameters in all places used it
+* `Issues`:
+    * Fix of [#697](https://github.com/InsanusMokrassar/TelegramBotAPI/issues/697)
+
+## 5.0.2
+
+* `Versions`:
+    * `MicroUtils`: `0.16.6` -> `0.16.8`
+    * `Ktor`: `2.2.2` -> `2.2.3`
+* `BehaviourBuilder`:
+    * Fixes in `BehaviourContext.onEditedContentMessage` - now it will trigger callback on channel post edits too
+
+## 5.0.1
+
+* `Versions`:
+    * `MicroUtils`: `0.16.4` -> `0.16.6`
+    * `Ktor`: `2.2.1` -> `2.2.2`
+* `Core`:
+    * Fixes in `SendMediaGroup` request
+    * Fixes in `SetChatAdministratorCustomTitle` request (thanks to [@madhead](https://github.com/madhead))
+
+## 5.0.0
+
+[Bot API 6.4](https://core.telegram.org/bots/api-changelog#december-30-2022) support!
+
+* Long-polling improvements
+
+## 4.2.4
+
+* `Core`:
+    * Fixes in webhook parts adapter
+* `BehaviourBuilderWithFSM`:
+    * Fixes in `DefaultBehaviourContextWithFSM`
+
+## 4.2.3
+
+* `Versions`:
+  * `MicroUtils`: `0.16.2` -> `0.16.4`
+* `Core`:
+    * Simplify default `RequestsLimiter` (`ExceptionsOnlyLimiter`) (thanks to [@y9san9](https://github.com/y9san9) for help)
+
+## 4.2.2
+
+* `Versions`:
+    * `MicroUtils`: `0.16.0` -> `0.16.2`
+* `Core`:
+    * Fix of [#694](https://github.com/InsanusMokrassar/TelegramBotAPI/issues/694): add opportunity to create `ChatId` and `ChatIdWithThreadId` from `IdChatIdentifier`
+
+## 4.2.1
+
+* `Versions`:
+    * `MicroUtils`: `0.15.0` -> `0.16.0`
+    * `Ktor`: `2.1.3` -> `2.2.1`
+* `Utils`:
+    * Improve support of `makeLinkToMessage` extensions
+
+## 4.2.0
+
+* `Versions`:
+    * `Kotlin`: `1.7.21` -> `1.7.22`
+    * `MicroUtils`: `0.14.4` -> `0.15.0`
+
+## 4.1.3
+
+* `Versions`:
+    * `MicroUtils`: `0.14.2` -> `0.14.4`
+* `Core`:
+    * `ContentMessage`, `CommonMessage`, `PossiblyMediaGroupMessage` and `PossiblySentViaBotCommonMessage` got `out`
+      variance
+    * `UserId` now is `ChatId` instead of `IdChatIdentififer`
+
+## 4.1.2
+
+* `Versions`:
+    * `MicroUtils`: `0.14.1` -> `0.14.2`
+* `BehaviourBuilder`:
+    * Fixes in `CallbackQuery` waiters
+
+## 4.1.1
+
+* `Core`:
+  * Add opportunity to create `IdChatIdentifier` with optional `threadId`
+  * New serializer `FullChatIdentifierSerializer` with serialization of `ChatIdWithThreadId`
+
+## 4.1.0
+
+* `Versions`:
+    * `Kotlin`: `1.7.20` -> `1.7.21`
+    * `MicroUtils`: `0.14.0` -> `0.14.1`
+    * `Korlibs`: `3.3.1` -> `3.4.0`
+    * `UUID`: `0.5.0` -> `0.6.0`
+* `Core`:
+  * All the chats identifiers has been rewritten as value classes
+  * New chat identifier: `ChatIdWithThreadId`
+  * `RawMessage` will create `ChatIdWithThreadId` chat id under the hood by default
+  * All the methods which potentially using `threadId` will try to take it from `chatId`
+* `API`:
+  * All default `threadId` null values has been replaced with auto-calculated threadId from chats/chat ids
+
+## 4.0.0
+
+**!!! THIS UPDATE CONTAINS FULL REWORK OF MEDIA GROUPS FUNCTIONALITY !!!**
+
+**THIS UPDATE CONTAINS BREAKING CHANGES**
+
+* `Common`:
+  * All the media groups have been rewritten. Since this update, there are no separated messages types for media groups,
+    but new type of content (`MediaGroupContent`) has been introduced
+  * [Bot API 6.3](https://core.telegram.org/bots/api-changelog#november-5-2022) support
+* `Versions`:
+  * `MicroUtils`: `0.13.2` -> `0.14.0`
+* `Core`:
+  * New requests
+
+## 3.3.1
+
+* `Versions`:
+    * `Ktor`: `2.1.2` -> `2.1.3`
+    * `Klock`: `3.2.0` -> `3.3.1`
+    * `MicroUtils`: `0.13.1` -> `0.13.2`
+* `Utils`:
+    * New extensions on `CommonMessage`: `hasCommands` and `hasNoCommands`. Useful for the `initialFilter` parameter in behaviour builder triggers.
+
+## 3.3.0
+
+**THIS VERSION CONTAINS UPGRADE KOTLIN (AND ALL RELATED LIBRARIES) UP TO 1.7.20**
+
+* `Versions`:
+    * `Kotlin`: `1.7.10` -> `1.7.20`
+    * `Kotlin Serialization`: `1.4.0` -> `1.4.1`
+    * `Korlibs`: `3.1.0` -> `3.2.0`
+    * `MicroUtils`: `0.12.17` -> `0.13.1`
+* `Core`:
+    * Add opportunity to create command text source and add command in entities builder
+      via `BotCommamd` (thanks to [d1shin](https://github.com/InsanusMokrassar/TelegramBotAPI/pull/664))
+* `API`:
+    * New extensions `TelegramBot#getStickerSetOrNull` and `TelegramBot#getStickerSetOrThrow`
+        * Old `TelegramBot#getStickerSet` has been deprecated
+* `Behaviour Builder`:
+    * Add opportunity to use triggers and waiters with `BotCommand` (thanks to [d1shin](https://github.com/InsanusMokrassar/TelegramBotAPI/pull/664))
+
+## 3.2.7
+
+* `Versions`:
+    * `MicroUtils`: `0.12.13` -> `0.12.17`
+    * `Ktor`: `2.1.1` -> `2.1.2`
+* `Utils`:
+  * Next classes become typealiases instead of classes:
+    * `ReplyKeyboardBuilder`
+    * `ReplyKeyboardRowBuilder`
+    * `InlineKeyboardBuilder`
+    * `InlineKeyboardRowBuilder`
+
+## 3.2.6
+
+* `Core`:
+    * Fixes in `ChatMemberSerializer#serialize` method
+    * Migration of `EntitiesBuilder` from `Utils` to `Core`
+* `API`:
+    * All the extensions related to text messages (replies, sending, editing) got their duplicates with `buildEntities` lambda and separator
+* `Utils`:
+    * Migration of `EntitiesBuilder` from `Utils` to `Core`
+
+## 3.2.5
+
+* `Common`:
+  * Improve support of new exceptions recovering mechanism
+
+## 3.2.4
+
+* `API`:
+    * New `edit`'s with chats and message ids
+
+## 3.2.3
+
+* `Core`:
+  * Fixes in `DeleteMyCommands`
+
+## 3.2.2
+
+* `Versions`:
+  * `MicroUtils`: `0.12.10` -> `0.12.13`
+* `Core`:
+  * `MessageIdentifier` has been renamed to `MessageId`
+* `API`:
+  * New `reply`'es with chats and message ids
+
+## 3.2.1
+
+* `Versions`:
+    * `Ktor`: `2.1.0` -> `2.1.1`
+    * `Korlibs`: `3.0.0` -> `3.1.0`
+    * `MicroUtils`: `0.12.4` -> `0.12.10`
+
+## 3.2.0
+
+**Since this update, `RequestsExecutor#execute` may throw only `BotException`. In case you wish to handle some exceptions from `execute` you must catch `BotException` and handle its `cause`**
+
+* `Versions`:
+    * `Serialization`: `1.4.0-RC` -> `1.4.0`
+    * `MicroUtils`: `0.12.1` -> `0.12.4`
+* `Core`:
+  * `SetWebhook#allowedUpdates` now is `ALL_UPDATES_LIST` by default instead of `null`
+* `API`:
+  * Extension `TelegramBot#setWebhook` parameter `allowedUpdates` now is `ALL_UPDATES_LIST` by default instead of `null`
+* `Utils`:
+  * All related to long polling extensions parameters `allowedUpdates` now are `ALL_UPDATES_LIST` by default instead of `null`
+
+## 3.1.1
+
+* `Common`:
+    * Complete Bot API 6.2 implementation
+
+## 3.1.0
+
+**This update contains including of Bot API 6.2**
+
+* `Versions`:
+    * `Ktor`: `2.0.3` -> `2.1.0`
+    * `MicroUtils`: `0.12.0` -> `0.12.1`
+* `Core`:
+  * Add support of `custom emoji`s
+  * Add support of `sticker_type`
+
+## 3.0.2
+
+**ALL OLD DEPRECATIONS HAVE BEEN REMOVED**
+
+**`copyMessage` HAVE CHANGED THEIR SIGNATURE BY SWAPPING FROM AND TO CHAT IDS**
+
+* `Versions`:
+  * `Kotlin`: `1.6.21` -> `1.7.10`
+  * `Serialization`: `1.3.3` -> `1.4.0-RC`
+  * `Korlibs`: `2.7.0` -> `3.0.0`
+  * `UUID`: `0.4.1` -> `0.5.0`
+  * `MicroUtils`: `0.11.13` -> `0.12.0`
+* `Core`:
+    * Interface `ReplyMakrup` has been renamed to `WithReplyMarkup` to correspond its purpose
+    * Data class `LeftChatMember` has been renamed to `LeftChatMemberEvent` to avoid type ambiguite with the other `LeftChatMember`
+    * `ForwardInfo` hierarchy has been fully reworked:
+      * `AnonymousForwardInfo` -> `ForwardInfo.ByAnonymous`
+      * `UserForwardInfo` -> `ForwardInfo.ByUser`
+      * `ForwardFromPublicChatInfo` -> `ForwardInfo.PublicChat`
+      * `ForwardFromChannelInfo` -> `ForwardInfo.PublicChat.FromChannel`
+      * `ForwardFromSupergroupInfo` -> `ForwardInfo.PublicChat.FromSupergroup`
+      * `ForwardInfo.PublicChat.SentByChannel` ___has been created___
+* `API`:
+    * Add new `Flow`-based live locations API
+    * Add `sendLocation` for sending live locations
+* `Utils`:
+  * **BREAKING CHANGES** Now all new classcasts (like `Chat.ifPrivateChat` etc.) have been rewritten to be generated with `ksp` and `kotlin poet`
+
+*Note: Versions 3.0.0 and 3.0.1 have been published with errors and didn't recommend to use*
+
+## 2.2.2
+
+* `Utils`:
+  * `buildEntities` now is inline
+* `Behaviour Builder`:
+  * Fixes in `CallbackQuery` triggers
+
+## 2.2.1
+
+* `Versions`:
+    * `Coroutines`: `1.6.3` -> `1.6.4`
+    * `MicroUtils`: `0.11.12` -> `0.11.13`
+* `Core`:
+    * New `typealiase`s for `CommonMessage` with all supported content types, more info: [PR](https://github.com/InsanusMokrassar/TelegramBotAPI/pull/629)
+* `Utils`:
+    * New extensions for all types of messages `*.withContentOrNull` and `*.withContentOrThrow` as analogies to the same ones from class casts
+
+## 2.2.0
+
+* `Core`:
+  * For `CopyMessage` order of parameters has been changed
+  * `ReplyForce` defaults changes:
+    * All old companion properties (like `ReplyForce.ReplyForceSelective`) have been renamed:
+      * `ReplyForceSelective` -> `Selective`
+      * `ReplyForceNonSelective` -> `NonSelective`
+      * `ReplyForceDefault` -> `Default`
+    * New companion functions:
+      * `ReplyForce#Selective`
+      * `ReplyForce#NonSelective`
+  * Rename `CreatorChatMember` -> `OwnerChatMember`
+* `API`:
+  * For `copyMessage` order of parameters has been changed
+* `Utils`:
+  * New extension `Message#sameChat`
+  * New extension `Message#sameMessage`
+  * New functions `flatInlineKeyboard` and `flatReplyKeyboard`
+  * Experimentally add new triple of class casts: `if*`, `*OrNull` and `*OrThrow`
+
+## 2.1.3
+
+* `Versions`:
+  * `MicroUtils`: `0.11.9` -> `0.11.12`
+* `Utils`:
+  * Rename `UserId` extension `link` to `userLink`
+* `Core`
+  * `ChatJoinRequest#inviteLink` is nullable due to the fact that join requests without link do not require invite link
+
+## 2.1.2
+
+* `Versions`:
+  * `Coroutines`: `1.6.1` -> `1.6.3`
+  * `Ktor`: `2.0.2` -> `2.0.3`
+  * `MicroUtils`: `0.11.6` -> `0.11.9`
+
 ## 2.1.1
 
 * `API`:

README.md

@@ -1,8 +1,19 @@
-# TelegramBotAPI [![Maven Central](https://maven-badges.herokuapp.com/maven-central/dev.inmo/tgbotapi/badge.svg)](https://maven-badges.herokuapp.com/maven-central/dev.inmo/tgbotapi) [![Supported version](https://img.shields.io/badge/Telegram%20Bot%20API-6.1-blue)](https://core.telegram.org/bots/api-changelog#june-20-2022)
+# TelegramBotAPI [![Maven Central](https://maven-badges.herokuapp.com/maven-central/dev.inmo/tgbotapi/badge.svg)](https://maven-badges.herokuapp.com/maven-central/dev.inmo/tgbotapi) [![Supported version](https://img.shields.io/badge/Telegram%20Bot%20API-6.9-blue)](https://core.telegram.org/bots/api-changelog#september-22-2023)
 
-| [![Awesome Kotlin Badge](https://kotlin.link/awesome-kotlin.svg)](https://github.com/KotlinBy/awesome-kotlin) [![Build Status](https://github.com/InsanusMokrassar/TelegramBotAPI/workflows/Build/badge.svg)](https://github.com/InsanusMokrassar/TelegramBotAPI/actions) [![Small survey](https://img.shields.io/static/v1?label=Google&message=Survey&color=blue&logo=google-sheets)](https://docs.google.com/forms/d/e/1FAIpQLSctdJHT_aEniyYT0-IUAEfo1hsIlezX2owlkEAYX4KPl2V2_A/viewform?usp=sf_link) [![Chat in Telegram](https://img.shields.io/static/v1?label=Telegram&message=Chat&color=blue&logo=telegram)](https://t.me/InMoTelegramBotAPI) |
-|:---:|
-| [![Create bot](https://img.shields.io/static/v1?label=Github&message=Template&color=blue&logo=github)](https://github.com/InsanusMokrassar/TelegramBotAPI-bot_template/generate) [![Examples](https://img.shields.io/static/v1?label=Github&message=Examples&color=blue&logo=github)](https://github.com/InsanusMokrassar/TelegramBotAPI-examples/) [![KDocs](https://img.shields.io/static/v1?label=Dokka&message=KDocs&color=blue&logo=kotlin)](https://tgbotapi.inmo.dev/index.html) [![Mini tutorial](https://img.shields.io/static/v1?label=Bookstack&message=Tutorial&color=blue&logo=bookstack)](https://bookstack.inmo.dev/books/telegrambotapi/chapter/introduction-tutorial) |
+|          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)                                    |
+|:----------------------:|:-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------:|
+|      Useful repos      |                           [![Create bot](https://img.shields.io/static/v1?label=Github&message=Template&color=blue&logo=github)](https://github.com/InsanusMokrassar/TelegramBotAPI-bot_template/generate) [![Examples](https://img.shields.io/static/v1?label=Github&message=Examples&color=blue&logo=github)](https://github.com/InsanusMokrassar/TelegramBotAPI-examples/)                           |
+|          Misc          |                              [![Awesome Kotlin Badge](https://kotlin.link/awesome-kotlin.svg)](https://github.com/KotlinBy/awesome-kotlin) [![Small survey](https://img.shields.io/static/v1?label=Google&message=Survey&color=blue&logo=google-sheets)](https://docs.google.com/forms/d/e/1FAIpQLSctdJHT_aEniyYT0-IUAEfo1hsIlezX2owlkEAYX4KPl2V2_A/viewform?usp=sf_link)                               |
+|       Platforms        |                                                                                                      ![JVM](https://img.shields.io/badge/JVM-red?style=plastic&logo=openjdk&logoColor=white) ![Js](https://img.shields.io/badge/JavaScript-323330?style=plastic&logo=javascript&logoColor=F7DF1E)                                                                                                       |
+| Experimental Platforms |                                                                                                [![Linux x64](https://img.shields.io/badge/LinuxX64-FCC624?style=plastic&logo=linux&logoColor=black)](https://kotlinlang.org/docs/native-target-support.html#tier-1) [![MinGW x64](https://img.shields.io/badge/MinGWX64-black?style=plastic&logo=windows&logoColor=green)](https://kotlinlang.org/docs/native-target-support.html#tier-1)                                                                                                 |
+
+<!--- [![Telegram Channel](./resources/tg_channel_qr.jpg)](https://t.me/ktgbotapi) --->
+
+<p align="center">
+  <a href="https://t.me/ktgbotapi">
+    <img src="./resources/tg_channel_qr.jpg">
+  </a>
+</p>
 
 Hello! This is a set of libraries for working with Telegram Bot API.
 
@@ -107,5 +118,5 @@ suspend fun main() {
 ### More examples
 
 You may find examples in [this project](https://github.com/InsanusMokrassar/TelegramBotAPI-examples). Besides, you are
-always welcome in our [wiki](https://github.com/InsanusMokrassar/TelegramBotAPI/wiki/About-this-project) and
+always welcome in our [bookstack](https://bookstack.inmo.dev/books/telegrambotapi) and
 [chat](https://t.me/InMoTelegramBotAPIChat).

build.gradle

@@ -6,19 +6,27 @@ buildscript {
     }
 
     dependencies {
-        classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:$kotlin_version"
-        classpath "org.jetbrains.kotlin:kotlin-serialization:$kotlin_version"
-        classpath "com.github.breadmoirai:github-release:$github_release_plugin_version"
+        classpath libs.kotlin.gradle.plugin
+        classpath libs.kotlin.ksp.plugin
+        classpath libs.kotlin.serialization.plugin
+        classpath libs.kotlin.dokka.plugin
+        classpath libs.github.release.plugin
     }
 }
 
 plugins {
-    id "org.jetbrains.kotlin.multiplatform" version "$kotlin_version" apply false
-    id "org.jetbrains.kotlin.plugin.serialization" version "$kotlin_version" apply false
+    alias(libs.plugins.kotlin.dokka)
+    alias(libs.plugins.versions)
 }
 
 // temporal crutch until legacy tests will be stabled or legacy target will be removed
 allprojects {
+    repositories {
+        mavenLocal()
+        mavenCentral()
+        google()
+        maven { url "https://nexus.inmo.dev/repository/maven-releases/" }
+    }
     if (it != rootProject.findProject("docs")) {
         tasks.whenTaskAdded { task ->
             if(task.name == "jsLegacyBrowserTest" || task.name == "jsLegacyNodeTest") {
@@ -27,6 +35,7 @@ allprojects {
         }
     }
 }
+apply from: "./extensions.gradle"
 
 private String getCurrentVersionChangelog() {
     OutputStream changelogDataOS = new ByteArrayOutputStream()
@@ -48,7 +57,7 @@ if (new File(projectDir, "secret.gradle").exists()) {
         owner "InsanusMokrassar"
         repo "TelegramBotAPI"
 
-        tagName "$library_version"
+        tagName "v$library_version"
         releaseName "$library_version"
         targetCommitish "$library_version"
 

docs/build.gradle

@@ -1,45 +1,17 @@
-buildscript {
-    repositories {
-        mavenLocal()
-        mavenCentral()
-    }
-
-    dependencies {
-        classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:$kotlin_version"
-        classpath "org.jetbrains.kotlin:kotlin-serialization:$kotlin_version"
-        classpath "org.jetbrains.dokka:dokka-gradle-plugin:$dokka_version"
-    }
-}
-
 plugins {
     id "org.jetbrains.kotlin.multiplatform"
     id "org.jetbrains.kotlin.plugin.serialization"
-    id "org.jetbrains.dokka" version "$dokka_version"
+    id "org.jetbrains.dokka"
 }
 
-repositories {
-    mavenLocal()
-    mavenCentral()
-}
+project.description = "Full collection of all built-in tgbotapi tools"
+
+apply from: "$mppProjectWithSerializationPresetPath"
 
 kotlin {
-    jvm {
-        compilations.main {
-            kotlinOptions {
-                jvmTarget = "1.8"
-            }
-        }
-    }
-    js(IR) {
-        browser()
-        nodejs()
-    }
-
     sourceSets {
         commonMain {
             dependencies {
-                implementation kotlin('stdlib')
-
                 api project(":tgbotapi.core")
                 api project(":tgbotapi.api")
                 api project(":tgbotapi.utils")
@@ -58,12 +30,13 @@ kotlin {
 
 private List<SourceDirectorySet> findSourcesWithName(String... approximateNames) {
     return parent.subprojects
-        .findAll { it != project }
-        .collectMany { it.kotlin.sourceSets }
-        .findAll { sourceSet -> approximateNames.any {
-            nameToFilter -> sourceSet.name.contains(nameToFilter)
-            }
-        }.collect { it.kotlin }
+            .findAll { it != project && it.hasProperty("kotlin") }
+            .collectMany { it.kotlin.sourceSets }
+            .findAll { sourceSet ->
+                approximateNames.any { nameToFilter ->
+                    sourceSet.name.contains(nameToFilter)
+                }
+            }.collect { it.kotlin }
 }
 
 Object callback = {
@@ -81,8 +54,8 @@ Object callback = {
             skipDeprecated.set(true)
 
             sourceLink {
-                localDirectory.set(file("./"))
-                remoteUrl.set(new URL("https://github.com/InsanusMokrassar/TelegramBotAPI/blob/master/"))
+                localDirectory.set(file("../"))
+                remoteUrl.set(new URL("https://github.com/InsanusMokrassar/ktgbotapi/tree/master"))
                 remoteLineSuffix.set("#L")
             }
         }
@@ -103,8 +76,3 @@ Object callback = {
 
 tasks.dokkaGfm(callback)
 tasks.dokkaHtml(callback)
-
-java {
-    sourceCompatibility = JavaVersion.VERSION_1_8
-    targetCompatibility = JavaVersion.VERSION_1_8
-}

extensions.gradle

@@ -0,0 +1,8 @@
+allprojects {
+    ext {
+        mppProjectWithSerializationPresetPath = "${rootProject.projectDir.absolutePath}/mppProjectWithSerialization.gradle"
+        mppJsProjectPresetPath = "${rootProject.projectDir.absolutePath}/mppJsProject.gradle"
+
+        publishGradlePath = "${rootProject.projectDir.absolutePath}/publish.gradle"
+    }
+}

gradle.properties

@@ -5,21 +5,5 @@ kotlin.js.generate.externals=true
 kotlin.incremental=true
 kotlin.incremental.js=true
 
-kotlin_version=1.6.21
-kotlin_coroutines_version=1.6.1
-kotlin_serialisation_runtime_version=1.3.3
-korlibs_version=2.7.0
-uuid_version=0.4.1
-ktor_version=2.0.2
-
-micro_utils_version=0.11.6
-
-javax_activation_version=1.1.1
-
-
-dokka_version=1.6.21
-
 library_group=dev.inmo
-library_version=2.1.1
-
-github_release_plugin_version=2.4.1
+library_version=9.4.3

gradle/libs.versions.toml

@@ -0,0 +1,79 @@
+[versions]
+
+kotlin = "1.9.22"
+kotlin-serialization = "1.6.2"
+kotlin-coroutines = "1.7.3"
+
+javax-activation = "1.1.1"
+
+korlibs = "4.0.10"
+uuid = "0.8.2"
+ktor = "2.3.7"
+
+ksp = "1.9.21-1.0.16"
+kotlin-poet = "1.15.3"
+
+microutils = "0.20.23"
+kslog = "1.3.1"
+
+versions = "0.50.0"
+
+github-release-plugin = "2.4.1"
+dokka = "1.9.10"
+
+[libraries]
+
+kotlin = { module = "org.jetbrains.kotlin:kotlin-stdlib", version.ref = "kotlin" }
+kotlin-coroutines = { module = "org.jetbrains.kotlinx:kotlinx-coroutines-core", version.ref = "kotlin-coroutines" }
+kotlin-serialization = { module = "org.jetbrains.kotlinx:kotlinx-serialization-json", version.ref = "kotlin-serialization" }
+kotlin-serialization-properties = { module = "org.jetbrains.kotlinx:kotlinx-serialization-properties", version.ref = "kotlin-serialization" }
+kotlin-test-common = { module = "org.jetbrains.kotlin:kotlin-test-common", version.ref = "kotlin" }
+kotlin-test-annotations-common = { module = "org.jetbrains.kotlin:kotlin-test-annotations-common", version.ref = "kotlin" }
+kotlin-test-junit = { module = "org.jetbrains.kotlin:kotlin-test-junit", version.ref = "kotlin" }
+kotlin-test-js = { module = "org.jetbrains.kotlin:kotlin-test-js", version.ref = "kotlin" }
+
+ktor-client-core = { module = "io.ktor:ktor-client-core", version.ref = "ktor" }
+ktor-client-cio = { module = "io.ktor:ktor-client-cio", version.ref = "ktor" }
+ktor-client-curl = { module = "io.ktor:ktor-client-curl", version.ref = "ktor" }
+ktor-client-winhttp = { module = "io.ktor:ktor-client-winhttp", version.ref = "ktor" }
+ktor-server = { module = "io.ktor:ktor-server", version.ref = "ktor" }
+ktor-server-host-common = { module = "io.ktor:ktor-server-host-common", version.ref = "ktor" }
+
+javax-activation = { module = "javax.activation:activation", version.ref = "javax-activation" }
+
+korlibs-klock =  { module = "com.soywiz.korlibs.klock:klock", version.ref = "korlibs" }
+korlibs-krypto =  { module = "com.soywiz.korlibs.krypto:krypto", version.ref = "korlibs" }
+
+uuid = { module = "com.benasher44:uuid", version.ref = "uuid" }
+
+microutils-coroutines = { module = "dev.inmo:micro_utils.coroutines", version.ref = "microutils" }
+microutils-serialization-base64 = { module = "dev.inmo:micro_utils.serialization.base64", version.ref = "microutils" }
+microutils-serialization-encapsulator = { module = "dev.inmo:micro_utils.serialization.encapsulator", version.ref = "microutils" }
+microutils-serialization-typedSerializer = { module = "dev.inmo:micro_utils.serialization.typed_serializer", version.ref = "microutils" }
+microutils-serialization-mapper = { module = "dev.inmo:micro_utils.serialization.mapper", version.ref = "microutils" }
+microutils-languageCodes = { module = "dev.inmo:micro_utils.language_codes", version.ref = "microutils" }
+microutils-ktor-common = { module = "dev.inmo:micro_utils.ktor.common", version.ref = "microutils" }
+microutils-fsm-common = { module = "dev.inmo:micro_utils.fsm.common", version.ref = "microutils" }
+
+kslog = { module = "dev.inmo:kslog", version.ref = "kslog" }
+
+# ksp dependencies
+
+kotlin-poet = { module = "com.squareup:kotlinpoet-ksp", version.ref = "kotlin-poet" }
+ksp = { module = "com.google.devtools.ksp:symbol-processing-api", version.ref = "ksp" }
+
+# buildscript classpaths
+
+kotlin-gradle-plugin = { module = "org.jetbrains.kotlin:kotlin-gradle-plugin", version.ref = "kotlin" }
+kotlin-ksp-plugin = { module = "com.google.devtools.ksp:symbol-processing-gradle-plugin", version.ref = "ksp" }
+kotlin-serialization-plugin = { module = "org.jetbrains.kotlin:kotlin-serialization", version.ref = "kotlin" }
+kotlin-dokka-plugin = { module = "org.jetbrains.dokka:dokka-gradle-plugin", version.ref = "dokka" }
+github-release-plugin = { module = "com.github.breadmoirai:github-release", version.ref = "github-release-plugin" }
+
+[plugins]
+
+kotlin-jvm = { id = "org.jetbrains.kotlin.jvm", version.ref = "kotlin" }
+kotlin-multiplatform = { id = "org.jetbrains.kotlin.multiplatform", version.ref = "kotlin" }
+kotlin-serialization = { id = "org.jetbrains.kotlin.plugin.serialization", version.ref = "kotlin" }
+kotlin-dokka = { id = "org.jetbrains.dokka", version.ref = "dokka" }
+versions = { id = "com.github.ben-manes.versions", version.ref = "versions" }

gradle/wrapper/gradle-wrapper.properties

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

mppJsProject.gradle

@@ -0,0 +1,32 @@
+project.version = "$version"
+project.group = "$group"
+
+apply from: "$publishGradlePath"
+
+kotlin {
+    js (IR) {
+        browser()
+        nodejs()
+    }
+
+    sourceSets {
+        commonMain {
+            dependencies {
+                implementation libs.kotlin
+                api libs.kotlin.serialization
+            }
+        }
+        commonTest {
+            dependencies {
+                implementation libs.kotlin.test.common
+                implementation libs.kotlin.test.annotations.common
+            }
+        }
+        jsTest {
+            dependencies {
+                implementation libs.kotlin.test.js
+                implementation libs.kotlin.test.junit
+            }
+        }
+    }
+}

mppProjectWithSerialization.gradle

@@ -0,0 +1,58 @@
+project.version = "$library_version"
+project.group = "$library_group"
+
+kotlin {
+    jvm {
+        compilations.main {
+            kotlinOptions {
+                jvmTarget = "17"
+            }
+        }
+    }
+    js (IR) {
+        browser()
+        nodejs()
+    }
+    linuxX64()
+    mingwX64()
+    linuxArm64()
+
+    sourceSets {
+        commonMain {
+            dependencies {
+                implementation libs.kotlin
+                api libs.kotlin.serialization
+            }
+        }
+        commonTest {
+            dependencies {
+                implementation libs.kotlin.test.common
+                implementation libs.kotlin.test.annotations.common
+            }
+        }
+        jvmTest {
+            dependencies {
+                implementation libs.kotlin.test.junit
+            }
+        }
+        jsTest {
+            dependencies {
+                implementation libs.kotlin.test.js
+                implementation libs.kotlin.test.junit
+            }
+        }
+        all {
+            languageSettings {
+                optIn('dev.inmo.tgbotapi.utils.RiskFeature')
+                optIn('dev.inmo.tgbotapi.utils.PreviewFeature')
+                optIn('dev.inmo.micro_utils.common.Warning')
+                optIn('dev.inmo.micro_utils.common.PreviewFeature')
+            }
+        }
+    }
+}
+
+java {
+    sourceCompatibility = JavaVersion.VERSION_17
+    targetCompatibility = JavaVersion.VERSION_17
+}

publish.gradle

@@ -1,7 +1,7 @@
 apply plugin: 'maven-publish'
 
 task javadocsJar(type: Jar) {
-    classifier = 'javadoc'
+    archiveClassifier = 'javadoc'
 }
 
 publishing {
@@ -42,20 +42,36 @@ publishing {
                 maven {
                     name = "GithubPackages"
                     url = uri("https://maven.pkg.github.com/InsanusMokrassar/TelegramBotAPI")
+            
                     credentials {
                         username = project.hasProperty('GITHUBPACKAGES_USER') ? project.property('GITHUBPACKAGES_USER') : System.getenv('GITHUBPACKAGES_USER')
                         password = project.hasProperty('GITHUBPACKAGES_PASSWORD') ? project.property('GITHUBPACKAGES_PASSWORD') : System.getenv('GITHUBPACKAGES_PASSWORD')
                     }
+            
+                }
+            }
+            if ((project.hasProperty('INMONEXUS_USER') || System.getenv('INMONEXUS_USER') != null) && (project.hasProperty('INMONEXUS_PASSWORD') || System.getenv('INMONEXUS_PASSWORD') != null)) {
+                maven {
+                    name = "InmoNexus"
+                    url = uri("https://nexus.inmo.dev/repository/maven-releases/")
+            
+                    credentials {
+                        username = project.hasProperty('INMONEXUS_USER') ? project.property('INMONEXUS_USER') : System.getenv('INMONEXUS_USER')
+                        password = project.hasProperty('INMONEXUS_PASSWORD') ? project.property('INMONEXUS_PASSWORD') : System.getenv('INMONEXUS_PASSWORD')
+                    }
+            
                 }
             }
             if ((project.hasProperty('SONATYPE_USER') || System.getenv('SONATYPE_USER') != null) && (project.hasProperty('SONATYPE_PASSWORD') || System.getenv('SONATYPE_PASSWORD') != null)) {
                 maven {
                     name = "sonatype"
                     url = uri("https://oss.sonatype.org/service/local/staging/deploy/maven2/")
+            
                     credentials {
                         username = project.hasProperty('SONATYPE_USER') ? project.property('SONATYPE_USER') : System.getenv('SONATYPE_USER')
                         password = project.hasProperty('SONATYPE_PASSWORD') ? project.property('SONATYPE_PASSWORD') : System.getenv('SONATYPE_PASSWORD')
                     }
+            
                 }
             }
         }
@@ -76,4 +92,27 @@ if (project.hasProperty("signing.gnupg.keyName")) {
             dependsOn(it)
         }
     }
+
+    // Workaround to make android sign operations depend on signing tasks
+    project.getTasks().withType(AbstractPublishToMaven.class).configureEach {
+        def signingTasks = project.getTasks().withType(Sign.class)
+        mustRunAfter(signingTasks)
+    }
+    // Workaround to make test tasks use sign
+    project.getTasks().withType(Sign.class).configureEach { signTask ->
+        def withoutSign = (signTask.name.startsWith("sign") ? signTask.name.minus("sign") : signTask.name)
+        def pubName = withoutSign.endsWith("Publication") ? withoutSign.substring(0, withoutSign.length() - "Publication".length()) : withoutSign
+        // These tasks only exist for native targets, hence findByName() to avoid trying to find them for other targets
+
+        // Task ':linkDebugTest<platform>' uses this output of task ':sign<platform>Publication' without declaring an explicit or implicit dependency
+        def debugTestTask = tasks.findByName("linkDebugTest$pubName")
+        if (debugTestTask != null) {
+            signTask.mustRunAfter(debugTestTask)
+        }
+        // Task ':compileTestKotlin<platform>' uses this output of task ':sign<platform>Publication' without declaring an explicit or implicit dependency
+        def testTask = tasks.findByName("compileTestKotlin$pubName")
+        if (testTask != null) {
+            signTask.mustRunAfter(testTask)
+        }
+    }
 }

publish.kpsb

@@ -1 +1 @@
-{"licenses":[{"id":"Apache-2.0","title":"Apache Software License 2.0","url":"https://github.com/InsanusMokrassar/TelegramBotAPI/blob/master/LICENSE"}],"mavenConfig":{"name":"${project.name}","description":"${project.description}","url":"https://insanusmokrassar.github.io/TelegramBotAPI/TelegramBotAPI","vcsUrl":"https://github.com/insanusmokrassar/TelegramBotAPI.git","developers":[{"id":"InsanusMokrassar","name":"Ovsiannikov Aleksei","eMail":"ovsyannikov.alexey95@gmail.com"}],"repositories":[{"name":"GithubPackages","url":"https://maven.pkg.github.com/InsanusMokrassar/TelegramBotAPI"},{"name":"sonatype","url":"https://oss.sonatype.org/service/local/staging/deploy/maven2/"}],"gpgSigning":{"type":"dev.inmo.kmppscriptbuilder.core.models.GpgSigning.Optional"}}}
+{"licenses":[{"id":"Apache-2.0","title":"Apache Software License 2.0","url":"https://github.com/InsanusMokrassar/TelegramBotAPI/blob/master/LICENSE"}],"mavenConfig":{"name":"${project.name}","description":"${project.description}","url":"https://insanusmokrassar.github.io/TelegramBotAPI/TelegramBotAPI","vcsUrl":"https://github.com/insanusmokrassar/TelegramBotAPI.git","developers":[{"id":"InsanusMokrassar","name":"Ovsiannikov Aleksei","eMail":"ovsyannikov.alexey95@gmail.com"}],"repositories":[{"name":"GithubPackages","url":"https://maven.pkg.github.com/InsanusMokrassar/TelegramBotAPI"},{"name":"InmoNexus","url":"https://nexus.inmo.dev/repository/maven-releases/"},{"name":"sonatype","url":"https://oss.sonatype.org/service/local/staging/deploy/maven2/"}],"gpgSigning":{"type":"dev.inmo.kmppscriptbuilder.core.models.GpgSigning.Optional"}}}

settings.gradle

@@ -12,10 +12,10 @@ pluginManagement {
 }
 
 include ":tgbotapi.core"
+include ":tgbotapi.ksp"
 include ":tgbotapi.api"
 include ":tgbotapi.utils"
 include ":tgbotapi.behaviour_builder"
 include ":tgbotapi.behaviour_builder.fsm"
 include ":tgbotapi"
 include ":tgbotapi.webapps"
-include ":docs"

tgbotapi.api/build.gradle

@@ -1,56 +1,21 @@
-buildscript {
-    repositories {
-        mavenLocal()
-        mavenCentral()
-    }
-
-    dependencies {
-        classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:$kotlin_version"
-        classpath "org.jetbrains.kotlin:kotlin-serialization:$kotlin_version"
-    }
-}
-
 plugins {
     id "org.jetbrains.kotlin.multiplatform"
     id "org.jetbrains.kotlin.plugin.serialization"
+    id "org.jetbrains.dokka"
 }
 
-project.version = "$library_version"
-project.group = "$library_group"
 project.description = "API extensions with \"Telegram Bot API\"-like extensions for TelegramBot and RequestsExecutor"
 
-apply from: "../publish.gradle"
-
-repositories {
-    mavenLocal()
-    mavenCentral()
-}
+apply from: "$mppProjectWithSerializationPresetPath"
+apply from: "$publishGradlePath"
 
 kotlin {
-    jvm {
-        compilations.main {
-            kotlinOptions {
-                jvmTarget = "1.8"
-            }
-        }
-    }
-    js(IR) {
-        browser()
-        nodejs()
-    }
-
     sourceSets {
         commonMain {
             dependencies {
-                implementation kotlin('stdlib')
                 api project(":tgbotapi.core")
             }
         }
     }
 }
 
-java {
-    sourceCompatibility = JavaVersion.VERSION_1_8
-    targetCompatibility = JavaVersion.VERSION_1_8
-}
-

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

@@ -3,34 +3,46 @@ package dev.inmo.tgbotapi.extensions.api
 import dev.inmo.tgbotapi.bot.TelegramBot
 import dev.inmo.tgbotapi.requests.DeleteMessage
 import dev.inmo.tgbotapi.types.ChatIdentifier
-import dev.inmo.tgbotapi.types.MessageIdentifier
+import dev.inmo.tgbotapi.types.MessageId
 import dev.inmo.tgbotapi.types.chat.Chat
+import dev.inmo.tgbotapi.types.message.abstracts.ContentMessage
 import dev.inmo.tgbotapi.types.message.abstracts.Message
+import dev.inmo.tgbotapi.types.message.content.MediaGroupCollectionContent
+import dev.inmo.tgbotapi.types.message.content.MediaGroupContent
 
 suspend fun TelegramBot.deleteMessage(
     chatId: ChatIdentifier,
-    messageId: MessageIdentifier
+    messageId: MessageId
 ) = execute(
     DeleteMessage(chatId, messageId)
 )
 
 suspend fun TelegramBot.deleteMessage(
     chat: Chat,
-    messageId: MessageIdentifier
+    messageId: MessageId
 ) = deleteMessage(chat.id, messageId)
 
 suspend fun TelegramBot.deleteMessage(
     message: Message
-) = deleteMessage(message.chat, message.messageId)
+): Boolean {
+    val mediaGroupContent = ((message as? ContentMessage<*>) ?.content as? MediaGroupCollectionContent<*>)
+    if (mediaGroupContent == null) {
+        return deleteMessage(message.chat, message.messageId)
+    } else {
+        return mediaGroupContent.group.map {
+            deleteMessage(it.sourceMessage)
+        }.all { it }
+    }
+}
 
 suspend fun TelegramBot.delete(
     chatId: ChatIdentifier,
-    messageId: MessageIdentifier
+    messageId: MessageId
 ) = deleteMessage(chatId, messageId)
 
 suspend fun TelegramBot.delete(
     chat: Chat,
-    messageId: MessageIdentifier
+    messageId: MessageId
 ) = deleteMessage(chat, messageId)
 
 suspend fun TelegramBot.delete(

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

@@ -3,54 +3,62 @@ package dev.inmo.tgbotapi.extensions.api
 import dev.inmo.tgbotapi.bot.TelegramBot
 import dev.inmo.tgbotapi.requests.ForwardMessage
 import dev.inmo.tgbotapi.types.ChatIdentifier
-import dev.inmo.tgbotapi.types.MessageIdentifier
+import dev.inmo.tgbotapi.types.MessageId
+import dev.inmo.tgbotapi.types.MessageThreadId
 import dev.inmo.tgbotapi.types.chat.Chat
 import dev.inmo.tgbotapi.types.message.abstracts.Message
+import dev.inmo.tgbotapi.types.threadId
 
 suspend fun TelegramBot.forwardMessage(
     fromChatId: ChatIdentifier,
     toChatId: ChatIdentifier,
-    messageId: MessageIdentifier,
+    messageId: MessageId,
+    threadId: MessageThreadId? = toChatId.threadId,
     disableNotification: Boolean = false,
     protectContent: Boolean = false
 ) = execute(
-    ForwardMessage(fromChatId, toChatId, messageId, disableNotification, protectContent)
+    ForwardMessage(fromChatId, toChatId, messageId, threadId, disableNotification, protectContent)
 )
 
 suspend fun TelegramBot.forwardMessage(
     fromChat: Chat,
     toChatId: ChatIdentifier,
-    messageId: MessageIdentifier,
+    messageId: MessageId,
+    threadId: MessageThreadId? = toChatId.threadId,
     disableNotification: Boolean = false,
     protectContent: Boolean = false
-) = forwardMessage(fromChat.id, toChatId, messageId, disableNotification, protectContent)
+) = forwardMessage(fromChat.id, toChatId, messageId, threadId, disableNotification, protectContent)
 
 suspend fun TelegramBot.forwardMessage(
     fromChatId: ChatIdentifier,
     toChat: Chat,
-    messageId: MessageIdentifier,
+    messageId: MessageId,
+    threadId: MessageThreadId? = toChat.id.threadId,
     disableNotification: Boolean = false,
     protectContent: Boolean = false
-) = forwardMessage(fromChatId, toChat.id, messageId, disableNotification, protectContent)
+) = forwardMessage(fromChatId, toChat.id, messageId, threadId, disableNotification, protectContent)
 
 suspend fun TelegramBot.forwardMessage(
     fromChat: Chat,
     toChat: Chat,
-    messageId: MessageIdentifier,
+    messageId: MessageId,
+    threadId: MessageThreadId? = toChat.id.threadId,
     disableNotification: Boolean = false,
     protectContent: Boolean = false
-) = forwardMessage(fromChat.id, toChat.id, messageId, disableNotification, protectContent)
+) = forwardMessage(fromChat.id, toChat.id, messageId, threadId, disableNotification, protectContent)
 
 suspend fun TelegramBot.forwardMessage(
     toChatId: ChatIdentifier,
     message: Message,
+    threadId: MessageThreadId? = toChatId.threadId,
     disableNotification: Boolean = false,
     protectContent: Boolean = false
-) = forwardMessage(message.chat, toChatId, message.messageId, disableNotification, protectContent)
+) = forwardMessage(message.chat, toChatId, message.messageId, threadId, disableNotification, protectContent)
 
 suspend fun TelegramBot.forwardMessage(
     toChat: Chat,
     message: Message,
+    threadId: MessageThreadId? = toChat.id.threadId,
     disableNotification: Boolean = false,
     protectContent: Boolean = false
-) = forwardMessage(message.chat, toChat, message.messageId, disableNotification, protectContent)
+) = forwardMessage(message.chat, toChat, message.messageId, threadId, disableNotification, protectContent)

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

@@ -0,0 +1,27 @@
+package dev.inmo.tgbotapi.extensions.api
+
+import dev.inmo.tgbotapi.bot.TelegramBot
+import dev.inmo.tgbotapi.requests.GetUpdates
+import dev.inmo.tgbotapi.requests.GetUpdatesRaw
+import dev.inmo.tgbotapi.types.*
+import dev.inmo.tgbotapi.types.update.abstracts.Update
+
+suspend fun TelegramBot.getRawUpdates(
+    offset: UpdateIdentifier? = null,
+    limit: Int = getUpdatesLimit.last,
+    timeout: Seconds? = null,
+    allowed_updates: List<String>? = ALL_UPDATES_LIST
+) = execute(
+    GetUpdatesRaw(
+        offset, limit, timeout, allowed_updates
+    )
+)
+
+suspend fun TelegramBot.getRawUpdates(
+    lastUpdate: Update,
+    limit: Int = getUpdatesLimit.last,
+    timeout: Seconds? = null,
+    allowed_updates: List<String>? = ALL_UPDATES_LIST
+) = getRawUpdates(
+    lastUpdate.updateId + 1, limit, timeout, allowed_updates
+)

tgbotapi.api/src/commonMain/kotlin/dev/inmo/tgbotapi/extensions/api/InternalUtils/UpdatesUtils.kt

@@ -1,70 +1,57 @@
 package dev.inmo.tgbotapi.extensions.api.InternalUtils
 
 import dev.inmo.tgbotapi.types.MediaGroupIdentifier
-import dev.inmo.tgbotapi.types.UpdateIdentifier
-import dev.inmo.tgbotapi.types.message.abstracts.MediaGroupMessage
+import dev.inmo.tgbotapi.types.message.abstracts.PossiblySentViaBotCommonMessage
+import dev.inmo.tgbotapi.types.message.content.MediaGroupPartContent
 import dev.inmo.tgbotapi.types.update.*
 import dev.inmo.tgbotapi.types.update.abstracts.*
-import dev.inmo.tgbotapi.types.update.media_group.*
-
-internal fun Update.lastUpdateIdentifier(): UpdateIdentifier {
-    return if (this is SentMediaGroupUpdate) {
-        origins.last().updateId
-    } else {
-        updateId
-    }
-}
-
-internal fun List<Update>.lastUpdateIdentifier(): UpdateIdentifier? {
-    return maxByOrNull { it.updateId } ?.lastUpdateIdentifier()
-}
+import dev.inmo.tgbotapi.utils.extensions.asMediaGroupMessage
 
+/**
+ * Will convert incoming list of updates to list with [MediaGroupUpdate]s
+ */
 internal fun List<Update>.convertWithMediaGroupUpdates(): List<Update> {
     val resultUpdates = mutableListOf<Update>()
-    val mediaGroups = mutableMapOf<MediaGroupIdentifier, MutableList<BaseSentMessageUpdate>>()
+    val mediaGroups = mutableMapOf<MediaGroupIdentifier, MutableList<Pair<BaseSentMessageUpdate, PossiblySentViaBotCommonMessage<MediaGroupPartContent>>>>()
+
     for (update in this) {
-        val data = (update.data as? MediaGroupMessage<*>)
-        if (data == null) {
+        val message = (update.data as? PossiblySentViaBotCommonMessage<*>) ?.let {
+            if (it.content is MediaGroupPartContent) {
+                it as PossiblySentViaBotCommonMessage<MediaGroupPartContent>
+            } else {
+                null
+            }
+        }
+        val mediaGroupId = message ?.mediaGroupId
+        if (message == null || mediaGroupId == null) {
             resultUpdates.add(update)
             continue
         }
         when (update) {
-            is BaseEditMessageUpdate -> resultUpdates.add(
-                update.toEditMediaGroupUpdate()
-            )
             is BaseSentMessageUpdate -> {
-                mediaGroups.getOrPut(data.mediaGroupId) {
+                mediaGroups.getOrPut(mediaGroupId) {
                     mutableListOf()
-                }.add(update)
+                }.add(update to message)
             }
             else -> resultUpdates.add(update)
         }
     }
-    mediaGroups.values.map {
-        it.toSentMediaGroupUpdate() ?.let { mediaGroupUpdate ->
-            resultUpdates.add(mediaGroupUpdate)
-        }
+
+    mediaGroups.map { (_, updatesWithMessages) ->
+        val update = updatesWithMessages.maxBy { it.first.updateId }.first
+        resultUpdates.add(
+            update.copy(updatesWithMessages.map { it.second }.asMediaGroupMessage())
+        )
     }
+
     resultUpdates.sortBy { it.updateId }
     return resultUpdates
 }
 
-internal fun List<BaseSentMessageUpdate>.toSentMediaGroupUpdate(): SentMediaGroupUpdate? = (this as? SentMediaGroupUpdate) ?: let {
-    if (isEmpty()) {
-        return@let null
-    }
-    val resultList = sortedBy { it.updateId }
-    when (first()) {
-        is MessageUpdate -> MessageMediaGroupUpdate(resultList)
-        is ChannelPostUpdate -> ChannelPostMediaGroupUpdate(resultList)
-        else -> null
-    }
-}
-
-internal fun BaseEditMessageUpdate.toEditMediaGroupUpdate(): EditMediaGroupUpdate = (this as? EditMediaGroupUpdate) ?: let {
-    when (this) {
-        is EditMessageUpdate -> EditMessageMediaGroupUpdate(this)
-        is EditChannelPostUpdate -> EditChannelPostMediaGroupUpdate(this)
-        else -> error("Unsupported type of ${BaseEditMessageUpdate::class.simpleName}")
-    }
-}
+/**
+ * @return [EditMessageMediaGroupUpdate] in case if [this] is [EditMessageUpdate]. When [this] object is
+ * [EditChannelPostUpdate] instance - will return [EditChannelPostMediaGroupUpdate]
+ *
+ * @throws IllegalStateException
+ */
+internal fun BaseEditMessageUpdate.toEditMediaGroupUpdate() = this

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

@@ -0,0 +1,168 @@
+package dev.inmo.tgbotapi.extensions.api
+
+import dev.inmo.micro_utils.coroutines.LinkedSupervisorJob
+import dev.inmo.micro_utils.coroutines.launchSafelyWithoutExceptions
+import dev.inmo.tgbotapi.abstracts.*
+import dev.inmo.tgbotapi.abstracts.types.WithReplyMarkup
+import dev.inmo.tgbotapi.bot.TelegramBot
+import dev.inmo.tgbotapi.extensions.api.edit.edit
+import dev.inmo.tgbotapi.extensions.api.send.send
+import dev.inmo.tgbotapi.extensions.api.send.sendLiveLocation
+import dev.inmo.tgbotapi.types.*
+import dev.inmo.tgbotapi.types.buttons.InlineKeyboardMarkup
+import dev.inmo.tgbotapi.types.location.LiveLocation
+import dev.inmo.tgbotapi.types.location.Location
+import dev.inmo.tgbotapi.types.message.abstracts.ContentMessage
+import dev.inmo.tgbotapi.types.message.content.LocationContent
+import kotlinx.coroutines.*
+import kotlinx.coroutines.flow.Flow
+import kotlinx.coroutines.flow.FlowCollector
+import kotlinx.coroutines.flow.map
+import kotlinx.serialization.Serializable
+import kotlin.js.JsName
+import kotlin.jvm.JvmName
+import kotlin.math.ceil
+
+@Serializable
+data class EditLiveLocationInfo(
+    override val latitude: Double,
+    override val longitude: Double,
+    override val horizontalAccuracy: Meters? = null,
+    override val heading: Degrees? = null,
+    override val proximityAlertRadius: Meters? = null,
+    override val replyMarkup: InlineKeyboardMarkup? = null
+) : Locationed, HorizontallyAccured, ProximityAlertable, Headed, WithReplyMarkup
+
+/**
+ * Will [sendLiveLocation] with the first [EditLiveLocationInfo] data and update than. Each [liveTimeMillis] passing,
+ * the message will be sent again and new edits will be applied to the new message
+ */
+suspend fun TelegramBot.handleLiveLocation(
+    chatId: ChatIdentifier,
+    locationsFlow: Flow<EditLiveLocationInfo>,
+    liveTimeMillis: Long = defaultLivePeriodDelayMillis,
+    threadId: MessageThreadId? = chatId.threadId,
+    disableNotification: Boolean = false,
+    protectContent: Boolean = false,
+    replyToMessageId: MessageId? = null,
+    allowSendingWithoutReply: Boolean? = null,
+    sentMessageFlow: FlowCollector<ContentMessage<LocationContent>>? = null
+) {
+    var currentLiveLocationMessage: ContentMessage<LocationContent>? = null
+    val updateMessageJob = CoroutineScope(currentCoroutineContext().LinkedSupervisorJob()).launchSafelyWithoutExceptions(start = CoroutineStart.LAZY) {
+        while (isActive) {
+            delay(liveTimeMillis)
+            // Remove previous location message info to resend live location message
+            currentLiveLocationMessage = null
+        }
+    }
+    locationsFlow.collect {
+        val capturedLiveLocationMessage = currentLiveLocationMessage
+        if (capturedLiveLocationMessage == null) {
+            updateMessageJob.start()
+            currentLiveLocationMessage = send(
+                chatId,
+                it.latitude,
+                it.longitude,
+                ceil(liveTimeMillis.toDouble() / 1000).toInt(),
+                it.horizontalAccuracy,
+                it.heading,
+                it.proximityAlertRadius,
+                threadId,
+                disableNotification,
+                protectContent,
+                replyToMessageId,
+                allowSendingWithoutReply,
+                it.replyMarkup
+            ).also {
+                sentMessageFlow ?.emit(it)
+            }
+        } else {
+            edit(
+                capturedLiveLocationMessage,
+                it.latitude,
+                it.longitude,
+                it.horizontalAccuracy,
+                it.heading,
+                it.proximityAlertRadius,
+                it.replyMarkup
+            ).also {
+                sentMessageFlow ?.emit(it)
+            }
+        }
+    }
+}
+
+/**
+ * Will apply [Flow.map] to the [locationsFlow] to create [EditLiveLocationInfo] and pass the result flow to the
+ * [handleLiveLocation] with [Flow] typed by [EditLiveLocationInfo]
+ */
+@JvmName("handleLiveLocationWithLocation")
+@JsName("handleLiveLocationWithLocation")
+suspend fun TelegramBot.handleLiveLocation(
+    chatId: ChatIdentifier,
+    locationsFlow: Flow<Location>,
+    liveTimeMillis: Long = defaultLivePeriodDelayMillis,
+    threadId: MessageThreadId? = chatId.threadId,
+    disableNotification: Boolean = false,
+    protectContent: Boolean = false,
+    replyToMessageId: MessageId? = null,
+    allowSendingWithoutReply: Boolean? = null,
+    sentMessageFlow: FlowCollector<ContentMessage<LocationContent>>? = null
+) {
+    handleLiveLocation(
+        chatId,
+        locationsFlow.map {
+            EditLiveLocationInfo(
+                it.latitude,
+                it.longitude,
+                it.horizontalAccuracy,
+                (it as? LiveLocation) ?.heading,
+                (it as? LiveLocation) ?.proximityAlertRadius,
+                (it as? WithReplyMarkup) ?.replyMarkup as? InlineKeyboardMarkup
+            )
+        },
+        liveTimeMillis,
+        threadId,
+        disableNotification,
+        protectContent,
+        replyToMessageId,
+        allowSendingWithoutReply,
+        sentMessageFlow
+    )
+}
+
+/**
+ * Will apply [Flow.map] to the [locationsFlow] to create [EditLiveLocationInfo] and pass the result flow to the
+ * [handleLiveLocation] with [Flow] typed by [EditLiveLocationInfo]
+ */
+@JvmName("handleLiveLocationWithLatLong")
+@JsName("handleLiveLocationWithLatLong")
+suspend fun TelegramBot.handleLiveLocation(
+    chatId: ChatIdentifier,
+    locationsFlow: Flow<Pair<Double, Double>>,
+    liveTimeMillis: Long = defaultLivePeriodDelayMillis,
+    threadId: MessageThreadId? = chatId.threadId,
+    disableNotification: Boolean = false,
+    protectContent: Boolean = false,
+    replyToMessageId: MessageId? = null,
+    allowSendingWithoutReply: Boolean? = null,
+    sentMessageFlow: FlowCollector<ContentMessage<LocationContent>>? = null
+) {
+    handleLiveLocation(
+        chatId,
+        locationsFlow.map { (lat, long) ->
+            EditLiveLocationInfo(
+                lat,
+                long
+            )
+        },
+        liveTimeMillis,
+        threadId,
+        disableNotification,
+        protectContent,
+        replyToMessageId,
+        allowSendingWithoutReply,
+        sentMessageFlow
+    )
+}

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

@@ -1,23 +1,39 @@
 package dev.inmo.tgbotapi.extensions.api
 
-import com.soywiz.klock.DateTime
-import com.soywiz.klock.TimeSpan
+import korlibs.time.DateTime
+import korlibs.time.TimeSpan
+import dev.inmo.micro_utils.coroutines.LinkedSupervisorJob
+import dev.inmo.micro_utils.coroutines.launchSafelyWithoutExceptions
+import dev.inmo.tgbotapi.abstracts.types.WithReplyMarkup
 import dev.inmo.tgbotapi.bot.TelegramBot
+import dev.inmo.tgbotapi.extensions.api.edit.edit
 import dev.inmo.tgbotapi.extensions.api.edit.location.live.editLiveLocation
 import dev.inmo.tgbotapi.extensions.api.edit.location.live.stopLiveLocation
+import dev.inmo.tgbotapi.extensions.api.send.send
+import dev.inmo.tgbotapi.extensions.api.send.sendLiveLocation
 import dev.inmo.tgbotapi.requests.send.SendLiveLocation
 import dev.inmo.tgbotapi.types.*
 import dev.inmo.tgbotapi.types.buttons.InlineKeyboardMarkup
 import dev.inmo.tgbotapi.types.buttons.KeyboardMarkup
 import dev.inmo.tgbotapi.types.chat.Chat
 import dev.inmo.tgbotapi.types.location.LiveLocation
+import dev.inmo.tgbotapi.types.location.Location
 import dev.inmo.tgbotapi.types.location.StaticLocation
 import dev.inmo.tgbotapi.types.message.abstracts.ContentMessage
 import dev.inmo.tgbotapi.types.message.abstracts.Message
 import dev.inmo.tgbotapi.types.message.content.LocationContent
+import dev.inmo.tgbotapi.utils.extensions.threadIdOrNull
 import io.ktor.utils.io.core.Closeable
 import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.CoroutineStart
+import kotlinx.coroutines.currentCoroutineContext
+import kotlinx.coroutines.delay
+import kotlinx.coroutines.flow.Flow
+import kotlinx.coroutines.flow.map
+import kotlinx.coroutines.isActive
 import kotlinx.coroutines.launch
+import kotlin.js.JsName
+import kotlin.jvm.JvmName
 import kotlin.math.ceil
 
 val defaultLivePeriodDelayMillis = (livePeriodLimit.last - 60L) * 1000L
@@ -44,7 +60,8 @@ class LiveLocationProvider internal constructor(
         private set
         get() = field || leftUntilCloseMillis.millisecondsLong < 0L
 
-    private var message: ContentMessage<LocationContent> = initMessage
+    var message: ContentMessage<LocationContent> = initMessage
+        private set
     val lastLocation: LiveLocation
         get() = message.content.location as LiveLocation
 
@@ -90,9 +107,10 @@ suspend fun TelegramBot.startLiveLocation(
     initHorizontalAccuracy: Meters? = null,
     initHeading: Degrees? = null,
     initProximityAlertRadius: Meters? = null,
+    threadId: MessageThreadId? = chatId.threadId,
     disableNotification: Boolean = false,
     protectContent: Boolean = false,
-    replyToMessageId: MessageIdentifier? = null,
+    replyToMessageId: MessageId? = null,
     allowSendingWithoutReply: Boolean? = null,
     replyMarkup: KeyboardMarkup? = null
 ): LiveLocationProvider {
@@ -106,6 +124,7 @@ suspend fun TelegramBot.startLiveLocation(
             initHorizontalAccuracy,
             initHeading,
             initProximityAlertRadius,
+            threadId,
             disableNotification,
             protectContent,
             replyToMessageId,
@@ -135,9 +154,10 @@ suspend fun TelegramBot.startLiveLocation(
     initHorizontalAccuracy: Meters? = null,
     initHeading: Degrees? = null,
     initProximityAlertRadius: Meters? = null,
+    threadId: MessageThreadId? = chat.id.threadId,
     disableNotification: Boolean = false,
     protectContent: Boolean = false,
-    replyToMessageId: MessageIdentifier? = null,
+    replyToMessageId: MessageId? = null,
     allowSendingWithoutReply: Boolean? = null,
     replyMarkup: KeyboardMarkup? = null
 ): LiveLocationProvider = startLiveLocation(
@@ -149,6 +169,7 @@ suspend fun TelegramBot.startLiveLocation(
     initHorizontalAccuracy,
     initHeading,
     initProximityAlertRadius,
+    threadId,
     disableNotification,
     protectContent,
     replyToMessageId,
@@ -162,15 +183,16 @@ suspend fun TelegramBot.startLiveLocation(
  */
 suspend fun TelegramBot.startLiveLocation(
     scope: CoroutineScope,
-    chatId: ChatId,
+    chatId: IdChatIdentifier,
     location: StaticLocation,
     liveTimeMillis: Long = defaultLivePeriodDelayMillis,
     initHorizontalAccuracy: Meters? = null,
     initHeading: Degrees? = null,
     initProximityAlertRadius: Meters? = null,
+    threadId: MessageThreadId? = chatId.threadId,
     disableNotification: Boolean = false,
     protectContent: Boolean = false,
-    replyToMessageId: MessageIdentifier? = null,
+    replyToMessageId: MessageId? = null,
     allowSendingWithoutReply: Boolean? = null,
     replyMarkup: KeyboardMarkup? = null
 ): LiveLocationProvider = startLiveLocation(
@@ -182,6 +204,7 @@ suspend fun TelegramBot.startLiveLocation(
     initHorizontalAccuracy,
     initHeading,
     initProximityAlertRadius,
+    threadId,
     disableNotification,
     protectContent,
     replyToMessageId,
@@ -201,9 +224,10 @@ suspend fun TelegramBot.startLiveLocation(
     initHorizontalAccuracy: Meters? = null,
     initHeading: Degrees? = null,
     initProximityAlertRadius: Meters? = null,
+    threadId: MessageThreadId? = chat.id.threadId,
     disableNotification: Boolean = false,
     protectContent: Boolean = false,
-    replyToMessageId: MessageIdentifier? = null,
+    replyToMessageId: MessageId? = null,
     allowSendingWithoutReply: Boolean? = null,
     replyMarkup: KeyboardMarkup? = null
 ): LiveLocationProvider = startLiveLocation(
@@ -215,6 +239,7 @@ suspend fun TelegramBot.startLiveLocation(
     initHorizontalAccuracy,
     initHeading,
     initProximityAlertRadius,
+    threadId,
     disableNotification,
     protectContent,
     replyToMessageId,
@@ -235,6 +260,7 @@ suspend inline fun TelegramBot.replyWithLiveLocation(
     initHorizontalAccuracy: Meters? = null,
     initHeading: Degrees? = null,
     initProximityAlertRadius: Meters? = null,
+    threadId: MessageThreadId? = to.threadIdOrNull,
     disableNotification: Boolean = false,
     protectContent: Boolean = false,
     allowSendingWithoutReply: Boolean? = null,
@@ -248,6 +274,7 @@ suspend inline fun TelegramBot.replyWithLiveLocation(
     initHorizontalAccuracy,
     initHeading,
     initProximityAlertRadius,
+    threadId,
     disableNotification,
     protectContent,
     to.messageId,
@@ -267,6 +294,7 @@ suspend inline fun TelegramBot.replyWithLiveLocation(
     initHorizontalAccuracy: Meters? = null,
     initHeading: Degrees? = null,
     initProximityAlertRadius: Meters? = null,
+    threadId: MessageThreadId? = to.threadIdOrNull,
     disableNotification: Boolean = false,
     protectContent: Boolean = false,
     allowSendingWithoutReply: Boolean? = null,
@@ -279,6 +307,7 @@ suspend inline fun TelegramBot.replyWithLiveLocation(
     initHorizontalAccuracy,
     initHeading,
     initProximityAlertRadius,
+    threadId,
     disableNotification,
     protectContent,
     to.messageId,

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

@@ -13,7 +13,7 @@ import dev.inmo.tgbotapi.types.message.abstracts.Message
  */
 suspend fun TelegramBot.stopPoll(
     chatId: ChatIdentifier,
-    messageId: MessageIdentifier,
+    messageId: MessageId,
     replyMarkup: InlineKeyboardMarkup? = null
 ) = execute(
     StopPoll(chatId, messageId, replyMarkup)
@@ -25,7 +25,7 @@ suspend fun TelegramBot.stopPoll(
  */
 suspend fun TelegramBot.stopPoll(
     chat: Chat,
-    messageId: MessageIdentifier,
+    messageId: MessageId,
     replyMarkup: InlineKeyboardMarkup? = null
 ) = stopPoll(chat.id, messageId, replyMarkup)
 
@@ -34,7 +34,7 @@ suspend fun TelegramBot.stopPoll(
  * as a builder for that
  */
 suspend fun TelegramBot.stopPoll(
-    chatId: ChatId,
+    chatId: IdChatIdentifier,
     message: Message,
     replyMarkup: InlineKeyboardMarkup? = null
 ) = stopPoll(chatId, message.messageId, replyMarkup)

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

@@ -2,6 +2,7 @@ package dev.inmo.tgbotapi.extensions.api.answers
 
 import dev.inmo.tgbotapi.bot.TelegramBot
 import dev.inmo.tgbotapi.requests.answers.AnswerInlineQuery
+import dev.inmo.tgbotapi.requests.answers.InlineQueryResultsButton
 import dev.inmo.tgbotapi.types.InlineQueries.InlineQueryResult.abstracts.InlineQueryResult
 import dev.inmo.tgbotapi.types.InlineQueries.query.InlineQuery
 import dev.inmo.tgbotapi.types.InlineQueryIdentifier
@@ -12,8 +13,37 @@ suspend fun TelegramBot.answerInlineQuery(
     cachedTime: Int? = null,
     isPersonal: Boolean? = null,
     nextOffset: String? = null,
-    switchPmText: String? = null,
-    switchPmParameter: String? = null
+    button: InlineQueryResultsButton? = null
+) = execute(
+    AnswerInlineQuery(inlineQueryID, results, cachedTime, isPersonal, nextOffset, button)
+)
+
+suspend fun TelegramBot.answerInlineQuery(
+    inlineQuery: InlineQuery,
+    results: List<InlineQueryResult> = emptyList(),
+    cachedTime: Int? = null,
+    isPersonal: Boolean? = null,
+    nextOffset: String? = null,
+    button: InlineQueryResultsButton? = null
+) = answerInlineQuery(inlineQuery.id, results, cachedTime, isPersonal, nextOffset, button)
+
+suspend fun TelegramBot.answer(
+    inlineQuery: InlineQuery,
+    results: List<InlineQueryResult> = emptyList(),
+    cachedTime: Int? = null,
+    isPersonal: Boolean? = null,
+    nextOffset: String? = null,
+    button: InlineQueryResultsButton? = null
+) = answerInlineQuery(inlineQuery.id, results, cachedTime, isPersonal, nextOffset, button)
+
+suspend fun TelegramBot.answerInlineQuery(
+    inlineQueryID: InlineQueryIdentifier,
+    results: List<InlineQueryResult> = emptyList(),
+    cachedTime: Int? = null,
+    isPersonal: Boolean? = null,
+    nextOffset: String? = null,
+    switchPmText: String?,
+    switchPmParameter: String?
 ) = execute(
     AnswerInlineQuery(inlineQueryID, results, cachedTime, isPersonal, nextOffset, switchPmText, switchPmParameter)
 )
@@ -24,8 +54,8 @@ suspend fun TelegramBot.answerInlineQuery(
     cachedTime: Int? = null,
     isPersonal: Boolean? = null,
     nextOffset: String? = null,
-    switchPmText: String? = null,
-    switchPmParameter: String? = null
+    switchPmText: String?,
+    switchPmParameter: String?
 ) = answerInlineQuery(inlineQuery.id, results, cachedTime, isPersonal, nextOffset, switchPmText, switchPmParameter)
 
 suspend fun TelegramBot.answer(
@@ -34,6 +64,6 @@ suspend fun TelegramBot.answer(
     cachedTime: Int? = null,
     isPersonal: Boolean? = null,
     nextOffset: String? = null,
-    switchPmText: String? = null,
-    switchPmParameter: String? = null
+    switchPmText: String?,
+    switchPmParameter: String?
 ) = answerInlineQuery(inlineQuery.id, results, cachedTime, isPersonal, nextOffset, switchPmText, switchPmParameter)

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

@@ -1,6 +1,6 @@
 package dev.inmo.tgbotapi.extensions.api.bot
 
-import dev.inmo.micro_utils.language_codes.IetfLanguageCode
+import dev.inmo.micro_utils.language_codes.IetfLang
 import dev.inmo.tgbotapi.bot.TelegramBot
 import dev.inmo.tgbotapi.requests.bot.DeleteMyCommands
 import dev.inmo.tgbotapi.types.commands.BotCommandScope
@@ -8,10 +8,10 @@ import dev.inmo.tgbotapi.types.commands.BotCommandScopeDefault
 
 suspend fun TelegramBot.deleteMyCommands(
     scope: BotCommandScope = BotCommandScopeDefault,
-    languageCode: IetfLanguageCode?
+    languageCode: IetfLang?
 ) = execute(DeleteMyCommands(scope, languageCode))
 
 suspend fun TelegramBot.deleteMyCommands(
     scope: BotCommandScope = BotCommandScopeDefault,
     languageCode: String? = null
-) = deleteMyCommands(scope, languageCode ?.let(::IetfLanguageCode))
+) = deleteMyCommands(scope, languageCode ?.let(::IetfLang))

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

@@ -1,6 +1,6 @@
 package dev.inmo.tgbotapi.extensions.api.bot
 
-import dev.inmo.micro_utils.language_codes.IetfLanguageCode
+import dev.inmo.micro_utils.language_codes.IetfLang
 import dev.inmo.tgbotapi.bot.TelegramBot
 import dev.inmo.tgbotapi.requests.bot.GetMyCommands
 import dev.inmo.tgbotapi.types.commands.BotCommandScope
@@ -8,10 +8,10 @@ import dev.inmo.tgbotapi.types.commands.BotCommandScopeDefault
 
 suspend fun TelegramBot.getMyCommands(
     scope: BotCommandScope = BotCommandScopeDefault,
-    languageCode: IetfLanguageCode? = null
+    languageCode: IetfLang? = null
 ) = execute(GetMyCommands(scope, languageCode))
 
 suspend fun TelegramBot.getMyCommands(
     scope: BotCommandScope = BotCommandScopeDefault,
     languageCode: String?
-) = getMyCommands(scope, languageCode ?.let(::IetfLanguageCode))
+) = getMyCommands(scope, languageCode ?.let(::IetfLang))

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

@@ -0,0 +1,13 @@
+package dev.inmo.tgbotapi.extensions.api.bot
+
+import dev.inmo.micro_utils.language_codes.IetfLang
+import dev.inmo.tgbotapi.bot.TelegramBot
+import dev.inmo.tgbotapi.requests.bot.GetMyDescription
+
+suspend fun TelegramBot.getMyDescription(
+    languageCode: IetfLang? = null
+) = execute(GetMyDescription(languageCode))
+
+suspend fun TelegramBot.getMyDescription(
+    languageCode: String?
+) = getMyDescription(languageCode ?.let(::IetfLang))

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

@@ -0,0 +1,13 @@
+package dev.inmo.tgbotapi.extensions.api.bot
+
+import dev.inmo.micro_utils.language_codes.IetfLang
+import dev.inmo.tgbotapi.bot.TelegramBot
+import dev.inmo.tgbotapi.requests.bot.GetMyName
+
+suspend fun TelegramBot.getMyName(
+    languageCode: IetfLang? = null
+) = execute(GetMyName(languageCode))
+
+suspend fun TelegramBot.getMyName(
+    languageCode: String?
+) = getMyName(languageCode ?.let(::IetfLang))

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

@@ -0,0 +1,16 @@
+package dev.inmo.tgbotapi.extensions.api.bot
+
+import dev.inmo.micro_utils.language_codes.IetfLang
+import dev.inmo.tgbotapi.bot.TelegramBot
+import dev.inmo.tgbotapi.requests.bot.GetMyCommands
+import dev.inmo.tgbotapi.requests.bot.GetMyShortDescription
+import dev.inmo.tgbotapi.types.commands.BotCommandScope
+import dev.inmo.tgbotapi.types.commands.BotCommandScopeDefault
+
+suspend fun TelegramBot.getMyShortDescription(
+    languageCode: IetfLang? = null
+) = execute(GetMyShortDescription(languageCode))
+
+suspend fun TelegramBot.getMyShortDescription(
+    languageCode: String?
+) = getMyShortDescription(languageCode ?.let(::IetfLang))

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

@@ -1,6 +1,6 @@
 package dev.inmo.tgbotapi.extensions.api.bot
 
-import dev.inmo.micro_utils.language_codes.IetfLanguageCode
+import dev.inmo.micro_utils.language_codes.IetfLang
 import dev.inmo.tgbotapi.bot.TelegramBot
 import dev.inmo.tgbotapi.requests.bot.SetMyCommands
 import dev.inmo.tgbotapi.types.BotCommand
@@ -10,20 +10,20 @@ import dev.inmo.tgbotapi.types.commands.BotCommandScopeDefault
 suspend fun TelegramBot.setMyCommands(
     commands: List<BotCommand>,
     scope: BotCommandScope = BotCommandScopeDefault,
-    languageCode: IetfLanguageCode?
+    languageCode: IetfLang?
 ) = execute(SetMyCommands(commands, scope, languageCode))
 
 suspend fun TelegramBot.setMyCommands(
     vararg commands: BotCommand,
     scope: BotCommandScope = BotCommandScopeDefault,
-    languageCode: IetfLanguageCode?
+    languageCode: IetfLang?
 ) = setMyCommands(commands.toList(), scope, languageCode)
 
 suspend fun TelegramBot.setMyCommands(
     commands: List<BotCommand>,
     scope: BotCommandScope = BotCommandScopeDefault,
     languageCode: String? = null
-) = setMyCommands(commands, scope, languageCode ?.let(::IetfLanguageCode))
+) = setMyCommands(commands, scope, languageCode ?.let(::IetfLang))
 
 suspend fun TelegramBot.setMyCommands(
     vararg commands: BotCommand,

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

@@ -2,17 +2,17 @@ package dev.inmo.tgbotapi.extensions.api.bot
 
 import dev.inmo.tgbotapi.bot.TelegramBot
 import dev.inmo.tgbotapi.requests.bot.SetMyDefaultAdministratorRights
-import dev.inmo.tgbotapi.types.chat.member.ChatAdministratorRightsImpl
+import dev.inmo.tgbotapi.types.chat.member.ChatCommonAdministratorRights
 
 suspend fun TelegramBot.setMyDefaultAdministratorRights(
-    rights: ChatAdministratorRightsImpl,
+    rights: ChatCommonAdministratorRights,
     forChannels: Boolean? = null
 ) = execute(SetMyDefaultAdministratorRights(rights, forChannels))
 
 suspend fun TelegramBot.setMyDefaultAdministratorRightsForChannels(
-    rights: ChatAdministratorRightsImpl
+    rights: ChatCommonAdministratorRights
 ) = setMyDefaultAdministratorRights(rights, forChannels = true)
 
 suspend fun TelegramBot.setMyDefaultAdministratorRightsForGroupsAndSupergroups(
-    rights: ChatAdministratorRightsImpl
+    rights: ChatCommonAdministratorRights
 ) = setMyDefaultAdministratorRights(rights, forChannels = false)

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

@@ -0,0 +1,19 @@
+package dev.inmo.tgbotapi.extensions.api.bot
+
+import dev.inmo.micro_utils.language_codes.IetfLang
+import dev.inmo.tgbotapi.bot.TelegramBot
+import dev.inmo.tgbotapi.requests.bot.GetMyCommands
+import dev.inmo.tgbotapi.requests.bot.GetMyDescription
+import dev.inmo.tgbotapi.requests.bot.SetMyDescription
+import dev.inmo.tgbotapi.types.commands.BotCommandScope
+import dev.inmo.tgbotapi.types.commands.BotCommandScopeDefault
+
+suspend fun TelegramBot.setMyDescription(
+    description: String? = null,
+    languageCode: IetfLang? = null
+) = execute(SetMyDescription(description, languageCode))
+
+suspend fun TelegramBot.setMyDescription(
+    description: String?,
+    languageCode: String?
+) = setMyDescription(description, languageCode ?.let(::IetfLang))

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

@@ -0,0 +1,19 @@
+package dev.inmo.tgbotapi.extensions.api.bot
+
+import dev.inmo.micro_utils.language_codes.IetfLang
+import dev.inmo.tgbotapi.bot.TelegramBot
+import dev.inmo.tgbotapi.requests.bot.GetMyCommands
+import dev.inmo.tgbotapi.requests.bot.GetMyName
+import dev.inmo.tgbotapi.requests.bot.SetMyName
+import dev.inmo.tgbotapi.types.commands.BotCommandScope
+import dev.inmo.tgbotapi.types.commands.BotCommandScopeDefault
+
+suspend fun TelegramBot.setMyName(
+    name: String? = null,
+    languageCode: IetfLang? = null
+) = execute(SetMyName(name, languageCode))
+
+suspend fun TelegramBot.setMyName(
+    name: String?,
+    languageCode: String?
+) = setMyName(name, languageCode ?.let(::IetfLang))

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

@@ -0,0 +1,15 @@
+package dev.inmo.tgbotapi.extensions.api.bot
+
+import dev.inmo.micro_utils.language_codes.IetfLang
+import dev.inmo.tgbotapi.bot.TelegramBot
+import dev.inmo.tgbotapi.requests.bot.SetMyShortDescription
+
+suspend fun TelegramBot.setMyShortDescription(
+    shortDescription: String? = null,
+    languageCode: IetfLang? = null
+) = execute(SetMyShortDescription(shortDescription, languageCode))
+
+suspend fun TelegramBot.setMyShortDescription(
+    shortDescription: String?,
+    languageCode: String?
+) = setMyShortDescription(shortDescription, languageCode ?.let(::IetfLang))

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

@@ -0,0 +1,28 @@
+package dev.inmo.tgbotapi.extensions.api.chat.forum
+
+import dev.inmo.tgbotapi.bot.TelegramBot
+import dev.inmo.tgbotapi.requests.chat.forum.CloseForumTopic
+import dev.inmo.tgbotapi.types.ChatIdentifier
+import dev.inmo.tgbotapi.types.ForumTopic
+import dev.inmo.tgbotapi.types.MessageThreadId
+import dev.inmo.tgbotapi.types.chat.Chat
+
+suspend fun TelegramBot.closeForumTopic(
+    chatId: ChatIdentifier,
+    messageThreadId: MessageThreadId
+) = execute(
+    CloseForumTopic(
+        chatId,
+        messageThreadId
+    )
+)
+
+suspend fun TelegramBot.closeForumTopic(
+    chat: Chat,
+    messageThreadId: MessageThreadId
+) = closeForumTopic(chat.id, messageThreadId)
+
+suspend fun TelegramBot.closeForumTopic(
+    chat: Chat,
+    forumTopic: ForumTopic
+) = closeForumTopic(chat.id, forumTopic.messageThreadId)

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

@@ -0,0 +1,19 @@
+package dev.inmo.tgbotapi.extensions.api.chat.forum
+
+import dev.inmo.tgbotapi.bot.TelegramBot
+import dev.inmo.tgbotapi.requests.chat.forum.CloseForumTopic
+import dev.inmo.tgbotapi.requests.chat.forum.CloseGeneralForumTopic
+import dev.inmo.tgbotapi.types.ChatIdentifier
+import dev.inmo.tgbotapi.types.ForumTopic
+import dev.inmo.tgbotapi.types.MessageThreadId
+import dev.inmo.tgbotapi.types.chat.Chat
+
+suspend fun TelegramBot.closeGeneralForumTopic(
+    chatId: ChatIdentifier
+) = execute(
+    CloseGeneralForumTopic(chatId)
+)
+
+suspend fun TelegramBot.closeGeneralForumTopic(
+    chat: Chat
+) = closeGeneralForumTopic(chat.id)

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

@@ -0,0 +1,29 @@
+package dev.inmo.tgbotapi.extensions.api.chat.forum
+
+import dev.inmo.tgbotapi.bot.TelegramBot
+import dev.inmo.tgbotapi.requests.chat.forum.CreateForumTopic
+import dev.inmo.tgbotapi.types.ChatIdentifier
+import dev.inmo.tgbotapi.types.CustomEmojiId
+import dev.inmo.tgbotapi.types.chat.Chat
+import dev.inmo.tgbotapi.utils.RGBColor
+
+suspend fun TelegramBot.createForumTopic(
+    chatId: ChatIdentifier,
+    name: String,
+    color: RGBColor,
+    iconEmojiId: CustomEmojiId? = null
+) = execute(
+    CreateForumTopic(
+        chatId,
+        name,
+        color,
+        iconEmojiId
+    )
+)
+
+suspend fun TelegramBot.createForumTopic(
+    chat: Chat,
+    name: String,
+    color: RGBColor,
+    iconEmojiId: CustomEmojiId? = null
+) = createForumTopic(chat.id, name, color, iconEmojiId)

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

@@ -0,0 +1,33 @@
+package dev.inmo.tgbotapi.extensions.api.chat.forum
+
+import dev.inmo.tgbotapi.bot.TelegramBot
+import dev.inmo.tgbotapi.requests.chat.forum.DeleteForumTopic
+import dev.inmo.tgbotapi.types.ChatIdentifier
+import dev.inmo.tgbotapi.types.ForumTopic
+import dev.inmo.tgbotapi.types.MessageThreadId
+import dev.inmo.tgbotapi.types.chat.Chat
+
+suspend fun TelegramBot.deleteForumTopic(
+    chatId: ChatIdentifier,
+    messageThreadId: MessageThreadId
+) = execute(
+    DeleteForumTopic(
+        chatId,
+        messageThreadId
+    )
+)
+
+suspend fun TelegramBot.deleteForumTopic(
+    chatId: ChatIdentifier,
+    forumTopic: ForumTopic
+) = deleteForumTopic(chatId, forumTopic.messageThreadId)
+
+suspend fun TelegramBot.deleteForumTopic(
+    chat: Chat,
+    messageThreadId: MessageThreadId
+) = deleteForumTopic(chat.id, messageThreadId)
+
+suspend fun TelegramBot.deleteForumTopic(
+    chat: Chat,
+    forumTopic: ForumTopic
+) = deleteForumTopic(chat.id, forumTopic.messageThreadId)

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

@@ -0,0 +1,36 @@
+package dev.inmo.tgbotapi.extensions.api.chat.forum
+
+import dev.inmo.tgbotapi.bot.TelegramBot
+import dev.inmo.tgbotapi.requests.chat.forum.EditForumTopic
+import dev.inmo.tgbotapi.types.ChatIdentifier
+import dev.inmo.tgbotapi.types.CustomEmojiId
+import dev.inmo.tgbotapi.types.ForumTopic
+import dev.inmo.tgbotapi.types.MessageThreadId
+import dev.inmo.tgbotapi.types.chat.Chat
+
+suspend fun TelegramBot.editForumTopic(
+    chatId: ChatIdentifier,
+    messageThreadId: MessageThreadId,
+    name: String? = null,
+    iconEmojiId: CustomEmojiId? = null
+) = execute(
+    EditForumTopic(
+        chatId,
+        messageThreadId,
+        name,
+        iconEmojiId
+    )
+)
+
+suspend fun TelegramBot.editForumTopic(
+    chat: Chat,
+    messageThreadId: MessageThreadId,
+    name: String? = null,
+    iconEmojiId: CustomEmojiId? = null
+) = editForumTopic(chat.id, messageThreadId, name, iconEmojiId)
+
+suspend fun TelegramBot.editForumTopic(
+    chatIdentifier: ChatIdentifier,
+    forumTopic: ForumTopic,
+    iconEmojiId: CustomEmojiId? = forumTopic.iconEmojiId
+) = editForumTopic(chatIdentifier, forumTopic.messageThreadId, forumTopic.name, iconEmojiId)

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

@@ -0,0 +1,30 @@
+package dev.inmo.tgbotapi.extensions.api.chat.forum
+
+import dev.inmo.tgbotapi.bot.TelegramBot
+import dev.inmo.tgbotapi.requests.chat.forum.EditForumTopic
+import dev.inmo.tgbotapi.requests.chat.forum.EditGeneralForumTopic
+import dev.inmo.tgbotapi.types.ChatIdentifier
+import dev.inmo.tgbotapi.types.CustomEmojiId
+import dev.inmo.tgbotapi.types.ForumTopic
+import dev.inmo.tgbotapi.types.MessageThreadId
+import dev.inmo.tgbotapi.types.chat.Chat
+
+suspend fun TelegramBot.editGeneralForumTopic(
+    chatId: ChatIdentifier,
+    name: String
+) = execute(
+    EditGeneralForumTopic(
+        chatId,
+        name
+    )
+)
+
+suspend fun TelegramBot.editGeneralForumTopic(
+    chat: Chat,
+    name: String
+) = editGeneralForumTopic(chat.id, name)
+
+suspend fun TelegramBot.editGeneralForumTopic(
+    chatIdentifier: ChatIdentifier,
+    forumTopic: ForumTopic,
+) = editGeneralForumTopic(chatIdentifier, forumTopic.name)

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

@@ -0,0 +1,20 @@
+package dev.inmo.tgbotapi.extensions.api.chat.forum
+
+import dev.inmo.tgbotapi.bot.TelegramBot
+import dev.inmo.tgbotapi.requests.chat.forum.CloseForumTopic
+import dev.inmo.tgbotapi.requests.chat.forum.CloseGeneralForumTopic
+import dev.inmo.tgbotapi.requests.chat.forum.HideGeneralForumTopic
+import dev.inmo.tgbotapi.types.ChatIdentifier
+import dev.inmo.tgbotapi.types.ForumTopic
+import dev.inmo.tgbotapi.types.MessageThreadId
+import dev.inmo.tgbotapi.types.chat.Chat
+
+suspend fun TelegramBot.hideGeneralForumTopic(
+    chatId: ChatIdentifier
+) = execute(
+    HideGeneralForumTopic(chatId)
+)
+
+suspend fun TelegramBot.hideGeneralForumTopic(
+    chat: Chat
+) = hideGeneralForumTopic(chat.id)

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

@@ -0,0 +1,28 @@
+package dev.inmo.tgbotapi.extensions.api.chat.forum
+
+import dev.inmo.tgbotapi.bot.TelegramBot
+import dev.inmo.tgbotapi.requests.chat.forum.ReopenForumTopic
+import dev.inmo.tgbotapi.types.ChatIdentifier
+import dev.inmo.tgbotapi.types.ForumTopic
+import dev.inmo.tgbotapi.types.MessageThreadId
+import dev.inmo.tgbotapi.types.chat.Chat
+
+suspend fun TelegramBot.reopenForumTopic(
+    chatId: ChatIdentifier,
+    messageThreadId: MessageThreadId
+) = execute(
+    ReopenForumTopic(
+        chatId,
+        messageThreadId
+    )
+)
+
+suspend fun TelegramBot.reopenForumTopic(
+    chat: Chat,
+    messageThreadId: MessageThreadId
+) = reopenForumTopic(chat.id, messageThreadId)
+
+suspend fun TelegramBot.reopenForumTopic(
+    chat: Chat,
+    forumTopic: ForumTopic
+) = reopenForumTopic(chat.id, forumTopic.messageThreadId)

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

@@ -0,0 +1,19 @@
+package dev.inmo.tgbotapi.extensions.api.chat.forum
+
+import dev.inmo.tgbotapi.bot.TelegramBot
+import dev.inmo.tgbotapi.requests.chat.forum.ReopenForumTopic
+import dev.inmo.tgbotapi.requests.chat.forum.ReopenGeneralForumTopic
+import dev.inmo.tgbotapi.types.ChatIdentifier
+import dev.inmo.tgbotapi.types.ForumTopic
+import dev.inmo.tgbotapi.types.MessageThreadId
+import dev.inmo.tgbotapi.types.chat.Chat
+
+suspend fun TelegramBot.reopenGeneralForumTopic(
+    chatId: ChatIdentifier
+) = execute(
+    ReopenGeneralForumTopic(chatId)
+)
+
+suspend fun TelegramBot.reopenGeneralForumTopic(
+    chat: Chat
+) = reopenGeneralForumTopic(chat.id)

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

@@ -0,0 +1,21 @@
+package dev.inmo.tgbotapi.extensions.api.chat.forum
+
+import dev.inmo.tgbotapi.bot.TelegramBot
+import dev.inmo.tgbotapi.requests.chat.forum.CloseForumTopic
+import dev.inmo.tgbotapi.requests.chat.forum.CloseGeneralForumTopic
+import dev.inmo.tgbotapi.requests.chat.forum.HideGeneralForumTopic
+import dev.inmo.tgbotapi.requests.chat.forum.UnhideGeneralForumTopic
+import dev.inmo.tgbotapi.types.ChatIdentifier
+import dev.inmo.tgbotapi.types.ForumTopic
+import dev.inmo.tgbotapi.types.MessageThreadId
+import dev.inmo.tgbotapi.types.chat.Chat
+
+suspend fun TelegramBot.unhideGeneralForumTopic(
+    chatId: ChatIdentifier
+) = execute(
+    UnhideGeneralForumTopic(chatId)
+)
+
+suspend fun TelegramBot.unhideGeneralForumTopic(
+    chat: Chat
+) = unhideGeneralForumTopic(chat.id)

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

@@ -0,0 +1,28 @@
+package dev.inmo.tgbotapi.extensions.api.chat.forum
+
+import dev.inmo.tgbotapi.bot.TelegramBot
+import dev.inmo.tgbotapi.requests.chat.forum.UnpinAllForumTopicMessages
+import dev.inmo.tgbotapi.types.ChatIdentifier
+import dev.inmo.tgbotapi.types.ForumTopic
+import dev.inmo.tgbotapi.types.MessageThreadId
+import dev.inmo.tgbotapi.types.chat.Chat
+
+suspend fun TelegramBot.unpinAllForumTopicMessages(
+    chatId: ChatIdentifier,
+    messageThreadId: MessageThreadId
+) = execute(
+    UnpinAllForumTopicMessages(
+        chatId,
+        messageThreadId
+    )
+)
+
+suspend fun TelegramBot.unpinAllForumTopicMessages(
+    chat: Chat,
+    messageThreadId: MessageThreadId
+) = unpinAllForumTopicMessages(chat.id, messageThreadId)
+
+suspend fun TelegramBot.unpinAllForumTopicMessages(
+    chat: Chat,
+    forumTopic: ForumTopic
+) = unpinAllForumTopicMessages(chat.id, forumTopic.messageThreadId)

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

@@ -0,0 +1,21 @@
+package dev.inmo.tgbotapi.extensions.api.chat.forum
+
+import dev.inmo.tgbotapi.bot.TelegramBot
+import dev.inmo.tgbotapi.requests.chat.forum.UnpinAllForumTopicMessages
+import dev.inmo.tgbotapi.requests.chat.forum.UnpinAllGeneralForumTopicMessages
+import dev.inmo.tgbotapi.types.ChatIdentifier
+import dev.inmo.tgbotapi.types.ForumTopic
+import dev.inmo.tgbotapi.types.MessageThreadId
+import dev.inmo.tgbotapi.types.chat.Chat
+
+suspend fun TelegramBot.unpinAllGeneralForumTopicMessages(
+    chatId: ChatIdentifier
+) = execute(
+    UnpinAllGeneralForumTopicMessages(
+        chatId
+    )
+)
+
+suspend fun TelegramBot.unpinAllGeneralForumTopicMessages(
+    chat: Chat
+) = unpinAllGeneralForumTopicMessages(chat.id)

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

@@ -3,7 +3,27 @@ package dev.inmo.tgbotapi.extensions.api.chat.get
 import dev.inmo.tgbotapi.bot.TelegramBot
 import dev.inmo.tgbotapi.requests.chat.get.GetChat
 import dev.inmo.tgbotapi.types.ChatIdentifier
-import dev.inmo.tgbotapi.types.chat.*
+import dev.inmo.tgbotapi.types.chat.ChannelChat
+import dev.inmo.tgbotapi.types.chat.ChannelChatImpl
+import dev.inmo.tgbotapi.types.chat.Chat
+import dev.inmo.tgbotapi.types.chat.CommonUser
+import dev.inmo.tgbotapi.types.chat.ExtendedChannelChat
+import dev.inmo.tgbotapi.types.chat.ExtendedChannelChatImpl
+import dev.inmo.tgbotapi.types.chat.ExtendedGroupChat
+import dev.inmo.tgbotapi.types.chat.ExtendedGroupChatImpl
+import dev.inmo.tgbotapi.types.chat.ExtendedPrivateChat
+import dev.inmo.tgbotapi.types.chat.ExtendedPrivateChatImpl
+import dev.inmo.tgbotapi.types.chat.ExtendedPublicChat
+import dev.inmo.tgbotapi.types.chat.ExtendedSupergroupChat
+import dev.inmo.tgbotapi.types.chat.ExtendedSupergroupChatImpl
+import dev.inmo.tgbotapi.types.chat.ExtendedUser
+import dev.inmo.tgbotapi.types.chat.GroupChat
+import dev.inmo.tgbotapi.types.chat.GroupChatImpl
+import dev.inmo.tgbotapi.types.chat.PrivateChat
+import dev.inmo.tgbotapi.types.chat.PrivateChatImpl
+import dev.inmo.tgbotapi.types.chat.PublicChat
+import dev.inmo.tgbotapi.types.chat.SupergroupChat
+import dev.inmo.tgbotapi.types.chat.SupergroupChatImpl
 import dev.inmo.tgbotapi.utils.PreviewFeature
 
 suspend fun TelegramBot.getChat(

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

@@ -2,11 +2,11 @@ package dev.inmo.tgbotapi.extensions.api.chat.get
 
 import dev.inmo.tgbotapi.bot.TelegramBot
 import dev.inmo.tgbotapi.requests.chat.get.GetChatMenuButton
-import dev.inmo.tgbotapi.types.*
+import dev.inmo.tgbotapi.types.IdChatIdentifier
 import dev.inmo.tgbotapi.types.chat.PrivateChat
 
 suspend fun TelegramBot.getChatMenuButton(
-    chatId: ChatId
+    chatId: IdChatIdentifier
 ) = execute(GetChatMenuButton(chatId))
 
 suspend fun TelegramBot.getChatMenuButton(

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

@@ -2,7 +2,5 @@ package dev.inmo.tgbotapi.extensions.api.chat.get
 
 import dev.inmo.tgbotapi.bot.TelegramBot
 import dev.inmo.tgbotapi.requests.chat.get.GetDefaultChatMenuButton
-import dev.inmo.tgbotapi.requests.chat.modify.SetDefaultChatMenuButton
-import dev.inmo.tgbotapi.types.MenuButton
 
 suspend fun TelegramBot.getDefaultChatMenuButton() = execute(GetDefaultChatMenuButton)

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

@@ -0,0 +1,6 @@
+package dev.inmo.tgbotapi.extensions.api.chat.get
+
+import dev.inmo.tgbotapi.bot.TelegramBot
+import dev.inmo.tgbotapi.requests.chat.get.GetForumTopicIconStickers
+
+suspend fun TelegramBot.getForumTopicIconStickers() = execute(GetForumTopicIconStickers)

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

@@ -2,8 +2,10 @@ package dev.inmo.tgbotapi.extensions.api.chat.invite_links
 
 import dev.inmo.tgbotapi.bot.TelegramBot
 import dev.inmo.tgbotapi.requests.chat.invite_links.ApproveChatJoinRequest
-import dev.inmo.tgbotapi.types.*
-import dev.inmo.tgbotapi.types.chat.*
+import dev.inmo.tgbotapi.types.ChatIdentifier
+import dev.inmo.tgbotapi.types.UserId
+import dev.inmo.tgbotapi.types.chat.ChatJoinRequest
+import dev.inmo.tgbotapi.types.chat.PublicChat
 import dev.inmo.tgbotapi.types.chat.User
 import dev.inmo.tgbotapi.types.update.ChatJoinRequestUpdate
 

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

@@ -1,10 +1,13 @@
 package dev.inmo.tgbotapi.extensions.api.chat.invite_links
 
-import com.soywiz.klock.DateTime
+import korlibs.time.DateTime
 import dev.inmo.tgbotapi.bot.TelegramBot
 import dev.inmo.tgbotapi.requests.chat.invite_links.CreateChatInviteLink
-import dev.inmo.tgbotapi.types.*
+import dev.inmo.tgbotapi.types.ChatIdentifier
+import dev.inmo.tgbotapi.types.MembersLimit
+import dev.inmo.tgbotapi.types.TelegramDate
 import dev.inmo.tgbotapi.types.chat.PublicChat
+import dev.inmo.tgbotapi.types.toTelegramDate
 
 suspend fun TelegramBot.createChatInviteLinkUnlimited(
     chatId: ChatIdentifier,

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

@@ -2,8 +2,10 @@ package dev.inmo.tgbotapi.extensions.api.chat.invite_links
 
 import dev.inmo.tgbotapi.bot.TelegramBot
 import dev.inmo.tgbotapi.requests.chat.invite_links.DeclineChatJoinRequest
-import dev.inmo.tgbotapi.types.*
-import dev.inmo.tgbotapi.types.chat.*
+import dev.inmo.tgbotapi.types.ChatIdentifier
+import dev.inmo.tgbotapi.types.UserId
+import dev.inmo.tgbotapi.types.chat.ChatJoinRequest
+import dev.inmo.tgbotapi.types.chat.PublicChat
 import dev.inmo.tgbotapi.types.chat.User
 import dev.inmo.tgbotapi.types.update.ChatJoinRequestUpdate
 

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

@@ -1,10 +1,14 @@
 package dev.inmo.tgbotapi.extensions.api.chat.invite_links
 
-import com.soywiz.klock.DateTime
+import korlibs.time.DateTime
 import dev.inmo.tgbotapi.bot.TelegramBot
 import dev.inmo.tgbotapi.requests.chat.invite_links.EditChatInviteLink
-import dev.inmo.tgbotapi.types.*
+import dev.inmo.tgbotapi.types.ChatIdentifier
+import dev.inmo.tgbotapi.types.ChatInviteLink
+import dev.inmo.tgbotapi.types.MembersLimit
+import dev.inmo.tgbotapi.types.TelegramDate
 import dev.inmo.tgbotapi.types.chat.PublicChat
+import dev.inmo.tgbotapi.types.toTelegramDate
 
 suspend fun TelegramBot.editChatInviteLinkUnlimited(
     chatId: ChatIdentifier,

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

@@ -2,7 +2,10 @@ package dev.inmo.tgbotapi.extensions.api.chat.members
 
 import dev.inmo.tgbotapi.bot.TelegramBot
 import dev.inmo.tgbotapi.requests.chat.members.BanChatMember
-import dev.inmo.tgbotapi.types.*
+import dev.inmo.tgbotapi.types.IdChatIdentifier
+import dev.inmo.tgbotapi.types.ChatIdentifier
+import dev.inmo.tgbotapi.types.TelegramDate
+import dev.inmo.tgbotapi.types.UserId
 import dev.inmo.tgbotapi.types.chat.PublicChat
 import dev.inmo.tgbotapi.types.chat.User
 
@@ -21,7 +24,7 @@ suspend fun TelegramBot.banChatMember(
 ) = banChatMember(chat.id, userId, untilDate, revokeMessages)
 
 suspend fun TelegramBot.banChatMember(
-    chatId: ChatId,
+    chatId: IdChatIdentifier,
     user: User,
     untilDate: TelegramDate? = null,
     revokeMessages: Boolean? = null

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

@@ -2,21 +2,22 @@ package dev.inmo.tgbotapi.extensions.api.chat.members
 
 import dev.inmo.tgbotapi.bot.TelegramBot
 import dev.inmo.tgbotapi.requests.chat.members.BanChatSenderChat
-import dev.inmo.tgbotapi.types.*
+import dev.inmo.tgbotapi.types.IdChatIdentifier
+import dev.inmo.tgbotapi.types.ChatIdentifier
 import dev.inmo.tgbotapi.types.chat.PublicChat
 
 suspend fun TelegramBot.banChatSenderChat(
     chatId: ChatIdentifier,
-    senderChatId: ChatId
+    senderChatId: IdChatIdentifier
 ) = execute(BanChatSenderChat(chatId, senderChatId))
 
 suspend fun TelegramBot.banChatSenderChat(
     chat: PublicChat,
-    senderChatId: ChatId
+    senderChatId: IdChatIdentifier
 ) = banChatSenderChat(chat.id, senderChatId)
 
 suspend fun TelegramBot.banChatSenderChat(
-    chatId: ChatId,
+    chatId: IdChatIdentifier,
     senderChat: PublicChat
 ) = banChatSenderChat(chatId, senderChat.id)
 

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

@@ -2,7 +2,9 @@ package dev.inmo.tgbotapi.extensions.api.chat.members
 
 import dev.inmo.tgbotapi.bot.TelegramBot
 import dev.inmo.tgbotapi.requests.chat.members.GetChatMember
-import dev.inmo.tgbotapi.types.*
+import dev.inmo.tgbotapi.types.IdChatIdentifier
+import dev.inmo.tgbotapi.types.ChatIdentifier
+import dev.inmo.tgbotapi.types.UserId
 import dev.inmo.tgbotapi.types.chat.PublicChat
 import dev.inmo.tgbotapi.types.chat.User
 
@@ -17,7 +19,7 @@ suspend fun TelegramBot.getChatMember(
 ) = getChatMember(chat.id, userId)
 
 suspend fun TelegramBot.getChatMember(
-    chatId: ChatId,
+    chatId: IdChatIdentifier,
     user: User
 ) = getChatMember(chatId, user.id)
 

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

@@ -0,0 +1,157 @@
+package dev.inmo.tgbotapi.extensions.api.chat.members
+
+import dev.inmo.tgbotapi.bot.TelegramBot
+import dev.inmo.tgbotapi.requests.chat.members.PromoteChannelAdministrator
+import dev.inmo.tgbotapi.requests.chat.members.PromoteChatMember
+import dev.inmo.tgbotapi.types.IdChatIdentifier
+import dev.inmo.tgbotapi.types.ChatIdentifier
+import dev.inmo.tgbotapi.types.TelegramDate
+import dev.inmo.tgbotapi.types.UserId
+import dev.inmo.tgbotapi.types.chat.PublicChat
+import dev.inmo.tgbotapi.types.chat.User
+
+suspend fun TelegramBot.promoteChannelAdministrator(
+    chatId: ChatIdentifier,
+    userId: UserId,
+    untilDate: TelegramDate? = null,
+    isAnonymous: Boolean? = null,
+    canChangeInfo: Boolean? = null,
+    canPostMessages: Boolean? = null,
+    canEditMessages: Boolean? = null,
+    canDeleteMessages: Boolean? = null,
+    canInviteUsers: Boolean? = null,
+    canRestrictMembers: Boolean? = null,
+    canPromoteMembers: Boolean? = null,
+    canManageVideoChats: Boolean? = null,
+    canManageChat: Boolean? = null,
+    canPostStories: Boolean? = null,
+    canEditStories: Boolean? = null,
+    canDeleteStories: Boolean? = null
+) = execute(
+    PromoteChannelAdministrator(
+        chatId = chatId,
+        userId = userId,
+        untilDate = untilDate,
+        isAnonymous = isAnonymous,
+        canChangeInfo = canChangeInfo,
+        canPostMessages = canPostMessages,
+        canEditMessages = canEditMessages,
+        canDeleteMessages = canDeleteMessages,
+        canInviteUsers = canInviteUsers,
+        canRestrictMembers = canRestrictMembers,
+        canPromoteMembers = canPromoteMembers,
+        canManageVideoChats = canManageVideoChats,
+        canManageChat = canManageChat,
+        canPostStories = canPostStories,
+        canEditStories = canEditStories,
+        canDeleteStories = canDeleteStories
+    )
+)
+
+suspend fun TelegramBot.promoteChannelAdministrator(
+    chat: PublicChat,
+    userId: UserId,
+    untilDate: TelegramDate? = null,
+    isAnonymous: Boolean? = null,
+    canChangeInfo: Boolean? = null,
+    canPostMessages: Boolean? = null,
+    canEditMessages: Boolean? = null,
+    canDeleteMessages: Boolean? = null,
+    canInviteUsers: Boolean? = null,
+    canRestrictMembers: Boolean? = null,
+    canPromoteMembers: Boolean? = null,
+    canManageVideoChats: Boolean? = null,
+    canManageChat: Boolean? = null,
+    canPostStories: Boolean? = null,
+    canEditStories: Boolean? = null,
+    canDeleteStories: Boolean? = null
+) = promoteChannelAdministrator(
+    chat.id,
+    userId,
+    untilDate = untilDate,
+    isAnonymous = isAnonymous,
+    canChangeInfo = canChangeInfo,
+    canPostMessages = canPostMessages,
+    canEditMessages = canEditMessages,
+    canDeleteMessages = canDeleteMessages,
+    canInviteUsers = canInviteUsers,
+    canRestrictMembers = canRestrictMembers,
+    canPromoteMembers = canPromoteMembers,
+    canManageVideoChats = canManageVideoChats,
+    canManageChat = canManageChat,
+    canPostStories = canPostStories,
+    canEditStories = canEditStories,
+    canDeleteStories = canDeleteStories
+)
+
+suspend fun TelegramBot.promoteChannelAdministrator(
+    chatId: IdChatIdentifier,
+    user: User,
+    untilDate: TelegramDate? = null,
+    isAnonymous: Boolean? = null,
+    canChangeInfo: Boolean? = null,
+    canPostMessages: Boolean? = null,
+    canEditMessages: Boolean? = null,
+    canDeleteMessages: Boolean? = null,
+    canInviteUsers: Boolean? = null,
+    canRestrictMembers: Boolean? = null,
+    canPromoteMembers: Boolean? = null,
+    canManageVideoChats: Boolean? = null,
+    canManageChat: Boolean? = null,
+    canPostStories: Boolean? = null,
+    canEditStories: Boolean? = null,
+    canDeleteStories: Boolean? = null
+) = promoteChannelAdministrator(
+    chatId,
+    user.id,
+    untilDate = untilDate,
+    isAnonymous = isAnonymous,
+    canChangeInfo = canChangeInfo,
+    canPostMessages = canPostMessages,
+    canEditMessages = canEditMessages,
+    canDeleteMessages = canDeleteMessages,
+    canInviteUsers = canInviteUsers,
+    canRestrictMembers = canRestrictMembers,
+    canPromoteMembers = canPromoteMembers,
+    canManageVideoChats = canManageVideoChats,
+    canManageChat = canManageChat,
+    canPostStories = canPostStories,
+    canEditStories = canEditStories,
+    canDeleteStories = canDeleteStories
+)
+
+suspend fun TelegramBot.promoteChannelAdministrator(
+    chat: PublicChat,
+    user: User,
+    untilDate: TelegramDate? = null,
+    isAnonymous: Boolean? = null,
+    canChangeInfo: Boolean? = null,
+    canPostMessages: Boolean? = null,
+    canEditMessages: Boolean? = null,
+    canDeleteMessages: Boolean? = null,
+    canInviteUsers: Boolean? = null,
+    canRestrictMembers: Boolean? = null,
+    canPromoteMembers: Boolean? = null,
+    canManageVideoChats: Boolean? = null,
+    canManageChat: Boolean? = null,
+    canPostStories: Boolean? = null,
+    canEditStories: Boolean? = null,
+    canDeleteStories: Boolean? = null
+) = promoteChannelAdministrator(
+    chat.id,
+    user.id,
+    untilDate = untilDate,
+    isAnonymous = isAnonymous,
+    canChangeInfo = canChangeInfo,
+    canPostMessages = canPostMessages,
+    canEditMessages = canEditMessages,
+    canDeleteMessages = canDeleteMessages,
+    canInviteUsers = canInviteUsers,
+    canRestrictMembers = canRestrictMembers,
+    canPromoteMembers = canPromoteMembers,
+    canManageVideoChats = canManageVideoChats,
+    canManageChat = canManageChat,
+    canPostStories = canPostStories,
+    canEditStories = canEditStories,
+    canDeleteStories = canDeleteStories
+)

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

@@ -0,0 +1,116 @@
+package dev.inmo.tgbotapi.extensions.api.chat.members
+
+import dev.inmo.tgbotapi.bot.TelegramBot
+import dev.inmo.tgbotapi.requests.chat.members.PromoteChatMember
+import dev.inmo.tgbotapi.types.IdChatIdentifier
+import dev.inmo.tgbotapi.types.ChatIdentifier
+import dev.inmo.tgbotapi.types.TelegramDate
+import dev.inmo.tgbotapi.types.UserId
+import dev.inmo.tgbotapi.types.chat.PublicChat
+import dev.inmo.tgbotapi.types.chat.User
+
+suspend fun TelegramBot.promoteChatAdministrator(
+    chatId: ChatIdentifier,
+    userId: UserId,
+    untilDate: TelegramDate? = null,
+    isAnonymous: Boolean? = null,
+    canChangeInfo: Boolean? = null,
+    canDeleteMessages: Boolean? = null,
+    canInviteUsers: Boolean? = null,
+    canRestrictMembers: Boolean? = null,
+    canPromoteMembers: Boolean? = null,
+    canManageVideoChats: Boolean? = null,
+    canManageChat: Boolean? = null,
+) = execute(
+    PromoteChatMember(
+        chatId,
+        userId,
+        untilDate,
+        isAnonymous,
+        canChangeInfo,
+        canDeleteMessages,
+        canInviteUsers,
+        canRestrictMembers,
+        canPromoteMembers,
+        canManageVideoChats,
+        canManageChat
+    )
+)
+
+suspend fun TelegramBot.promoteChatAdministrator(
+    chat: PublicChat,
+    userId: UserId,
+    untilDate: TelegramDate? = null,
+    isAnonymous: Boolean? = null,
+    canChangeInfo: Boolean? = null,
+    canDeleteMessages: Boolean? = null,
+    canInviteUsers: Boolean? = null,
+    canRestrictMembers: Boolean? = null,
+    canPromoteMembers: Boolean? = null,
+    canManageVideoChats: Boolean? = null,
+    canManageChat: Boolean? = null,
+) = promoteChatAdministrator(
+    chat.id,
+    userId,
+    untilDate,
+    isAnonymous,
+    canChangeInfo,
+    canDeleteMessages,
+    canInviteUsers,
+    canRestrictMembers,
+    canPromoteMembers,
+    canManageVideoChats,
+    canManageChat
+)
+
+suspend fun TelegramBot.promoteChatAdministrator(
+    chatId: IdChatIdentifier,
+    user: User,
+    untilDate: TelegramDate? = null,
+    isAnonymous: Boolean? = null,
+    canChangeInfo: Boolean? = null,
+    canDeleteMessages: Boolean? = null,
+    canInviteUsers: Boolean? = null,
+    canRestrictMembers: Boolean? = null,
+    canPromoteMembers: Boolean? = null,
+    canManageVideoChats: Boolean? = null,
+    canManageChat: Boolean? = null,
+) = promoteChatAdministrator(
+    chatId,
+    user.id,
+    untilDate,
+    isAnonymous,
+    canChangeInfo,
+    canDeleteMessages,
+    canInviteUsers,
+    canRestrictMembers,
+    canPromoteMembers,
+    canManageVideoChats,
+    canManageChat
+)
+
+suspend fun TelegramBot.promoteChatAdministrator(
+    chat: PublicChat,
+    user: User,
+    untilDate: TelegramDate? = null,
+    isAnonymous: Boolean? = null,
+    canChangeInfo: Boolean? = null,
+    canDeleteMessages: Boolean? = null,
+    canInviteUsers: Boolean? = null,
+    canRestrictMembers: Boolean? = null,
+    canPromoteMembers: Boolean? = null,
+    canManageVideoChats: Boolean? = null,
+    canManageChat: Boolean? = null,
+) = promoteChatAdministrator(
+    chat.id,
+    user.id,
+    untilDate,
+    isAnonymous,
+    canChangeInfo,
+    canDeleteMessages,
+    canInviteUsers,
+    canRestrictMembers,
+    canPromoteMembers,
+    canManageVideoChats,
+    canManageChat
+)

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

@@ -1,11 +1,13 @@
 package dev.inmo.tgbotapi.extensions.api.chat.members
 
+import dev.inmo.micro_utils.common.Warning
 import dev.inmo.tgbotapi.bot.TelegramBot
 import dev.inmo.tgbotapi.requests.chat.members.PromoteChatMember
 import dev.inmo.tgbotapi.types.*
 import dev.inmo.tgbotapi.types.chat.PublicChat
 import dev.inmo.tgbotapi.types.chat.User
 
+@Warning("This method is too common. Use it with caution")
 suspend fun TelegramBot.promoteChatMember(
     chatId: ChatIdentifier,
     userId: UserId,
@@ -20,26 +22,35 @@ suspend fun TelegramBot.promoteChatMember(
     canPinMessages: Boolean? = null,
     canPromoteMembers: Boolean? = null,
     canManageVideoChats: Boolean? = null,
-    canManageChat: Boolean?
+    canManageChat: Boolean? = null,
+    canManageTopics: Boolean? = null,
+    canPostStories: Boolean? = null,
+    canEditStories: Boolean? = null,
+    canDeleteStories: Boolean? = null
 ) = execute(
     PromoteChatMember(
-        chatId,
-        userId,
-        untilDate,
-        isAnonymous,
-        canChangeInfo,
-        canPostMessages,
-        canEditMessages,
-        canDeleteMessages,
-        canInviteUsers,
-        canRestrictMembers,
-        canPinMessages,
-        canPromoteMembers,
-        canManageVideoChats,
-        canManageChat
+        chatId = chatId,
+        userId = userId,
+        untilDate = untilDate,
+        isAnonymous = isAnonymous,
+        canChangeInfo = canChangeInfo,
+        canPostMessages = canPostMessages,
+        canEditMessages = canEditMessages,
+        canDeleteMessages = canDeleteMessages,
+        canInviteUsers = canInviteUsers,
+        canRestrictMembers = canRestrictMembers,
+        canPinMessages = canPinMessages,
+        canPromoteMembers = canPromoteMembers,
+        canManageVideoChats = canManageVideoChats,
+        canManageChat = canManageChat,
+        canManageTopics = canManageTopics,
+        canPostStories = canPostStories,
+        canEditStories = canEditStories,
+        canDeleteStories = canDeleteStories
     )
 )
 
+@Warning("This method is too common. Use it with caution")
 suspend fun TelegramBot.promoteChatMember(
     chat: PublicChat,
     userId: UserId,
@@ -54,26 +65,35 @@ suspend fun TelegramBot.promoteChatMember(
     canPinMessages: Boolean? = null,
     canPromoteMembers: Boolean? = null,
     canManageVideoChats: Boolean? = null,
-    canManageChat: Boolean? = null
+    canManageChat: Boolean? = null,
+    canManageTopics: Boolean? = null,
+    canPostStories: Boolean? = null,
+    canEditStories: Boolean? = null,
+    canDeleteStories: Boolean? = null
 ) = promoteChatMember(
     chat.id,
     userId,
-    untilDate,
-    isAnonymous,
-    canChangeInfo,
-    canPostMessages,
-    canEditMessages,
-    canDeleteMessages,
-    canInviteUsers,
-    canRestrictMembers,
-    canPinMessages,
-    canPromoteMembers,
-    canManageVideoChats,
-    canManageChat
+    untilDate = untilDate,
+    isAnonymous = isAnonymous,
+    canChangeInfo = canChangeInfo,
+    canPostMessages = canPostMessages,
+    canEditMessages = canEditMessages,
+    canDeleteMessages = canDeleteMessages,
+    canInviteUsers = canInviteUsers,
+    canRestrictMembers = canRestrictMembers,
+    canPinMessages = canPinMessages,
+    canPromoteMembers = canPromoteMembers,
+    canManageVideoChats = canManageVideoChats,
+    canManageChat = canManageChat,
+    canManageTopics = canManageTopics,
+    canPostStories = canPostStories,
+    canEditStories = canEditStories,
+    canDeleteStories = canDeleteStories
 )
 
+@Warning("This method is too common. Use it with caution")
 suspend fun TelegramBot.promoteChatMember(
-    chatId: ChatId,
+    chatId: IdChatIdentifier,
     user: User,
     untilDate: TelegramDate? = null,
     isAnonymous: Boolean? = null,
@@ -86,24 +106,33 @@ suspend fun TelegramBot.promoteChatMember(
     canPinMessages: Boolean? = null,
     canPromoteMembers: Boolean? = null,
     canManageVideoChats: Boolean? = null,
-    canManageChat: Boolean? = null
+    canManageChat: Boolean? = null,
+    canManageTopics: Boolean? = null,
+    canPostStories: Boolean? = null,
+    canEditStories: Boolean? = null,
+    canDeleteStories: Boolean? = null
 ) = promoteChatMember(
     chatId,
     user.id,
-    untilDate,
-    isAnonymous,
-    canChangeInfo,
-    canPostMessages,
-    canEditMessages,
-    canDeleteMessages,
-    canInviteUsers,
-    canRestrictMembers,
-    canPinMessages,
-    canPromoteMembers,
-    canManageVideoChats,
-    canManageChat
+    untilDate = untilDate,
+    isAnonymous = isAnonymous,
+    canChangeInfo = canChangeInfo,
+    canPostMessages = canPostMessages,
+    canEditMessages = canEditMessages,
+    canDeleteMessages = canDeleteMessages,
+    canInviteUsers = canInviteUsers,
+    canRestrictMembers = canRestrictMembers,
+    canPinMessages = canPinMessages,
+    canPromoteMembers = canPromoteMembers,
+    canManageVideoChats = canManageVideoChats,
+    canManageChat = canManageChat,
+    canManageTopics = canManageTopics,
+    canPostStories = canPostStories,
+    canEditStories = canEditStories,
+    canDeleteStories = canDeleteStories
 )
 
+@Warning("This method is too common. Use it with caution")
 suspend fun TelegramBot.promoteChatMember(
     chat: PublicChat,
     user: User,
@@ -118,20 +147,28 @@ suspend fun TelegramBot.promoteChatMember(
     canPinMessages: Boolean? = null,
     canPromoteMembers: Boolean? = null,
     canManageVideoChats: Boolean? = null,
-    canManageChat: Boolean? = null
+    canManageChat: Boolean? = null,
+    canManageTopics: Boolean? = null,
+    canPostStories: Boolean? = null,
+    canEditStories: Boolean? = null,
+    canDeleteStories: Boolean? = null
 ) = promoteChatMember(
     chat.id,
     user.id,
-    untilDate,
-    isAnonymous,
-    canChangeInfo,
-    canPostMessages,
-    canEditMessages,
-    canDeleteMessages,
-    canInviteUsers,
-    canRestrictMembers,
-    canPinMessages,
-    canPromoteMembers,
-    canManageVideoChats,
-    canManageChat
+    untilDate = untilDate,
+    isAnonymous = isAnonymous,
+    canChangeInfo = canChangeInfo,
+    canPostMessages = canPostMessages,
+    canEditMessages = canEditMessages,
+    canDeleteMessages = canDeleteMessages,
+    canInviteUsers = canInviteUsers,
+    canRestrictMembers = canRestrictMembers,
+    canPinMessages = canPinMessages,
+    canPromoteMembers = canPromoteMembers,
+    canManageVideoChats = canManageVideoChats,
+    canManageChat = canManageChat,
+    canManageTopics = canManageTopics,
+    canPostStories = canPostStories,
+    canEditStories = canEditStories,
+    canDeleteStories = canDeleteStories
 )

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

@@ -0,0 +1,133 @@
+package dev.inmo.tgbotapi.extensions.api.chat.members
+
+import dev.inmo.tgbotapi.bot.TelegramBot
+import dev.inmo.tgbotapi.requests.chat.members.PromoteChatMember
+import dev.inmo.tgbotapi.requests.chat.members.PromoteSupergroupAdministrator
+import dev.inmo.tgbotapi.types.IdChatIdentifier
+import dev.inmo.tgbotapi.types.ChatIdentifier
+import dev.inmo.tgbotapi.types.TelegramDate
+import dev.inmo.tgbotapi.types.UserId
+import dev.inmo.tgbotapi.types.chat.PublicChat
+import dev.inmo.tgbotapi.types.chat.User
+
+suspend fun TelegramBot.promoteSupergroupAdministrator(
+    chatId: ChatIdentifier,
+    userId: UserId,
+    untilDate: TelegramDate? = null,
+    isAnonymous: Boolean? = null,
+    canChangeInfo: Boolean? = null,
+    canDeleteMessages: Boolean? = null,
+    canInviteUsers: Boolean? = null,
+    canRestrictMembers: Boolean? = null,
+    canPinMessages: Boolean? = null,
+    canPromoteMembers: Boolean? = null,
+    canManageVideoChats: Boolean? = null,
+    canManageChat: Boolean? = null,
+    canManageTopics: Boolean? = null,
+) = execute(
+    PromoteSupergroupAdministrator(
+        chatId = chatId,
+        userId = userId,
+        untilDate = untilDate,
+        isAnonymous = isAnonymous,
+        canChangeInfo = canChangeInfo,
+        canDeleteMessages = canDeleteMessages,
+        canInviteUsers = canInviteUsers,
+        canRestrictMembers = canRestrictMembers,
+        canPinMessages = canPinMessages,
+        canPromoteMembers = canPromoteMembers,
+        canManageVideoChats = canManageVideoChats,
+        canManageChat = canManageChat,
+        canManageTopics = canManageTopics
+    )
+)
+
+suspend fun TelegramBot.promoteSupergroupAdministrator(
+    chat: PublicChat,
+    userId: UserId,
+    untilDate: TelegramDate? = null,
+    isAnonymous: Boolean? = null,
+    canChangeInfo: Boolean? = null,
+    canDeleteMessages: Boolean? = null,
+    canInviteUsers: Boolean? = null,
+    canRestrictMembers: Boolean? = null,
+    canPinMessages: Boolean? = null,
+    canPromoteMembers: Boolean? = null,
+    canManageVideoChats: Boolean? = null,
+    canManageChat: Boolean? = null,
+    canManageTopics: Boolean? = null,
+) = promoteSupergroupAdministrator(
+    chat.id,
+    userId,
+    untilDate = untilDate,
+    isAnonymous = isAnonymous,
+    canChangeInfo = canChangeInfo,
+    canDeleteMessages = canDeleteMessages,
+    canInviteUsers = canInviteUsers,
+    canRestrictMembers = canRestrictMembers,
+    canPinMessages = canPinMessages,
+    canPromoteMembers = canPromoteMembers,
+    canManageVideoChats = canManageVideoChats,
+    canManageChat = canManageChat,
+    canManageTopics = canManageTopics
+)
+
+suspend fun TelegramBot.promoteSupergroupAdministrator(
+    chatId: IdChatIdentifier,
+    user: User,
+    untilDate: TelegramDate? = null,
+    isAnonymous: Boolean? = null,
+    canChangeInfo: Boolean? = null,
+    canDeleteMessages: Boolean? = null,
+    canInviteUsers: Boolean? = null,
+    canRestrictMembers: Boolean? = null,
+    canPinMessages: Boolean? = null,
+    canPromoteMembers: Boolean? = null,
+    canManageVideoChats: Boolean? = null,
+    canManageChat: Boolean? = null,
+    canManageTopics: Boolean? = null,
+) = promoteSupergroupAdministrator(
+    chatId,
+    user.id,
+    untilDate = untilDate,
+    isAnonymous = isAnonymous,
+    canChangeInfo = canChangeInfo,
+    canDeleteMessages = canDeleteMessages,
+    canInviteUsers = canInviteUsers,
+    canRestrictMembers = canRestrictMembers,
+    canPinMessages = canPinMessages,
+    canPromoteMembers = canPromoteMembers,
+    canManageVideoChats = canManageVideoChats,
+    canManageChat = canManageChat,
+    canManageTopics = canManageTopics
+)
+
+suspend fun TelegramBot.promoteSupergroupAdministrator(
+    chat: PublicChat,
+    user: User,
+    untilDate: TelegramDate? = null,
+    isAnonymous: Boolean? = null,
+    canChangeInfo: Boolean? = null,
+    canDeleteMessages: Boolean? = null,
+    canInviteUsers: Boolean? = null,
+    canRestrictMembers: Boolean? = null,
+    canPinMessages: Boolean? = null,
+    canPromoteMembers: Boolean? = null,
+    canManageVideoChats: Boolean? = null,
+    canManageChat: Boolean? = null,
+    canManageTopics: Boolean? = null,
+) = promoteSupergroupAdministrator(
+    chat.id,
+    user.id,
+    untilDate = untilDate,
+    isAnonymous = isAnonymous,
+    canChangeInfo = canChangeInfo,
+    canDeleteMessages = canDeleteMessages,
+    canInviteUsers = canInviteUsers,
+    canRestrictMembers = canRestrictMembers,
+    canPinMessages = canPinMessages,
+    canPromoteMembers = canPromoteMembers,
+    canManageVideoChats = canManageVideoChats,
+    canManageChat = canManageChat,
+    canManageTopics = canManageTopics
+)

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

@@ -2,35 +2,43 @@ package dev.inmo.tgbotapi.extensions.api.chat.members
 
 import dev.inmo.tgbotapi.bot.TelegramBot
 import dev.inmo.tgbotapi.requests.chat.members.RestrictChatMember
-import dev.inmo.tgbotapi.types.*
-import dev.inmo.tgbotapi.types.chat.*
+import dev.inmo.tgbotapi.types.IdChatIdentifier
+import dev.inmo.tgbotapi.types.ChatIdentifier
+import dev.inmo.tgbotapi.types.TelegramDate
+import dev.inmo.tgbotapi.types.UserId
+import dev.inmo.tgbotapi.types.chat.ChatPermissions
+import dev.inmo.tgbotapi.types.chat.PublicChat
 import dev.inmo.tgbotapi.types.chat.User
 
 suspend fun TelegramBot.restrictChatMember(
     chatId: ChatIdentifier,
     userId: UserId,
     untilDate: TelegramDate? = null,
-    permissions: ChatPermissions = ChatPermissions()
-) = execute(RestrictChatMember(chatId, userId, untilDate, permissions))
+    permissions: ChatPermissions = ChatPermissions(),
+    useIndependentChatPermissions: Boolean? = permissions.isGranular.takeIf { it }
+) = execute(RestrictChatMember(chatId, userId, untilDate, permissions, useIndependentChatPermissions))
 
 suspend fun TelegramBot.restrictChatMember(
     chat: PublicChat,
     userId: UserId,
     untilDate: TelegramDate? = null,
-    permissions: ChatPermissions = ChatPermissions()
-) = restrictChatMember(chat.id, userId, untilDate, permissions)
+    permissions: ChatPermissions = ChatPermissions(),
+    useIndependentChatPermissions: Boolean? = permissions.isGranular.takeIf { it }
+) = restrictChatMember(chat.id, userId, untilDate, permissions, useIndependentChatPermissions)
 
 suspend fun TelegramBot.restrictChatMember(
-    chatId: ChatId,
+    chatId: IdChatIdentifier,
     user: User,
     untilDate: TelegramDate? = null,
-    permissions: ChatPermissions = ChatPermissions()
-) = restrictChatMember(chatId, user.id, untilDate, permissions)
+    permissions: ChatPermissions = ChatPermissions(),
+    useIndependentChatPermissions: Boolean? = permissions.isGranular.takeIf { it }
+) = restrictChatMember(chatId, user.id, untilDate, permissions, useIndependentChatPermissions)
 
 suspend fun TelegramBot.restrictChatMember(
     chat: PublicChat,
     user: User,
     untilDate: TelegramDate? = null,
-    permissions: ChatPermissions = ChatPermissions()
-) = restrictChatMember(chat.id, user.id, untilDate, permissions)
+    permissions: ChatPermissions = ChatPermissions(),
+    useIndependentChatPermissions: Boolean? = permissions.isGranular.takeIf { it }
+) = restrictChatMember(chat.id, user.id, untilDate, permissions, useIndependentChatPermissions)
 

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

@@ -2,12 +2,13 @@ package dev.inmo.tgbotapi.extensions.api.chat.members
 
 import dev.inmo.tgbotapi.bot.TelegramBot
 import dev.inmo.tgbotapi.requests.chat.members.SetChatAdministratorCustomTitle
-import dev.inmo.tgbotapi.types.*
+import dev.inmo.tgbotapi.types.IdChatIdentifier
+import dev.inmo.tgbotapi.types.UserId
 import dev.inmo.tgbotapi.types.chat.PublicChat
 import dev.inmo.tgbotapi.types.chat.User
 
 suspend fun TelegramBot.setChatAdministratorCustomTitle(
-    chatId: ChatId,
+    chatId: IdChatIdentifier,
     userId: UserId,
     customTitle: String
 ) = execute(SetChatAdministratorCustomTitle(chatId, userId, customTitle))
@@ -19,7 +20,7 @@ suspend fun TelegramBot.setChatAdministratorCustomTitle(
 ) = setChatAdministratorCustomTitle(chat.id, userId, customTitle)
 
 suspend fun TelegramBot.setChatAdministratorCustomTitle(
-    chatId: ChatId,
+    chatId: IdChatIdentifier,
     user: User,
     customTitle: String
 ) = setChatAdministratorCustomTitle(chatId, user.id, customTitle)

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

@@ -2,7 +2,9 @@ package dev.inmo.tgbotapi.extensions.api.chat.members
 
 import dev.inmo.tgbotapi.bot.TelegramBot
 import dev.inmo.tgbotapi.requests.chat.members.UnbanChatMember
-import dev.inmo.tgbotapi.types.*
+import dev.inmo.tgbotapi.types.IdChatIdentifier
+import dev.inmo.tgbotapi.types.ChatIdentifier
+import dev.inmo.tgbotapi.types.UserId
 import dev.inmo.tgbotapi.types.chat.PublicChat
 import dev.inmo.tgbotapi.types.chat.User
 
@@ -19,7 +21,7 @@ suspend fun TelegramBot.unbanChatMember(
 ) = unbanChatMember(chat.id, userId, onlyIfBanned)
 
 suspend fun TelegramBot.unbanChatMember(
-    chatId: ChatId,
+    chatId: IdChatIdentifier,
     user: User,
     onlyIfBanned: Boolean? = null
 ) = unbanChatMember(chatId, user.id, onlyIfBanned)

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

@@ -1,22 +1,23 @@
 package dev.inmo.tgbotapi.extensions.api.chat.members
 
 import dev.inmo.tgbotapi.bot.TelegramBot
-import dev.inmo.tgbotapi.requests.chat.members.*
-import dev.inmo.tgbotapi.types.*
+import dev.inmo.tgbotapi.requests.chat.members.UnbanChatSenderChat
+import dev.inmo.tgbotapi.types.IdChatIdentifier
+import dev.inmo.tgbotapi.types.ChatIdentifier
 import dev.inmo.tgbotapi.types.chat.PublicChat
 
 suspend fun TelegramBot.unbanChatSenderChat(
     chatId: ChatIdentifier,
-    senderChatId: ChatId
+    senderChatId: IdChatIdentifier
 ) = execute(UnbanChatSenderChat(chatId, senderChatId))
 
 suspend fun TelegramBot.unbanChatSenderChat(
     chat: PublicChat,
-    senderChatId: ChatId
+    senderChatId: IdChatIdentifier
 ) = unbanChatSenderChat(chat.id, senderChatId)
 
 suspend fun TelegramBot.unbanChatSenderChat(
-    chatId: ChatId,
+    chatId: IdChatIdentifier,
     senderChat: PublicChat
 ) = unbanChatSenderChat(chatId, senderChat.id)
 

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

@@ -3,19 +3,19 @@ package dev.inmo.tgbotapi.extensions.api.chat.modify
 import dev.inmo.tgbotapi.bot.TelegramBot
 import dev.inmo.tgbotapi.requests.chat.modify.PinChatMessage
 import dev.inmo.tgbotapi.types.ChatIdentifier
-import dev.inmo.tgbotapi.types.MessageIdentifier
+import dev.inmo.tgbotapi.types.MessageId
 import dev.inmo.tgbotapi.types.chat.Chat
 import dev.inmo.tgbotapi.types.message.abstracts.Message
 
 suspend fun TelegramBot.pinChatMessage(
     chatId: ChatIdentifier,
-    messageId: MessageIdentifier,
+    messageId: MessageId,
     disableNotification: Boolean = false
 ) = execute(PinChatMessage(chatId, messageId, disableNotification))
 
 suspend fun TelegramBot.pinChatMessage(
     chat: Chat,
-    messageId: MessageIdentifier,
+    messageId: MessageId,
     disableNotification: Boolean = false
 ) = pinChatMessage(chat.id, messageId, disableNotification)
 

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

@@ -1,12 +1,13 @@
 package dev.inmo.tgbotapi.extensions.api.chat.modify
 
 import dev.inmo.tgbotapi.bot.TelegramBot
-import dev.inmo.tgbotapi.requests.chat.modify.*
-import dev.inmo.tgbotapi.types.*
+import dev.inmo.tgbotapi.requests.chat.modify.SetChatMenuButton
+import dev.inmo.tgbotapi.types.IdChatIdentifier
+import dev.inmo.tgbotapi.types.MenuButton
 import dev.inmo.tgbotapi.types.chat.PrivateChat
 
 suspend fun TelegramBot.setChatMenuButton(
-    chatId: ChatId,
+    chatId: IdChatIdentifier,
     menuButton: MenuButton
 ) = execute(SetChatMenuButton(chatId, menuButton))
 

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

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

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

@@ -3,18 +3,18 @@ package dev.inmo.tgbotapi.extensions.api.chat.modify
 import dev.inmo.tgbotapi.bot.TelegramBot
 import dev.inmo.tgbotapi.requests.chat.modify.UnpinChatMessage
 import dev.inmo.tgbotapi.types.ChatIdentifier
-import dev.inmo.tgbotapi.types.MessageIdentifier
+import dev.inmo.tgbotapi.types.MessageId
 import dev.inmo.tgbotapi.types.chat.Chat
 import dev.inmo.tgbotapi.types.message.abstracts.Message
 
 suspend fun TelegramBot.unpinChatMessage(
     chatId: ChatIdentifier,
-    messageId: MessageIdentifier? = null
+    messageId: MessageId? = null
 ) = execute(UnpinChatMessage(chatId, messageId))
 
 suspend fun TelegramBot.unpinChatMessage(
     chat: Chat,
-    messageId: MessageIdentifier? = null
+    messageId: MessageId? = null
 ) = unpinChatMessage(chat.id, messageId)
 
 suspend fun TelegramBot.unpinChatMessage(

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

@@ -18,6 +18,8 @@ import dev.inmo.tgbotapi.types.message.abstracts.Message
 import dev.inmo.tgbotapi.types.message.content.*
 import dev.inmo.tgbotapi.types.message.textsources.TextSource
 import dev.inmo.tgbotapi.types.message.textsources.TextSourcesList
+import dev.inmo.tgbotapi.utils.EntitiesBuilderBody
+import dev.inmo.tgbotapi.utils.buildEntities
 
 /**
  * @param replyMarkup Some [InlineKeyboardMarkup]. See [dev.inmo.tgbotapi.extensions.utils.types.buttons.inlineKeyboard]
@@ -50,7 +52,7 @@ suspend fun <T> TelegramBot.edit(
  */
 suspend fun TelegramBot.edit(
     chatId: ChatIdentifier,
-    messageId: MessageIdentifier,
+    messageId: MessageId,
     latitude: Double,
     longitude: Double,
     horizontalAccuracy: Meters? = null,
@@ -65,7 +67,7 @@ suspend fun TelegramBot.edit(
  */
 suspend fun TelegramBot.edit(
     chat: Chat,
-    messageId: MessageIdentifier,
+    messageId: MessageId,
     latitude: Double,
     longitude: Double,
     horizontalAccuracy: Meters? = null,
@@ -94,7 +96,7 @@ suspend fun TelegramBot.edit(
  */
 suspend fun TelegramBot.edit(
     chatId: ChatIdentifier,
-    messageId: MessageIdentifier,
+    messageId: MessageId,
     location: LiveLocation,
     replyMarkup: InlineKeyboardMarkup? = null
 ) = editLiveLocation(
@@ -107,7 +109,7 @@ suspend fun TelegramBot.edit(
  */
 suspend fun TelegramBot.edit(
     chat: Chat,
-    messageId: MessageIdentifier,
+    messageId: MessageId,
     location: LiveLocation,
     replyMarkup: InlineKeyboardMarkup? = null
 ) = editLiveLocation(chat, messageId, location, replyMarkup)
@@ -128,7 +130,7 @@ suspend fun TelegramBot.edit(
  */
 suspend fun TelegramBot.edit(
     chatId: ChatIdentifier,
-    messageId: MessageIdentifier,
+    messageId: MessageId,
     media: TelegramMedia,
     replyMarkup: InlineKeyboardMarkup? = null
 ) = editMessageMedia(chatId, messageId, media, replyMarkup)
@@ -139,7 +141,7 @@ suspend fun TelegramBot.edit(
  */
 suspend fun TelegramBot.edit(
     chat: Chat,
-    messageId: MessageIdentifier,
+    messageId: MessageId,
     media: TelegramMedia,
     replyMarkup: InlineKeyboardMarkup? = null
 ) = editMessageMedia(chat, messageId, media, replyMarkup)
@@ -160,7 +162,7 @@ suspend fun TelegramBot.edit(
  */
 suspend fun TelegramBot.edit(
     chatId: ChatIdentifier,
-    messageId: MessageIdentifier,
+    messageId: MessageId,
     replyMarkup: InlineKeyboardMarkup? = null
 ) = editMessageReplyMarkup(chatId, messageId, replyMarkup)
 
@@ -170,7 +172,7 @@ suspend fun TelegramBot.edit(
  */
 suspend fun TelegramBot.edit(
     chat: Chat,
-    messageId: MessageIdentifier,
+    messageId: MessageId,
     replyMarkup: InlineKeyboardMarkup? = null
 ) = editMessageReplyMarkup(chat, messageId, replyMarkup)
 
@@ -183,6 +185,57 @@ suspend fun TelegramBot.edit(
     replyMarkup: InlineKeyboardMarkup? = null
 ) = editMessageReplyMarkup(message, replyMarkup)
 
+/**
+ * @param replyMarkup Some [InlineKeyboardMarkup]. See [dev.inmo.tgbotapi.extensions.utils.types.buttons.inlineKeyboard]
+ * as a builder for that
+ */
+suspend fun TelegramBot.edit(
+    chatId: ChatIdentifier,
+    messageId: MessageId,
+    text: String,
+    parseMode: ParseMode? = null,
+    disableWebPagePreview: Boolean? = null,
+    replyMarkup: InlineKeyboardMarkup? = null
+) = editMessageText(chatId, messageId, text, parseMode, disableWebPagePreview, replyMarkup)
+
+/**
+ * @param replyMarkup Some [InlineKeyboardMarkup]. See [dev.inmo.tgbotapi.extensions.utils.types.buttons.inlineKeyboard]
+ * as a builder for that
+ */
+suspend fun TelegramBot.edit(
+    chatId: ChatIdentifier,
+    messageId: MessageId,
+    entities: TextSourcesList,
+    disableWebPagePreview: Boolean? = null,
+    replyMarkup: InlineKeyboardMarkup? = null
+) = editMessageText(chatId, messageId, entities, disableWebPagePreview, replyMarkup)
+
+/**
+ * @param replyMarkup Some [InlineKeyboardMarkup]. See [dev.inmo.tgbotapi.extensions.utils.types.buttons.inlineKeyboard]
+ * as a builder for that
+ */
+suspend fun TelegramBot.edit(
+    chatId: ChatIdentifier,
+    messageId: MessageId,
+    separator: TextSource? = null,
+    disableWebPagePreview: Boolean? = null,
+    replyMarkup: InlineKeyboardMarkup? = null,
+    builderBody: EntitiesBuilderBody
+) = edit(chatId, messageId, buildEntities(separator, builderBody), disableWebPagePreview, replyMarkup)
+
+/**
+ * @param replyMarkup Some [InlineKeyboardMarkup]. See [dev.inmo.tgbotapi.extensions.utils.types.buttons.inlineKeyboard]
+ * as a builder for that
+ */
+suspend fun TelegramBot.edit(
+    chatId: ChatIdentifier,
+    messageId: MessageId,
+    separator: String,
+    disableWebPagePreview: Boolean? = null,
+    replyMarkup: InlineKeyboardMarkup? = null,
+    builderBody: EntitiesBuilderBody
+) = edit(chatId, messageId, buildEntities(separator, builderBody), disableWebPagePreview, replyMarkup)
+
 /**
  * @param replyMarkup Some [InlineKeyboardMarkup]. See [dev.inmo.tgbotapi.extensions.utils.types.buttons.inlineKeyboard]
  * as a builder for that
@@ -193,7 +246,7 @@ suspend fun TelegramBot.edit(
     parseMode: ParseMode? = null,
     disableWebPagePreview: Boolean? = null,
     replyMarkup: InlineKeyboardMarkup? = null
-) = editMessageText(message, text, parseMode, disableWebPagePreview, replyMarkup)
+) = edit(message.chat.id, message.messageId, text, parseMode, disableWebPagePreview, replyMarkup)
 
 /**
  * @param replyMarkup Some [InlineKeyboardMarkup]. See [dev.inmo.tgbotapi.extensions.utils.types.buttons.inlineKeyboard]
@@ -204,4 +257,52 @@ suspend fun TelegramBot.edit(
     entities: TextSourcesList,
     disableWebPagePreview: Boolean? = null,
     replyMarkup: InlineKeyboardMarkup? = null
-) = editMessageText(message, entities, disableWebPagePreview, replyMarkup)
+) = edit(message.chat.id, message.messageId, entities, disableWebPagePreview, replyMarkup)
+
+/**
+ * @param replyMarkup Some [InlineKeyboardMarkup]. See [dev.inmo.tgbotapi.extensions.utils.types.buttons.inlineKeyboard]
+ * as a builder for that
+ */
+suspend fun TelegramBot.edit(
+    message: ContentMessage<TextContent>,
+    separator: TextSource? = null,
+    disableWebPagePreview: Boolean? = null,
+    replyMarkup: InlineKeyboardMarkup? = null,
+    builderBody: EntitiesBuilderBody
+) = edit(message, buildEntities(separator, builderBody), disableWebPagePreview, replyMarkup)
+
+/**
+ * @param replyMarkup Some [InlineKeyboardMarkup]. See [dev.inmo.tgbotapi.extensions.utils.types.buttons.inlineKeyboard]
+ * as a builder for that
+ */
+suspend fun TelegramBot.edit(
+    message: ContentMessage<TextContent>,
+    separator: String,
+    disableWebPagePreview: Boolean? = null,
+    replyMarkup: InlineKeyboardMarkup? = null,
+    builderBody: EntitiesBuilderBody
+) = edit(message, buildEntities(separator, builderBody), disableWebPagePreview, replyMarkup)
+
+/**
+ * @param replyMarkup Some [InlineKeyboardMarkup]. See [dev.inmo.tgbotapi.extensions.utils.types.buttons.inlineKeyboard]
+ * as a builder for that
+ */
+suspend fun TelegramBot.editMessageText(
+    message: ContentMessage<TextContent>,
+    separator: TextSource? = null,
+    disableWebPagePreview: Boolean? = null,
+    replyMarkup: InlineKeyboardMarkup? = null,
+    builderBody: EntitiesBuilderBody
+) = edit(message, buildEntities(separator, builderBody), disableWebPagePreview, replyMarkup)
+
+/**
+ * @param replyMarkup Some [InlineKeyboardMarkup]. See [dev.inmo.tgbotapi.extensions.utils.types.buttons.inlineKeyboard]
+ * as a builder for that
+ */
+suspend fun TelegramBot.editMessageText(
+    message: ContentMessage<TextContent>,
+    separator: String,
+    disableWebPagePreview: Boolean? = null,
+    replyMarkup: InlineKeyboardMarkup? = null,
+    builderBody: EntitiesBuilderBody
+) = edit(message, buildEntities(separator, builderBody), disableWebPagePreview, replyMarkup)

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

@@ -0,0 +1,114 @@
+package dev.inmo.tgbotapi.extensions.api.edit
+
+import dev.inmo.tgbotapi.abstracts.TextedWithTextSources
+import dev.inmo.tgbotapi.bot.TelegramBot
+import dev.inmo.tgbotapi.extensions.api.edit.caption.editMessageCaption
+import dev.inmo.tgbotapi.extensions.api.edit.location.live.editLiveLocation
+import dev.inmo.tgbotapi.extensions.api.edit.media.editMessageMedia
+import dev.inmo.tgbotapi.extensions.api.edit.reply_markup.editMessageReplyMarkup
+import dev.inmo.tgbotapi.extensions.api.edit.text.editMessageText
+import dev.inmo.tgbotapi.types.*
+import dev.inmo.tgbotapi.types.buttons.InlineKeyboardMarkup
+import dev.inmo.tgbotapi.types.chat.Chat
+import dev.inmo.tgbotapi.types.location.LiveLocation
+import dev.inmo.tgbotapi.types.media.TelegramMedia
+import dev.inmo.tgbotapi.types.message.ParseMode
+import dev.inmo.tgbotapi.types.message.abstracts.ContentMessage
+import dev.inmo.tgbotapi.types.message.abstracts.Message
+import dev.inmo.tgbotapi.types.message.content.*
+import dev.inmo.tgbotapi.types.message.textsources.TextSource
+import dev.inmo.tgbotapi.types.message.textsources.TextSourcesList
+import dev.inmo.tgbotapi.utils.EntitiesBuilderBody
+import dev.inmo.tgbotapi.utils.buildEntities
+
+/**
+ * @param replyMarkup Some [InlineKeyboardMarkup]. See [dev.inmo.tgbotapi.extensions.utils.types.buttons.inlineKeyboard]
+ * as a builder for that
+ */
+suspend fun TelegramBot.edit(
+    messageId: InlineMessageIdentifier,
+    latitude: Double,
+    longitude: Double,
+    horizontalAccuracy: Meters? = null,
+    heading: Degrees? = null,
+    proximityAlertRadius: Meters? = null,
+    replyMarkup: InlineKeyboardMarkup? = null
+) = editLiveLocation(messageId, latitude, longitude, horizontalAccuracy, heading, proximityAlertRadius, replyMarkup)
+
+/**
+ * @param replyMarkup Some [InlineKeyboardMarkup]. See [dev.inmo.tgbotapi.extensions.utils.types.buttons.inlineKeyboard]
+ * as a builder for that
+ */
+suspend fun TelegramBot.edit(
+    messageId: InlineMessageIdentifier,
+    location: LiveLocation,
+    replyMarkup: InlineKeyboardMarkup? = null
+) = editLiveLocation(
+    messageId, location, replyMarkup
+)
+
+/**
+ * @param replyMarkup Some [InlineKeyboardMarkup]. See [dev.inmo.tgbotapi.extensions.utils.types.buttons.inlineKeyboard]
+ * as a builder for that
+ */
+suspend fun TelegramBot.edit(
+    messageId: InlineMessageIdentifier,
+    media: TelegramMedia,
+    replyMarkup: InlineKeyboardMarkup? = null
+) = editMessageMedia(messageId, media, replyMarkup)
+
+/**
+ * @param replyMarkup Some [InlineKeyboardMarkup]. See [dev.inmo.tgbotapi.extensions.utils.types.buttons.inlineKeyboard]
+ * as a builder for that
+ */
+suspend fun TelegramBot.edit(
+    messageId: InlineMessageIdentifier,
+    replyMarkup: InlineKeyboardMarkup? = null
+) = editMessageReplyMarkup(messageId, replyMarkup)
+
+/**
+ * @param replyMarkup Some [InlineKeyboardMarkup]. See [dev.inmo.tgbotapi.extensions.utils.types.buttons.inlineKeyboard]
+ * as a builder for that
+ */
+suspend fun TelegramBot.edit(
+    messageId: InlineMessageIdentifier,
+    text: String,
+    parseMode: ParseMode? = null,
+    disableWebPagePreview: Boolean? = null,
+    replyMarkup: InlineKeyboardMarkup? = null
+) = editMessageText(messageId, text, parseMode, disableWebPagePreview, replyMarkup)
+
+/**
+ * @param replyMarkup Some [InlineKeyboardMarkup]. See [dev.inmo.tgbotapi.extensions.utils.types.buttons.inlineKeyboard]
+ * as a builder for that
+ */
+suspend fun TelegramBot.edit(
+    messageId: InlineMessageIdentifier,
+    entities: TextSourcesList,
+    disableWebPagePreview: Boolean? = null,
+    replyMarkup: InlineKeyboardMarkup? = null
+) = editMessageText(messageId, entities, disableWebPagePreview, replyMarkup)
+
+/**
+ * @param replyMarkup Some [InlineKeyboardMarkup]. See [dev.inmo.tgbotapi.extensions.utils.types.buttons.inlineKeyboard]
+ * as a builder for that
+ */
+suspend fun TelegramBot.edit(
+    messageId: InlineMessageIdentifier,
+    separator: TextSource? = null,
+    disableWebPagePreview: Boolean? = null,
+    replyMarkup: InlineKeyboardMarkup? = null,
+    builderBody: EntitiesBuilderBody
+) = edit(messageId, buildEntities(separator, builderBody), disableWebPagePreview, replyMarkup)
+
+/**
+ * @param replyMarkup Some [InlineKeyboardMarkup]. See [dev.inmo.tgbotapi.extensions.utils.types.buttons.inlineKeyboard]
+ * as a builder for that
+ */
+suspend fun TelegramBot.edit(
+    messageId: InlineMessageIdentifier,
+    separator: String,
+    disableWebPagePreview: Boolean? = null,
+    replyMarkup: InlineKeyboardMarkup? = null,
+    builderBody: EntitiesBuilderBody
+) = edit(messageId, buildEntities(separator, builderBody), disableWebPagePreview, replyMarkup)

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

@@ -6,7 +6,7 @@ import dev.inmo.tgbotapi.requests.edit.caption.EditChatMessageCaption
 import dev.inmo.tgbotapi.types.ChatIdentifier
 import dev.inmo.tgbotapi.types.message.textsources.TextSource
 import dev.inmo.tgbotapi.types.message.textsources.TextSourcesList
-import dev.inmo.tgbotapi.types.MessageIdentifier
+import dev.inmo.tgbotapi.types.MessageId
 import dev.inmo.tgbotapi.types.message.ParseMode
 import dev.inmo.tgbotapi.types.buttons.InlineKeyboardMarkup
 import dev.inmo.tgbotapi.types.chat.Chat
@@ -21,7 +21,7 @@ import dev.inmo.tgbotapi.utils.RiskFeature
  */
 suspend fun TelegramBot.editMessageCaption(
     chatId: ChatIdentifier,
-    messageId: MessageIdentifier,
+    messageId: MessageId,
     text: String,
     parseMode: ParseMode? = null,
     replyMarkup: InlineKeyboardMarkup? = null
@@ -35,7 +35,7 @@ suspend fun TelegramBot.editMessageCaption(
  */
 suspend fun TelegramBot.editMessageCaption(
     chat: Chat,
-    messageId: MessageIdentifier,
+    messageId: MessageId,
     text: String,
     parseMode: ParseMode? = null,
     replyMarkup: InlineKeyboardMarkup? = null
@@ -61,7 +61,7 @@ suspend fun <T> TelegramBot.editMessageCaption(
  */
 suspend fun TelegramBot.editMessageCaption(
     chatId: ChatIdentifier,
-    messageId: MessageIdentifier,
+    messageId: MessageId,
     entities: TextSourcesList,
     replyMarkup: InlineKeyboardMarkup? = null
 ) = execute(
@@ -74,7 +74,7 @@ suspend fun TelegramBot.editMessageCaption(
  */
 suspend fun TelegramBot.editMessageCaption(
     chat: Chat,
-    messageId: MessageIdentifier,
+    messageId: MessageId,
     entities: List<TextSource>,
     replyMarkup: InlineKeyboardMarkup? = null
 ) = editMessageCaption(chat.id, messageId, entities, replyMarkup)

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

@@ -15,7 +15,7 @@ import dev.inmo.tgbotapi.types.message.content.LocationContent
  */
 suspend fun TelegramBot.editLiveLocation(
     chatId: ChatIdentifier,
-    messageId: MessageIdentifier,
+    messageId: MessageId,
     latitude: Double,
     longitude: Double,
     horizontalAccuracy: Meters? = null,
@@ -34,7 +34,7 @@ suspend fun TelegramBot.editLiveLocation(
  */
 suspend fun TelegramBot.editLiveLocation(
     chat: Chat,
-    messageId: MessageIdentifier,
+    messageId: MessageId,
     latitude: Double,
     longitude: Double,
     horizontalAccuracy: Meters? = null,
@@ -63,7 +63,7 @@ suspend fun TelegramBot.editLiveLocation(
  */
 suspend fun TelegramBot.editLiveLocation(
     chatId: ChatIdentifier,
-    messageId: MessageIdentifier,
+    messageId: MessageId,
     location: LiveLocation,
     replyMarkup: InlineKeyboardMarkup? = null
 ) = execute(
@@ -78,7 +78,7 @@ suspend fun TelegramBot.editLiveLocation(
  */
 suspend fun TelegramBot.editLiveLocation(
     chat: Chat,
-    messageId: MessageIdentifier,
+    messageId: MessageId,
     location: LiveLocation,
     replyMarkup: InlineKeyboardMarkup? = null
 ) = editLiveLocation(chat.id, messageId, location.latitude, location.longitude, location.horizontalAccuracy, location.heading, location.proximityAlertRadius, replyMarkup)

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

@@ -3,7 +3,7 @@ package dev.inmo.tgbotapi.extensions.api.edit.location.live
 import dev.inmo.tgbotapi.bot.TelegramBot
 import dev.inmo.tgbotapi.requests.edit.location.live.StopChatMessageLiveLocation
 import dev.inmo.tgbotapi.types.ChatIdentifier
-import dev.inmo.tgbotapi.types.MessageIdentifier
+import dev.inmo.tgbotapi.types.MessageId
 import dev.inmo.tgbotapi.types.buttons.InlineKeyboardMarkup
 import dev.inmo.tgbotapi.types.chat.Chat
 import dev.inmo.tgbotapi.types.message.abstracts.ContentMessage
@@ -15,7 +15,7 @@ import dev.inmo.tgbotapi.types.message.content.LocationContent
  */
 suspend fun TelegramBot.stopLiveLocation(
     chatId: ChatIdentifier,
-    messageId: MessageIdentifier,
+    messageId: MessageId,
     replyMarkup: InlineKeyboardMarkup? = null
 ) = execute(
     StopChatMessageLiveLocation(
@@ -29,7 +29,7 @@ suspend fun TelegramBot.stopLiveLocation(
  */
 suspend fun TelegramBot.stopLiveLocation(
     chat: Chat,
-    messageId: MessageIdentifier,
+    messageId: MessageId,
     replyMarkup: InlineKeyboardMarkup? = null
 ) = stopLiveLocation(chat.id, messageId, replyMarkup)
 

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

@@ -4,7 +4,7 @@ import dev.inmo.tgbotapi.bot.TelegramBot
 import dev.inmo.tgbotapi.requests.edit.media.EditChatMessageMedia
 import dev.inmo.tgbotapi.types.ChatIdentifier
 import dev.inmo.tgbotapi.types.media.TelegramMedia
-import dev.inmo.tgbotapi.types.MessageIdentifier
+import dev.inmo.tgbotapi.types.MessageId
 import dev.inmo.tgbotapi.types.buttons.InlineKeyboardMarkup
 import dev.inmo.tgbotapi.types.chat.Chat
 import dev.inmo.tgbotapi.types.message.abstracts.ContentMessage
@@ -16,7 +16,7 @@ import dev.inmo.tgbotapi.types.message.content.MediaContent
  */
 suspend fun TelegramBot.editMessageMedia(
     chatId: ChatIdentifier,
-    messageId: MessageIdentifier,
+    messageId: MessageId,
     media: TelegramMedia,
     replyMarkup: InlineKeyboardMarkup? = null
 ) = execute(
@@ -29,7 +29,7 @@ suspend fun TelegramBot.editMessageMedia(
  */
 suspend fun TelegramBot.editMessageMedia(
     chat: Chat,
-    messageId: MessageIdentifier,
+    messageId: MessageId,
     media: TelegramMedia,
     replyMarkup: InlineKeyboardMarkup? = null
 ) = editMessageMedia(chat.id, messageId, media, replyMarkup)

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

@@ -10,7 +10,7 @@ import dev.inmo.tgbotapi.types.buttons.InlineKeyboardMarkup
  * @param replyMarkup Some [InlineKeyboardMarkup]. See [dev.inmo.tgbotapi.extensions.utils.types.buttons.inlineKeyboard]
  * as a builder for that
  */
-suspend fun TelegramBot.editMessageCaption(
+suspend fun TelegramBot.editMessageMedia(
     inlineMessageId: InlineMessageIdentifier,
     media: TelegramMedia,
     replyMarkup: InlineKeyboardMarkup? = null

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

@@ -3,7 +3,7 @@ package dev.inmo.tgbotapi.extensions.api.edit.reply_markup
 import dev.inmo.tgbotapi.bot.TelegramBot
 import dev.inmo.tgbotapi.requests.edit.reply_markup.EditChatMessageReplyMarkup
 import dev.inmo.tgbotapi.types.ChatIdentifier
-import dev.inmo.tgbotapi.types.MessageIdentifier
+import dev.inmo.tgbotapi.types.MessageId
 import dev.inmo.tgbotapi.types.buttons.InlineKeyboardMarkup
 import dev.inmo.tgbotapi.types.chat.Chat
 import dev.inmo.tgbotapi.types.message.abstracts.Message
@@ -14,7 +14,7 @@ import dev.inmo.tgbotapi.types.message.abstracts.Message
  */
 suspend fun TelegramBot.editMessageReplyMarkup(
     chatId: ChatIdentifier,
-    messageId: MessageIdentifier,
+    messageId: MessageId,
     replyMarkup: InlineKeyboardMarkup? = null
 ) = execute(
     EditChatMessageReplyMarkup(chatId, messageId, replyMarkup)
@@ -26,7 +26,7 @@ suspend fun TelegramBot.editMessageReplyMarkup(
  */
 suspend fun TelegramBot.editMessageReplyMarkup(
     chat: Chat,
-    messageId: MessageIdentifier,
+    messageId: MessageId,
     replyMarkup: InlineKeyboardMarkup? = null
 ) = editMessageReplyMarkup(chat.id, messageId, replyMarkup)
 

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

@@ -4,14 +4,15 @@ import dev.inmo.tgbotapi.bot.TelegramBot
 import dev.inmo.tgbotapi.requests.edit.text.EditChatMessageText
 import dev.inmo.tgbotapi.types.ChatIdentifier
 import dev.inmo.tgbotapi.types.message.textsources.TextSourcesList
-import dev.inmo.tgbotapi.types.MessageIdentifier
+import dev.inmo.tgbotapi.types.MessageId
 import dev.inmo.tgbotapi.types.message.ParseMode
 import dev.inmo.tgbotapi.types.buttons.InlineKeyboardMarkup
 import dev.inmo.tgbotapi.types.chat.Chat
 import dev.inmo.tgbotapi.types.message.abstracts.ContentMessage
 import dev.inmo.tgbotapi.types.message.abstracts.Message
 import dev.inmo.tgbotapi.types.message.content.TextContent
-import dev.inmo.tgbotapi.utils.RiskFeature
+import dev.inmo.tgbotapi.types.message.textsources.TextSource
+import dev.inmo.tgbotapi.utils.*
 
 /**
  * @param replyMarkup Some [InlineKeyboardMarkup]. See [dev.inmo.tgbotapi.extensions.utils.types.buttons.inlineKeyboard]
@@ -19,7 +20,7 @@ import dev.inmo.tgbotapi.utils.RiskFeature
  */
 suspend fun TelegramBot.editMessageText(
     chatId: ChatIdentifier,
-    messageId: MessageIdentifier,
+    messageId: MessageId,
     text: String,
     parseMode: ParseMode? = null,
     disableWebPagePreview: Boolean? = null,
@@ -34,7 +35,7 @@ suspend fun TelegramBot.editMessageText(
  */
 suspend fun TelegramBot.editMessageText(
     chat: Chat,
-    messageId: MessageIdentifier,
+    messageId: MessageId,
     text: String,
     parseMode: ParseMode? = null,
     disableWebPagePreview: Boolean? = null,
@@ -59,7 +60,7 @@ suspend fun TelegramBot.editMessageText(
  */
 suspend fun TelegramBot.editMessageText(
     chatId: ChatIdentifier,
-    messageId: MessageIdentifier,
+    messageId: MessageId,
     entities: TextSourcesList,
     disableWebPagePreview: Boolean? = null,
     replyMarkup: InlineKeyboardMarkup? = null
@@ -67,18 +68,70 @@ suspend fun TelegramBot.editMessageText(
     EditChatMessageText(chatId, messageId, entities, disableWebPagePreview, replyMarkup)
 )
 
+/**
+ * @param replyMarkup Some [InlineKeyboardMarkup]. See [dev.inmo.tgbotapi.extensions.utils.types.buttons.inlineKeyboard]
+ * as a builder for that
+ */
+suspend fun TelegramBot.editMessageText(
+    chatId: ChatIdentifier,
+    messageId: MessageId,
+    separator: TextSource? = null,
+    disableWebPagePreview: Boolean? = null,
+    replyMarkup: InlineKeyboardMarkup? = null,
+    builderBody: EntitiesBuilderBody
+) = editMessageText(chatId, messageId, buildEntities(separator, builderBody), disableWebPagePreview, replyMarkup)
+
+/**
+ * @param replyMarkup Some [InlineKeyboardMarkup]. See [dev.inmo.tgbotapi.extensions.utils.types.buttons.inlineKeyboard]
+ * as a builder for that
+ */
+suspend fun TelegramBot.editMessageText(
+    chatId: ChatIdentifier,
+    messageId: MessageId,
+    separator: String,
+    disableWebPagePreview: Boolean? = null,
+    replyMarkup: InlineKeyboardMarkup? = null,
+    builderBody: EntitiesBuilderBody
+) = editMessageText(chatId, messageId, buildEntities(separator, builderBody), disableWebPagePreview, replyMarkup)
+
 /**
  * @param replyMarkup Some [InlineKeyboardMarkup]. See [dev.inmo.tgbotapi.extensions.utils.types.buttons.inlineKeyboard]
  * as a builder for that
  */
 suspend fun TelegramBot.editMessageText(
     chat: Chat,
-    messageId: MessageIdentifier,
+    messageId: MessageId,
     entities: TextSourcesList,
     disableWebPagePreview: Boolean? = null,
     replyMarkup: InlineKeyboardMarkup? = null
 ) = editMessageText(chat.id, messageId, entities, disableWebPagePreview, replyMarkup)
 
+/**
+ * @param replyMarkup Some [InlineKeyboardMarkup]. See [dev.inmo.tgbotapi.extensions.utils.types.buttons.inlineKeyboard]
+ * as a builder for that
+ */
+suspend fun TelegramBot.editMessageText(
+    chat: Chat,
+    messageId: MessageId,
+    separator: TextSource? = null,
+    disableWebPagePreview: Boolean? = null,
+    replyMarkup: InlineKeyboardMarkup? = null,
+    builderBody: EntitiesBuilderBody
+) = editMessageText(chat.id, messageId, buildEntities(separator, builderBody), disableWebPagePreview, replyMarkup)
+
+/**
+ * @param replyMarkup Some [InlineKeyboardMarkup]. See [dev.inmo.tgbotapi.extensions.utils.types.buttons.inlineKeyboard]
+ * as a builder for that
+ */
+suspend fun TelegramBot.editMessageText(
+    chat: Chat,
+    messageId: MessageId,
+    separator: String,
+    disableWebPagePreview: Boolean? = null,
+    replyMarkup: InlineKeyboardMarkup? = null,
+    builderBody: EntitiesBuilderBody
+) = editMessageText(chat.id, messageId, buildEntities(separator, builderBody), disableWebPagePreview, replyMarkup)
+
 /**
  * @param replyMarkup Some [InlineKeyboardMarkup]. See [dev.inmo.tgbotapi.extensions.utils.types.buttons.inlineKeyboard]
  * as a builder for that
@@ -90,6 +143,30 @@ suspend fun TelegramBot.editMessageText(
     replyMarkup: InlineKeyboardMarkup? = null
 ) = editMessageText(message.chat.id, message.messageId, entities, disableWebPagePreview, replyMarkup)
 
+/**
+ * @param replyMarkup Some [InlineKeyboardMarkup]. See [dev.inmo.tgbotapi.extensions.utils.types.buttons.inlineKeyboard]
+ * as a builder for that
+ */
+suspend fun TelegramBot.editMessageText(
+    message: ContentMessage<TextContent>,
+    separator: TextSource? = null,
+    disableWebPagePreview: Boolean? = null,
+    replyMarkup: InlineKeyboardMarkup? = null,
+    builderBody: EntitiesBuilderBody
+) = editMessageText(message.chat.id, message.messageId, buildEntities(separator, builderBody), disableWebPagePreview, replyMarkup)
+
+/**
+ * @param replyMarkup Some [InlineKeyboardMarkup]. See [dev.inmo.tgbotapi.extensions.utils.types.buttons.inlineKeyboard]
+ * as a builder for that
+ */
+suspend fun TelegramBot.editMessageText(
+    message: ContentMessage<TextContent>,
+    separator: String,
+    disableWebPagePreview: Boolean? = null,
+    replyMarkup: InlineKeyboardMarkup? = null,
+    builderBody: EntitiesBuilderBody
+) = editMessageText(message.chat.id, message.messageId, buildEntities(separator, builderBody), disableWebPagePreview, replyMarkup)
+
 /**
  * @param replyMarkup Some [InlineKeyboardMarkup]. See [dev.inmo.tgbotapi.extensions.utils.types.buttons.inlineKeyboard]
  * as a builder for that
@@ -101,3 +178,29 @@ suspend fun TelegramBot.editMessageText(
     disableWebPagePreview: Boolean? = null,
     replyMarkup: InlineKeyboardMarkup? = null
 ) = editMessageText(message.chat.id, message.messageId, entities, disableWebPagePreview, replyMarkup)
+
+/**
+ * @param replyMarkup Some [InlineKeyboardMarkup]. See [dev.inmo.tgbotapi.extensions.utils.types.buttons.inlineKeyboard]
+ * as a builder for that
+ */
+@RiskFeature("This method is unsafe due to absence of any guaranties about the type of message. In case if message is not text message this method will throw an exception")
+suspend fun TelegramBot.editMessageText(
+    message: Message,
+    separator: TextSource? = null,
+    disableWebPagePreview: Boolean? = null,
+    replyMarkup: InlineKeyboardMarkup? = null,
+    builderBody: EntitiesBuilderBody
+) = editMessageText(message.chat.id, message.messageId, buildEntities(separator, builderBody), disableWebPagePreview, replyMarkup)
+
+/**
+ * @param replyMarkup Some [InlineKeyboardMarkup]. See [dev.inmo.tgbotapi.extensions.utils.types.buttons.inlineKeyboard]
+ * as a builder for that
+ */
+@RiskFeature("This method is unsafe due to absence of any guaranties about the type of message. In case if message is not text message this method will throw an exception")
+suspend fun TelegramBot.editMessageText(
+    message: Message,
+    separator: String,
+    disableWebPagePreview: Boolean? = null,
+    replyMarkup: InlineKeyboardMarkup? = null,
+    builderBody: EntitiesBuilderBody
+) = editMessageText(message.chat.id, message.messageId, buildEntities(separator, builderBody), disableWebPagePreview, replyMarkup)

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

@@ -6,6 +6,9 @@ import dev.inmo.tgbotapi.types.InlineMessageIdentifier
 import dev.inmo.tgbotapi.types.message.textsources.TextSourcesList
 import dev.inmo.tgbotapi.types.message.ParseMode
 import dev.inmo.tgbotapi.types.buttons.InlineKeyboardMarkup
+import dev.inmo.tgbotapi.types.message.textsources.TextSource
+import dev.inmo.tgbotapi.utils.EntitiesBuilderBody
+import dev.inmo.tgbotapi.utils.buildEntities
 
 /**
  * @param replyMarkup Some [InlineKeyboardMarkup]. See [dev.inmo.tgbotapi.extensions.utils.types.buttons.inlineKeyboard]
@@ -29,3 +32,27 @@ suspend fun TelegramBot.editMessageText(
     disableWebPagePreview: Boolean? = null,
     replyMarkup: InlineKeyboardMarkup? = null
 ) = execute(EditInlineMessageText(inlineMessageId, entities, disableWebPagePreview, replyMarkup))
+
+/**
+ * @param replyMarkup Some [InlineKeyboardMarkup]. See [dev.inmo.tgbotapi.extensions.utils.types.buttons.inlineKeyboard]
+ * as a builder for that
+ */
+suspend fun TelegramBot.editMessageText(
+    inlineMessageId: InlineMessageIdentifier,
+    separator: TextSource? = null,
+    disableWebPagePreview: Boolean? = null,
+    replyMarkup: InlineKeyboardMarkup? = null,
+    builderBody: EntitiesBuilderBody
+) = editMessageText(inlineMessageId, buildEntities(separator, builderBody), disableWebPagePreview, replyMarkup)
+
+/**
+ * @param replyMarkup Some [InlineKeyboardMarkup]. See [dev.inmo.tgbotapi.extensions.utils.types.buttons.inlineKeyboard]
+ * as a builder for that
+ */
+suspend fun TelegramBot.editMessageText(
+    inlineMessageId: InlineMessageIdentifier,
+    separator: String,
+    disableWebPagePreview: Boolean? = null,
+    replyMarkup: InlineKeyboardMarkup? = null,
+    builderBody: EntitiesBuilderBody
+) = editMessageText(inlineMessageId, buildEntities(separator, builderBody), disableWebPagePreview, replyMarkup)

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

@@ -10,16 +10,16 @@ import dev.inmo.tgbotapi.types.message.content.GameContent
 
 suspend fun TelegramBot.getGameScore(
     userId: UserId,
-    chatId: ChatId,
-    messageId: MessageIdentifier
+    chatId: IdChatIdentifier,
+    messageId: MessageId
 ) = execute(
     GetGameHighScoresByChat(userId, chatId, messageId)
 )
 
 suspend fun TelegramBot.getGameScore(
     user: CommonUser,
-    chatId: ChatId,
-    messageId: MessageIdentifier
+    chatId: IdChatIdentifier,
+    messageId: MessageId
 ) = getGameScore(
     user.id, chatId, messageId
 )
@@ -27,7 +27,7 @@ suspend fun TelegramBot.getGameScore(
 suspend fun TelegramBot.getGameScore(
     userId: UserId,
     chat: Chat,
-    messageId: MessageIdentifier
+    messageId: MessageId
 ) = getGameScore(
     userId, chat.id, messageId
 )
@@ -35,7 +35,7 @@ suspend fun TelegramBot.getGameScore(
 suspend fun TelegramBot.getGameScore(
     user: CommonUser,
     chat: Chat,
-    messageId: MessageIdentifier
+    messageId: MessageId
 ) = getGameScore(
     user.id, chat.id, messageId
 )

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

@@ -11,8 +11,8 @@ import dev.inmo.tgbotapi.types.message.content.GameContent
 suspend fun TelegramBot.setGameScore(
     userId: UserId,
     score: Long,
-    chatId: ChatId,
-    messageId: MessageIdentifier,
+    chatId: IdChatIdentifier,
+    messageId: MessageId,
     force: Boolean = false,
     disableEditMessage: Boolean = false
 ) = execute(
@@ -22,8 +22,8 @@ suspend fun TelegramBot.setGameScore(
 suspend fun TelegramBot.setGameScore(
     user: CommonUser,
     score: Long,
-    chatId: ChatId,
-    messageId: MessageIdentifier,
+    chatId: IdChatIdentifier,
+    messageId: MessageId,
     force: Boolean = false,
     disableEditMessage: Boolean = false
 ) = setGameScore(
@@ -34,7 +34,7 @@ suspend fun TelegramBot.setGameScore(
     userId: UserId,
     score: Long,
     chat: Chat,
-    messageId: MessageIdentifier,
+    messageId: MessageId,
     force: Boolean = false,
     disableEditMessage: Boolean = false
 ) = setGameScore(
@@ -45,7 +45,7 @@ suspend fun TelegramBot.setGameScore(
     user: CommonUser,
     score: Long,
     chat: Chat,
-    messageId: MessageIdentifier,
+    messageId: MessageId,
     force: Boolean = false,
     disableEditMessage: Boolean = false
 ) = setGameScore(

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

@@ -0,0 +1,37 @@
+package dev.inmo.tgbotapi.extensions.api.get
+
+import dev.inmo.tgbotapi.bot.TelegramBot
+import dev.inmo.tgbotapi.requests.get.GetCustomEmojiStickers
+import dev.inmo.tgbotapi.requests.get.GetStickerSet
+import dev.inmo.tgbotapi.types.CustomEmojiId
+import dev.inmo.tgbotapi.types.files.Sticker
+import kotlin.js.JsName
+import kotlin.jvm.JvmName
+
+suspend fun TelegramBot.getCustomEmojiStickers(
+    customEmojiIds: List<CustomEmojiId>
+) = execute(
+    GetCustomEmojiStickers(customEmojiIds)
+)
+
+@JvmName("getCustomEmojiStickersWithStringsList")
+@JsName("getCustomEmojiStickersWithStringsList")
+suspend fun TelegramBot.getCustomEmojiStickers(
+    customEmojiIds: List<String>
+) = getCustomEmojiStickers(customEmojiIds.map(::CustomEmojiId))
+
+suspend fun TelegramBot.getCustomEmojiStickerOrNull(
+    customEmojiId: CustomEmojiId
+) = getCustomEmojiStickers(listOf(customEmojiId)).firstOrNull()
+
+suspend fun TelegramBot.getCustomEmojiStickerOrThrow(
+    customEmojiId: CustomEmojiId
+) = getCustomEmojiStickers(listOf(customEmojiId)).first()
+
+suspend fun TelegramBot.getCustomEmojiStickerOrNull(
+    customEmojiId: String
+) = getCustomEmojiStickerOrNull(CustomEmojiId(customEmojiId))
+
+suspend fun TelegramBot.getCustomEmojiStickerOrThrow(
+    customEmojiId: String
+) = getCustomEmojiStickerOrThrow(CustomEmojiId(customEmojiId))

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

@@ -10,7 +10,13 @@ suspend fun TelegramBot.getStickerSet(
     GetStickerSet(name)
 )
 
-suspend fun TelegramBot.getStickerSet(
+suspend fun TelegramBot.getStickerSetOrNull(
+    sticker: Sticker
+) = sticker.stickerSetName ?.let {
+    getStickerSet(it)
+}
+
+suspend fun TelegramBot.getStickerSetOrThrow(
     sticker: Sticker
 ) = getStickerSet(
     sticker.stickerSetName ?: error("Sticker must contains stickerSetName to be correctly used in getStickerSet method")

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

@@ -4,11 +4,13 @@ import dev.inmo.tgbotapi.bot.TelegramBot
 import dev.inmo.tgbotapi.requests.send.CopyMessage
 import dev.inmo.tgbotapi.types.ChatIdentifier
 import dev.inmo.tgbotapi.types.message.textsources.TextSourcesList
-import dev.inmo.tgbotapi.types.MessageIdentifier
+import dev.inmo.tgbotapi.types.MessageId
+import dev.inmo.tgbotapi.types.MessageThreadId
 import dev.inmo.tgbotapi.types.message.ParseMode
 import dev.inmo.tgbotapi.types.buttons.KeyboardMarkup
 import dev.inmo.tgbotapi.types.chat.Chat
 import dev.inmo.tgbotapi.types.message.abstracts.Message
+import dev.inmo.tgbotapi.types.threadId
 
 /**
  * @param replyMarkup Some of [KeyboardMarkup]. See [dev.inmo.tgbotapi.extensions.utils.types.buttons.replyKeyboard] or
@@ -16,17 +18,30 @@ import dev.inmo.tgbotapi.types.message.abstracts.Message
  */
 suspend inline fun TelegramBot.copyMessage(
     fromChatId: ChatIdentifier,
+    messageId: MessageId,
     toChatId: ChatIdentifier,
-    messageId: MessageIdentifier,
     text: String? = null,
     parseMode: ParseMode? = null,
+    threadId: MessageThreadId? = toChatId.threadId,
     disableNotification: Boolean = false,
     protectContent: Boolean = false,
-    replyToMessageId: MessageIdentifier? = null,
+    replyToMessageId: MessageId? = null,
     allowSendingWithoutReply: Boolean? = null,
     replyMarkup: KeyboardMarkup? = null
 ) = execute(
-    CopyMessage(fromChatId, toChatId, messageId, text, parseMode, disableNotification, protectContent, replyToMessageId, allowSendingWithoutReply, replyMarkup)
+    CopyMessage(
+        fromChatId,
+        messageId,
+        toChatId,
+        text,
+        parseMode,
+        threadId,
+        disableNotification,
+        protectContent,
+        replyToMessageId,
+        allowSendingWithoutReply,
+        replyMarkup
+    )
 )
 
 /**
@@ -35,16 +50,17 @@ suspend inline fun TelegramBot.copyMessage(
  */
 suspend inline fun TelegramBot.copyMessage(
     fromChat: Chat,
+    messageId: MessageId,
     toChatId: ChatIdentifier,
-    messageId: MessageIdentifier,
     text: String? = null,
     parseMode: ParseMode? = null,
+    threadId: MessageThreadId? = toChatId.threadId,
     disableNotification: Boolean = false,
     protectContent: Boolean = false,
-    replyToMessageId: MessageIdentifier? = null,
+    replyToMessageId: MessageId? = null,
     allowSendingWithoutReply: Boolean? = null,
     replyMarkup: KeyboardMarkup? = null
-) = copyMessage(fromChat.id, toChatId, messageId, text, parseMode, disableNotification, protectContent, replyToMessageId, allowSendingWithoutReply, replyMarkup)
+) = copyMessage(fromChat.id, messageId, toChatId, text, parseMode, threadId, disableNotification, protectContent, replyToMessageId, allowSendingWithoutReply, replyMarkup)
 
 /**
  * @param replyMarkup Some of [KeyboardMarkup]. See [dev.inmo.tgbotapi.extensions.utils.types.buttons.replyKeyboard] or
@@ -52,16 +68,17 @@ suspend inline fun TelegramBot.copyMessage(
  */
 suspend inline fun TelegramBot.copyMessage(
     fromChatId: ChatIdentifier,
+    messageId: MessageId,
     toChat: Chat,
-    messageId: MessageIdentifier,
     text: String? = null,
     parseMode: ParseMode? = null,
+    threadId: MessageThreadId? = toChat.id.threadId,
     disableNotification: Boolean = false,
     protectContent: Boolean = false,
-    replyToMessageId: MessageIdentifier? = null,
+    replyToMessageId: MessageId? = null,
     allowSendingWithoutReply: Boolean? = null,
     replyMarkup: KeyboardMarkup? = null
-) = copyMessage(fromChatId, toChat.id, messageId, text, parseMode, disableNotification, protectContent, replyToMessageId, allowSendingWithoutReply, replyMarkup)
+) = copyMessage(fromChatId, messageId, toChat.id, text, parseMode, threadId, disableNotification, protectContent, replyToMessageId, allowSendingWithoutReply, replyMarkup)
 
 /**
  * @param replyMarkup Some of [KeyboardMarkup]. See [dev.inmo.tgbotapi.extensions.utils.types.buttons.replyKeyboard] or
@@ -69,48 +86,17 @@ suspend inline fun TelegramBot.copyMessage(
  */
 suspend inline fun TelegramBot.copyMessage(
     fromChat: Chat,
+    messageId: MessageId,
     toChat: Chat,
-    messageId: MessageIdentifier,
     text: String? = null,
     parseMode: ParseMode? = null,
+    threadId: MessageThreadId? = toChat.id.threadId,
     disableNotification: Boolean = false,
     protectContent: Boolean = false,
-    replyToMessageId: MessageIdentifier? = null,
+    replyToMessageId: MessageId? = null,
     allowSendingWithoutReply: Boolean? = null,
     replyMarkup: KeyboardMarkup? = null
-) = copyMessage(fromChat.id, toChat.id, messageId, text, parseMode, disableNotification, protectContent, replyToMessageId, allowSendingWithoutReply, replyMarkup)
-
-/**
- * @param replyMarkup Some of [KeyboardMarkup]. See [dev.inmo.tgbotapi.extensions.utils.types.buttons.replyKeyboard] or
- * [dev.inmo.tgbotapi.extensions.utils.types.buttons.inlineKeyboard] as a builders for that param
- */
-suspend inline fun TelegramBot.copyMessage(
-    toChatId: ChatIdentifier,
-    message: Message,
-    text: String? = null,
-    parseMode: ParseMode? = null,
-    disableNotification: Boolean = false,
-    protectContent: Boolean = false,
-    replyToMessageId: MessageIdentifier? = null,
-    allowSendingWithoutReply: Boolean? = null,
-    replyMarkup: KeyboardMarkup? = null
-) = copyMessage(message.chat, toChatId, message.messageId, text, parseMode, disableNotification, protectContent, replyToMessageId, allowSendingWithoutReply, replyMarkup)
-
-/**
- * @param replyMarkup Some of [KeyboardMarkup]. See [dev.inmo.tgbotapi.extensions.utils.types.buttons.replyKeyboard] or
- * [dev.inmo.tgbotapi.extensions.utils.types.buttons.inlineKeyboard] as a builders for that param
- */
-suspend inline fun TelegramBot.copyMessage(
-    toChat: Chat,
-    message: Message,
-    text: String? = null,
-    parseMode: ParseMode? = null,
-    disableNotification: Boolean = false,
-    protectContent: Boolean = false,
-    replyToMessageId: MessageIdentifier? = null,
-    allowSendingWithoutReply: Boolean? = null,
-    replyMarkup: KeyboardMarkup? = null
-) = copyMessage(message.chat, toChat, message.messageId, text, parseMode, disableNotification, protectContent, replyToMessageId, allowSendingWithoutReply, replyMarkup)
+) = copyMessage(fromChat.id, messageId, toChat.id, text, parseMode, threadId, disableNotification, protectContent, replyToMessageId, allowSendingWithoutReply, replyMarkup)
 
 
 /**
@@ -119,16 +105,28 @@ suspend inline fun TelegramBot.copyMessage(
  */
 suspend inline fun TelegramBot.copyMessage(
     fromChatId: ChatIdentifier,
+    messageId: MessageId,
     toChatId: ChatIdentifier,
-    messageId: MessageIdentifier,
     entities: TextSourcesList,
+    threadId: MessageThreadId? = toChatId.threadId,
     disableNotification: Boolean = false,
     protectContent: Boolean = false,
-    replyToMessageId: MessageIdentifier? = null,
+    replyToMessageId: MessageId? = null,
     allowSendingWithoutReply: Boolean? = null,
     replyMarkup: KeyboardMarkup? = null
 ) = execute(
-    CopyMessage(fromChatId, toChatId, messageId, entities, disableNotification, protectContent, replyToMessageId, allowSendingWithoutReply, replyMarkup)
+    CopyMessage(
+        fromChatId,
+        messageId,
+        toChatId,
+        entities,
+        threadId,
+        disableNotification,
+        protectContent,
+        replyToMessageId,
+        allowSendingWithoutReply,
+        replyMarkup
+    )
 )
 
 /**
@@ -137,15 +135,16 @@ suspend inline fun TelegramBot.copyMessage(
  */
 suspend inline fun TelegramBot.copyMessage(
     fromChat: Chat,
+    messageId: MessageId,
     toChatId: ChatIdentifier,
-    messageId: MessageIdentifier,
     entities: TextSourcesList,
+    threadId: MessageThreadId? = toChatId.threadId,
     disableNotification: Boolean = false,
     protectContent: Boolean = false,
-    replyToMessageId: MessageIdentifier? = null,
+    replyToMessageId: MessageId? = null,
     allowSendingWithoutReply: Boolean? = null,
     replyMarkup: KeyboardMarkup? = null
-) = copyMessage(fromChat.id, toChatId, messageId, entities, disableNotification, protectContent, replyToMessageId, allowSendingWithoutReply, replyMarkup)
+) = copyMessage(fromChat.id, messageId, toChatId, entities, threadId, disableNotification, protectContent, replyToMessageId, allowSendingWithoutReply, replyMarkup)
 
 /**
  * @param replyMarkup Some of [KeyboardMarkup]. See [dev.inmo.tgbotapi.extensions.utils.types.buttons.replyKeyboard] or
@@ -153,15 +152,16 @@ suspend inline fun TelegramBot.copyMessage(
  */
 suspend inline fun TelegramBot.copyMessage(
     fromChatId: ChatIdentifier,
+    messageId: MessageId,
     toChat: Chat,
-    messageId: MessageIdentifier,
     entities: TextSourcesList,
+    threadId: MessageThreadId? = toChat.id.threadId,
     disableNotification: Boolean = false,
     protectContent: Boolean = false,
-    replyToMessageId: MessageIdentifier? = null,
+    replyToMessageId: MessageId? = null,
     allowSendingWithoutReply: Boolean? = null,
     replyMarkup: KeyboardMarkup? = null
-) = copyMessage(fromChatId, toChat.id, messageId, entities, disableNotification, protectContent, replyToMessageId, allowSendingWithoutReply, replyMarkup)
+) = copyMessage(fromChatId, messageId, toChat.id, entities, threadId, disableNotification, protectContent, replyToMessageId, allowSendingWithoutReply, replyMarkup)
 
 /**
  * @param replyMarkup Some of [KeyboardMarkup]. See [dev.inmo.tgbotapi.extensions.utils.types.buttons.replyKeyboard] or
@@ -169,15 +169,50 @@ suspend inline fun TelegramBot.copyMessage(
  */
 suspend inline fun TelegramBot.copyMessage(
     fromChat: Chat,
+    messageId: MessageId,
     toChat: Chat,
-    messageId: MessageIdentifier,
     entities: TextSourcesList,
+    threadId: MessageThreadId? = toChat.id.threadId,
     disableNotification: Boolean = false,
     protectContent: Boolean = false,
-    replyToMessageId: MessageIdentifier? = null,
+    replyToMessageId: MessageId? = null,
     allowSendingWithoutReply: Boolean? = null,
     replyMarkup: KeyboardMarkup? = null
-) = copyMessage(fromChat.id, toChat.id, messageId, entities, disableNotification, protectContent, replyToMessageId, allowSendingWithoutReply, replyMarkup)
+) = copyMessage(fromChat.id, messageId, toChat.id, entities, threadId, disableNotification, protectContent, replyToMessageId, allowSendingWithoutReply, replyMarkup)
+
+/**
+ * @param replyMarkup Some of [KeyboardMarkup]. See [dev.inmo.tgbotapi.extensions.utils.types.buttons.replyKeyboard] or
+ * [dev.inmo.tgbotapi.extensions.utils.types.buttons.inlineKeyboard] as a builders for that param
+ */
+suspend inline fun TelegramBot.copyMessage(
+    toChatId: ChatIdentifier,
+    message: Message,
+    text: String? = null,
+    parseMode: ParseMode? = null,
+    threadId: MessageThreadId? = toChatId.threadId,
+    disableNotification: Boolean = false,
+    protectContent: Boolean = false,
+    replyToMessageId: MessageId? = null,
+    allowSendingWithoutReply: Boolean? = null,
+    replyMarkup: KeyboardMarkup? = null
+) = copyMessage(message.chat, message.messageId, toChatId, text, parseMode, threadId, disableNotification, protectContent, replyToMessageId, allowSendingWithoutReply, replyMarkup)
+
+/**
+ * @param replyMarkup Some of [KeyboardMarkup]. See [dev.inmo.tgbotapi.extensions.utils.types.buttons.replyKeyboard] or
+ * [dev.inmo.tgbotapi.extensions.utils.types.buttons.inlineKeyboard] as a builders for that param
+ */
+suspend inline fun TelegramBot.copyMessage(
+    toChat: Chat,
+    message: Message,
+    text: String? = null,
+    parseMode: ParseMode? = null,
+    threadId: MessageThreadId? = toChat.id.threadId,
+    disableNotification: Boolean = false,
+    protectContent: Boolean = false,
+    replyToMessageId: MessageId? = null,
+    allowSendingWithoutReply: Boolean? = null,
+    replyMarkup: KeyboardMarkup? = null
+) = copyMessage(message.chat, message.messageId, toChat, text, parseMode, threadId, disableNotification, protectContent, replyToMessageId, allowSendingWithoutReply, replyMarkup)
 
 /**
  * @param replyMarkup Some of [KeyboardMarkup]. See [dev.inmo.tgbotapi.extensions.utils.types.buttons.replyKeyboard] or
@@ -187,12 +222,13 @@ suspend inline fun TelegramBot.copyMessage(
     toChatId: ChatIdentifier,
     message: Message,
     entities: TextSourcesList,
+    threadId: MessageThreadId? = toChatId.threadId,
     disableNotification: Boolean = false,
     protectContent: Boolean = false,
-    replyToMessageId: MessageIdentifier? = null,
+    replyToMessageId: MessageId? = null,
     allowSendingWithoutReply: Boolean? = null,
     replyMarkup: KeyboardMarkup? = null
-) = copyMessage(message.chat, toChatId, message.messageId, entities, disableNotification, protectContent, replyToMessageId, allowSendingWithoutReply, replyMarkup)
+) = copyMessage(message.chat, message.messageId, toChatId, entities, threadId, disableNotification, protectContent, replyToMessageId, allowSendingWithoutReply, replyMarkup)
 
 /**
  * @param replyMarkup Some of [KeyboardMarkup]. See [dev.inmo.tgbotapi.extensions.utils.types.buttons.replyKeyboard] or
@@ -202,9 +238,247 @@ suspend inline fun TelegramBot.copyMessage(
     toChat: Chat,
     message: Message,
     entities: TextSourcesList,
+    threadId: MessageThreadId? = toChat.id.threadId,
     disableNotification: Boolean = false,
     protectContent: Boolean = false,
-    replyToMessageId: MessageIdentifier? = null,
+    replyToMessageId: MessageId? = null,
     allowSendingWithoutReply: Boolean? = null,
     replyMarkup: KeyboardMarkup? = null
-) = copyMessage(message.chat, toChat, message.messageId, entities, disableNotification, protectContent, replyToMessageId, allowSendingWithoutReply, replyMarkup)
+) = copyMessage(message.chat, message.messageId, toChat, entities, threadId, disableNotification, protectContent, replyToMessageId, allowSendingWithoutReply, replyMarkup)
+
+/**
+ * @param replyMarkup Some of [KeyboardMarkup]. See [dev.inmo.tgbotapi.extensions.utils.types.buttons.replyKeyboard] or
+ * [dev.inmo.tgbotapi.extensions.utils.types.buttons.inlineKeyboard] as a builders for that param
+ */
+suspend inline fun TelegramBot.copyMessage(
+    toChatId: ChatIdentifier,
+    fromChatId: ChatIdentifier,
+    messageId: MessageId,
+    text: String? = null,
+    parseMode: ParseMode? = null,
+    threadId: MessageThreadId? = toChatId.threadId,
+    disableNotification: Boolean = false,
+    protectContent: Boolean = false,
+    replyToMessageId: MessageId? = null,
+    allowSendingWithoutReply: Boolean? = null,
+    replyMarkup: KeyboardMarkup? = null
+) = execute(
+    CopyMessage(
+        fromChatId,
+        messageId,
+        toChatId,
+        text,
+        parseMode,
+        threadId,
+        disableNotification,
+        protectContent,
+        replyToMessageId,
+        allowSendingWithoutReply,
+        replyMarkup
+    )
+)
+
+/**
+ * @param replyMarkup Some of [KeyboardMarkup]. See [dev.inmo.tgbotapi.extensions.utils.types.buttons.replyKeyboard] or
+ * [dev.inmo.tgbotapi.extensions.utils.types.buttons.inlineKeyboard] as a builders for that param
+ */
+suspend inline fun TelegramBot.copyMessage(
+    toChatId: ChatIdentifier,
+    fromChat: Chat,
+    messageId: MessageId,
+    text: String? = null,
+    parseMode: ParseMode? = null,
+    threadId: MessageThreadId? = toChatId.threadId,
+    disableNotification: Boolean = false,
+    protectContent: Boolean = false,
+    replyToMessageId: MessageId? = null,
+    allowSendingWithoutReply: Boolean? = null,
+    replyMarkup: KeyboardMarkup? = null
+) = copyMessage(
+    toChatId,
+    fromChat.id,
+    messageId,
+    text,
+    parseMode,
+    threadId,
+    disableNotification,
+    protectContent,
+    replyToMessageId,
+    allowSendingWithoutReply,
+    replyMarkup
+)
+
+/**
+ * @param replyMarkup Some of [KeyboardMarkup]. See [dev.inmo.tgbotapi.extensions.utils.types.buttons.replyKeyboard] or
+ * [dev.inmo.tgbotapi.extensions.utils.types.buttons.inlineKeyboard] as a builders for that param
+ */
+suspend inline fun TelegramBot.copyMessage(
+    toChat: Chat,
+    fromChatId: ChatIdentifier,
+    messageId: MessageId,
+    text: String? = null,
+    parseMode: ParseMode? = null,
+    threadId: MessageThreadId? = toChat.id.threadId,
+    disableNotification: Boolean = false,
+    protectContent: Boolean = false,
+    replyToMessageId: MessageId? = null,
+    allowSendingWithoutReply: Boolean? = null,
+    replyMarkup: KeyboardMarkup? = null
+) = copyMessage(
+    toChat.id,
+    fromChatId,
+    messageId,
+    text,
+    parseMode,
+    threadId,
+    disableNotification,
+    protectContent,
+    replyToMessageId,
+    allowSendingWithoutReply,
+    replyMarkup
+)
+
+/**
+ * @param replyMarkup Some of [KeyboardMarkup]. See [dev.inmo.tgbotapi.extensions.utils.types.buttons.replyKeyboard] or
+ * [dev.inmo.tgbotapi.extensions.utils.types.buttons.inlineKeyboard] as a builders for that param
+ */
+suspend inline fun TelegramBot.copyMessage(
+    toChat: Chat,
+    fromChat: Chat,
+    messageId: MessageId,
+    text: String? = null,
+    parseMode: ParseMode? = null,
+    threadId: MessageThreadId? = toChat.id.threadId,
+    disableNotification: Boolean = false,
+    protectContent: Boolean = false,
+    replyToMessageId: MessageId? = null,
+    allowSendingWithoutReply: Boolean? = null,
+    replyMarkup: KeyboardMarkup? = null
+) = copyMessage(
+    toChat.id,
+    fromChat.id,
+    messageId,
+    text,
+    parseMode,
+    threadId,
+    disableNotification,
+    protectContent,
+    replyToMessageId,
+    allowSendingWithoutReply,
+    replyMarkup
+)
+
+
+/**
+ * @param replyMarkup Some of [KeyboardMarkup]. See [dev.inmo.tgbotapi.extensions.utils.types.buttons.replyKeyboard] or
+ * [dev.inmo.tgbotapi.extensions.utils.types.buttons.inlineKeyboard] as a builders for that param
+ */
+suspend inline fun TelegramBot.copyMessage(
+    toChatId: ChatIdentifier,
+    fromChatId: ChatIdentifier,
+    messageId: MessageId,
+    entities: TextSourcesList,
+    threadId: MessageThreadId? = toChatId.threadId,
+    disableNotification: Boolean = false,
+    protectContent: Boolean = false,
+    replyToMessageId: MessageId? = null,
+    allowSendingWithoutReply: Boolean? = null,
+    replyMarkup: KeyboardMarkup? = null
+) = execute(
+    CopyMessage(
+        fromChatId,
+        messageId,
+        toChatId,
+        entities,
+        threadId,
+        disableNotification,
+        protectContent,
+        replyToMessageId,
+        allowSendingWithoutReply,
+        replyMarkup
+    )
+)
+
+/**
+ * @param replyMarkup Some of [KeyboardMarkup]. See [dev.inmo.tgbotapi.extensions.utils.types.buttons.replyKeyboard] or
+ * [dev.inmo.tgbotapi.extensions.utils.types.buttons.inlineKeyboard] as a builders for that param
+ */
+suspend inline fun TelegramBot.copyMessage(
+    toChatId: ChatIdentifier,
+    fromChat: Chat,
+    messageId: MessageId,
+    entities: TextSourcesList,
+    threadId: MessageThreadId? = toChatId.threadId,
+    disableNotification: Boolean = false,
+    protectContent: Boolean = false,
+    replyToMessageId: MessageId? = null,
+    allowSendingWithoutReply: Boolean? = null,
+    replyMarkup: KeyboardMarkup? = null
+) = copyMessage(
+    toChatId,
+    fromChat.id,
+    messageId,
+    entities,
+    threadId,
+    disableNotification,
+    protectContent,
+    replyToMessageId,
+    allowSendingWithoutReply,
+    replyMarkup
+)
+
+/**
+ * @param replyMarkup Some of [KeyboardMarkup]. See [dev.inmo.tgbotapi.extensions.utils.types.buttons.replyKeyboard] or
+ * [dev.inmo.tgbotapi.extensions.utils.types.buttons.inlineKeyboard] as a builders for that param
+ */
+suspend inline fun TelegramBot.copyMessage(
+    toChat: Chat,
+    fromChatId: ChatIdentifier,
+    messageId: MessageId,
+    entities: TextSourcesList,
+    threadId: MessageThreadId? = toChat.id.threadId,
+    disableNotification: Boolean = false,
+    protectContent: Boolean = false,
+    replyToMessageId: MessageId? = null,
+    allowSendingWithoutReply: Boolean? = null,
+    replyMarkup: KeyboardMarkup? = null
+) = copyMessage(
+    toChat.id,
+    fromChatId,
+    messageId,
+    entities,
+    threadId,
+    disableNotification,
+    protectContent,
+    replyToMessageId,
+    allowSendingWithoutReply,
+    replyMarkup
+)
+
+/**
+ * @param replyMarkup Some of [KeyboardMarkup]. See [dev.inmo.tgbotapi.extensions.utils.types.buttons.replyKeyboard] or
+ * [dev.inmo.tgbotapi.extensions.utils.types.buttons.inlineKeyboard] as a builders for that param
+ */
+suspend inline fun TelegramBot.copyMessage(
+    toChat: Chat,
+    fromChat: Chat,
+    messageId: MessageId,
+    entities: TextSourcesList,
+    threadId: MessageThreadId? = toChat.id.threadId,
+    disableNotification: Boolean = false,
+    protectContent: Boolean = false,
+    replyToMessageId: MessageId? = null,
+    allowSendingWithoutReply: Boolean? = null,
+    replyMarkup: KeyboardMarkup? = null
+) = copyMessage(
+    toChat.id,
+    fromChat.id,
+    messageId,
+    entities,
+    threadId,
+    disableNotification,
+    protectContent,
+    replyToMessageId,
+    allowSendingWithoutReply,
+    replyMarkup
+)

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

@@ -1,173 +0,0 @@
-package dev.inmo.tgbotapi.extensions.api.send
-
-import dev.inmo.tgbotapi.bot.TelegramBot
-import dev.inmo.tgbotapi.extensions.api.send.media.sendMediaGroup
-import dev.inmo.tgbotapi.types.ChatIdentifier
-import dev.inmo.tgbotapi.types.media.*
-import dev.inmo.tgbotapi.types.message.textsources.TextSourcesList
-import dev.inmo.tgbotapi.types.MessageIdentifier
-import dev.inmo.tgbotapi.types.message.ParseMode
-import dev.inmo.tgbotapi.types.chat.Chat
-import dev.inmo.tgbotapi.types.message.abstracts.MediaGroupMessage
-import dev.inmo.tgbotapi.types.message.content.MediaGroupContent
-import dev.inmo.tgbotapi.types.update.media_group.SentMediaGroupUpdate
-
-/**
- * Send media group via [sendMediaGroup] extension with edited [entities] of first [messages] element. Other elements
- * will be copied as they are
- */
-suspend inline fun TelegramBot.copyMessages(
-    toChatId: ChatIdentifier,
-    messages: List<MediaGroupMessage<MediaGroupContent>>,
-    text: String? = null,
-    parseMode: ParseMode? = null,
-    disableNotification: Boolean = false,
-    protectContent: Boolean = false,
-    replyToMessageId: MessageIdentifier? = null,
-    allowSendingWithoutReply: Boolean? = null
-): List<MediaGroupMessage<MediaGroupContent>> {
-    val first = messages.first().content.toMediaGroupMemberTelegramMedia().let {
-        if (text != null) {
-            when (it) {
-                is TelegramMediaAudio -> it.copy(text = text, parseMode = parseMode)
-                is TelegramMediaDocument -> it.copy(text = text, parseMode = parseMode)
-                is TelegramMediaPhoto -> it.copy(text = text, parseMode = parseMode)
-                is TelegramMediaVideo -> it.copy(text = text, parseMode = parseMode)
-            }
-        } else {
-            it
-        }
-    }
-
-    return sendMediaGroup(
-        toChatId,
-        listOf(first) + messages.drop(1).map {
-            it.content.toMediaGroupMemberTelegramMedia()
-        },
-        disableNotification,
-        protectContent,
-        replyToMessageId,
-        allowSendingWithoutReply
-    )
-}
-
-/**
- * Send media group via [sendMediaGroup] extension with edited [entities] of first [messages] element. Other elements
- * will be copied as they are
- */
-suspend inline fun TelegramBot.copyMessages(
-    toChat: Chat,
-    messages: List<MediaGroupMessage<MediaGroupContent>>,
-    text: String? = null,
-    parseMode: ParseMode? = null,
-    disableNotification: Boolean = false,
-    protectContent: Boolean = false,
-    replyToMessageId: MessageIdentifier? = null,
-    allowSendingWithoutReply: Boolean? = null
-) = copyMessages(toChat.id, messages, text, parseMode, disableNotification, protectContent, replyToMessageId, allowSendingWithoutReply)
-
-/**
- * Send media group via [sendMediaGroup] extension with edited [entities] of first [messages] element. Other elements
- * will be copied as they are
- */
-suspend inline fun TelegramBot.copyMessages(
-    toChat: ChatIdentifier,
-    update: SentMediaGroupUpdate,
-    text: String? = null,
-    parseMode: ParseMode? = null,
-    disableNotification: Boolean = false,
-    protectContent: Boolean = false,
-    replyToMessageId: MessageIdentifier? = null,
-    allowSendingWithoutReply: Boolean? = null
-) = copyMessages(toChat, update.data, text, parseMode, disableNotification, protectContent, replyToMessageId, allowSendingWithoutReply)
-
-/**
- * Send media group via [sendMediaGroup] extension with edited [entities] of first [messages] element. Other elements
- * will be copied as they are
- */
-suspend inline fun TelegramBot.copyMessages(
-    toChat: Chat,
-    update: SentMediaGroupUpdate,
-    text: String? = null,
-    parseMode: ParseMode? = null,
-    disableNotification: Boolean = false,
-    protectContent: Boolean = false,
-    replyToMessageId: MessageIdentifier? = null,
-    allowSendingWithoutReply: Boolean? = null
-) = copyMessages(toChat.id, update, text, parseMode, disableNotification, protectContent, replyToMessageId, allowSendingWithoutReply)
-
-/**
- * Send media group via [sendMediaGroup] extension with edited [entities] of first [messages] element. Other elements
- * will be copied as they are
- */
-suspend inline fun TelegramBot.copyMessages(
-    toChatId: ChatIdentifier,
-    messages: List<MediaGroupMessage<MediaGroupContent>>,
-    entities: TextSourcesList,
-    disableNotification: Boolean = false,
-    protectContent: Boolean = false,
-    replyToMessageId: MessageIdentifier? = null,
-    allowSendingWithoutReply: Boolean? = null
-): List<MediaGroupMessage<MediaGroupContent>> {
-    val first = messages.first().content.toMediaGroupMemberTelegramMedia().let {
-        when (it) {
-            is TelegramMediaAudio -> TelegramMediaAudio(it.file, entities, it.duration, it.performer, it.title, it.thumb)
-            is TelegramMediaDocument -> TelegramMediaDocument(it.file, entities, it.thumb, it.disableContentTypeDetection)
-            is TelegramMediaPhoto -> TelegramMediaPhoto(it.file, entities)
-            is TelegramMediaVideo -> TelegramMediaVideo(it.file, entities, it.width, it.height, it.duration, it.thumb)
-        }
-    }
-
-    return sendMediaGroup(
-        toChatId,
-        listOf(first) + messages.drop(1).map {
-            it.content.toMediaGroupMemberTelegramMedia()
-        },
-        disableNotification,
-        protectContent,
-        replyToMessageId,
-        allowSendingWithoutReply
-    )
-}
-
-/**
- * Send media group via [sendMediaGroup] extension with edited [entities] of first [messages] element. Other elements
- * will be copied as they are
- */
-suspend inline fun TelegramBot.copyMessages(
-    toChat: Chat,
-    messages: List<MediaGroupMessage<MediaGroupContent>>,
-    entities: TextSourcesList,
-    disableNotification: Boolean = false,
-    protectContent: Boolean = false,
-    replyToMessageId: MessageIdentifier? = null,
-    allowSendingWithoutReply: Boolean? = null
-) = copyMessages(toChat.id, messages, entities, disableNotification, protectContent, replyToMessageId, allowSendingWithoutReply)
-
-/**
- * Send media group via [sendMediaGroup] extension with edited [entities] of first [messages] element. Other elements
- * will be copied as they are
- */
-suspend inline fun TelegramBot.copyMessages(
-    toChat: ChatIdentifier,
-    update: SentMediaGroupUpdate,
-    entities: TextSourcesList,
-    disableNotification: Boolean = false,
-    protectContent: Boolean = false,
-    replyToMessageId: MessageIdentifier? = null,
-    allowSendingWithoutReply: Boolean? = null
-) = copyMessages(toChat, update.data, entities, disableNotification, protectContent, replyToMessageId, allowSendingWithoutReply)
-
-/**
- * Send media group via [sendMediaGroup] extension with edited [entities] of first [messages] element. Other elements
- * will be copied as they are
- */
-suspend inline fun TelegramBot.copyMessages(
-    toChat: Chat,
-    update: SentMediaGroupUpdate,
-    entities: TextSourcesList,
-    disableNotification: Boolean = false,
-    protectContent: Boolean = false,
-    replyToMessageId: MessageIdentifier? = null,
-    allowSendingWithoutReply: Boolean? = null
-) = copyMessages(toChat.id, update, entities, disableNotification, protectContent, replyToMessageId, allowSendingWithoutReply)

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

@@ -1,6 +1,7 @@
 package dev.inmo.tgbotapi.extensions.api.send
 
 import dev.inmo.tgbotapi.bot.TelegramBot
+import dev.inmo.tgbotapi.extensions.api.*
 import dev.inmo.tgbotapi.extensions.api.send.games.sendGame
 import dev.inmo.tgbotapi.extensions.api.send.media.*
 import dev.inmo.tgbotapi.extensions.api.send.payments.sendInvoice
@@ -10,7 +11,6 @@ import dev.inmo.tgbotapi.requests.abstracts.InputFile
 import dev.inmo.tgbotapi.requests.send.media.rawSendingMediaGroupsWarning
 import dev.inmo.tgbotapi.types.*
 import dev.inmo.tgbotapi.types.media.*
-import dev.inmo.tgbotapi.types.message.textsources.TextSource
 import dev.inmo.tgbotapi.types.message.textsources.TextSourcesList
 import dev.inmo.tgbotapi.types.message.ParseMode
 import dev.inmo.tgbotapi.types.buttons.InlineKeyboardMarkup
@@ -23,12 +23,18 @@ import dev.inmo.tgbotapi.types.files.Sticker
 import dev.inmo.tgbotapi.types.games.Game
 import dev.inmo.tgbotapi.types.location.*
 import dev.inmo.tgbotapi.types.message.abstracts.Message
+import dev.inmo.tgbotapi.types.message.abstracts.PossiblyTopicMessage
 import dev.inmo.tgbotapi.types.message.content.*
+import dev.inmo.tgbotapi.types.message.textsources.TextSource
 import dev.inmo.tgbotapi.types.payments.LabeledPrice
 import dev.inmo.tgbotapi.types.payments.abstracts.Currency
 import dev.inmo.tgbotapi.types.polls.*
 import dev.inmo.tgbotapi.types.venue.Venue
-import dev.inmo.tgbotapi.utils.RiskFeature
+import dev.inmo.tgbotapi.utils.*
+import dev.inmo.tgbotapi.utils.extensions.threadIdOrNull
+import kotlinx.coroutines.flow.Flow
+import kotlin.js.JsName
+import kotlin.jvm.JvmName
 
 
 // Contact
@@ -51,6 +57,7 @@ suspend inline fun TelegramBot.reply(
     phoneNumber,
     firstName,
     lastName,
+    to.threadIdOrNull,
     disableNotification,
     protectContent,
     to.messageId,
@@ -72,6 +79,7 @@ suspend inline fun TelegramBot.reply(
 ) = sendContact(
     to.chat,
     contact,
+    to.threadIdOrNull,
     disableNotification,
     protectContent,
     to.messageId,
@@ -93,7 +101,7 @@ suspend inline fun TelegramBot.replyWithDice(
     protectContent: Boolean = false,
     allowSendingWithoutReply: Boolean? = null,
     replyMarkup: KeyboardMarkup? = null
-) = sendDice(to.chat, animationType, disableNotification, protectContent, to.messageId, allowSendingWithoutReply, replyMarkup)
+) = sendDice(to.chat, animationType, to.threadIdOrNull, disableNotification, protectContent, to.messageId, allowSendingWithoutReply, replyMarkup)
 
 /**
  * @param replyMarkup Some of [KeyboardMarkup]. See [dev.inmo.tgbotapi.extensions.utils.types.buttons.replyKeyboard] or
@@ -127,6 +135,7 @@ suspend inline fun TelegramBot.reply(
     to.chat,
     latitude,
     longitude,
+    to.threadIdOrNull,
     disableNotification,
     protectContent,
     allowSendingWithoutReply,
@@ -148,6 +157,7 @@ suspend inline fun TelegramBot.reply(
 ) = sendLocation(
     to.chat,
     location,
+    to.threadIdOrNull,
     disableNotification,
     protectContent,
     allowSendingWithoutReply,
@@ -176,6 +186,7 @@ suspend inline fun TelegramBot.reply(
     text,
     parseMode,
     disableWebPagePreview,
+    to.threadIdOrNull,
     disableNotification,
     protectContent,
     to.messageId,
@@ -199,6 +210,7 @@ suspend inline fun TelegramBot.reply(
     to.chat,
     entities,
     disableWebPagePreview,
+    to.threadIdOrNull,
     disableNotification,
     protectContent,
     to.messageId,
@@ -206,6 +218,36 @@ suspend inline fun TelegramBot.reply(
     replyMarkup
 )
 
+/**
+ * @param replyMarkup Some [InlineKeyboardMarkup]. See [dev.inmo.tgbotapi.extensions.utils.types.buttons.inlineKeyboard]
+ * as a builder for that
+ */
+suspend fun TelegramBot.reply(
+    to: Message,
+    separator: TextSource? = null,
+    disableWebPagePreview: Boolean? = null,
+    disableNotification: Boolean = false,
+    protectContent: Boolean = false,
+    allowSendingWithoutReply: Boolean? = null,
+    replyMarkup: KeyboardMarkup? = null,
+    builderBody: EntitiesBuilderBody
+) = reply(to, buildEntities(separator, builderBody), disableWebPagePreview, disableNotification, protectContent, allowSendingWithoutReply, replyMarkup)
+
+/**
+ * @param replyMarkup Some [InlineKeyboardMarkup]. See [dev.inmo.tgbotapi.extensions.utils.types.buttons.inlineKeyboard]
+ * as a builder for that
+ */
+suspend fun TelegramBot.reply(
+    to: Message,
+    separator: String,
+    disableWebPagePreview: Boolean? = null,
+    disableNotification: Boolean = false,
+    protectContent: Boolean = false,
+    allowSendingWithoutReply: Boolean? = null,
+    replyMarkup: KeyboardMarkup? = null,
+    builderBody: EntitiesBuilderBody
+) = reply(to, buildEntities(separator, builderBody), disableWebPagePreview, disableNotification, protectContent, allowSendingWithoutReply, replyMarkup)
+
 
 // Venue
 
@@ -237,6 +279,7 @@ suspend inline fun TelegramBot.reply(
     foursquareType = foursquareType,
     googlePlaceId = googlePlaceId,
     googlePlaceType = googlePlaceType,
+    threadId = to.threadIdOrNull,
     disableNotification = disableNotification,
     protectContent = protectContent,
     replyToMessageId = to.messageId,
@@ -267,6 +310,7 @@ suspend inline fun TelegramBot.reply(
     foursquareType = foursquareType,
     googlePlaceId = googlePlaceId,
     googlePlaceType = googlePlaceType,
+    threadId = to.threadIdOrNull,
     disableNotification = disableNotification,
     protectContent = protectContent,
     replyToMessageId = to.messageId,
@@ -284,6 +328,7 @@ suspend inline fun TelegramBot.reply(
 ) = sendVenue(
     chat = to.chat,
     venue = venue,
+    threadId = to.threadIdOrNull,
     disableNotification = disableNotification,
     protectContent = protectContent,
     replyToMessageId = to.messageId,
@@ -302,7 +347,7 @@ suspend inline fun TelegramBot.replyWithGame(
     allowSendingWithoutReply: Boolean? = null,
     replyMarkup: KeyboardMarkup? = null
 ) = sendGame(
-    to.chat, gameShortName, disableNotification, protectContent, to.messageId, allowSendingWithoutReply, replyMarkup
+    to.chat, gameShortName, to.threadIdOrNull, disableNotification, protectContent, to.messageId, allowSendingWithoutReply, replyMarkup
 )
 
 suspend inline fun TelegramBot.replyWithGame(
@@ -313,7 +358,7 @@ suspend inline fun TelegramBot.replyWithGame(
     allowSendingWithoutReply: Boolean? = null,
     replyMarkup: KeyboardMarkup? = null
 ) = sendGame(
-    to.chat, game.title, disableNotification, protectContent, to.messageId, allowSendingWithoutReply, replyMarkup
+    to.chat, game.title, to.threadIdOrNull, disableNotification, protectContent, to.messageId, allowSendingWithoutReply, replyMarkup
 )
 
 suspend inline fun TelegramBot.reply(
@@ -334,6 +379,7 @@ suspend inline fun TelegramBot.replyWithAnimation(
     thumb: InputFile? = null,
     text: String? = null,
     parseMode: ParseMode? = null,
+    spoilered: Boolean = false,
     duration: Long? = null,
     width: Int? = null,
     height: Int? = null,
@@ -347,9 +393,11 @@ suspend inline fun TelegramBot.replyWithAnimation(
     thumb,
     text,
     parseMode,
+    spoilered,
     duration,
     width,
     height,
+    to.threadIdOrNull,
     disableNotification,
     protectContent,
     to.messageId,
@@ -362,6 +410,7 @@ suspend inline fun TelegramBot.reply(
     animation: AnimationFile,
     text: String? = null,
     parseMode: ParseMode? = null,
+    spoilered: Boolean = false,
     duration: Long? = null,
     width: Int? = null,
     height: Int? = null,
@@ -369,12 +418,13 @@ suspend inline fun TelegramBot.reply(
     protectContent: Boolean = false,
     allowSendingWithoutReply: Boolean? = null,
     replyMarkup: KeyboardMarkup? = null
-) = sendAnimation(to.chat, animation, text, parseMode, duration, width, height, disableNotification, protectContent, to.messageId, allowSendingWithoutReply, replyMarkup)
+) = sendAnimation(to.chat, animation, text, parseMode, spoilered, duration, width, height, to.threadIdOrNull, disableNotification, protectContent, to.messageId, allowSendingWithoutReply, replyMarkup)
 
 suspend inline fun TelegramBot.replyWithAnimation(
     to: Message,
     animation: InputFile,
     entities: TextSourcesList,
+    spoilered: Boolean = false,
     thumb: InputFile? = null,
     duration: Long? = null,
     width: Int? = null,
@@ -388,9 +438,11 @@ suspend inline fun TelegramBot.replyWithAnimation(
     animation,
     thumb,
     entities,
+    spoilered,
     duration,
     width,
     height,
+    to.threadIdOrNull,
     disableNotification,
     protectContent,
     to.messageId,
@@ -402,6 +454,7 @@ suspend inline fun TelegramBot.reply(
     to: Message,
     animation: AnimationFile,
     entities: TextSourcesList,
+    spoilered: Boolean = false,
     duration: Long? = null,
     width: Int? = null,
     height: Int? = null,
@@ -409,7 +462,7 @@ suspend inline fun TelegramBot.reply(
     protectContent: Boolean = false,
     allowSendingWithoutReply: Boolean? = null,
     replyMarkup: KeyboardMarkup? = null
-) = sendAnimation(to.chat, animation, entities, duration, width, height, disableNotification, protectContent, to.messageId, allowSendingWithoutReply, replyMarkup)
+) = sendAnimation(to.chat, animation, entities, spoilered, duration, width, height, to.threadIdOrNull, disableNotification, protectContent, to.messageId, allowSendingWithoutReply, replyMarkup)
 
 
 // Audio
@@ -427,7 +480,7 @@ suspend inline fun TelegramBot.replyWithAudio(
     protectContent: Boolean = false,
     allowSendingWithoutReply: Boolean? = null,
     replyMarkup: KeyboardMarkup? = null
-) = sendAudio(to.chat, audio, thumb, text, parseMode, duration, performer, title, disableNotification, protectContent, to.messageId, allowSendingWithoutReply, replyMarkup)
+) = sendAudio(to.chat, audio, thumb, text, parseMode, duration, performer, title, to.threadIdOrNull, disableNotification, protectContent, to.messageId, allowSendingWithoutReply, replyMarkup)
 
 suspend inline fun TelegramBot.reply(
     to: Message,
@@ -439,7 +492,7 @@ suspend inline fun TelegramBot.reply(
     protectContent: Boolean = false,
     allowSendingWithoutReply: Boolean? = null,
     replyMarkup: KeyboardMarkup? = null
-) = sendAudio(to.chat, audio, text, parseMode, title, disableNotification, protectContent, to.messageId, allowSendingWithoutReply, replyMarkup)
+) = sendAudio(to.chat, audio, text, parseMode, title, to.threadIdOrNull, disableNotification, protectContent, to.messageId, allowSendingWithoutReply, replyMarkup)
 
 suspend inline fun TelegramBot.replyWithAudio(
     to: Message,
@@ -453,7 +506,7 @@ suspend inline fun TelegramBot.replyWithAudio(
     protectContent: Boolean = false,
     allowSendingWithoutReply: Boolean? = null,
     replyMarkup: KeyboardMarkup? = null
-) = sendAudio(to.chat, audio, thumb, entities, duration, performer, title, disableNotification, protectContent, to.messageId, allowSendingWithoutReply, replyMarkup)
+) = sendAudio(to.chat, audio, thumb, entities, duration, performer, title, to.threadIdOrNull, disableNotification, protectContent, to.messageId, allowSendingWithoutReply, replyMarkup)
 
 suspend inline fun TelegramBot.reply(
     to: Message,
@@ -464,7 +517,7 @@ suspend inline fun TelegramBot.reply(
     protectContent: Boolean = false,
     allowSendingWithoutReply: Boolean? = null,
     replyMarkup: KeyboardMarkup? = null
-) = sendAudio(to.chat, audio, entities, title, disableNotification, protectContent, to.messageId, allowSendingWithoutReply, replyMarkup)
+) = sendAudio(to.chat, audio, entities, title, to.threadIdOrNull, disableNotification, protectContent, to.messageId, allowSendingWithoutReply, replyMarkup)
 
 
 // Documents
@@ -480,7 +533,7 @@ suspend inline fun TelegramBot.replyWithDocument(
     allowSendingWithoutReply: Boolean? = null,
     replyMarkup: KeyboardMarkup? = null,
     disableContentTypeDetection: Boolean? = null
-) = sendDocument(to.chat, document, thumb, text, parseMode, disableNotification, protectContent, to.messageId, allowSendingWithoutReply, replyMarkup, disableContentTypeDetection)
+) = sendDocument(to.chat, document, thumb, text, parseMode, to.threadIdOrNull, disableNotification, protectContent, to.messageId, allowSendingWithoutReply, replyMarkup, disableContentTypeDetection)
 
 suspend inline fun TelegramBot.reply(
     to: Message,
@@ -492,7 +545,7 @@ suspend inline fun TelegramBot.reply(
     allowSendingWithoutReply: Boolean? = null,
     replyMarkup: KeyboardMarkup? = null,
     disableContentTypeDetection: Boolean? = null
-) = sendDocument(to.chat, document, text, parseMode, disableNotification, protectContent, to.messageId, allowSendingWithoutReply, replyMarkup, disableContentTypeDetection)
+) = sendDocument(to.chat, document, text, parseMode, to.threadIdOrNull, disableNotification, protectContent, to.messageId, allowSendingWithoutReply, replyMarkup, disableContentTypeDetection)
 
 suspend inline fun TelegramBot.replyWithDocument(
     to: Message,
@@ -504,7 +557,7 @@ suspend inline fun TelegramBot.replyWithDocument(
     allowSendingWithoutReply: Boolean? = null,
     replyMarkup: KeyboardMarkup? = null,
     disableContentTypeDetection: Boolean? = null
-) = sendDocument(to.chat, document, thumb, entities, disableNotification, protectContent, to.messageId, allowSendingWithoutReply, replyMarkup, disableContentTypeDetection)
+) = sendDocument(to.chat, document, thumb, entities, to.threadIdOrNull, disableNotification, protectContent, to.messageId, allowSendingWithoutReply, replyMarkup, disableContentTypeDetection)
 
 suspend inline fun TelegramBot.reply(
     to: Message,
@@ -515,7 +568,7 @@ suspend inline fun TelegramBot.reply(
     allowSendingWithoutReply: Boolean? = null,
     replyMarkup: KeyboardMarkup? = null,
     disableContentTypeDetection: Boolean? = null
-) = sendDocument(to.chat, document, entities, disableNotification, protectContent, to.messageId, allowSendingWithoutReply, replyMarkup, disableContentTypeDetection)
+) = sendDocument(to.chat, document, entities, to.threadIdOrNull, disableNotification, protectContent, to.messageId, allowSendingWithoutReply, replyMarkup, disableContentTypeDetection)
 
 
 // Media Group
@@ -527,7 +580,7 @@ suspend inline fun TelegramBot.replyWithMediaGroup(
     disableNotification: Boolean = false,
     protectContent: Boolean = false,
     allowSendingWithoutReply: Boolean? = null
-) = sendMediaGroup(to.chat, media, disableNotification, protectContent, to.messageId, allowSendingWithoutReply)
+) = sendMediaGroup(to.chat, media, to.threadIdOrNull, disableNotification, protectContent, to.messageId, allowSendingWithoutReply)
 
 suspend inline fun TelegramBot.replyWithPlaylist(
     to: Message,
@@ -535,7 +588,7 @@ suspend inline fun TelegramBot.replyWithPlaylist(
     disableNotification: Boolean = false,
     protectContent: Boolean = false,
     allowSendingWithoutReply: Boolean? = null
-) = sendPlaylist(to.chat, media, disableNotification, protectContent, to.messageId, allowSendingWithoutReply)
+) = sendPlaylist(to.chat, media, to.threadIdOrNull, disableNotification, protectContent, to.messageId, allowSendingWithoutReply)
 
 suspend inline fun TelegramBot.replyWithDocuments(
     to: Message,
@@ -543,7 +596,7 @@ suspend inline fun TelegramBot.replyWithDocuments(
     disableNotification: Boolean = false,
     protectContent: Boolean = false,
     allowSendingWithoutReply: Boolean? = null
-) = sendDocumentsGroup(to.chat, media, disableNotification, protectContent, to.messageId, allowSendingWithoutReply)
+) = sendDocumentsGroup(to.chat, media, to.threadIdOrNull, disableNotification, protectContent, to.messageId, allowSendingWithoutReply)
 
 suspend inline fun TelegramBot.replyWithGallery(
     to: Message,
@@ -551,7 +604,7 @@ suspend inline fun TelegramBot.replyWithGallery(
     disableNotification: Boolean = false,
     protectContent: Boolean = false,
     allowSendingWithoutReply: Boolean? = null
-) = sendVisualMediaGroup(to.chat, media, disableNotification, protectContent, to.messageId, allowSendingWithoutReply)
+) = sendVisualMediaGroup(to.chat, media, to.threadIdOrNull, disableNotification, protectContent, to.messageId, allowSendingWithoutReply)
 
 
 // Photo
@@ -561,64 +614,70 @@ suspend inline fun TelegramBot.replyWithPhoto(
     fileId: InputFile,
     text: String? = null,
     parseMode: ParseMode? = null,
+    spoilered: Boolean = false,
     disableNotification: Boolean = false,
     protectContent: Boolean = false,
     allowSendingWithoutReply: Boolean? = null,
     replyMarkup: KeyboardMarkup? = null
-) = sendPhoto(to.chat, fileId, text, parseMode, disableNotification, protectContent, to.messageId, allowSendingWithoutReply, replyMarkup)
+) = sendPhoto(to.chat, fileId, text, parseMode, spoilered, to.threadIdOrNull, disableNotification, protectContent, to.messageId, allowSendingWithoutReply, replyMarkup)
 
 suspend inline fun TelegramBot.reply(
     to: Message,
     photo: Photo,
     text: String? = null,
     parseMode: ParseMode? = null,
+    spoilered: Boolean = false,
     disableNotification: Boolean = false,
     protectContent: Boolean = false,
     allowSendingWithoutReply: Boolean? = null,
     replyMarkup: KeyboardMarkup? = null
-) = sendPhoto(to.chat, photo, text, parseMode, disableNotification, protectContent, to.messageId, allowSendingWithoutReply, replyMarkup)
+) = sendPhoto(to.chat, photo, text, parseMode, spoilered, to.threadIdOrNull, disableNotification, protectContent, to.messageId, allowSendingWithoutReply, replyMarkup)
 
 suspend inline fun TelegramBot.reply(
     to: Message,
     photoSize: PhotoSize,
     text: String? = null,
     parseMode: ParseMode? = null,
+    spoilered: Boolean = false,
     disableNotification: Boolean = false,
     protectContent: Boolean = false,
     allowSendingWithoutReply: Boolean? = null,
     replyMarkup: KeyboardMarkup? = null
-) = sendPhoto(to.chat, photoSize, text, parseMode, disableNotification, protectContent, to.messageId, allowSendingWithoutReply, replyMarkup)
+) = sendPhoto(to.chat, photoSize, text, parseMode, spoilered, to.threadIdOrNull, disableNotification, protectContent, to.messageId, allowSendingWithoutReply, replyMarkup)
 
 
 suspend inline fun TelegramBot.replyWithPhoto(
     to: Message,
     fileId: InputFile,
     entities: TextSourcesList,
+    spoilered: Boolean = false,
     disableNotification: Boolean = false,
     protectContent: Boolean = false,
     allowSendingWithoutReply: Boolean? = null,
     replyMarkup: KeyboardMarkup? = null
-) = sendPhoto(to.chat, fileId, entities, disableNotification, protectContent, to.messageId, allowSendingWithoutReply, replyMarkup)
+) = sendPhoto(to.chat, fileId, entities, spoilered, to.threadIdOrNull, disableNotification, protectContent, to.messageId, allowSendingWithoutReply, replyMarkup)
 
 suspend inline fun TelegramBot.reply(
     to: Message,
     photo: Photo,
     entities: TextSourcesList,
+    spoilered: Boolean = false,
     disableNotification: Boolean = false,
     protectContent: Boolean = false,
     allowSendingWithoutReply: Boolean? = null,
     replyMarkup: KeyboardMarkup? = null
-) = sendPhoto(to.chat, photo, entities, disableNotification, protectContent, to.messageId, allowSendingWithoutReply, replyMarkup)
+) = sendPhoto(to.chat, photo, entities, spoilered, to.threadIdOrNull, disableNotification, protectContent, to.messageId, allowSendingWithoutReply, replyMarkup)
 
 suspend inline fun TelegramBot.reply(
     to: Message,
     photoSize: PhotoSize,
     entities: TextSourcesList,
+    spoilered: Boolean = false,
     disableNotification: Boolean = false,
     protectContent: Boolean = false,
     allowSendingWithoutReply: Boolean? = null,
     replyMarkup: KeyboardMarkup? = null
-) = sendPhoto(to.chat, photoSize, entities, disableNotification, protectContent, to.messageId, allowSendingWithoutReply, replyMarkup)
+) = sendPhoto(to.chat, photoSize, entities, spoilered, to.threadIdOrNull, disableNotification, protectContent, to.messageId, allowSendingWithoutReply, replyMarkup)
 
 
 // Sticker
@@ -626,20 +685,22 @@ suspend inline fun TelegramBot.reply(
 suspend inline fun TelegramBot.replyWithSticker(
     to: Message,
     sticker: InputFile,
+    emoji: String? = null,
     disableNotification: Boolean = false,
     protectContent: Boolean = false,
     allowSendingWithoutReply: Boolean? = null,
     replyMarkup: KeyboardMarkup? = null
-) = sendSticker(to.chat, sticker, disableNotification, protectContent, to.messageId, allowSendingWithoutReply, replyMarkup)
+) = sendSticker(to.chat, sticker, to.threadIdOrNull, emoji, disableNotification, protectContent, to.messageId, allowSendingWithoutReply, replyMarkup)
 
 suspend inline fun TelegramBot.reply(
     to: Message,
     sticker: Sticker,
+    emoji: String? = null,
     disableNotification: Boolean = false,
     protectContent: Boolean = false,
     allowSendingWithoutReply: Boolean? = null,
     replyMarkup: KeyboardMarkup? = null
-) = sendSticker(to.chat, sticker, disableNotification, protectContent, to.messageId, allowSendingWithoutReply, replyMarkup)
+) = sendSticker(to.chat, sticker, to.threadIdOrNull, emoji, disableNotification, protectContent, to.messageId, allowSendingWithoutReply, replyMarkup)
 
 
 // Videos
@@ -650,6 +711,7 @@ suspend inline fun TelegramBot.replyWithVideo(
     thumb: InputFile? = null,
     text: String? = null,
     parseMode: ParseMode? = null,
+    spoilered: Boolean = false,
     duration: Long? = null,
     width: Int? = null,
     height: Int? = null,
@@ -657,24 +719,26 @@ suspend inline fun TelegramBot.replyWithVideo(
     protectContent: Boolean = false,
     allowSendingWithoutReply: Boolean? = null,
     replyMarkup: KeyboardMarkup? = null
-) = sendVideo(to.chat, video, thumb, text, parseMode, duration, width, height, disableNotification, protectContent, to.messageId, allowSendingWithoutReply, replyMarkup)
+) = sendVideo(to.chat, video, thumb, text, parseMode, spoilered, duration, width, height, to.threadIdOrNull, disableNotification, protectContent, to.messageId, allowSendingWithoutReply, replyMarkup)
 
 suspend inline fun TelegramBot.reply(
     to: Message,
     video: VideoFile,
     text: String? = null,
     parseMode: ParseMode? = null,
+    spoilered: Boolean = false,
     disableNotification: Boolean = false,
     protectContent: Boolean = false,
     allowSendingWithoutReply: Boolean? = null,
     replyMarkup: KeyboardMarkup? = null
-) = sendVideo(to.chat, video, text, parseMode, disableNotification, protectContent, to.messageId, allowSendingWithoutReply, replyMarkup)
+) = sendVideo(to.chat, video, text, parseMode, spoilered, to.threadIdOrNull, disableNotification, protectContent, to.messageId, allowSendingWithoutReply, replyMarkup)
 
 suspend inline fun TelegramBot.replyWithVideo(
     to: Message,
     video: InputFile,
     thumb: InputFile? = null,
     entities: TextSourcesList,
+    spoilered: Boolean = false,
     duration: Long? = null,
     width: Int? = null,
     height: Int? = null,
@@ -682,17 +746,18 @@ suspend inline fun TelegramBot.replyWithVideo(
     protectContent: Boolean = false,
     allowSendingWithoutReply: Boolean? = null,
     replyMarkup: KeyboardMarkup? = null
-) = sendVideo(to.chat, video, thumb, entities, duration, width, height, disableNotification, protectContent, to.messageId, allowSendingWithoutReply, replyMarkup)
+) = sendVideo(to.chat, video, thumb, entities, spoilered, duration, width, height, to.threadIdOrNull, disableNotification, protectContent, to.messageId, allowSendingWithoutReply, replyMarkup)
 
 suspend inline fun TelegramBot.reply(
     to: Message,
     video: VideoFile,
     entities: TextSourcesList,
+    spoilered: Boolean = false,
     disableNotification: Boolean = false,
     protectContent: Boolean = false,
     allowSendingWithoutReply: Boolean? = null,
     replyMarkup: KeyboardMarkup? = null
-) = sendVideo(to.chat, video, entities, disableNotification, protectContent, to.messageId, allowSendingWithoutReply, replyMarkup)
+) = sendVideo(to.chat, video, entities, spoilered, to.threadIdOrNull, disableNotification, protectContent, to.messageId, allowSendingWithoutReply, replyMarkup)
 
 
 // VideoNotes
@@ -707,7 +772,7 @@ suspend inline fun TelegramBot.replyWithVideoNote(
     protectContent: Boolean = false,
     allowSendingWithoutReply: Boolean? = null,
     replyMarkup: KeyboardMarkup? = null
-) = sendVideoNote(to.chat, videoNote, thumb, duration, size, disableNotification, protectContent, to.messageId, allowSendingWithoutReply, replyMarkup)
+) = sendVideoNote(to.chat, videoNote, thumb, duration, size, to.threadIdOrNull, disableNotification, protectContent, to.messageId, allowSendingWithoutReply, replyMarkup)
 
 suspend inline fun TelegramBot.reply(
     to: Message,
@@ -716,7 +781,7 @@ suspend inline fun TelegramBot.reply(
     protectContent: Boolean = false,
     allowSendingWithoutReply: Boolean? = null,
     replyMarkup: KeyboardMarkup? = null
-) = sendVideoNote(to.chat, videoNote, disableNotification, protectContent, to.messageId, allowSendingWithoutReply, replyMarkup)
+) = sendVideoNote(to.chat, videoNote, to.threadIdOrNull, disableNotification, protectContent, to.messageId, allowSendingWithoutReply, replyMarkup)
 
 
 // Voice
@@ -731,7 +796,7 @@ suspend inline fun TelegramBot.replyWithVoice(
     protectContent: Boolean = false,
     allowSendingWithoutReply: Boolean? = null,
     replyMarkup: KeyboardMarkup? = null
-) = sendVoice(to.chat, voice, text, parseMode, duration, disableNotification, protectContent, to.messageId, allowSendingWithoutReply, replyMarkup)
+) = sendVoice(to.chat, voice, text, parseMode, duration, to.threadIdOrNull, disableNotification, protectContent, to.messageId, allowSendingWithoutReply, replyMarkup)
 
 suspend inline fun TelegramBot.reply(
     to: Message,
@@ -742,7 +807,7 @@ suspend inline fun TelegramBot.reply(
     protectContent: Boolean = false,
     allowSendingWithoutReply: Boolean? = null,
     replyMarkup: KeyboardMarkup? = null
-) = sendVoice(to.chat, voice, text, parseMode, disableNotification, protectContent, to.messageId, allowSendingWithoutReply, replyMarkup)
+) = sendVoice(to.chat, voice, text, parseMode, to.threadIdOrNull, disableNotification, protectContent, to.messageId, allowSendingWithoutReply, replyMarkup)
 
 
 suspend inline fun TelegramBot.replyWithVoice(
@@ -754,7 +819,7 @@ suspend inline fun TelegramBot.replyWithVoice(
     protectContent: Boolean = false,
     allowSendingWithoutReply: Boolean? = null,
     replyMarkup: KeyboardMarkup? = null
-) = sendVoice(to.chat, voice, entities, duration, disableNotification, protectContent, to.messageId, allowSendingWithoutReply, replyMarkup)
+) = sendVoice(to.chat, voice, entities, duration, to.threadIdOrNull, disableNotification, protectContent, to.messageId, allowSendingWithoutReply, replyMarkup)
 
 suspend inline fun TelegramBot.reply(
     to: Message,
@@ -764,7 +829,7 @@ suspend inline fun TelegramBot.reply(
     protectContent: Boolean = false,
     allowSendingWithoutReply: Boolean? = null,
     replyMarkup: KeyboardMarkup? = null
-) = sendVoice(to.chat, voice, entities, disableNotification, protectContent, to.messageId, allowSendingWithoutReply, replyMarkup)
+) = sendVoice(to.chat, voice, entities, to.threadIdOrNull, disableNotification, protectContent, to.messageId, allowSendingWithoutReply, replyMarkup)
 
 
 // Invoice
@@ -796,7 +861,7 @@ suspend inline fun TelegramBot.reply(
     protectContent: Boolean = false,
     allowSendingWithoutReply: Boolean? = null,
     replyMarkup: InlineKeyboardMarkup? = null
-) = sendInvoice(to.chat.id, title, description, payload, providerToken, currency, prices, maxTipAmount, suggestedTipAmounts, startParameter, providerData, requireName, requirePhoneNumber, requireEmail, requireShippingAddress, shouldSendPhoneNumberToProvider, shouldSendEmailToProvider, priceDependOnShipAddress, disableNotification, protectContent, to.messageId, allowSendingWithoutReply, replyMarkup)
+) = sendInvoice(to.chat.id, title, description, payload, providerToken, currency, prices, maxTipAmount, suggestedTipAmounts, startParameter, providerData, requireName, requirePhoneNumber, requireEmail, requireShippingAddress, shouldSendPhoneNumberToProvider, shouldSendEmailToProvider, priceDependOnShipAddress, to.threadIdOrNull, disableNotification, protectContent, to.messageId, allowSendingWithoutReply, replyMarkup)
 
 
 // Polls
@@ -813,7 +878,7 @@ suspend inline fun TelegramBot.reply(
     protectContent: Boolean = false,
     allowSendingWithoutReply: Boolean? = null,
     replyMarkup: KeyboardMarkup? = null
-) = sendRegularPoll(to.chat, question, options, isAnonymous, isClosed, allowMultipleAnswers, closeInfo, disableNotification, protectContent, to.messageId, allowSendingWithoutReply, replyMarkup)
+) = sendRegularPoll(to.chat, question, options, isAnonymous, isClosed, allowMultipleAnswers, closeInfo, to.threadIdOrNull, disableNotification, protectContent, to.messageId, allowSendingWithoutReply, replyMarkup)
 
 suspend inline fun TelegramBot.reply(
     to: Message,
@@ -828,7 +893,7 @@ suspend inline fun TelegramBot.reply(
     protectContent: Boolean = false,
     allowSendingWithoutReply: Boolean? = null,
     replyMarkup: KeyboardMarkup? = null
-) = sendRegularPoll(to.chat, poll, isClosed, question, options, isAnonymous, allowMultipleAnswers, closeInfo, disableNotification, protectContent, to.messageId, allowSendingWithoutReply, replyMarkup)
+) = sendRegularPoll(to.chat, poll, isClosed, question, options, isAnonymous, allowMultipleAnswers, closeInfo, to.threadIdOrNull, disableNotification, protectContent, to.messageId, allowSendingWithoutReply, replyMarkup)
 
 suspend inline fun TelegramBot.reply(
     to: Message,
@@ -844,7 +909,7 @@ suspend inline fun TelegramBot.reply(
     protectContent: Boolean = false,
     allowSendingWithoutReply: Boolean? = null,
     replyMarkup: KeyboardMarkup? = null
-) = sendQuizPoll(to.chat, question, options, correctOptionId, isAnonymous, isClosed, explanation, parseMode, closeInfo, disableNotification, protectContent, to.messageId, allowSendingWithoutReply, replyMarkup)
+) = sendQuizPoll(to.chat, question, options, correctOptionId, isAnonymous, isClosed, explanation, parseMode, closeInfo, to.threadIdOrNull, disableNotification, protectContent, to.messageId, allowSendingWithoutReply, replyMarkup)
 
 suspend inline fun TelegramBot.reply(
     to: Message,
@@ -861,7 +926,7 @@ suspend inline fun TelegramBot.reply(
     protectContent: Boolean = false,
     allowSendingWithoutReply: Boolean? = null,
     replyMarkup: KeyboardMarkup? = null
-) = sendQuizPoll(to.chat, isClosed, quizPoll, question, options, correctOptionId, isAnonymous, explanation, parseMode, closeInfo, disableNotification, protectContent, to.messageId, allowSendingWithoutReply, replyMarkup)
+) = sendQuizPoll(to.chat, isClosed, quizPoll, question, options, correctOptionId, isAnonymous, explanation, parseMode, closeInfo, to.threadIdOrNull, disableNotification, protectContent, to.messageId, allowSendingWithoutReply, replyMarkup)
 
 suspend inline fun TelegramBot.reply(
     to: Message,
@@ -876,7 +941,7 @@ suspend inline fun TelegramBot.reply(
     protectContent: Boolean = false,
     allowSendingWithoutReply: Boolean? = null,
     replyMarkup: KeyboardMarkup? = null
-) = sendQuizPoll(to.chat, question, options, correctOptionId, isAnonymous, isClosed, entities, closeInfo, disableNotification, protectContent, to.messageId, allowSendingWithoutReply, replyMarkup)
+) = sendQuizPoll(to.chat, question, options, correctOptionId, isAnonymous, isClosed, entities, closeInfo, to.threadIdOrNull, disableNotification, protectContent, to.messageId, allowSendingWithoutReply, replyMarkup)
 
 suspend inline fun TelegramBot.reply(
     to: Message,
@@ -892,7 +957,7 @@ suspend inline fun TelegramBot.reply(
     protectContent: Boolean = false,
     allowSendingWithoutReply: Boolean? = null,
     replyMarkup: KeyboardMarkup? = null
-) = sendQuizPoll(to.chat, isClosed, quizPoll, question, options, correctOptionId, isAnonymous, entities, closeInfo, disableNotification, protectContent, to.messageId, allowSendingWithoutReply, replyMarkup)
+) = sendQuizPoll(to.chat, isClosed, quizPoll, question, options, correctOptionId, isAnonymous, entities, closeInfo, to.threadIdOrNull, disableNotification, protectContent, to.messageId, allowSendingWithoutReply, replyMarkup)
 
 
 suspend inline fun TelegramBot.reply(
@@ -943,19 +1008,31 @@ suspend inline fun TelegramBot.reply(
 suspend inline fun TelegramBot.reply(
     to: Message,
     fromChatId: ChatIdentifier,
-    messageId: MessageIdentifier,
+    messageId: MessageId,
     text: String? = null,
     parseMode: ParseMode? = null,
     disableNotification: Boolean = false,
     protectContent: Boolean = false,
     allowSendingWithoutReply: Boolean? = null,
     replyMarkup: KeyboardMarkup? = null
-) = copyMessage(fromChatId, to.chat.id, messageId, text, parseMode, disableNotification, protectContent, to.messageId, allowSendingWithoutReply, replyMarkup)
+) = copyMessage(
+    to.chat.id,
+    fromChatId,
+    messageId,
+    text,
+    parseMode,
+    to.threadIdOrNull,
+    disableNotification,
+    protectContent,
+    to.messageId,
+    allowSendingWithoutReply,
+    replyMarkup
+)
 
 suspend inline fun TelegramBot.reply(
     to: Message,
     fromChat: Chat,
-    messageId: MessageIdentifier,
+    messageId: MessageId,
     text: String? = null,
     parseMode: ParseMode? = null,
     disableNotification: Boolean = false,
@@ -982,16 +1059,92 @@ suspend fun TelegramBot.reply(
     protectContent: Boolean = false,
     allowSendingWithoutReply: Boolean? = null,
     replyMarkup: KeyboardMarkup? = null
+): Message = execute(
+    content.createResend(
+        to.chat.id,
+        to.threadIdOrNull,
+        disableNotification,
+        protectContent,
+        to.messageId,
+        allowSendingWithoutReply,
+        replyMarkup
+    )
+)
+
+/**
+ * Will use [handleLiveLocation] with replying to [message] each time new message will be sent by live location update
+ *
+ * @see handleLiveLocation
+ */
+suspend fun TelegramBot.reply(
+    message: Message,
+    locationsFlow: Flow<EditLiveLocationInfo>,
+    liveTimeMillis: Long = defaultLivePeriodDelayMillis,
+    disableNotification: Boolean = false,
+    protectContent: Boolean = false,
+    allowSendingWithoutReply: Boolean? = null
+) = handleLiveLocation(
+    message.chat.id,
+    locationsFlow,
+    liveTimeMillis,
+    message.threadIdOrNull,
+    disableNotification,
+    protectContent,
+    message.messageId,
+    allowSendingWithoutReply
+)
+
+/**
+ * Will use [handleLiveLocation] with replying to [message] each time new message will be sent by live location update
+ *
+ * @see handleLiveLocation
+ */
+@JvmName("replyLiveLocationWithLocation")
+@JsName("replyLiveLocationWithLocation")
+suspend fun TelegramBot.reply(
+    message: Message,
+    locationsFlow: Flow<Location>,
+    liveTimeMillis: Long = defaultLivePeriodDelayMillis,
+    disableNotification: Boolean = false,
+    protectContent: Boolean = false,
+    allowSendingWithoutReply: Boolean? = null
 ) {
-    execute(
-        content.createResend(
-            to.chat.id,
-            disableNotification,
-            protectContent,
-            to.messageId,
-            allowSendingWithoutReply,
-            replyMarkup
-        )
+    handleLiveLocation(
+        message.chat.id,
+        locationsFlow,
+        liveTimeMillis,
+        message.threadIdOrNull,
+        disableNotification,
+        protectContent,
+        message.messageId,
+        allowSendingWithoutReply
+    )
+}
+
+/**
+ * Will use [handleLiveLocation] with replying to [message] each time new message will be sent by live location update
+ *
+ * @see handleLiveLocation
+ */
+@JvmName("replyLiveLocationWithLatLong")
+@JsName("replyLiveLocationWithLatLong")
+suspend fun TelegramBot.reply(
+    message: Message,
+    locationsFlow: Flow<Pair<Double, Double>>,
+    liveTimeMillis: Long = defaultLivePeriodDelayMillis,
+    disableNotification: Boolean = false,
+    protectContent: Boolean = false,
+    allowSendingWithoutReply: Boolean? = null
+) {
+    handleLiveLocation(
+        message.chat.id,
+        locationsFlow,
+        liveTimeMillis,
+        message.threadIdOrNull,
+        disableNotification,
+        protectContent,
+        message.messageId,
+        allowSendingWithoutReply
     )
 }
 
@@ -1100,7 +1253,7 @@ suspend fun TelegramBot.reply(
             allowSendingWithoutReply = allowSendingWithoutReply,
             replyMarkup = replyMarkup
         )
-        is AudioMediaGroupContent -> reply(
+        is AudioMediaGroupPartContent -> reply(
             to = to,
             audio = content.media,
             text = text,
@@ -1156,7 +1309,7 @@ suspend fun TelegramBot.reply(
 suspend fun TelegramBot.reply(
     to: Message,
     content: TextedMediaContent,
-    entities: List<TextSource>,
+    entities: TextSourcesList,
     disableNotification: Boolean = false,
     protectContent: Boolean = false,
     allowSendingWithoutReply: Boolean? = null,
@@ -1172,7 +1325,7 @@ suspend fun TelegramBot.reply(
             allowSendingWithoutReply = allowSendingWithoutReply,
             replyMarkup = replyMarkup
         )
-        is AudioMediaGroupContent -> reply(
+        is AudioMediaGroupPartContent -> reply(
             to = to,
             audio = content.media,
             entities = entities,

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

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

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

@@ -3,104 +3,129 @@ package dev.inmo.tgbotapi.extensions.api.send
 import dev.inmo.tgbotapi.bot.TelegramBot
 import dev.inmo.tgbotapi.requests.send.SendAction
 import dev.inmo.tgbotapi.types.ChatIdentifier
+import dev.inmo.tgbotapi.types.MessageThreadId
 import dev.inmo.tgbotapi.types.actions.*
 import dev.inmo.tgbotapi.types.chat.Chat
+import dev.inmo.tgbotapi.types.threadId
 
 suspend fun TelegramBot.sendBotAction(
     chatId: ChatIdentifier,
-    action: BotAction
+    action: BotAction,
+    threadId: MessageThreadId? = chatId.threadId
 ) = execute(
-    SendAction(chatId, action)
+    SendAction(chatId, action, threadId)
 )
 
 suspend fun TelegramBot.sendBotAction(
     chat: Chat,
-    action: BotAction
-) = sendBotAction(chat.id, action)
+    action: BotAction,
+    threadId: MessageThreadId? = chat.id.threadId
+) = sendBotAction(chat.id, action, threadId)
 
 
 suspend fun TelegramBot.sendActionTyping(
-    chatId: ChatIdentifier
-) = sendBotAction(chatId, TypingAction)
+    chatId: ChatIdentifier,
+    threadId: MessageThreadId? = chatId.threadId
+) = sendBotAction(chatId, TypingAction, threadId)
 
 suspend fun TelegramBot.sendActionUploadPhoto(
-    chatId: ChatIdentifier
-) = sendBotAction(chatId, UploadPhotoAction)
+    chatId: ChatIdentifier,
+    threadId: MessageThreadId? = chatId.threadId
+) = sendBotAction(chatId, UploadPhotoAction, threadId)
 
 suspend fun TelegramBot.sendActionRecordVideo(
-    chatId: ChatIdentifier
-) = sendBotAction(chatId, RecordVideoAction)
+    chatId: ChatIdentifier,
+    threadId: MessageThreadId? = chatId.threadId
+) = sendBotAction(chatId, RecordVideoAction, threadId)
 
 suspend fun TelegramBot.sendActionUploadVideo(
-    chatId: ChatIdentifier
-) = sendBotAction(chatId, UploadVideoAction)
+    chatId: ChatIdentifier,
+    threadId: MessageThreadId? = chatId.threadId
+) = sendBotAction(chatId, UploadVideoAction, threadId)
 
 suspend fun TelegramBot.sendActionRecordVoice(
-    chatId: ChatIdentifier
-) = sendBotAction(chatId, RecordVoiceAction)
+    chatId: ChatIdentifier,
+    threadId: MessageThreadId? = chatId.threadId
+) = sendBotAction(chatId, RecordVoiceAction, threadId)
 
 suspend fun TelegramBot.sendActionUploadVoice(
-    chatId: ChatIdentifier
-) = sendBotAction(chatId, UploadVoiceAction)
+    chatId: ChatIdentifier,
+    threadId: MessageThreadId? = chatId.threadId
+) = sendBotAction(chatId, UploadVoiceAction, threadId)
 
 suspend fun TelegramBot.sendActionUploadDocument(
-    chatId: ChatIdentifier
-) = sendBotAction(chatId, UploadDocumentAction)
+    chatId: ChatIdentifier,
+    threadId: MessageThreadId? = chatId.threadId
+) = sendBotAction(chatId, UploadDocumentAction, threadId)
 
 suspend fun TelegramBot.sendActionFindLocation(
-    chatId: ChatIdentifier
-) = sendBotAction(chatId, FindLocationAction)
+    chatId: ChatIdentifier,
+    threadId: MessageThreadId? = chatId.threadId
+) = sendBotAction(chatId, FindLocationAction, threadId)
 
 suspend fun TelegramBot.sendActionRecordVideoNote(
-    chatId: ChatIdentifier
-) = sendBotAction(chatId, RecordVideoNoteAction)
+    chatId: ChatIdentifier,
+    threadId: MessageThreadId? = chatId.threadId
+) = sendBotAction(chatId, RecordVideoNoteAction, threadId)
 
 suspend fun TelegramBot.sendActionUploadVideoNote(
-    chatId: ChatIdentifier
-) = sendBotAction(chatId, UploadVideoNoteAction)
+    chatId: ChatIdentifier,
+    threadId: MessageThreadId? = chatId.threadId
+) = sendBotAction(chatId, UploadVideoNoteAction, threadId)
 
 
 suspend fun TelegramBot.sendActionTyping(
-    chat: Chat
-) = sendBotAction(chat, TypingAction)
+    chat: Chat,
+    threadId: MessageThreadId? = chat.id.threadId
+) = sendBotAction(chat, TypingAction, threadId)
 
 suspend fun TelegramBot.sendActionUploadPhoto(
-    chat: Chat
-) = sendBotAction(chat, UploadPhotoAction)
+    chat: Chat,
+    threadId: MessageThreadId? = chat.id.threadId
+) = sendBotAction(chat, UploadPhotoAction, threadId)
 
 suspend fun TelegramBot.sendActionRecordVideo(
-    chat: Chat
-) = sendBotAction(chat, RecordVideoAction)
+    chat: Chat,
+    threadId: MessageThreadId? = chat.id.threadId
+) = sendBotAction(chat, RecordVideoAction, threadId)
 
 suspend fun TelegramBot.sendActionUploadVideo(
-    chat: Chat
-) = sendBotAction(chat, UploadVideoAction)
+    chat: Chat,
+    threadId: MessageThreadId? = chat.id.threadId
+) = sendBotAction(chat, UploadVideoAction, threadId)
 
 suspend fun TelegramBot.sendActionRecordVoice(
-    chat: Chat
-) = sendBotAction(chat, RecordVoiceAction)
+    chat: Chat,
+    threadId: MessageThreadId? = chat.id.threadId
+) = sendBotAction(chat, RecordVoiceAction, threadId)
 
 suspend fun TelegramBot.sendActionUploadVoice(
-    chat: Chat
-) = sendBotAction(chat, UploadVoiceAction)
+    chat: Chat,
+    threadId: MessageThreadId? = chat.id.threadId
+) = sendBotAction(chat, UploadVoiceAction, threadId)
 
 suspend fun TelegramBot.sendActionUploadDocument(
-    chat: Chat
-) = sendBotAction(chat, UploadDocumentAction)
+    chat: Chat,
+    threadId: MessageThreadId? = chat.id.threadId
+) = sendBotAction(chat, UploadDocumentAction, threadId)
 
 suspend fun TelegramBot.sendActionFindLocation(
-    chat: Chat
-) = sendBotAction(chat, FindLocationAction)
+    chat: Chat,
+    threadId: MessageThreadId? = chat.id.threadId
+) = sendBotAction(chat, FindLocationAction, threadId)
 
 suspend fun TelegramBot.sendActionRecordVideoNote(
-    chat: Chat
-) = sendBotAction(chat, RecordVideoNoteAction)
+    chat: Chat,
+    threadId: MessageThreadId? = chat.id.threadId
+) = sendBotAction(chat, RecordVideoNoteAction, threadId)
 
 suspend fun TelegramBot.sendActionUploadVideoNote(
-    chat: Chat
-) = sendBotAction(chat, UploadVideoNoteAction)
+    chat: Chat,
+    threadId: MessageThreadId? = chat.id.threadId
+) = sendBotAction(chat, UploadVideoNoteAction, threadId)
 
 suspend fun TelegramBot.sendActionChooseStickerAction(
-    chat: Chat
-) = sendBotAction(chat, ChooseStickerAction)
+    chat: Chat,
+    threadId: MessageThreadId? = chat.id.threadId
+) = sendBotAction(chat, ChooseStickerAction, threadId)
 

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

@@ -9,7 +9,6 @@ import dev.inmo.tgbotapi.types.actions.*
 import dev.inmo.tgbotapi.types.chat.Chat
 import kotlinx.coroutines.*
 import kotlin.contracts.*
-import kotlin.coroutines.coroutineContext
 
 private const val refreshTime: MilliSeconds = (botActionActualityTime - 1) * 1000L
 typealias TelegramBotActionCallback<T> = suspend TelegramBot.() -> T
@@ -37,15 +36,16 @@ suspend fun <T> TelegramBot.withAction(
 
 @OptIn(ExperimentalContracts::class)
 suspend fun <T> TelegramBot.withAction(
-    chatId: ChatId,
+    chatId: IdChatIdentifier,
     action: BotAction,
+    threadId: MessageThreadId? = chatId.threadId,
     block: TelegramBotActionCallback<T>
 ): T {
     contract {
         callsInPlace(block, InvocationKind.EXACTLY_ONCE)
     }
     return withAction(
-        SendAction(chatId, action),
+        SendAction(chatId, action, threadId),
         block
     )
 }
@@ -54,6 +54,7 @@ suspend fun <T> TelegramBot.withAction(
 suspend fun <T> TelegramBot.withAction(
     chat: Chat,
     action: BotAction,
+    threadId: MessageThreadId? = chat.id.threadId,
     block: TelegramBotActionCallback<T>
 ): T {
     contract {
@@ -62,163 +63,164 @@ suspend fun <T> TelegramBot.withAction(
     return withAction(
         chat.id,
         action,
+        threadId,
         block
     )
 }
 
 @OptIn(ExperimentalContracts::class)
-suspend fun <T> TelegramBot.withTypingAction(chatId: ChatId, block: TelegramBotActionCallback<T>) : T {
+suspend fun <T> TelegramBot.withTypingAction(chatId: IdChatIdentifier, threadId: MessageThreadId? = chatId.threadId,block: TelegramBotActionCallback<T>) : T {
     contract {
         callsInPlace(block, InvocationKind.EXACTLY_ONCE)
     }
-    return withAction(chatId, TypingAction, block)
+    return withAction(chatId, TypingAction, threadId, block)
 }
 @OptIn(ExperimentalContracts::class)
-suspend fun <T> TelegramBot.withUploadPhotoAction(chatId: ChatId, block: TelegramBotActionCallback<T>) : T {
+suspend fun <T> TelegramBot.withUploadPhotoAction(chatId: IdChatIdentifier, threadId: MessageThreadId? = chatId.threadId,block: TelegramBotActionCallback<T>) : T {
     contract {
         callsInPlace(block, InvocationKind.EXACTLY_ONCE)
     }
-    return withAction(chatId, UploadPhotoAction, block)
+    return withAction(chatId, UploadPhotoAction, threadId, block)
 }
 @OptIn(ExperimentalContracts::class)
-suspend fun <T> TelegramBot.withRecordVideoAction(chatId: ChatId, block: TelegramBotActionCallback<T>) : T {
+suspend fun <T> TelegramBot.withRecordVideoAction(chatId: IdChatIdentifier, threadId: MessageThreadId? = chatId.threadId,block: TelegramBotActionCallback<T>) : T {
     contract {
         callsInPlace(block, InvocationKind.EXACTLY_ONCE)
     }
-    return withAction(chatId, RecordVideoAction, block)
+    return withAction(chatId, RecordVideoAction, threadId, block)
 }
 @OptIn(ExperimentalContracts::class)
-suspend fun <T> TelegramBot.withUploadVideoAction(chatId: ChatId, block: TelegramBotActionCallback<T>) : T {
+suspend fun <T> TelegramBot.withUploadVideoAction(chatId: IdChatIdentifier, threadId: MessageThreadId? = chatId.threadId,block: TelegramBotActionCallback<T>) : T {
     contract {
         callsInPlace(block, InvocationKind.EXACTLY_ONCE)
     }
-    return withAction(chatId, UploadVideoAction, block)
+    return withAction(chatId, UploadVideoAction, threadId, block)
 }
 @OptIn(ExperimentalContracts::class)
-suspend fun <T> TelegramBot.withRecordVoiceAction(chatId: ChatId, block: TelegramBotActionCallback<T>) : T {
+suspend fun <T> TelegramBot.withRecordVoiceAction(chatId: IdChatIdentifier, threadId: MessageThreadId? = chatId.threadId,block: TelegramBotActionCallback<T>) : T {
     contract {
         callsInPlace(block, InvocationKind.EXACTLY_ONCE)
     }
-    return withAction(chatId, RecordVoiceAction, block)
+    return withAction(chatId, RecordVoiceAction, threadId, block)
 }
 @OptIn(ExperimentalContracts::class)
-suspend fun <T> TelegramBot.withUploadVoiceAction(chatId: ChatId, block: TelegramBotActionCallback<T>) : T {
+suspend fun <T> TelegramBot.withUploadVoiceAction(chatId: IdChatIdentifier, threadId: MessageThreadId? = chatId.threadId,block: TelegramBotActionCallback<T>) : T {
     contract {
         callsInPlace(block, InvocationKind.EXACTLY_ONCE)
     }
-    return withAction(chatId, UploadVoiceAction, block)
+    return withAction(chatId, UploadVoiceAction, threadId, block)
 }
 @OptIn(ExperimentalContracts::class)
-suspend fun <T> TelegramBot.withUploadDocumentAction(chatId: ChatId, block: TelegramBotActionCallback<T>) : T {
+suspend fun <T> TelegramBot.withUploadDocumentAction(chatId: IdChatIdentifier, threadId: MessageThreadId? = chatId.threadId,block: TelegramBotActionCallback<T>) : T {
     contract {
         callsInPlace(block, InvocationKind.EXACTLY_ONCE)
     }
-    return withAction(chatId, UploadDocumentAction, block)
+    return withAction(chatId, UploadDocumentAction, threadId, block)
 }
 @OptIn(ExperimentalContracts::class)
-suspend fun <T> TelegramBot.withFindLocationAction(chatId: ChatId, block: TelegramBotActionCallback<T>) : T {
+suspend fun <T> TelegramBot.withFindLocationAction(chatId: IdChatIdentifier, threadId: MessageThreadId? = chatId.threadId,block: TelegramBotActionCallback<T>) : T {
     contract {
         callsInPlace(block, InvocationKind.EXACTLY_ONCE)
     }
-    return withAction(chatId, FindLocationAction, block)
+    return withAction(chatId, FindLocationAction, threadId, block)
 }
 @OptIn(ExperimentalContracts::class)
-suspend fun <T> TelegramBot.withRecordVideoNoteAction(chatId: ChatId, block: TelegramBotActionCallback<T>) : T {
+suspend fun <T> TelegramBot.withRecordVideoNoteAction(chatId: IdChatIdentifier, threadId: MessageThreadId? = chatId.threadId,block: TelegramBotActionCallback<T>) : T {
     contract {
         callsInPlace(block, InvocationKind.EXACTLY_ONCE)
     }
-    return withAction(chatId, RecordVideoNoteAction, block)
+    return withAction(chatId, RecordVideoNoteAction, threadId, block)
 }
 @OptIn(ExperimentalContracts::class)
-suspend fun <T> TelegramBot.withUploadVideoNoteAction(chatId: ChatId, block: TelegramBotActionCallback<T>) : T {
+suspend fun <T> TelegramBot.withUploadVideoNoteAction(chatId: IdChatIdentifier, threadId: MessageThreadId? = chatId.threadId,block: TelegramBotActionCallback<T>) : T {
     contract {
         callsInPlace(block, InvocationKind.EXACTLY_ONCE)
     }
-    return withAction(chatId, UploadVideoNoteAction, block)
+    return withAction(chatId, UploadVideoNoteAction, threadId, block)
 }
 @OptIn(ExperimentalContracts::class)
-suspend fun <T> TelegramBot.withChooseStickerAction(chatId: ChatId, block: TelegramBotActionCallback<T>) : T {
+suspend fun <T> TelegramBot.withChooseStickerAction(chatId: IdChatIdentifier, threadId: MessageThreadId? = chatId.threadId,block: TelegramBotActionCallback<T>) : T {
     contract {
         callsInPlace(block, InvocationKind.EXACTLY_ONCE)
     }
-    return withAction(chatId, ChooseStickerAction, block)
+    return withAction(chatId, ChooseStickerAction, threadId, block)
 }
 
 
 @OptIn(ExperimentalContracts::class)
-suspend fun <T> TelegramBot.withTypingAction(chat: Chat, block: TelegramBotActionCallback<T>) : T {
+suspend fun <T> TelegramBot.withTypingAction(chat: Chat, threadId: MessageThreadId? = chat.id.threadId,block: TelegramBotActionCallback<T>) : T {
     contract {
         callsInPlace(block, InvocationKind.EXACTLY_ONCE)
     }
-    return withAction(chat, TypingAction, block)
+    return withAction(chat, TypingAction, threadId, block)
 }
 @OptIn(ExperimentalContracts::class)
-suspend fun <T> TelegramBot.withUploadPhotoAction(chat: Chat, block: TelegramBotActionCallback<T>) : T {
+suspend fun <T> TelegramBot.withUploadPhotoAction(chat: Chat, threadId: MessageThreadId? = chat.id.threadId,block: TelegramBotActionCallback<T>) : T {
     contract {
         callsInPlace(block, InvocationKind.EXACTLY_ONCE)
     }
-    return withAction(chat, UploadPhotoAction, block)
+    return withAction(chat, UploadPhotoAction, threadId, block)
 }
 @OptIn(ExperimentalContracts::class)
-suspend fun <T> TelegramBot.withRecordVideoAction(chat: Chat, block: TelegramBotActionCallback<T>) : T {
+suspend fun <T> TelegramBot.withRecordVideoAction(chat: Chat, threadId: MessageThreadId? = chat.id.threadId,block: TelegramBotActionCallback<T>) : T {
     contract {
         callsInPlace(block, InvocationKind.EXACTLY_ONCE)
     }
-    return withAction(chat, RecordVideoAction, block)
+    return withAction(chat, RecordVideoAction, threadId, block)
 }
 @OptIn(ExperimentalContracts::class)
-suspend fun <T> TelegramBot.withUploadVideoAction(chat: Chat, block: TelegramBotActionCallback<T>) : T {
+suspend fun <T> TelegramBot.withUploadVideoAction(chat: Chat, threadId: MessageThreadId? = chat.id.threadId,block: TelegramBotActionCallback<T>) : T {
     contract {
         callsInPlace(block, InvocationKind.EXACTLY_ONCE)
     }
-    return withAction(chat, UploadVideoAction, block)
+    return withAction(chat, UploadVideoAction, threadId, block)
 }
 @OptIn(ExperimentalContracts::class)
-suspend fun <T> TelegramBot.withRecordVoiceAction(chat: Chat, block: TelegramBotActionCallback<T>) : T {
+suspend fun <T> TelegramBot.withRecordVoiceAction(chat: Chat, threadId: MessageThreadId? = chat.id.threadId,block: TelegramBotActionCallback<T>) : T {
     contract {
         callsInPlace(block, InvocationKind.EXACTLY_ONCE)
     }
-    return withAction(chat, RecordVoiceAction, block)
+    return withAction(chat, RecordVoiceAction, threadId, block)
 }
 @OptIn(ExperimentalContracts::class)
-suspend fun <T> TelegramBot.withUploadVoiceAction(chat: Chat, block: TelegramBotActionCallback<T>) : T {
+suspend fun <T> TelegramBot.withUploadVoiceAction(chat: Chat, threadId: MessageThreadId? = chat.id.threadId,block: TelegramBotActionCallback<T>) : T {
     contract {
         callsInPlace(block, InvocationKind.EXACTLY_ONCE)
     }
-    return withAction(chat, UploadVoiceAction, block)
+    return withAction(chat, UploadVoiceAction, threadId, block)
 }
 @OptIn(ExperimentalContracts::class)
-suspend fun <T> TelegramBot.withUploadDocumentAction(chat: Chat, block: TelegramBotActionCallback<T>) : T {
+suspend fun <T> TelegramBot.withUploadDocumentAction(chat: Chat, threadId: MessageThreadId? = chat.id.threadId,block: TelegramBotActionCallback<T>) : T {
     contract {
         callsInPlace(block, InvocationKind.EXACTLY_ONCE)
     }
-    return withAction(chat, UploadDocumentAction, block)
+    return withAction(chat, UploadDocumentAction, threadId, block)
 }
 @OptIn(ExperimentalContracts::class)
-suspend fun <T> TelegramBot.withFindLocationAction(chat: Chat, block: TelegramBotActionCallback<T>) : T {
+suspend fun <T> TelegramBot.withFindLocationAction(chat: Chat, threadId: MessageThreadId? = chat.id.threadId,block: TelegramBotActionCallback<T>) : T {
     contract {
         callsInPlace(block, InvocationKind.EXACTLY_ONCE)
     }
-    return withAction(chat, FindLocationAction, block)
+    return withAction(chat, FindLocationAction, threadId, block)
 }
 @OptIn(ExperimentalContracts::class)
-suspend fun <T> TelegramBot.withRecordVideoNoteAction(chat: Chat, block: TelegramBotActionCallback<T>) : T {
+suspend fun <T> TelegramBot.withRecordVideoNoteAction(chat: Chat, threadId: MessageThreadId? = chat.id.threadId,block: TelegramBotActionCallback<T>) : T {
     contract {
         callsInPlace(block, InvocationKind.EXACTLY_ONCE)
     }
-    return withAction(chat, RecordVideoNoteAction, block)
+    return withAction(chat, RecordVideoNoteAction, threadId, block)
 }
 @OptIn(ExperimentalContracts::class)
-suspend fun <T> TelegramBot.withUploadVideoNoteAction(chat: Chat, block: TelegramBotActionCallback<T>) : T {
+suspend fun <T> TelegramBot.withUploadVideoNoteAction(chat: Chat, threadId: MessageThreadId? = chat.id.threadId,block: TelegramBotActionCallback<T>) : T {
     contract {
         callsInPlace(block, InvocationKind.EXACTLY_ONCE)
     }
-    return withAction(chat, UploadVideoNoteAction, block)
+    return withAction(chat, UploadVideoNoteAction, threadId, block)
 }
 @OptIn(ExperimentalContracts::class)
-suspend fun <T> TelegramBot.withChooseStickerAction(chat: Chat, block: TelegramBotActionCallback<T>) : T {
+suspend fun <T> TelegramBot.withChooseStickerAction(chat: Chat, threadId: MessageThreadId? = chat.id.threadId,block: TelegramBotActionCallback<T>) : T {
     contract {
         callsInPlace(block, InvocationKind.EXACTLY_ONCE)
     }
-    return withAction(chat, ChooseStickerAction, block)
+    return withAction(chat, ChooseStickerAction, threadId, block)
 }

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

@@ -15,14 +15,15 @@ suspend fun TelegramBot.sendContact(
     phoneNumber: String,
     firstName: String,
     lastName: String? = null,
+    threadId: MessageThreadId? = chatId.threadId,
     disableNotification: Boolean = false,
     protectContent: Boolean = false,
-    replyToMessageId: MessageIdentifier? = null,
+    replyToMessageId: MessageId? = null,
     allowSendingWithoutReply: Boolean? = null,
     replyMarkup: KeyboardMarkup? = null
 ) = execute(
     SendContact(
-        chatId, phoneNumber, firstName, lastName, disableNotification, protectContent, replyToMessageId, allowSendingWithoutReply, replyMarkup
+        chatId, phoneNumber, firstName, lastName, threadId, disableNotification, protectContent, replyToMessageId, allowSendingWithoutReply, replyMarkup
     )
 )
 
@@ -33,14 +34,15 @@ suspend fun TelegramBot.sendContact(
 suspend fun TelegramBot.sendContact(
     chatId: ChatIdentifier,
     contact: Contact,
+    threadId: MessageThreadId? = chatId.threadId,
     disableNotification: Boolean = false,
     protectContent: Boolean = false,
-    replyToMessageId: MessageIdentifier? = null,
+    replyToMessageId: MessageId? = null,
     allowSendingWithoutReply: Boolean? = null,
     replyMarkup: KeyboardMarkup? = null
 ) = execute(
     SendContact(
-        chatId, contact, disableNotification, protectContent, replyToMessageId, allowSendingWithoutReply, replyMarkup
+        chatId, contact, threadId, disableNotification, protectContent, replyToMessageId, allowSendingWithoutReply, replyMarkup
     )
 )
 
@@ -53,13 +55,14 @@ suspend fun TelegramBot.sendContact(
     phoneNumber: String,
     firstName: String,
     lastName: String? = null,
+    threadId: MessageThreadId? = chat.id.threadId,
     disableNotification: Boolean = false,
     protectContent: Boolean = false,
-    replyToMessageId: MessageIdentifier? = null,
+    replyToMessageId: MessageId? = null,
     allowSendingWithoutReply: Boolean? = null,
     replyMarkup: KeyboardMarkup? = null
 ) = sendContact(
-    chat.id, phoneNumber, firstName, lastName, disableNotification, protectContent, replyToMessageId, allowSendingWithoutReply, replyMarkup
+    chat.id, phoneNumber, firstName, lastName, threadId, disableNotification, protectContent, replyToMessageId, allowSendingWithoutReply, replyMarkup
 )
 
 /**
@@ -69,11 +72,12 @@ suspend fun TelegramBot.sendContact(
 suspend fun TelegramBot.sendContact(
     chat: Chat,
     contact: Contact,
+    threadId: MessageThreadId? = chat.id.threadId,
     disableNotification: Boolean = false,
     protectContent: Boolean = false,
-    replyToMessageId: MessageIdentifier? = null,
+    replyToMessageId: MessageId? = null,
     allowSendingWithoutReply: Boolean? = null,
     replyMarkup: KeyboardMarkup? = null
 ) = sendContact(
-    chat.id, contact, disableNotification, protectContent, replyToMessageId, allowSendingWithoutReply, replyMarkup
+    chat.id, contact, threadId, disableNotification, protectContent, replyToMessageId, allowSendingWithoutReply, replyMarkup
 )

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

@@ -3,10 +3,12 @@ package dev.inmo.tgbotapi.extensions.api.send
 import dev.inmo.tgbotapi.bot.TelegramBot
 import dev.inmo.tgbotapi.requests.send.SendDice
 import dev.inmo.tgbotapi.types.ChatIdentifier
-import dev.inmo.tgbotapi.types.MessageIdentifier
+import dev.inmo.tgbotapi.types.MessageId
+import dev.inmo.tgbotapi.types.MessageThreadId
 import dev.inmo.tgbotapi.types.buttons.KeyboardMarkup
 import dev.inmo.tgbotapi.types.chat.Chat
 import dev.inmo.tgbotapi.types.dice.DiceAnimationType
+import dev.inmo.tgbotapi.types.threadId
 
 /**
  * @param replyMarkup Some of [KeyboardMarkup]. See [dev.inmo.tgbotapi.extensions.utils.types.buttons.replyKeyboard] or
@@ -15,13 +17,14 @@ import dev.inmo.tgbotapi.types.dice.DiceAnimationType
 suspend fun TelegramBot.sendDice(
     chatId: ChatIdentifier,
     animationType: DiceAnimationType? = null,
+    threadId: MessageThreadId? = chatId.threadId,
     disableNotification: Boolean = false,
     protectContent: Boolean = false,
-    replyToMessageId: MessageIdentifier? = null,
+    replyToMessageId: MessageId? = null,
     allowSendingWithoutReply: Boolean? = null,
     replyMarkup: KeyboardMarkup? = null
 ) = execute(
-    SendDice(chatId, animationType, disableNotification, protectContent, replyToMessageId, allowSendingWithoutReply, replyMarkup)
+    SendDice(chatId, animationType, threadId, disableNotification, protectContent, replyToMessageId, allowSendingWithoutReply, replyMarkup)
 )
 
 /**
@@ -31,9 +34,10 @@ suspend fun TelegramBot.sendDice(
 suspend fun TelegramBot.sendDice(
     chat: Chat,
     animationType: DiceAnimationType? = null,
+    threadId: MessageThreadId? = chat.id.threadId,
     disableNotification: Boolean = false,
     protectContent: Boolean = false,
-    replyToMessageId: MessageIdentifier? = null,
+    replyToMessageId: MessageId? = null,
     allowSendingWithoutReply: Boolean? = null,
     replyMarkup: KeyboardMarkup? = null
-) = sendDice(chat.id, animationType, disableNotification, protectContent, replyToMessageId, allowSendingWithoutReply, replyMarkup)
+) = sendDice(chat.id, animationType, threadId, disableNotification, protectContent, replyToMessageId, allowSendingWithoutReply, replyMarkup)

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

@@ -0,0 +1,222 @@
+package dev.inmo.tgbotapi.extensions.api.send
+
+import dev.inmo.tgbotapi.bot.TelegramBot
+import dev.inmo.tgbotapi.requests.send.SendLiveLocation
+import dev.inmo.tgbotapi.types.*
+import dev.inmo.tgbotapi.types.buttons.KeyboardMarkup
+import dev.inmo.tgbotapi.types.chat.Chat
+import dev.inmo.tgbotapi.types.location.Location
+
+/**
+ * @param replyMarkup Some of [KeyboardMarkup]. See [dev.inmo.tgbotapi.extensions.utils.types.buttons.replyKeyboard] or
+ * [dev.inmo.tgbotapi.extensions.utils.types.buttons.inlineKeyboard] as a builders for that param
+ */
+suspend fun TelegramBot.sendLocation(
+    chatId: ChatIdentifier,
+    latitude: Double,
+    longitude: Double,
+    livePeriod: Seconds,
+    horizontalAccuracy: Meters? = null,
+    heading: Degrees? = null,
+    proximityAlertRadius: Meters? = null,
+    threadId: MessageThreadId? = chatId.threadId,
+    disableNotification: Boolean = false,
+    protectContent: Boolean = false,
+    replyToMessageId: MessageId? = null,
+    allowSendingWithoutReply: Boolean? = null,
+    replyMarkup: KeyboardMarkup? = null
+) = execute(
+    SendLiveLocation(
+        chatId,
+        latitude,
+        longitude,
+        livePeriod,
+        horizontalAccuracy,
+        heading,
+        proximityAlertRadius,
+        threadId,
+        disableNotification,
+        protectContent,
+        replyToMessageId,
+        allowSendingWithoutReply,
+        replyMarkup
+    )
+)
+
+/**
+ * @param replyMarkup Some of [KeyboardMarkup]. See [dev.inmo.tgbotapi.extensions.utils.types.buttons.replyKeyboard] or
+ * [dev.inmo.tgbotapi.extensions.utils.types.buttons.inlineKeyboard] as a builders for that param
+ */
+suspend fun TelegramBot.sendLocation(
+    chatId: ChatIdentifier,
+    location: Location,
+    livePeriod: Seconds,
+    horizontalAccuracy: Meters? = null,
+    heading: Degrees? = null,
+    proximityAlertRadius: Meters? = null,
+    threadId: MessageThreadId? = chatId.threadId,
+    disableNotification: Boolean = false,
+    protectContent: Boolean = false,
+    replyToMessageId: MessageId? = null,
+    allowSendingWithoutReply: Boolean? = null,
+    replyMarkup: KeyboardMarkup? = null
+) = sendLocation(
+    chatId,
+    location.latitude,
+    location.longitude,
+    livePeriod,
+    horizontalAccuracy,
+    heading,
+    proximityAlertRadius,
+    threadId,
+    disableNotification,
+    protectContent,
+    replyToMessageId,
+    allowSendingWithoutReply,
+    replyMarkup
+)
+
+/**
+ * @param replyMarkup Some of [KeyboardMarkup]. See [dev.inmo.tgbotapi.extensions.utils.types.buttons.replyKeyboard] or
+ * [dev.inmo.tgbotapi.extensions.utils.types.buttons.inlineKeyboard] as a builders for that param
+ */
+suspend fun TelegramBot.sendLocation(
+    chat: Chat,
+    latitude: Double,
+    longitude: Double,
+    livePeriod: Seconds,
+    horizontalAccuracy: Meters? = null,
+    heading: Degrees? = null,
+    proximityAlertRadius: Meters? = null,
+    threadId: MessageThreadId? = chat.id.threadId,
+    disableNotification: Boolean = false,
+    protectContent: Boolean = false,
+    replyToMessageId: MessageId? = null,
+    allowSendingWithoutReply: Boolean? = null,
+    replyMarkup: KeyboardMarkup? = null
+) = sendLocation(
+    chat.id,
+    latitude,
+    longitude,
+    livePeriod,
+    horizontalAccuracy,
+    heading,
+    proximityAlertRadius,
+    threadId,
+    disableNotification,
+    protectContent,
+    replyToMessageId,
+    allowSendingWithoutReply,
+    replyMarkup
+)
+
+/**
+ * @param replyMarkup Some of [KeyboardMarkup]. See [dev.inmo.tgbotapi.extensions.utils.types.buttons.replyKeyboard] or
+ * [dev.inmo.tgbotapi.extensions.utils.types.buttons.inlineKeyboard] as a builders for that param
+ */
+suspend fun TelegramBot.sendLocation(
+    chat: Chat,
+    location: Location,
+    livePeriod: Seconds,
+    horizontalAccuracy: Meters? = null,
+    heading: Degrees? = null,
+    proximityAlertRadius: Meters? = null,
+    threadId: MessageThreadId? = chat.id.threadId,
+    disableNotification: Boolean = false,
+    protectContent: Boolean = false,
+    replyToMessageId: MessageId? = null,
+    allowSendingWithoutReply: Boolean? = null,
+    replyMarkup: KeyboardMarkup? = null
+) = sendLocation(
+    chat.id,
+    location.latitude,
+    location.longitude,
+    livePeriod,
+    horizontalAccuracy,
+    heading,
+    proximityAlertRadius,
+    threadId,
+    disableNotification,
+    protectContent,
+    replyToMessageId,
+    allowSendingWithoutReply,
+    replyMarkup
+)
+
+/**
+ * @param replyMarkup Some of [KeyboardMarkup]. See [dev.inmo.tgbotapi.extensions.utils.types.buttons.replyKeyboard] or
+ * [dev.inmo.tgbotapi.extensions.utils.types.buttons.inlineKeyboard] as a builders for that param
+ */
+suspend fun TelegramBot.sendLiveLocation(
+    chatId: ChatIdentifier,
+    latitude: Double,
+    longitude: Double,
+    livePeriod: Seconds,
+    horizontalAccuracy: Meters? = null,
+    heading: Degrees? = null,
+    proximityAlertRadius: Meters? = null,
+    threadId: MessageThreadId? = chatId.threadId,
+    disableNotification: Boolean = false,
+    protectContent: Boolean = false,
+    replyToMessageId: MessageId? = null,
+    allowSendingWithoutReply: Boolean? = null,
+    replyMarkup: KeyboardMarkup? = null
+) = sendLocation(chatId, latitude, longitude, livePeriod, horizontalAccuracy, heading, proximityAlertRadius, threadId, disableNotification, protectContent, replyToMessageId, allowSendingWithoutReply, replyMarkup)
+
+/**
+ * @param replyMarkup Some of [KeyboardMarkup]. See [dev.inmo.tgbotapi.extensions.utils.types.buttons.replyKeyboard] or
+ * [dev.inmo.tgbotapi.extensions.utils.types.buttons.inlineKeyboard] as a builders for that param
+ */
+suspend fun TelegramBot.sendLiveLocation(
+    chatId: ChatIdentifier,
+    location: Location,
+    livePeriod: Seconds,
+    horizontalAccuracy: Meters? = null,
+    heading: Degrees? = null,
+    proximityAlertRadius: Meters? = null,
+    threadId: MessageThreadId? = chatId.threadId,
+    disableNotification: Boolean = false,
+    protectContent: Boolean = false,
+    replyToMessageId: MessageId? = null,
+    allowSendingWithoutReply: Boolean? = null,
+    replyMarkup: KeyboardMarkup? = null
+) = sendLocation(chatId, location.latitude, location.longitude, livePeriod, horizontalAccuracy, heading, proximityAlertRadius, threadId, disableNotification, protectContent, replyToMessageId, allowSendingWithoutReply, replyMarkup)
+
+/**
+ * @param replyMarkup Some of [KeyboardMarkup]. See [dev.inmo.tgbotapi.extensions.utils.types.buttons.replyKeyboard] or
+ * [dev.inmo.tgbotapi.extensions.utils.types.buttons.inlineKeyboard] as a builders for that param
+ */
+suspend fun TelegramBot.sendLiveLocation(
+    chat: Chat,
+    latitude: Double,
+    longitude: Double,
+    livePeriod: Seconds,
+    horizontalAccuracy: Meters? = null,
+    heading: Degrees? = null,
+    proximityAlertRadius: Meters? = null,
+    threadId: MessageThreadId? = chat.id.threadId,
+    disableNotification: Boolean = false,
+    protectContent: Boolean = false,
+    replyToMessageId: MessageId? = null,
+    allowSendingWithoutReply: Boolean? = null,
+    replyMarkup: KeyboardMarkup? = null
+) = sendLocation(chat.id, latitude, longitude, livePeriod, horizontalAccuracy, heading, proximityAlertRadius, threadId, disableNotification, protectContent, replyToMessageId, allowSendingWithoutReply, replyMarkup)
+
+/**
+ * @param replyMarkup Some of [KeyboardMarkup]. See [dev.inmo.tgbotapi.extensions.utils.types.buttons.replyKeyboard] or
+ * [dev.inmo.tgbotapi.extensions.utils.types.buttons.inlineKeyboard] as a builders for that param
+ */
+suspend fun TelegramBot.sendLiveLocation(
+    chat: Chat,
+    location: Location,
+    livePeriod: Seconds,
+    horizontalAccuracy: Meters? = null,
+    heading: Degrees? = null,
+    proximityAlertRadius: Meters? = null,
+    threadId: MessageThreadId? = chat.id.threadId,
+    disableNotification: Boolean = false,
+    protectContent: Boolean = false,
+    replyToMessageId: MessageId? = null,
+    allowSendingWithoutReply: Boolean? = null,
+    replyMarkup: KeyboardMarkup? = null
+) = sendLocation(chat.id, location.latitude, location.longitude, livePeriod, horizontalAccuracy, heading, proximityAlertRadius, threadId, disableNotification, protectContent, replyToMessageId, allowSendingWithoutReply, replyMarkup)

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

@@ -2,12 +2,14 @@ package dev.inmo.tgbotapi.extensions.api.send
 
 import dev.inmo.tgbotapi.bot.TelegramBot
 import dev.inmo.tgbotapi.requests.send.SendTextMessage
-import dev.inmo.tgbotapi.types.ChatIdentifier
+import dev.inmo.tgbotapi.types.*
 import dev.inmo.tgbotapi.types.message.textsources.TextSourcesList
-import dev.inmo.tgbotapi.types.MessageIdentifier
 import dev.inmo.tgbotapi.types.message.ParseMode
 import dev.inmo.tgbotapi.types.buttons.KeyboardMarkup
 import dev.inmo.tgbotapi.types.chat.Chat
+import dev.inmo.tgbotapi.types.message.textsources.TextSource
+import dev.inmo.tgbotapi.utils.EntitiesBuilderBody
+import dev.inmo.tgbotapi.utils.buildEntities
 
 /**
  * @param replyMarkup Some of [KeyboardMarkup]. See [dev.inmo.tgbotapi.extensions.utils.types.buttons.replyKeyboard] or
@@ -18,13 +20,25 @@ suspend fun TelegramBot.sendMessage(
     text: String,
     parseMode: ParseMode? = null,
     disableWebPagePreview: Boolean? = null,
+    threadId: MessageThreadId? = chatId.threadId,
     disableNotification: Boolean = false,
     protectContent: Boolean = false,
-    replyToMessageId: MessageIdentifier? = null,
+    replyToMessageId: MessageId? = null,
     allowSendingWithoutReply: Boolean? = null,
     replyMarkup: KeyboardMarkup? = null
 ) = execute(
-    SendTextMessage(chatId, text, parseMode, disableWebPagePreview, disableNotification, protectContent, replyToMessageId, allowSendingWithoutReply, replyMarkup)
+    SendTextMessage(
+        chatId,
+        text,
+        parseMode,
+        disableWebPagePreview,
+        threadId,
+        disableNotification,
+        protectContent,
+        replyToMessageId,
+        allowSendingWithoutReply,
+        replyMarkup
+    )
 )
 
 /**
@@ -36,32 +50,16 @@ suspend fun TelegramBot.sendTextMessage(
     text: String,
     parseMode: ParseMode? = null,
     disableWebPagePreview: Boolean? = null,
+    threadId: MessageThreadId? = chatId.threadId,
     disableNotification: Boolean = false,
     protectContent: Boolean = false,
-    replyToMessageId: MessageIdentifier? = null,
+    replyToMessageId: MessageId? = null,
     allowSendingWithoutReply: Boolean? = null,
     replyMarkup: KeyboardMarkup? = null
 ) = sendMessage(
-    chatId, text, parseMode, disableWebPagePreview, disableNotification, protectContent, replyToMessageId, allowSendingWithoutReply, replyMarkup
+    chatId, text, parseMode, disableWebPagePreview, threadId, disableNotification, protectContent, replyToMessageId, allowSendingWithoutReply, replyMarkup
 )
 
-/**
- * @param replyMarkup Some of [KeyboardMarkup]. See [dev.inmo.tgbotapi.extensions.utils.types.buttons.replyKeyboard] or
- * [dev.inmo.tgbotapi.extensions.utils.types.buttons.inlineKeyboard] as a builders for that param
- */
-suspend fun TelegramBot.sendMessage(
-    chat: Chat,
-    text: String,
-    parseMode: ParseMode? = null,
-    disableWebPagePreview: Boolean? = null,
-    disableNotification: Boolean = false,
-    protectContent: Boolean = false,
-    replyToMessageId: MessageIdentifier? = null,
-    allowSendingWithoutReply: Boolean? = null,
-    replyMarkup: KeyboardMarkup? = null
-) = sendMessage(chat.id, text, parseMode, disableWebPagePreview, disableNotification, protectContent, replyToMessageId, allowSendingWithoutReply, replyMarkup)
-
-
 /**
  * @param replyMarkup Some of [KeyboardMarkup]. See [dev.inmo.tgbotapi.extensions.utils.types.buttons.replyKeyboard] or
  * [dev.inmo.tgbotapi.extensions.utils.types.buttons.inlineKeyboard] as a builders for that param
@@ -71,12 +69,31 @@ suspend fun TelegramBot.sendTextMessage(
     text: String,
     parseMode: ParseMode? = null,
     disableWebPagePreview: Boolean? = null,
+    threadId: MessageThreadId? = chat.id.threadId,
     disableNotification: Boolean = false,
     protectContent: Boolean = false,
-    replyToMessageId: MessageIdentifier? = null,
+    replyToMessageId: MessageId? = null,
     allowSendingWithoutReply: Boolean? = null,
     replyMarkup: KeyboardMarkup? = null
-) = sendTextMessage(chat.id, text, parseMode, disableWebPagePreview, disableNotification, protectContent, replyToMessageId, allowSendingWithoutReply, replyMarkup)
+) = sendTextMessage(chat.id, text, parseMode, disableWebPagePreview, threadId, disableNotification, protectContent, replyToMessageId, allowSendingWithoutReply, replyMarkup)
+
+
+/**
+ * @param replyMarkup Some of [KeyboardMarkup]. See [dev.inmo.tgbotapi.extensions.utils.types.buttons.replyKeyboard] or
+ * [dev.inmo.tgbotapi.extensions.utils.types.buttons.inlineKeyboard] as a builders for that param
+ */
+suspend fun TelegramBot.sendMessage(
+    chat: Chat,
+    text: String,
+    parseMode: ParseMode? = null,
+    disableWebPagePreview: Boolean? = null,
+    threadId: MessageThreadId? = chat.id.threadId,
+    disableNotification: Boolean = false,
+    protectContent: Boolean = false,
+    replyToMessageId: MessageId? = null,
+    allowSendingWithoutReply: Boolean? = null,
+    replyMarkup: KeyboardMarkup? = null
+) = sendMessage(chat.id, text, parseMode, disableWebPagePreview, threadId, disableNotification, protectContent, replyToMessageId, allowSendingWithoutReply, replyMarkup)
 
 /**
  * @param replyMarkup Some of [KeyboardMarkup]. See [dev.inmo.tgbotapi.extensions.utils.types.buttons.replyKeyboard] or
@@ -86,15 +103,51 @@ suspend fun TelegramBot.sendMessage(
     chatId: ChatIdentifier,
     entities: TextSourcesList,
     disableWebPagePreview: Boolean? = null,
+    threadId: MessageThreadId? = chatId.threadId,
     disableNotification: Boolean = false,
     protectContent: Boolean = false,
-    replyToMessageId: MessageIdentifier? = null,
+    replyToMessageId: MessageId? = null,
     allowSendingWithoutReply: Boolean? = null,
     replyMarkup: KeyboardMarkup? = null
 ) = execute(
-    SendTextMessage(chatId, entities, disableWebPagePreview, disableNotification, protectContent, replyToMessageId, allowSendingWithoutReply, replyMarkup)
+    SendTextMessage(chatId, entities, disableWebPagePreview, threadId, disableNotification, protectContent, replyToMessageId, allowSendingWithoutReply, replyMarkup)
 )
 
+/**
+ * @param replyMarkup Some [InlineKeyboardMarkup]. See [dev.inmo.tgbotapi.extensions.utils.types.buttons.inlineKeyboard]
+ * as a builder for that
+ */
+suspend fun TelegramBot.sendMessage(
+    chatId: ChatIdentifier,
+    separator: TextSource? = null,
+    disableWebPagePreview: Boolean? = null,
+    threadId: MessageThreadId? = chatId.threadId,
+    disableNotification: Boolean = false,
+    protectContent: Boolean = false,
+    replyToMessageId: MessageId? = null,
+    allowSendingWithoutReply: Boolean? = null,
+    replyMarkup: KeyboardMarkup? = null,
+    builderBody: EntitiesBuilderBody
+) = sendMessage(chatId, buildEntities(separator, builderBody), disableWebPagePreview, threadId, disableNotification, protectContent, replyToMessageId, allowSendingWithoutReply, replyMarkup)
+
+
+/**
+ * @param replyMarkup Some [InlineKeyboardMarkup]. See [dev.inmo.tgbotapi.extensions.utils.types.buttons.inlineKeyboard]
+ * as a builder for that
+ */
+suspend fun TelegramBot.sendMessage(
+    chatId: ChatIdentifier,
+    separator: String,
+    disableWebPagePreview: Boolean? = null,
+    threadId: MessageThreadId? = chatId.threadId,
+    disableNotification: Boolean = false,
+    protectContent: Boolean = false,
+    replyToMessageId: MessageId? = null,
+    allowSendingWithoutReply: Boolean? = null,
+    replyMarkup: KeyboardMarkup? = null,
+    builderBody: EntitiesBuilderBody
+) = sendMessage(chatId, buildEntities(separator, builderBody), disableWebPagePreview, threadId, disableNotification, protectContent, replyToMessageId, allowSendingWithoutReply, replyMarkup)
+
 /**
  * @param replyMarkup Some of [KeyboardMarkup]. See [dev.inmo.tgbotapi.extensions.utils.types.buttons.replyKeyboard] or
  * [dev.inmo.tgbotapi.extensions.utils.types.buttons.inlineKeyboard] as a builders for that param
@@ -103,15 +156,51 @@ suspend fun TelegramBot.sendTextMessage(
     chatId: ChatIdentifier,
     entities: TextSourcesList,
     disableWebPagePreview: Boolean? = null,
+    threadId: MessageThreadId? = chatId.threadId,
     disableNotification: Boolean = false,
     protectContent: Boolean = false,
-    replyToMessageId: MessageIdentifier? = null,
+    replyToMessageId: MessageId? = null,
     allowSendingWithoutReply: Boolean? = null,
     replyMarkup: KeyboardMarkup? = null
 ) = sendMessage(
-    chatId, entities, disableWebPagePreview, disableNotification, protectContent, replyToMessageId, allowSendingWithoutReply, replyMarkup
+    chatId, entities, disableWebPagePreview, threadId, disableNotification, protectContent, replyToMessageId, allowSendingWithoutReply, replyMarkup
 )
 
+/**
+ * @param replyMarkup Some [InlineKeyboardMarkup]. See [dev.inmo.tgbotapi.extensions.utils.types.buttons.inlineKeyboard]
+ * as a builder for that
+ */
+suspend fun TelegramBot.sendTextMessage(
+    chatId: ChatIdentifier,
+    separator: TextSource? = null,
+    disableWebPagePreview: Boolean? = null,
+    threadId: MessageThreadId? = chatId.threadId,
+    disableNotification: Boolean = false,
+    protectContent: Boolean = false,
+    replyToMessageId: MessageId? = null,
+    allowSendingWithoutReply: Boolean? = null,
+    replyMarkup: KeyboardMarkup? = null,
+    builderBody: EntitiesBuilderBody
+) = sendTextMessage(chatId, buildEntities(separator, builderBody), disableWebPagePreview, threadId, disableNotification, protectContent, replyToMessageId, allowSendingWithoutReply, replyMarkup)
+
+
+/**
+ * @param replyMarkup Some [InlineKeyboardMarkup]. See [dev.inmo.tgbotapi.extensions.utils.types.buttons.inlineKeyboard]
+ * as a builder for that
+ */
+suspend fun TelegramBot.sendTextMessage(
+    chatId: ChatIdentifier,
+    separator: String,
+    disableWebPagePreview: Boolean? = null,
+    threadId: MessageThreadId? = chatId.threadId,
+    disableNotification: Boolean = false,
+    protectContent: Boolean = false,
+    replyToMessageId: MessageId? = null,
+    allowSendingWithoutReply: Boolean? = null,
+    replyMarkup: KeyboardMarkup? = null,
+    builderBody: EntitiesBuilderBody
+) = sendTextMessage(chatId, buildEntities(separator, builderBody), disableWebPagePreview, threadId, disableNotification, protectContent, replyToMessageId, allowSendingWithoutReply, replyMarkup)
+
 /**
  * @param replyMarkup Some of [KeyboardMarkup]. See [dev.inmo.tgbotapi.extensions.utils.types.buttons.replyKeyboard] or
  * [dev.inmo.tgbotapi.extensions.utils.types.buttons.inlineKeyboard] as a builders for that param
@@ -120,12 +209,48 @@ suspend fun TelegramBot.sendMessage(
     chat: Chat,
     entities: TextSourcesList,
     disableWebPagePreview: Boolean? = null,
+    threadId: MessageThreadId? = chat.id.threadId,
     disableNotification: Boolean = false,
     protectContent: Boolean = false,
-    replyToMessageId: MessageIdentifier? = null,
+    replyToMessageId: MessageId? = null,
     allowSendingWithoutReply: Boolean? = null,
     replyMarkup: KeyboardMarkup? = null
-) = sendMessage(chat.id, entities, disableWebPagePreview, disableNotification, protectContent, replyToMessageId, allowSendingWithoutReply, replyMarkup)
+) = sendMessage(chat.id, entities, disableWebPagePreview, threadId, disableNotification, protectContent, replyToMessageId, allowSendingWithoutReply, replyMarkup)
+
+/**
+ * @param replyMarkup Some [InlineKeyboardMarkup]. See [dev.inmo.tgbotapi.extensions.utils.types.buttons.inlineKeyboard]
+ * as a builder for that
+ */
+suspend fun TelegramBot.sendMessage(
+    chat: Chat,
+    separator: TextSource? = null,
+    disableWebPagePreview: Boolean? = null,
+    threadId: MessageThreadId? = chat.id.threadId,
+    disableNotification: Boolean = false,
+    protectContent: Boolean = false,
+    replyToMessageId: MessageId? = null,
+    allowSendingWithoutReply: Boolean? = null,
+    replyMarkup: KeyboardMarkup? = null,
+    builderBody: EntitiesBuilderBody
+) = sendMessage(chat, buildEntities(separator, builderBody), disableWebPagePreview, threadId, disableNotification, protectContent, replyToMessageId, allowSendingWithoutReply, replyMarkup)
+
+
+/**
+ * @param replyMarkup Some [InlineKeyboardMarkup]. See [dev.inmo.tgbotapi.extensions.utils.types.buttons.inlineKeyboard]
+ * as a builder for that
+ */
+suspend fun TelegramBot.sendMessage(
+    chat: Chat,
+    separator: String,
+    disableWebPagePreview: Boolean? = null,
+    threadId: MessageThreadId? = chat.id.threadId,
+    disableNotification: Boolean = false,
+    protectContent: Boolean = false,
+    replyToMessageId: MessageId? = null,
+    allowSendingWithoutReply: Boolean? = null,
+    replyMarkup: KeyboardMarkup? = null,
+    builderBody: EntitiesBuilderBody
+) = sendMessage(chat, buildEntities(separator, builderBody), disableWebPagePreview, threadId, disableNotification, protectContent, replyToMessageId, allowSendingWithoutReply, replyMarkup)
 
 
 /**
@@ -136,9 +261,45 @@ suspend fun TelegramBot.sendTextMessage(
     chat: Chat,
     entities: TextSourcesList,
     disableWebPagePreview: Boolean? = null,
+    threadId: MessageThreadId? = chat.id.threadId,
     disableNotification: Boolean = false,
     protectContent: Boolean = false,
-    replyToMessageId: MessageIdentifier? = null,
+    replyToMessageId: MessageId? = null,
     allowSendingWithoutReply: Boolean? = null,
     replyMarkup: KeyboardMarkup? = null
-) = sendTextMessage(chat.id, entities, disableWebPagePreview, disableNotification, protectContent, replyToMessageId, allowSendingWithoutReply, replyMarkup)
+) = sendTextMessage(chat.id, entities, disableWebPagePreview, threadId, disableNotification, protectContent, replyToMessageId, allowSendingWithoutReply, replyMarkup)
+
+/**
+ * @param replyMarkup Some [InlineKeyboardMarkup]. See [dev.inmo.tgbotapi.extensions.utils.types.buttons.inlineKeyboard]
+ * as a builder for that
+ */
+suspend fun TelegramBot.sendTextMessage(
+    chat: Chat,
+    separator: TextSource? = null,
+    disableWebPagePreview: Boolean? = null,
+    threadId: MessageThreadId? = chat.id.threadId,
+    disableNotification: Boolean = false,
+    protectContent: Boolean = false,
+    replyToMessageId: MessageId? = null,
+    allowSendingWithoutReply: Boolean? = null,
+    replyMarkup: KeyboardMarkup? = null,
+    builderBody: EntitiesBuilderBody
+) = sendTextMessage(chat, buildEntities(separator, builderBody), disableWebPagePreview, threadId, disableNotification, protectContent, replyToMessageId, allowSendingWithoutReply, replyMarkup)
+
+
+/**
+ * @param replyMarkup Some [InlineKeyboardMarkup]. See [dev.inmo.tgbotapi.extensions.utils.types.buttons.inlineKeyboard]
+ * as a builder for that
+ */
+suspend fun TelegramBot.sendTextMessage(
+    chat: Chat,
+    separator: String,
+    disableWebPagePreview: Boolean? = null,
+    threadId: MessageThreadId? = chat.id.threadId,
+    disableNotification: Boolean = false,
+    protectContent: Boolean = false,
+    replyToMessageId: MessageId? = null,
+    allowSendingWithoutReply: Boolean? = null,
+    replyMarkup: KeyboardMarkup? = null,
+    builderBody: EntitiesBuilderBody
+) = sendTextMessage(chat, buildEntities(separator, builderBody), disableWebPagePreview, threadId, disableNotification, protectContent, replyToMessageId, allowSendingWithoutReply, replyMarkup)

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

@@ -3,10 +3,12 @@ package dev.inmo.tgbotapi.extensions.api.send
 import dev.inmo.tgbotapi.bot.TelegramBot
 import dev.inmo.tgbotapi.requests.send.SendStaticLocation
 import dev.inmo.tgbotapi.types.ChatIdentifier
-import dev.inmo.tgbotapi.types.MessageIdentifier
+import dev.inmo.tgbotapi.types.MessageId
+import dev.inmo.tgbotapi.types.MessageThreadId
 import dev.inmo.tgbotapi.types.buttons.KeyboardMarkup
 import dev.inmo.tgbotapi.types.chat.Chat
-import dev.inmo.tgbotapi.types.location.StaticLocation
+import dev.inmo.tgbotapi.types.location.Location
+import dev.inmo.tgbotapi.types.threadId
 
 /**
  * @param replyMarkup Some of [KeyboardMarkup]. See [dev.inmo.tgbotapi.extensions.utils.types.buttons.replyKeyboard] or
@@ -16,16 +18,18 @@ suspend fun TelegramBot.sendLocation(
     chatId: ChatIdentifier,
     latitude: Double,
     longitude: Double,
+    threadId: MessageThreadId? = chatId.threadId,
     disableNotification: Boolean = false,
     protectContent: Boolean = false,
     allowSendingWithoutReply: Boolean? = null,
-    replyToMessageId: MessageIdentifier? = null,
+    replyToMessageId: MessageId? = null,
     replyMarkup: KeyboardMarkup? = null
 ) = execute(
     SendStaticLocation(
         chatId,
         latitude,
         longitude,
+        threadId = threadId,
         disableNotification = disableNotification,
         protectContent = protectContent,
         allowSendingWithoutReply = allowSendingWithoutReply,
@@ -40,16 +44,18 @@ suspend fun TelegramBot.sendLocation(
  */
 suspend fun TelegramBot.sendLocation(
     chatId: ChatIdentifier,
-    location: StaticLocation,
+    location: Location,
+    threadId: MessageThreadId? = chatId.threadId,
     disableNotification: Boolean = false,
     protectContent: Boolean = false,
     allowSendingWithoutReply: Boolean? = null,
-    replyToMessageId: MessageIdentifier? = null,
+    replyToMessageId: MessageId? = null,
     replyMarkup: KeyboardMarkup? = null
 ) = sendLocation(
     chatId,
     location.latitude,
     location.longitude,
+    threadId,
     disableNotification,
     protectContent,
     allowSendingWithoutReply,
@@ -65,15 +71,17 @@ suspend fun TelegramBot.sendLocation(
     chat: Chat,
     latitude: Double,
     longitude: Double,
+    threadId: MessageThreadId? = chat.id.threadId,
     disableNotification: Boolean = false,
     protectContent: Boolean = false,
     allowSendingWithoutReply: Boolean? = null,
-    replyToMessageId: MessageIdentifier? = null,
+    replyToMessageId: MessageId? = null,
     replyMarkup: KeyboardMarkup? = null
 ) = sendLocation(
     chat.id,
     latitude,
     longitude,
+    threadId,
     disableNotification,
     protectContent,
     allowSendingWithoutReply,
@@ -87,16 +95,18 @@ suspend fun TelegramBot.sendLocation(
  */
 suspend fun TelegramBot.sendLocation(
     chat: Chat,
-    location: StaticLocation,
+    location: Location,
+    threadId: MessageThreadId? = chat.id.threadId,
     disableNotification: Boolean = false,
     protectContent: Boolean = false,
     allowSendingWithoutReply: Boolean? = null,
-    replyToMessageId: MessageIdentifier? = null,
+    replyToMessageId: MessageId? = null,
     replyMarkup: KeyboardMarkup? = null
 ) = sendLocation(
     chat.id,
     location.latitude,
     location.longitude,
+    threadId,
     disableNotification,
     protectContent,
     allowSendingWithoutReply,
@@ -112,12 +122,13 @@ suspend fun TelegramBot.sendStaticLocation(
     chatId: ChatIdentifier,
     latitude: Double,
     longitude: Double,
+    threadId: MessageThreadId? = chatId.threadId,
     disableNotification: Boolean = false,
     protectContent: Boolean = false,
     allowSendingWithoutReply: Boolean? = null,
-    replyToMessageId: MessageIdentifier? = null,
+    replyToMessageId: MessageId? = null,
     replyMarkup: KeyboardMarkup? = null
-) = sendLocation(chatId, latitude, longitude, disableNotification, protectContent, allowSendingWithoutReply, replyToMessageId, replyMarkup)
+) = sendLocation(chatId, latitude, longitude, threadId, disableNotification, protectContent, allowSendingWithoutReply, replyToMessageId, replyMarkup)
 
 /**
  * @param replyMarkup Some of [KeyboardMarkup]. See [dev.inmo.tgbotapi.extensions.utils.types.buttons.replyKeyboard] or
@@ -125,13 +136,14 @@ suspend fun TelegramBot.sendStaticLocation(
  */
 suspend fun TelegramBot.sendStaticLocation(
     chatId: ChatIdentifier,
-    location: StaticLocation,
+    location: Location,
+    threadId: MessageThreadId? = chatId.threadId,
     disableNotification: Boolean = false,
     protectContent: Boolean = false,
     allowSendingWithoutReply: Boolean? = null,
-    replyToMessageId: MessageIdentifier? = null,
+    replyToMessageId: MessageId? = null,
     replyMarkup: KeyboardMarkup? = null
-) = sendLocation(chatId, location.latitude, location.longitude, disableNotification, protectContent, allowSendingWithoutReply, replyToMessageId, replyMarkup)
+) = sendLocation(chatId, location.latitude, location.longitude, threadId, disableNotification, protectContent, allowSendingWithoutReply, replyToMessageId, replyMarkup)
 
 /**
  * @param replyMarkup Some of [KeyboardMarkup]. See [dev.inmo.tgbotapi.extensions.utils.types.buttons.replyKeyboard] or
@@ -141,12 +153,13 @@ suspend fun TelegramBot.sendStaticLocation(
     chat: Chat,
     latitude: Double,
     longitude: Double,
+    threadId: MessageThreadId? = chat.id.threadId,
     disableNotification: Boolean = false,
     protectContent: Boolean = false,
     allowSendingWithoutReply: Boolean? = null,
-    replyToMessageId: MessageIdentifier? = null,
+    replyToMessageId: MessageId? = null,
     replyMarkup: KeyboardMarkup? = null
-) = sendLocation(chat.id, latitude, longitude, disableNotification, protectContent, allowSendingWithoutReply, replyToMessageId, replyMarkup)
+) = sendLocation(chat.id, latitude, longitude, threadId, disableNotification, protectContent, allowSendingWithoutReply, replyToMessageId, replyMarkup)
 
 /**
  * @param replyMarkup Some of [KeyboardMarkup]. See [dev.inmo.tgbotapi.extensions.utils.types.buttons.replyKeyboard] or
@@ -154,10 +167,11 @@ suspend fun TelegramBot.sendStaticLocation(
  */
 suspend fun TelegramBot.sendStaticLocation(
     chat: Chat,
-    location: StaticLocation,
+    location: Location,
+    threadId: MessageThreadId? = chat.id.threadId,
     disableNotification: Boolean = false,
     protectContent: Boolean = false,
     allowSendingWithoutReply: Boolean? = null,
-    replyToMessageId: MessageIdentifier? = null,
+    replyToMessageId: MessageId? = null,
     replyMarkup: KeyboardMarkup? = null
-) = sendLocation(chat.id, location.latitude, location.longitude, disableNotification, protectContent, allowSendingWithoutReply, replyToMessageId, replyMarkup)
+) = sendLocation(chat.id, location.latitude, location.longitude, threadId, disableNotification, protectContent, allowSendingWithoutReply, replyToMessageId, replyMarkup)

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

@@ -22,9 +22,10 @@ suspend fun TelegramBot.sendVenue(
     foursquareType: FoursquareType? = null,
     googlePlaceId: GooglePlaceId? = null,
     googlePlaceType: GooglePlaceType? = null,
+    threadId: MessageThreadId? = chatId.threadId,
     disableNotification: Boolean = false,
     protectContent: Boolean = false,
-    replyToMessageId: MessageIdentifier? = null,
+    replyToMessageId: MessageId? = null,
     allowSendingWithoutReply: Boolean? = null,
     replyMarkup: KeyboardMarkup? = null
 ) = execute(
@@ -38,6 +39,7 @@ suspend fun TelegramBot.sendVenue(
         foursquareType = foursquareType,
         googlePlaceId = googlePlaceId,
         googlePlaceType = googlePlaceType,
+        threadId = threadId,
         disableNotification = disableNotification,
         protectContent = protectContent,
         replyToMessageId = replyToMessageId,
@@ -60,9 +62,10 @@ suspend fun TelegramBot.sendVenue(
     foursquareType: FoursquareType? = null,
     googlePlaceId: GooglePlaceId? = null,
     googlePlaceType: GooglePlaceType? = null,
+    threadId: MessageThreadId? = chat.id.threadId,
     disableNotification: Boolean = false,
     protectContent: Boolean = false,
-    replyToMessageId: MessageIdentifier? = null,
+    replyToMessageId: MessageId? = null,
     allowSendingWithoutReply: Boolean? = null,
     replyMarkup: KeyboardMarkup? = null
 ) = sendVenue(
@@ -75,6 +78,7 @@ suspend fun TelegramBot.sendVenue(
     foursquareType = foursquareType,
     googlePlaceId = googlePlaceId,
     googlePlaceType = googlePlaceType,
+    threadId = threadId,
     disableNotification = disableNotification,
     protectContent = protectContent,
     replyToMessageId = replyToMessageId,
@@ -95,9 +99,10 @@ suspend fun TelegramBot.sendVenue(
     foursquareType: FoursquareType? = null,
     googlePlaceId: GooglePlaceId? = null,
     googlePlaceType: GooglePlaceType? = null,
+    threadId: MessageThreadId? = chatId.threadId,
     disableNotification: Boolean = false,
     protectContent: Boolean = false,
-    replyToMessageId: MessageIdentifier? = null,
+    replyToMessageId: MessageId? = null,
     allowSendingWithoutReply: Boolean? = null,
     replyMarkup: KeyboardMarkup? = null
 ) = sendVenue(
@@ -110,6 +115,7 @@ suspend fun TelegramBot.sendVenue(
     foursquareType = foursquareType,
     googlePlaceId = googlePlaceId,
     googlePlaceType = googlePlaceType,
+    threadId = threadId,
     disableNotification = disableNotification,
     protectContent = protectContent,
     replyToMessageId = replyToMessageId,
@@ -130,9 +136,10 @@ suspend fun TelegramBot.sendVenue(
     foursquareType: FoursquareType? = null,
     googlePlaceId: GooglePlaceId? = null,
     googlePlaceType: GooglePlaceType? = null,
+    threadId: MessageThreadId? = chat.id.threadId,
     disableNotification: Boolean = false,
     protectContent: Boolean = false,
-    replyToMessageId: MessageIdentifier? = null,
+    replyToMessageId: MessageId? = null,
     allowSendingWithoutReply: Boolean? = null,
     replyMarkup: KeyboardMarkup? = null
 ) = sendVenue(
@@ -145,6 +152,7 @@ suspend fun TelegramBot.sendVenue(
     foursquareType = foursquareType,
     googlePlaceId = googlePlaceId,
     googlePlaceType = googlePlaceType,
+    threadId = threadId,
     disableNotification = disableNotification,
     protectContent = protectContent,
     replyToMessageId = replyToMessageId,
@@ -159,15 +167,17 @@ suspend fun TelegramBot.sendVenue(
 suspend fun TelegramBot.sendVenue(
     chatId: ChatIdentifier,
     venue: Venue,
+    threadId: MessageThreadId? = chatId.threadId,
     disableNotification: Boolean = false,
     protectContent: Boolean = false,
-    replyToMessageId: MessageIdentifier? = null,
+    replyToMessageId: MessageId? = null,
     allowSendingWithoutReply: Boolean? = null,
     replyMarkup: KeyboardMarkup? = null
 ) = execute(
     SendVenue(
         chatId = chatId,
         venue = venue,
+        threadId = threadId,
         disableNotification = disableNotification,
         protectContent = protectContent,
         replyToMessageId = replyToMessageId,
@@ -183,14 +193,16 @@ suspend fun TelegramBot.sendVenue(
 suspend fun TelegramBot.sendVenue(
     chat: Chat,
     venue: Venue,
+    threadId: MessageThreadId? = chat.id.threadId,
     disableNotification: Boolean = false,
     protectContent: Boolean = false,
-    replyToMessageId: MessageIdentifier? = null,
+    replyToMessageId: MessageId? = null,
     allowSendingWithoutReply: Boolean? = null,
     replyMarkup: KeyboardMarkup? = null
 ) = sendVenue(
     chatId = chat.id,
     venue = venue,
+    threadId = threadId,
     disableNotification = disableNotification,
     protectContent = protectContent,
     replyToMessageId = replyToMessageId,