fix links in toc of extensions readme

0.27.9

.github/labeler.yml

@@ -0,0 +1,10 @@
+api: "TelegramBotAPI-extensions-api/**"
+utils: "TelegramBotAPI-extensions-utils/**"
+core: "TelegramBotAPI/**" # currently not work
+
+code: "**/*.kt"
+gradle: "**/*.gradle"
+versions: "**/gradle.properties"
+markdown:
+  - "**/*.md"
+  - "!CHANGELOG.md"

.github/workflows/greetings.yml

@@ -0,0 +1,13 @@
+name: Greetings
+
+on: [pull_request, issues]
+
+jobs:
+  greeting:
+    runs-on: ubuntu-latest
+    steps:
+    - uses: actions/first-interaction@v1
+      with:
+        repo-token: ${{ secrets.GITHUB_TOKEN }}
+        issue-message: 'Welcome with your first issue'
+        pr-message: 'Welcome with your first PullRequest'

.github/workflows/label.yml

@@ -0,0 +1,18 @@
+# This workflow will triage pull requests and apply a label based on the
+# paths that are modified in the pull request.
+#
+# To use this workflow, you will need to set up a .github/labeler.yml
+# file with configuration.  For more information, see:
+# https://github.com/actions/labeler/blob/master/README.md
+
+name: "Pull Request Labeler"
+on:
+  - pull_request
+
+jobs:
+  triage:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/labeler@v2
+        with:
+          repo-token: "${{ secrets.GITHUB_TOKEN }}"

CHANGELOG.md

@@ -49,6 +49,163 @@
         * `closePollExactAfter`
         * `closePollAfter`
 
+### 0.27.10
+
+* `TelegramBotAPI-extensions-api`:
+    * Function `telegramBot(TelegramAPIUrlsKeeper)` was added
+* `TelegramBotAPI-extensions-utils`:
+    * Extension `Route#includeWebhookHandlingInRouteWithFlows` was added
+    * A lot of extensions like `FlowsUpdatesFilter#textMessages` were added:
+        * `FlowsUpdatesFilter#animationMessages`
+        * `FlowsUpdatesFilter#audioMessages`
+        * `FlowsUpdatesFilter#contactMessages`
+        * `FlowsUpdatesFilter#diceMessages`
+        * `FlowsUpdatesFilter#documentMessages`
+        * `FlowsUpdatesFilter#gameMessages`
+        * `FlowsUpdatesFilter#invoiceMessages`
+        * `FlowsUpdatesFilter#locationMessages`
+        * `FlowsUpdatesFilter#photoMessages`
+            * `FlowsUpdatesFilter#imageMessages`
+        * `FlowsUpdatesFilter#pollMessages`
+        * `FlowsUpdatesFilter#stickerMessages`
+        * `FlowsUpdatesFilter#textMessages`
+        * `FlowsUpdatesFilter#venueMessages`
+        * `FlowsUpdatesFilter#videoMessages`
+        * `FlowsUpdatesFilter#videoNoteMessages`
+        * `FlowsUpdatesFilter#voiceMessages`
+
+### 0.27.9
+
+* `Common`
+    * Versions updates:
+        * `Gradle Wrapper`: `6.5-all` -> `6.5.1-bin`
+        * `Coroutines`: `1.3.7` -> `1.3.8`
+        * `Klock`: `1.11.3` -> `1.11.14`
+        * `UUID`: `0.1.0` -> `0.1.1`
+
+### 0.27.8
+
+* `TelegramBotAPI`:
+    * `UnknownUpdateType` was renamed to `UnknownUpdate`
+    * Refactoring and optimization of `FlowsUpdatesFilter`
+    * `Venue` type was replaced to a new package: `com.github.insanusmokrassar.TelegramBotAPI.types.venue.Venue`
+    * `Venue` type now implements `Locationed` and delegate realisation to its `location` field
+    * `FoursquareId` and `FoursquareType` typealiases were added
+* `TelegramBotAPI-extensions-utils`:
+    * Several new functions `makeLinkToMessage` was added
+    * `Foursquare` data class was added
+        * Extension `Venue#foursquare` was added
+        * Factory function `Venue` with `Foursquare` parameter was added
+
+### 0.27.7
+
+* `TelegramBotAPI`:
+    * Operator function `unaryPlus` was added to `RowBuilder`. Now it is possible to write `row { +button }`
+    * Function `flatMatrix` was added for single-row columns
+    * Operator extension `RowBuilder#plus` was added to be able to write things like `row { this + button }`
+* `TelegramBotAPI-extensions-api`:
+    * Extensions `RequestsExecutor#sendVenue` with `Location` args were added
+* `TelegramBotAPI-extensions-utils`:
+    * Function `InlineKeyboardMarkup` for flat keyboards was added
+    * Function `ReplyKeyboardMarkup` for flat keyboards was added
+
+### 0.27.6
+
+* `Common`:
+    * Versions:
+        * `Kotlin Coroutines`: `1.3.6` -> `1.3.7`
+* `TelegramBotAPI`:
+    * Interface `PossiblySentViaBot` has been added
+        * Additional interface `PossiblySentViaBotCommonMessage` was added for more explicit typing declaration for
+        compiler
+            * Currently, only `ChannelMessage` and `CommonMessageImpl` are implementing the interface
+            `PossiblySentViaBotCommonMessage`. It could be changed in future
+    * Factory `buildMimeType` was added
+    * `BuiltinMimeTypes` was added
+    * Abstraction `ThumbedWithMimeTypeInlineQueryResult` with `thumbMimeType` field was added
+        * `InlineQueryResultGif` and `InlineQueryResultMpeg4Gif` now extend `ThumbedWithMimeTypeInlineQueryResult`
+        instead of `ThumbedInlineQueryResult`
+* `TelegramBotAPI-extensions-utils`:
+    * New extensions `onlyCommonMessages`, `onlySentViaBot` and `withoutSentViaBot` was added
+
+### 0.27.5
+
+* `Common`:
+    * Versions:
+        * `Klock`: `1.11.1` -> `1.11.3`
+* `TelegramotAPI`:
+    * Fix: for sending requests caption and text lengths limits were updated
+    * New variant of `row` was added
+    * `makeLinkToMessage` extensions has been deprecated (replaced into `TelegramBotAPI-extensions-utils`)
+    * Next things was deprecated and replaced into `TelegramBotAPI-extensions-utils`:
+        * All `String` formatting public extensions and functions
+        * All extensions like `CaptionedInput#toHtmlCaptions`
+        * All helper extensions for `List<BaseMessageUpdate>`
+        * All `RequestsExecutor#executeAsync` and `RequestsExecutor#executeUnsafe`
+    * `BotCommand` now more strictly check commands which passed to it
+        * Regex `BotCommandNameRegex` was added
+* `TelegramBotAPI-extensions-api`:
+    * A lot of `RequesstExecutor#getChat` extensions was added for more explicit types showing
+    * New `RequesstExecutor#setMyCommands` extension was added
+    * New field `BotBuilder#ktorClientEngineFactory` introduced
+        * Field `BotBuilder#ktorClientEngine` now is deprecated
+* `TelegramBotAPI-extensions-utils`:
+    * `safely` function was introduced. It is in `PreviewFeature` state currently
+    * `makeLinkToMessage` extensions has been added
+    * `makeLinkToAddStickerSet` function and its variations were added
+    * Next tools was added from `TelegramBotAPI`:
+        * All `String` formatting extensions and functions
+        * All extensions like `CaptionedInput#toHtmlCaptions`
+        * All helper extensions for `List<BaseMessageUpdate>`
+            * Several new extensions for `SentMediaGroupUpdate` were added:
+                * `SentMediaGroupUpdate#forwardInfo`
+                * `SentMediaGroupUpdate#replyTo`
+                * `SentMediaGroupUpdate#chat`
+                * `SentMediaGroupUpdate#mediaGroupId`
+            * Several `List<MediaGroupMessage>.createResend` extensions were added
+        * `RequestsExecutor#executeAsync` and `RequestsExecutor#executeUnsafe`
+
+### 0.27.4
+
+* `TelegramBotAPI-extensions-utils`:
+    * Several extensions for updates was added:
+        * `onlyBaseMessageUpdates`
+        * `onlySentMessageUpdates`
+        * `onlyEditMessageUpdates`
+        * `onlyMediaGroupsUpdates`
+        * `onlySentMediaGroupUpdates`
+        * `onlyEditMediaGroupUpdates`
+    * Renames in chat filters extensions:
+        * `filterBaseMessageUpdates` -> `filterBaseMessageUpdatesByChatId` and `filterBaseMessageUpdatesByChat`
+        * `filterSentMediaGroupUpdates` -> `filterSentMediaGroupUpdatesByChatId` and `filterSentMediaGroupUpdatesByChat`
+
+### 0.27.3
+
+* `TelegramBotAPI`:
+    * `UpdateDeserializationStrategy` is publicly available now
+    * All `setWebhook` extensions was marked as deprecated, renamed and replaced into `TelegramBotAPI-extensions-utils`
+    * Typealias `ExceptionHandler` was added - it will be used for `handleSafely`
+    * `SetWebhook` factories signatures was changed (backward compatibility was not broken)
+    * `executeUnsafe` now working differently
+        * Now it is possible to pass exceptions handler into `executeUnsafe`
+    * `BasketballDiceAnimationType` was added
+    * `UnknownDiceAnimationType` now is deprecated due to renaming - currently it is typealias for `CustomDiceAnimationType`
+        * `CustomDiceAnimationType` now is `data` class instead of common class
+    * `FlowsUpdatesFilter` will use size 64 by default for internal broadcast channels
+* `TelegramBotAPI-extensions-api`:
+    * Long Polling extensions now are deprecated in this project. It was replaced into `TelegramBotAPI-extensions-utils`
+    * Several `telegramBot` functions was renamed into `telegramBotWithCustomClientConfig`
+    * Add one more `setWebhookInfo` realisation
+* `TelegramBotAPI-extensions-utils`:
+    * Extension `toTelegramUpdate` was added
+    * Long Polling extensions were added
+    * Updates utils were added
+    * New extensions `startListenWebhooks`, `setWebhookInfoAndStartListenWebhooks` and `includeWebhookHandlingInRoute` was added
+    * New extension `CoroutineScope#updateHandlerWithMediaGroupsAdaptation` was added
+    * New extension `flowsUpdatesFilter` was added
+* `TelegramBotAPI-all`:
+    * Project was created
+
 ### 0.27.2
 
 * `Common`:

README.md

@@ -1,10 +1,12 @@
 # TelegramBotAPI
 
-| Common info                           | [![Awesome Kotlin Badge](https://kotlin.link/awesome-kotlin.svg)](https://github.com/KotlinBy/awesome-kotlin) [![Chat in Telegram](badges/chat.svg)](https://t.me/InMoTelegramBotAPI) [![Build Status](https://travis-ci.com/InsanusMokrassar/TelegramBotAPI.svg?branch=master)](https://travis-ci.com/InsanusMokrassar/TelegramBotAPI)                                                                                                                                                          |
+| Common info                           | [![Awesome Kotlin Badge](https://kotlin.link/awesome-kotlin.svg)](https://github.com/KotlinBy/awesome-kotlin) [![Build Status](https://travis-ci.com/InsanusMokrassar/TelegramBotAPI.svg?branch=master)](https://travis-ci.com/InsanusMokrassar/TelegramBotAPI) [Small survey](https://forms.gle/tnjuExdSKEr32ygKA)|
 | -------------------------------------:|:------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
-| TelegramBotAPI status                 | [![Download](https://api.bintray.com/packages/insanusmokrassar/StandardRepository/TelegramBotAPI/images/download.svg)](https://bintray.com/insanusmokrassar/StandardRepository/TelegramBotAPI/_latestVersion) [![Maven Central](https://maven-badges.herokuapp.com/maven-central/com.github.insanusmokrassar/TelegramBotAPI/badge.svg)](https://maven-badges.herokuapp.com/maven-central/com.github.insanusmokrassar/TelegramBotAPI)                                                             |
+| Useful links | [![Chat in Telegram](badges/chat.svg)](https://teleg.one/InMoTelegramBotAPI) [![KDocs](badges/kdocs.svg)](https://tgbotapi.inmo.dev/docs/index.html) [Examples](https://github.com/InsanusMokrassar/TelegramBotAPI-examples/), [Mini tutorial](https://bookstack.inmo.dev/books/telegrambotapi/chapter/introduction-tutorial) |
+| TelegramBotAPI status                 | [![Download](https://api.bintray.com/packages/insanusmokrassar/StandardRepository/TelegramBotAPI/images/download.svg)](https://bintray.com/insanusmokrassar/StandardRepository/TelegramBotAPI/_latestVersion) [![Maven Central](https://maven-badges.herokuapp.com/maven-central/com.github.insanusmokrassar/TelegramBotAPI/badge.svg)](https://maven-badges.herokuapp.com/maven-central/com.github.insanusmokrassar/TelegramBotAPI) |
 | TelegramBotAPI Extensions status      | [![Download](https://api.bintray.com/packages/insanusmokrassar/StandardRepository/TelegramBotAPI-extensions-api/images/download.svg)](https://bintray.com/insanusmokrassar/StandardRepository/TelegramBotAPI-extensions-api/_latestVersion) [![Maven Central](https://maven-badges.herokuapp.com/maven-central/com.github.insanusmokrassar/TelegramBotAPI-extensions-api/badge.svg)](https://maven-badges.herokuapp.com/maven-central/com.github.insanusmokrassar/TelegramBotAPI-extensions-api) |
 | TelegramBotAPI Util Extensions status | [![Download](https://api.bintray.com/packages/insanusmokrassar/StandardRepository/TelegramBotAPI-extensions-utils/images/download.svg)](https://bintray.com/insanusmokrassar/StandardRepository/TelegramBotAPI-extensions-utils/_latestVersion) [![Maven Central](https://maven-badges.herokuapp.com/maven-central/com.github.insanusmokrassar/TelegramBotAPI-extensions-utils/badge.svg)](https://maven-badges.herokuapp.com/maven-central/com.github.insanusmokrassar/TelegramBotAPI-extensions-utils) |
+| TelegramBotAPI All status                 | [![Download](https://api.bintray.com/packages/insanusmokrassar/StandardRepository/TelegramBotAPI-all/images/download.svg)](https://bintray.com/insanusmokrassar/StandardRepository/TelegramBotAPI-all/_latestVersion) [![Maven Central](https://maven-badges.herokuapp.com/maven-central/com.github.insanusmokrassar/TelegramBotAPI-all/badge.svg)](https://maven-badges.herokuapp.com/maven-central/com.github.insanusmokrassar/TelegramBotAPI-all)                                                             |
 
 It is a complex of libraries for working with `TelegramBotAPI` in type-safe and strict way as much as it possible. In
 the list of this complex currently next projects:
@@ -15,6 +17,7 @@ the list of this complex currently next projects:
   `RequestsExecutor`), which allows to use the core library in more pleasant way
 * [TelegramBotAPI Util Extensions](TelegramBotAPI-extensions-utils/README.md) - contains extensions for more comfortable
 work with commands, updates and other different things
+* [TelegramBotAPI All](TelegramBotAPI-all/README.md) - concentration of all previously mentioned libraries
 
 Most part of some specific solves or unuseful
 moments are describing by official [Telegram Bot API](https://core.telegram.org/bots/api).
@@ -62,15 +65,66 @@ kotlin {
 
 ## Ok, where should I start?
 
-In most cases, the most simple way will be to implement
-[TelegramBotAPI Extensions](TelegramBotAPI-extensions-api/README.md) and
-[TelegramBotAPI Util Extensions](TelegramBotAPI-extensions-utils/README.md) for the reason that they contains more
-simple tools. If you want to dive deeper in the core of library or develop something for it - welcome to
+![Libraries hierarchy](resources/TelegramBotAPI-libraries-hierarchy.svg)
+
+In most cases, the most simple way will be to implement [TelegramBotAPI All](TelegramBotAPI-all/README.md) - it contains
+all necessary tools for comfort usage of this library. If you want to exclude some libraries, you can implement just
+[TelegramBotAPI API Extensions](TelegramBotAPI-extensions-api/README.md),
+[TelegramBotAPI Util Extensions](TelegramBotAPI-extensions-utils/README.md) or even
 [TelegramBotAPI](TelegramBotAPI/README.md).
 
+If you want to dive deeper in the core of library or develop something for it - welcome to learn more from
+[TelegramBotAPI](TelegramBotAPI/README.md) and our [Telegram Chat](https://teleg.one/InMoTelegramBotAPIChat).
+
 Anyway, all libraries are very typical inside of them. Examples:
 
 * In `TelegramBotAPI` common request look like `requestsExecutor.execute(SomeRequest())`
 * `TelegramBotAPI-extensions-api` typical syntax look like `requestsExecutor.someRequest()` (in most cases it would be
 better to use `bot` name instead of `requestsExecutor`)
 * `TelegramBotAPI-extensions-utils` will look like `filter.filterBaseMessageUpdates(chatId).filterExactCommands(Regex("^.*$"))...`
+
+## Build instruction
+
+If you want to build this project or to contribute, there are several recommendations:
+
+### Build
+
+In case if you want to just build project, run next command:
+
+```bash
+./gradlew clean build
+```
+
+On windows:
+
+```
+gradlew.bat clean build
+```
+
+### Publishing for work with your version locally
+
+In case, if you want to work in your other projects using your modification (or some state) of this library,
+you can use next code:
+
+```bash
+./gradlew clean build publishToMavenLocal
+```
+
+On windows:
+
+```
+gradlew.bat clean build publishToMavenLocal
+```
+
+But you must remember, that in this case your local maven repo must be the first one from
+your project retrieving libraries:
+
+```groovy
+repositories {
+    mavenLocal() // that must be the first one
+    jcenter()
+    mavenCentral()
+}
+```
+
+Besides, for your own version you can change variable `library_version` in the file [gradle.properties](./gradle.properties).

TelegramBotAPI-all/README.md

@@ -0,0 +1,16 @@
+# TelegramBotAPI-all
+
+Concentration of all TelegramBotAPI libraries:
+
+* [TelegramBotAPI](../TelegramBotAPI/README.md)
+* [TelegramBotAPI Extensions](../TelegramBotAPI-extensions-api/README.md)
+* [TelegramBotAPI Util Extensions](../TelegramBotAPI-extensions-utils/README.md)
+
+## Implementation
+
+```groovy
+dependencies {
+    // ...
+    implementation "com.github.insanusmokrassar:TelegramBotAPI-all:tgBotAPIVersion"
+}
+```

TelegramBotAPI-all/build.gradle

@@ -0,0 +1,52 @@
+buildscript {
+    repositories {
+        mavenLocal()
+        jcenter()
+        mavenCentral()
+    }
+
+    dependencies {
+        classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:$kotlin_version"
+        classpath "org.jetbrains.kotlin:kotlin-serialization:$kotlin_version"
+        classpath "com.jfrog.bintray.gradle:gradle-bintray-plugin:$gradle_bintray_plugin_version"
+    }
+}
+
+plugins {
+    id "org.jetbrains.kotlin.multiplatform" version "$kotlin_version"
+    id "org.jetbrains.kotlin.plugin.serialization" version "$kotlin_version"
+}
+
+project.version = "$library_version"
+project.group = "$library_group"
+
+apply from: "publish.gradle"
+
+repositories {
+    mavenLocal()
+    jcenter()
+    mavenCentral()
+    maven { url "https://kotlin.bintray.com/kotlinx" }
+}
+
+kotlin {
+    jvm()
+    js()
+
+    sourceSets {
+        commonMain {
+            dependencies {
+                implementation kotlin('stdlib')
+                if ((project.hasProperty('RELEASE_MODE') && project.property('RELEASE_MODE') == "true") || System.getenv('RELEASE_MODE') == "true") {
+                    api "${project.group}:TelegramBotAPI:$library_version"
+                    api "${project.group}:TelegramBotAPI-extensions-api:$library_version"
+                    api "${project.group}:TelegramBotAPI-extensions-utils:$library_version"
+                } else {
+                    api project(":TelegramBotAPI")
+                    api project(":TelegramBotAPI-extensions-api")
+                    api project(":TelegramBotAPI-extensions-utils")
+                }
+            }
+        }
+    }
+}

TelegramBotAPI-all/maven.publish.gradle

@@ -0,0 +1,53 @@
+apply plugin: 'maven-publish'
+
+task javadocsJar(type: Jar) {
+    classifier = 'javadoc'
+}
+
+afterEvaluate {
+    project.publishing.publications.all {
+        // rename artifacts
+        groupId "${project.group}"
+        if (it.name.contains('kotlinMultiplatform')) {
+            artifactId = "${project.name}"
+        } else {
+            artifactId = "${project.name}-$name"
+        }
+    }
+}
+
+publishing {
+    publications.all {
+        artifact javadocsJar
+
+        pom {
+            description = "This project just include all subproject of TelegramBotAPI"
+            name = "Telegram Bot API All"
+            url = "https://insanusmokrassar.github.io/TelegramBotAPI/TelegramBotAPI-all"
+
+            scm {
+                developerConnection = "scm:git:[fetch=]https://github.com/insanusmokrassar/TelegramBotAPI.git[push=]https://github.com/insanusmokrassar/TelegramBotAPI.git"
+                url = "https://github.com/insanusmokrassar/TelegramBotAPI.git"
+            }
+
+            developers {
+                
+                    developer {
+                        id = "InsanusMokrassar"
+                        name = "Ovsiannikov Aleksei"
+                        email = "ovsyannikov.alexey95@gmail.com"
+                    }
+                
+            }
+
+            licenses {
+                
+                    license {
+                        name = "Apache Software License 2.0"
+                        url = "https://github.com/InsanusMokrassar/TelegramBotAPI/blob/master/LICENSE"
+                    }
+                
+            }
+        }
+    }
+}

TelegramBotAPI-all/mpp_publish_template.json

@@ -0,0 +1 @@
+{"bintrayConfig":{"repo":"StandardRepository","packageName":"${project.name}","packageVcs":"https://github.com/InsanusMokrassar/TelegramBotAPI"},"licenses":[{"id":"Apache-2.0","title":"Apache Software License 2.0","url":"https://github.com/InsanusMokrassar/TelegramBotAPI/blob/master/LICENSE"}],"mavenConfig":{"name":"Telegram Bot API All","description":"This project just include all subproject of TelegramBotAPI","url":"https://insanusmokrassar.github.io/TelegramBotAPI/TelegramBotAPI-all","vcsUrl":"https://github.com/insanusmokrassar/TelegramBotAPI.git","developers":[{"id":"InsanusMokrassar","name":"Ovsiannikov Aleksei","eMail":"ovsyannikov.alexey95@gmail.com"}]},"type":"Multiplatform"}

TelegramBotAPI-all/publish.gradle

@@ -0,0 +1,55 @@
+apply plugin: 'com.jfrog.bintray'
+
+apply from: "maven.publish.gradle"
+
+bintray {
+    user = project.hasProperty('BINTRAY_USER') ? project.property('BINTRAY_USER') : System.getenv('BINTRAY_USER')
+    key = project.hasProperty('BINTRAY_KEY') ? project.property('BINTRAY_KEY') : System.getenv('BINTRAY_KEY')
+    filesSpec {
+        from "${buildDir}/publications/"
+        eachFile {
+            String directorySubname = it.getFile().parentFile.name
+            if (it.getName() == "module.json") {
+                if (directorySubname == "kotlinMultiplatform") {
+                    it.setPath("${project.name}/${project.version}/${project.name}-${project.version}.module")
+                } else {
+                    it.setPath("${project.name}-${directorySubname}/${project.version}/${project.name}-${directorySubname}-${project.version}.module")
+                }
+            } else {
+                if (directorySubname == "kotlinMultiplatform" && it.getName() == "pom-default.xml") {
+                    it.setPath("${project.name}/${project.version}/${project.name}-${project.version}.pom")
+                } else {
+                    it.exclude()
+                }
+            }
+        }
+        into "${project.group}".replace(".", "/")
+    }
+    pkg {
+        repo = "StandardRepository"
+        name = "${project.name}"
+        vcsUrl = "https://github.com/InsanusMokrassar/TelegramBotAPI"
+        licenses = ["Apache-2.0"]
+        version {
+            name = "${project.version}"
+            released = new Date()
+            vcsTag = "${project.version}"
+            gpg {
+                sign = true
+                passphrase = project.hasProperty('signing.gnupg.passphrase') ? project.property('signing.gnupg.passphrase') : System.getenv('signing.gnupg.passphrase')
+            }
+        }
+    }
+}
+
+bintrayUpload.doFirst {
+    publications = publishing.publications.collect {
+        if (it.name.contains('kotlinMultiplatform')) {
+            null
+        } else {
+            it.name
+        }
+    } - null
+}
+
+bintrayUpload.dependsOn publishToMavenLocal

TelegramBotAPI-extensions-api/README.md

@@ -55,14 +55,22 @@ compile "com.github.insanusmokrassar:TelegramBotAPI-extensions-api:$telegrambota
 ## Example of usage and comparison with `TelegramBotAPI`
 
 Here presented review table for comparison of api from original [TelegramBotAPI](../TelegramBotAPI/README.md#Requests)
-and extensions-api library:
-
-In all examples supposed that you have created bot with next approximate lines:
+and extensions-api library. First of all, this library allow to create bot instance in a new way:
 
 ```kotlin
-val bot: RequestsExecutor = ...
+val bot = telegramBot("IT IS YOUR TOKEN")
 ```
 
+There are a lot of signature for this. For example, you can create bot with next code:
+
+```kotlin
+val bot = telegramBot("IT IS YOUR TOKEN") {
+    proxy = ProxyBuilder.socks("127.0.0.1", 1080)
+}
+```
+
+In all examples supposed that you have created bot.
+
 | TelegramBotAPI | TelegramBotAPI-extensions-api |
 |----------------|-------------------------------|
 | bot.execute(GetMe) |    bot.getMe()          |
@@ -70,6 +78,10 @@ val bot: RequestsExecutor = ...
 
 ## Updates
 
+**Currently, these paragraphs almost outdated due to the fact that extensions for listening of updates and webhooks were
+replaced into `TelegramBotAPI-extensions-utils`. But, most part of information below is correct with small fixes and
+adding of `TelegramBotAPI-extensions-utils` dependency.**
+
 Usually, it is more comfortable to use filter object to get separated types of updates:
 
 ```kotlin

TelegramBotAPI-extensions-api/build.gradle

@@ -40,7 +40,7 @@ kotlin {
                 if ((project.hasProperty('RELEASE_MODE') && project.property('RELEASE_MODE') == "true") || System.getenv('RELEASE_MODE') == "true") {
                     api "${project.group}:TelegramBotAPI:$library_version"
                 } else {
-                    implementation project(":TelegramBotAPI")
+                    api project(":TelegramBotAPI")
                 }
             }
         }

TelegramBotAPI-extensions-api/maven.publish.gradle

@@ -20,37 +20,33 @@ publishing {
     publications.all {
         artifact javadocsJar
 
-        pom.withXml {
-            asNode().children().last() + {
-                resolveStrategy = Closure.DELEGATE_FIRST
+        pom {
+            description = "API extensions which provide work with RequestsExecutor of TelegramBotAPI almost like it is described in original Telegram Bot API reference"
+            name = "Telegram Bot API Extensions for API"
+            url = "https://insanusmokrassar.github.io/TelegramBotAPI/TelegramBotAPI-extensions-api"
 
-                description "API extensions which provide work with RequestsExecutor of TelegramBotAPI almost like it is described in original Telegram Bot API reference"
-                name "Telegram Bot API Extensions for API"
-                url "https://insanusmokrassar.github.io/TelegramBotAPI"
+            scm {
+                developerConnection = "scm:git:[fetch=]https://github.com/insanusmokrassar/TelegramBotAPI.git[push=]https://github.com/insanusmokrassar/TelegramBotAPI.git"
+                url = "https://github.com/insanusmokrassar/TelegramBotAPI.git"
+            }
 
-                scm {
-                    developerConnection "scm:git:[fetch=]https://github.com/insanusmokrassar/TelegramBotAPI.git[push=]https://github.com/insanusmokrassar/TelegramBotAPI.git"
-                    url "https://github.com/insanusmokrassar/TelegramBotAPI.git"
-                }
+            developers {
+                
+                    developer {
+                        id = "InsanusMokrassar"
+                        name = "Ovsiannikov Aleksei"
+                        email = "ovsyannikov.alexey95@gmail.com"
+                    }
+                
+            }
 
-                developers {
-                    
-                        developer {
-                            id "InsanusMokrassar"
-                            name "Ovsiannikov Aleksei"
-                            email "ovsyannikov.alexey95@gmail.com"
-                        }
-                    
-                }
-
-                licenses {
-                    
-                        license {
-                            name "Apache Software License 2.0"
-                            url "https://github.com/InsanusMokrassar/TelegramBotAPI/blob/master/LICENSE"
-                        }
-                    
-                }
+            licenses {
+                
+                    license {
+                        name = "Apache Software License 2.0"
+                        url = "https://github.com/InsanusMokrassar/TelegramBotAPI/blob/master/LICENSE"
+                    }
+                
             }
         }
     }

TelegramBotAPI-extensions-api/mpp_publish_template.json

@@ -1 +1 @@
-{"bintrayConfig":{"repo":"StandardRepository","packageName":"${project.name}","packageVcs":"https://github.com/InsanusMokrassar/TelegramBotAPI"},"licenses":[{"id":"Apache-2.0","title":"Apache Software License 2.0","url":"https://github.com/InsanusMokrassar/TelegramBotAPI/blob/master/LICENSE"}],"mavenConfig":{"name":"Telegram Bot API Extensions for API","description":"API extensions which provide work with RequestsExecutor of TelegramBotAPI almost like it is described in original Telegram Bot API reference","url":"https://insanusmokrassar.github.io/TelegramBotAPI","vcsUrl":"https://github.com/insanusmokrassar/TelegramBotAPI.git","developers":[{"id":"InsanusMokrassar","name":"Ovsiannikov Aleksei","eMail":"ovsyannikov.alexey95@gmail.com"}]},"type":"Multiplatform"}
+{"bintrayConfig":{"repo":"StandardRepository","packageName":"${project.name}","packageVcs":"https://github.com/InsanusMokrassar/TelegramBotAPI"},"licenses":[{"id":"Apache-2.0","title":"Apache Software License 2.0","url":"https://github.com/InsanusMokrassar/TelegramBotAPI/blob/master/LICENSE"}],"mavenConfig":{"name":"Telegram Bot API Extensions for API","description":"API extensions which provide work with RequestsExecutor of TelegramBotAPI almost like it is described in original Telegram Bot API reference","url":"https://insanusmokrassar.github.io/TelegramBotAPI/TelegramBotAPI-extensions-api","vcsUrl":"https://github.com/insanusmokrassar/TelegramBotAPI.git","developers":[{"id":"InsanusMokrassar","name":"Ovsiannikov Aleksei","eMail":"ovsyannikov.alexey95@gmail.com"}]},"type":"Multiplatform"}

TelegramBotAPI-extensions-api/src/commonMain/kotlin/com/github/insanusmokrassar/TelegramBotAPI/extensions/api/BotBuilder.kt

@@ -0,0 +1,54 @@
+package com.github.insanusmokrassar.TelegramBotAPI.extensions.api
+
+import com.github.insanusmokrassar.TelegramBotAPI.bot.RequestsExecutor
+import com.github.insanusmokrassar.TelegramBotAPI.utils.TelegramAPIUrlsKeeper
+import io.ktor.client.HttpClient
+import io.ktor.client.HttpClientConfig
+import io.ktor.client.engine.*
+
+/**
+ * @param proxy Standard ktor [ProxyConfig]
+ * @param ktorClientEngine Engine like [io.ktor.client.engine.cio.CIO]
+ * @param ktorClientConfig Config block for preconfiguring of bot [HttpClient]
+ */
+data class BotBuilder internal constructor(
+    var proxy: ProxyConfig? = null,
+    @Deprecated("ktorClientEngineFactory parameter will be used preferable. In future this parameter will be removed")
+    var ktorClientEngine: HttpClientEngine? = null,
+    var ktorClientEngineFactory: HttpClientEngineFactory<out HttpClientEngineConfig>? = null,
+    var ktorClientConfig: (HttpClientConfig<*>.() -> Unit) ? = null
+) {
+    internal fun createHttpClient(): HttpClient = ktorClientEngineFactory ?.let {
+        HttpClient(
+            it.create {
+                this@create.proxy = this@BotBuilder.proxy ?: this@create.proxy
+            }
+        ) {
+            ktorClientConfig ?.let { it() }
+        }
+    } ?: ktorClientEngine ?.let { engine ->
+        HttpClient(engine) {
+            ktorClientConfig ?.let { it() }
+            engine {
+                this@engine.proxy = this@BotBuilder.proxy ?: this@engine.proxy
+            }
+        }
+    } ?: HttpClient {
+        ktorClientConfig ?.let { it() }
+        engine {
+            this@engine.proxy = this@BotBuilder.proxy ?: this@engine.proxy
+        }
+    }
+}
+
+/**
+ * @return Created by [telegramBotWithCustomClientConfig] function [RequestsExecutor]. This executor will be preconfigured using [token] and
+ * [block]
+ */
+fun telegramBot(
+    token: String,
+    block: BotBuilder.() -> Unit
+): RequestsExecutor = telegramBot(
+    TelegramAPIUrlsKeeper(token),
+    BotBuilder().apply(block).createHttpClient()
+)

TelegramBotAPI-extensions-api/src/commonMain/kotlin/com/github/insanusmokrassar/TelegramBotAPI/extensions/api/BotExtensions.kt

@@ -0,0 +1,76 @@
+package com.github.insanusmokrassar.TelegramBotAPI.extensions.api
+
+import com.github.insanusmokrassar.TelegramBotAPI.bot.Ktor.KtorRequestsExecutor
+import com.github.insanusmokrassar.TelegramBotAPI.bot.RequestsExecutor
+import com.github.insanusmokrassar.TelegramBotAPI.utils.TelegramAPIUrlsKeeper
+import io.ktor.client.HttpClient
+import io.ktor.client.HttpClientConfig
+import io.ktor.client.engine.HttpClientEngine
+
+/**
+ * Allows to create bot using bot [urlsKeeper] and already prepared [client]
+ */
+fun telegramBot(
+    urlsKeeper: TelegramAPIUrlsKeeper,
+    client: HttpClient = HttpClient()
+): RequestsExecutor = KtorRequestsExecutor(
+    urlsKeeper,
+    client
+)
+
+/**
+ * Allows to create bot using bot [urlsKeeper] and specify [HttpClientEngine] by passing [clientEngine] param and optionally
+ * configure [HttpClient] using [clientConfig]
+ */
+fun telegramBotWithCustomClientConfig(
+    urlsKeeper: TelegramAPIUrlsKeeper,
+    clientEngine: HttpClientEngine,
+    clientConfig: HttpClientConfig<*>.() -> Unit = {}
+): RequestsExecutor = telegramBot(
+    urlsKeeper,
+    HttpClient(clientEngine, clientConfig)
+)
+
+/**
+ * Allows to create bot using bot [urlsKeeper] and optionally configure [HttpClient] using [clientConfig]
+ */
+fun telegramBotWithCustomClientConfig(
+    urlsKeeper: TelegramAPIUrlsKeeper,
+    clientConfig: HttpClientConfig<*>.() -> Unit = {}
+): RequestsExecutor = telegramBot(
+    urlsKeeper,
+    HttpClient(clientConfig)
+)
+
+/**
+ * Allows to create bot using bot [token]
+ */
+fun telegramBot(
+    token: String
+): RequestsExecutor = telegramBotWithCustomClientConfig(TelegramAPIUrlsKeeper(token))
+
+/**
+ * Allows to create bot using bot [token] and already prepared [client]
+ */
+fun telegramBot(
+    token: String,
+    client: HttpClient
+): RequestsExecutor = telegramBot(TelegramAPIUrlsKeeper(token), client)
+
+/**
+ * Allows to create bot using bot [token] and configure [HttpClient] using [clientConfig]
+ */
+fun telegramBotWithCustomClientConfig(
+    token: String,
+    clientConfig: HttpClientConfig<*>.() -> Unit
+): RequestsExecutor = telegramBotWithCustomClientConfig(TelegramAPIUrlsKeeper(token), clientConfig)
+
+/**
+ * Allows to create bot using bot [token] and specify [HttpClientEngine] by passing [clientEngine] param and optionally
+ * configure [HttpClient] using [clientConfig]
+ */
+fun telegramBot(
+    token: String,
+    clientEngine: HttpClientEngine,
+    clientConfig: HttpClientConfig<*>.() -> Unit = {}
+): RequestsExecutor = telegramBotWithCustomClientConfig(TelegramAPIUrlsKeeper(token), clientEngine, clientConfig)

TelegramBotAPI-extensions-api/src/commonMain/kotlin/com/github/insanusmokrassar/TelegramBotAPI/extensions/api/JsonUtils.kt

@@ -0,0 +1,11 @@
+package com.github.insanusmokrassar.TelegramBotAPI.extensions.api
+
+import kotlinx.serialization.json.Json
+
+@Suppress("EXPERIMENTAL_API_USAGE")
+internal val nonstrictJsonFormat = Json {
+    isLenient = true
+    ignoreUnknownKeys = true
+    serializeSpecialFloatingPointValues = true
+    useArrayPolymorphism = true
+}

TelegramBotAPI-extensions-api/src/commonMain/kotlin/com/github/insanusmokrassar/TelegramBotAPI/extensions/api/bot/SetMyCommands.kt

@@ -7,3 +7,7 @@ import com.github.insanusmokrassar.TelegramBotAPI.types.BotCommand
 suspend fun RequestsExecutor.setMyCommands(
     commands: List<BotCommand>
 ) = execute(SetMyCommands(commands))
+
+suspend fun RequestsExecutor.setMyCommands(
+    vararg commands: BotCommand
+) = setMyCommands(commands.toList())

TelegramBotAPI-extensions-api/src/commonMain/kotlin/com/github/insanusmokrassar/TelegramBotAPI/extensions/api/chat/get/GetChat.kt

@@ -2,8 +2,12 @@ package com.github.insanusmokrassar.TelegramBotAPI.extensions.api.chat.get
 
 import com.github.insanusmokrassar.TelegramBotAPI.bot.RequestsExecutor
 import com.github.insanusmokrassar.TelegramBotAPI.requests.chat.get.GetChat
-import com.github.insanusmokrassar.TelegramBotAPI.types.ChatIdentifier
-import com.github.insanusmokrassar.TelegramBotAPI.types.chat.abstracts.Chat
+import com.github.insanusmokrassar.TelegramBotAPI.types.*
+import com.github.insanusmokrassar.TelegramBotAPI.types.chat.*
+import com.github.insanusmokrassar.TelegramBotAPI.types.chat.abstracts.*
+import com.github.insanusmokrassar.TelegramBotAPI.types.chat.abstracts.extended.*
+import com.github.insanusmokrassar.TelegramBotAPI.types.chat.extended.*
+import com.github.insanusmokrassar.TelegramBotAPI.utils.PreviewFeature
 
 suspend fun RequestsExecutor.getChat(
     chatId: ChatIdentifier
@@ -12,3 +16,117 @@ suspend fun RequestsExecutor.getChat(
 suspend fun RequestsExecutor.getChat(
     chat: Chat
 ) = getChat(chat.id)
+
+/**
+ * Will cast incoming [com.github.insanusmokrassar.TelegramBotAPI.types.chat.abstracts.extended.ExtendedChat] to a
+ * [ExtendedPublicChat] with unsafe operator "as"
+ *
+ * @throws ClassCastException
+ */
+@PreviewFeature
+suspend fun RequestsExecutor.getChat(
+    chat: PublicChat
+) = getChat(chat.id) as ExtendedPublicChat
+
+
+/**
+ * Will cast incoming [com.github.insanusmokrassar.TelegramBotAPI.types.chat.abstracts.extended.ExtendedChat] to a
+ * [ExtendedChannelChat] with unsafe operator "as"
+ *
+ * @throws ClassCastException
+ */
+@PreviewFeature
+suspend fun RequestsExecutor.getChat(
+    chat: ChannelChat
+) = getChat(chat.id) as ExtendedChannelChat
+
+/**
+ * Will cast incoming [com.github.insanusmokrassar.TelegramBotAPI.types.chat.abstracts.extended.ExtendedChat] to a
+ * [ExtendedChannelChatImpl] with unsafe operator "as"
+ *
+ * @throws ClassCastException
+ */
+@PreviewFeature
+suspend fun RequestsExecutor.getChat(
+    chat: ChannelChatImpl
+) = getChat(chat.id) as ExtendedChannelChatImpl
+
+
+/**
+ * Will cast incoming [com.github.insanusmokrassar.TelegramBotAPI.types.chat.abstracts.extended.ExtendedChat] to a
+ * [ExtendedGroupChat] with unsafe operator "as"
+ *
+ * @throws ClassCastException
+ */
+@PreviewFeature
+suspend fun RequestsExecutor.getChat(
+    chat: GroupChat
+) = getChat(chat.id) as ExtendedGroupChat
+
+/**
+ * Will cast incoming [com.github.insanusmokrassar.TelegramBotAPI.types.chat.abstracts.extended.ExtendedChat] to a
+ * [ExtendedGroupChatImpl] with unsafe operator "as"
+ *
+ * @throws ClassCastException
+ */
+@PreviewFeature
+suspend fun RequestsExecutor.getChat(
+    chat: GroupChatImpl
+) = getChat(chat.id) as ExtendedGroupChatImpl
+
+
+/**
+ * Will cast incoming [com.github.insanusmokrassar.TelegramBotAPI.types.chat.abstracts.extended.ExtendedChat] to a
+ * [ExtendedSupergroupChat] with unsafe operator "as"
+ *
+ * @throws ClassCastException
+ */
+@PreviewFeature
+suspend fun RequestsExecutor.getChat(
+    chat: SupergroupChat
+) = getChat(chat.id) as ExtendedSupergroupChat
+
+/**
+ * Will cast incoming [com.github.insanusmokrassar.TelegramBotAPI.types.chat.abstracts.extended.ExtendedChat] to a
+ * [ExtendedSupergroupChatImpl] with unsafe operator "as"
+ *
+ * @throws ClassCastException
+ */
+@PreviewFeature
+suspend fun RequestsExecutor.getChat(
+    chat: SupergroupChatImpl
+) = getChat(chat.id) as ExtendedSupergroupChatImpl
+
+
+/**
+ * Will cast incoming [com.github.insanusmokrassar.TelegramBotAPI.types.chat.abstracts.extended.ExtendedChat] to a
+ * [ExtendedPrivateChat] with unsafe operator "as"
+ *
+ * @throws ClassCastException
+ */
+@PreviewFeature
+suspend fun RequestsExecutor.getChat(
+    chat: PrivateChat
+) = getChat(chat.id) as ExtendedPrivateChat
+
+/**
+ * Will cast incoming [com.github.insanusmokrassar.TelegramBotAPI.types.chat.abstracts.extended.ExtendedChat] to a
+ * [ExtendedPrivateChatImpl] with unsafe operator "as"
+ *
+ * @throws ClassCastException
+ */
+@PreviewFeature
+suspend fun RequestsExecutor.getChat(
+    chat: PrivateChatImpl
+) = getChat(chat.id) as ExtendedPrivateChatImpl
+
+/**
+ * Will cast incoming [com.github.insanusmokrassar.TelegramBotAPI.types.chat.abstracts.extended.ExtendedChat] to a
+ * [ExtendedUser] with unsafe operator "as"
+ *
+ * @throws ClassCastException
+ */
+@PreviewFeature
+suspend fun RequestsExecutor.getChat(
+    chat: CommonUser
+) = getChat(chat.id) as ExtendedUser

TelegramBotAPI-extensions-api/src/commonMain/kotlin/com/github/insanusmokrassar/TelegramBotAPI/extensions/api/send/SendVenue.kt

@@ -5,6 +5,7 @@ import com.github.insanusmokrassar.TelegramBotAPI.requests.send.SendVenue
 import com.github.insanusmokrassar.TelegramBotAPI.types.*
 import com.github.insanusmokrassar.TelegramBotAPI.types.buttons.KeyboardMarkup
 import com.github.insanusmokrassar.TelegramBotAPI.types.chat.abstracts.Chat
+import com.github.insanusmokrassar.TelegramBotAPI.types.venue.Venue
 
 suspend fun RequestsExecutor.sendVenue(
     chatId: ChatIdentifier,
@@ -36,6 +37,32 @@ suspend fun RequestsExecutor.sendVenue(
     chat.id, latitude, longitude, title, address, foursquareId, disableNotification, replyToMessageId, replyMarkup
 )
 
+suspend fun RequestsExecutor.sendVenue(
+    chatId: ChatIdentifier,
+    location: Location,
+    title: String,
+    address: String,
+    foursquareId: String? = null,
+    disableNotification: Boolean = false,
+    replyToMessageId: MessageIdentifier? = null,
+    replyMarkup: KeyboardMarkup? = null
+) = sendVenue(
+    chatId, location.latitude, location.longitude, title, address, foursquareId, disableNotification, replyToMessageId, replyMarkup
+)
+
+suspend fun RequestsExecutor.sendVenue(
+    chat: Chat,
+    location: Location,
+    title: String,
+    address: String,
+    foursquareId: String? = null,
+    disableNotification: Boolean = false,
+    replyToMessageId: MessageIdentifier? = null,
+    replyMarkup: KeyboardMarkup? = null
+) = sendVenue(
+    chat.id, location.latitude, location.longitude, title, address, foursquareId, disableNotification, replyToMessageId, replyMarkup
+)
+
 suspend fun RequestsExecutor.sendVenue(
     chatId: ChatIdentifier,
     venue: Venue,

TelegramBotAPI-extensions-api/src/commonMain/kotlin/com/github/insanusmokrassar/TelegramBotAPI/extensions/api/updates/UpdatesPolling.kt

@@ -10,14 +10,14 @@ import com.github.insanusmokrassar.TelegramBotAPI.types.update.*
 import com.github.insanusmokrassar.TelegramBotAPI.types.update.MediaGroupUpdates.*
 import com.github.insanusmokrassar.TelegramBotAPI.types.update.abstracts.Update
 import com.github.insanusmokrassar.TelegramBotAPI.updateshandlers.*
-import com.github.insanusmokrassar.TelegramBotAPI.utils.PreviewFeature
-import com.github.insanusmokrassar.TelegramBotAPI.utils.handleSafely
+import com.github.insanusmokrassar.TelegramBotAPI.utils.*
 import kotlinx.coroutines.*
 
+@Deprecated("Replaced and renamed in TelegramBotAPI-extensions-utils")
 fun RequestsExecutor.startGettingOfUpdates(
     timeoutSeconds: Seconds = 30,
     scope: CoroutineScope = CoroutineScope(Dispatchers.Default),
-    exceptionsHandler: (suspend (Exception) -> Unit)? = null,
+    exceptionsHandler: (ExceptionHandler<Unit>)? = null,
     allowedUpdates: List<String>? = null,
     updatesReceiver: UpdateReceiver<Update>
 ): Job = scope.launch {
@@ -71,17 +71,19 @@ fun RequestsExecutor.startGettingOfUpdates(
 @FlowPreview
 @PreviewFeature
 @Suppress("unused")
+@Deprecated("Replaced and renamed in TelegramBotAPI-extensions-utils")
 fun RequestsExecutor.startGettingFlowsUpdates(
     timeoutSeconds: Seconds = 30,
     scope: CoroutineScope = CoroutineScope(Dispatchers.Default),
     exceptionsHandler: (suspend (Exception) -> Unit)? = null,
-    flowsUpdatesFilterUpdatesKeeperCount: Int = 64,
+    flowsUpdatesFilterUpdatesKeeperCount: Int = 100,
     flowUpdatesPreset: FlowsUpdatesFilter.() -> Unit = {}
 ): FlowsUpdatesFilter = FlowsUpdatesFilter(flowsUpdatesFilterUpdatesKeeperCount).apply {
     flowUpdatesPreset()
     startGettingOfUpdates(timeoutSeconds, scope, exceptionsHandler, allowedUpdates, asUpdateReceiver)
 }
 
+@Deprecated("Replaced and renamed in TelegramBotAPI-extensions-utils")
 fun RequestsExecutor.startGettingOfUpdates(
     updatesFilter: UpdatesFilter,
     timeoutSeconds: Seconds = 30,
@@ -95,6 +97,7 @@ fun RequestsExecutor.startGettingOfUpdates(
     updatesFilter.asUpdateReceiver
 )
 
+@Deprecated("Replaced and renamed in TelegramBotAPI-extensions-utils")
 fun RequestsExecutor.startGettingOfUpdates(
     messageCallback: UpdateReceiver<MessageUpdate>? = null,
     messageMediaGroupCallback: UpdateReceiver<MessageMediaGroupUpdate>? = null,
@@ -140,6 +143,7 @@ fun RequestsExecutor.startGettingOfUpdates(
 }
 
 @Suppress("unused")
+@Deprecated("Replaced and renamed in TelegramBotAPI-extensions-utils")
 fun RequestsExecutor.startGettingOfUpdates(
     messageCallback: UpdateReceiver<MessageUpdate>? = null,
     mediaGroupCallback: UpdateReceiver<MediaGroupUpdate>? = null,

TelegramBotAPI-extensions-api/src/commonMain/kotlin/com/github/insanusmokrassar/TelegramBotAPI/extensions/api/utils/UpdatesHandling.kt

@@ -0,0 +1,49 @@
+package com.github.insanusmokrassar.TelegramBotAPI.extensions.api.utils
+
+import com.github.insanusmokrassar.TelegramBotAPI.extensions.api.InternalUtils.convertWithMediaGroupUpdates
+import com.github.insanusmokrassar.TelegramBotAPI.types.message.abstracts.MediaGroupMessage
+import com.github.insanusmokrassar.TelegramBotAPI.types.update.abstracts.BaseMessageUpdate
+import com.github.insanusmokrassar.TelegramBotAPI.types.update.abstracts.Update
+import com.github.insanusmokrassar.TelegramBotAPI.updateshandlers.UpdateReceiver
+import com.github.insanusmokrassar.TelegramBotAPI.utils.extensions.accumulateByKey
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.channels.Channel
+import kotlinx.coroutines.launch
+
+/**
+ * Create [UpdateReceiver] object which will correctly accumulate updates and send into output updates which INCLUDE
+ * [com.github.insanusmokrassar.TelegramBotAPI.types.update.MediaGroupUpdates.MediaGroupUpdate]s.
+ *
+ * @see UpdateReceiver
+ */
+fun CoroutineScope.updateHandlerWithMediaGroupsAdaptation(
+    output: UpdateReceiver<Update>,
+    mediaGroupsDebounceMillis: Long = 1000L
+): UpdateReceiver<Update> {
+    val updatesChannel = Channel<Update>(Channel.UNLIMITED)
+    val mediaGroupChannel = Channel<Pair<String, BaseMessageUpdate>>(Channel.UNLIMITED)
+    val mediaGroupAccumulatedChannel = mediaGroupChannel.accumulateByKey(
+        mediaGroupsDebounceMillis,
+        scope = this
+    )
+
+    launch {
+        launch {
+            for (update in updatesChannel) {
+                when (val data = update.data) {
+                    is MediaGroupMessage -> mediaGroupChannel.send("${data.mediaGroupId}${update::class.simpleName}" to update as BaseMessageUpdate)
+                    else -> output(update)
+                }
+            }
+        }
+        launch {
+            for ((_, mediaGroup) in mediaGroupAccumulatedChannel) {
+                mediaGroup.convertWithMediaGroupUpdates().forEach {
+                    output(it)
+                }
+            }
+        }
+    }
+
+    return { updatesChannel.send(it) }
+}

TelegramBotAPI-extensions-api/src/commonMain/kotlin/com/github/insanusmokrassar/TelegramBotAPI/extensions/api/webhook/SetWebhookInfo.kt

@@ -5,6 +5,22 @@ import com.github.insanusmokrassar.TelegramBotAPI.requests.abstracts.FileId
 import com.github.insanusmokrassar.TelegramBotAPI.requests.abstracts.MultipartFile
 import com.github.insanusmokrassar.TelegramBotAPI.requests.webhook.SetWebhook
 
+/**
+ * Use this method to send information about webhook (like [url])
+ */
+suspend fun RequestsExecutor.setWebhookInfo(
+    url: String,
+    maxAllowedConnections: Int? = null,
+    allowedUpdates: List<String>? = null
+) = execute(
+    SetWebhook(
+        url, maxAllowedConnections, allowedUpdates
+    )
+)
+
+/**
+ * Use this method to send information about webhook (like [url] and [certificate])
+ */
 suspend fun RequestsExecutor.setWebhookInfo(
     url: String,
     certificate: FileId,
@@ -16,6 +32,9 @@ suspend fun RequestsExecutor.setWebhookInfo(
     )
 )
 
+/**
+ * Use this method to send information about webhook (like [url] and [certificate])
+ */
 suspend fun RequestsExecutor.setWebhookInfo(
     url: String,
     certificate: MultipartFile,

TelegramBotAPI-extensions-utils/README.md

@@ -1,4 +1,22 @@
-# TelegramBotAPI Util  Extensions
+# TelegramBotAPI Util Extensions
+
+- [TelegramBotAPI Util Extensions](#telegrambotapi-util-extensions)
+  * [What is it?](#what-is-it)
+  * [How to implement library?](#how-to-implement-library)
+    + [Maven](#maven)
+    + [Gradle](#gradle)
+  * [How to use?](#how-to-use)
+    + [Updates](#updates)
+      - [Long polling](#long-polling)
+      - [WebHooks (currently JVM-only)](#webhooks--currently-jvm-only)
+    + [Filters](#filters)
+      - [Sent messages](#sent-messages)
+        * [Common messages](#common-messages)
+        * [Chat actions](#chat-actions)
+    + [Shortcuts](#shortcuts)
+      - [ScheduledCloseInfo](#scheduledcloseinfo)
+
+<small><i><a href='http://ecotrust-canada.github.io/markdown-toc/'>Table of contents generated with markdown-toc</a></i></small>
 
 [![Download](https://api.bintray.com/packages/insanusmokrassar/StandardRepository/TelegramBotAPI-extensions-utils/images/download.svg) ](https://bintray.com/insanusmokrassar/StandardRepository/TelegramBotAPI-extensions-utils/_latestVersion)
 [![Maven Central](https://maven-badges.herokuapp.com/maven-central/com.github.insanusmokrassar/TelegramBotAPI-extensions-utils/badge.svg)](https://maven-badges.herokuapp.com/maven-central/com.github.insanusmokrassar/TelegramBotAPI-extensions-utils)
@@ -60,17 +78,125 @@ val filter = FlowsUpdatesFilter(64)
 Alternative way to use the things below:
 
 ```kotlin
-val filter = bot.startGettingUpdates(
+val filter = bot.startGettingFlowsUpdatesByLongPolling(
     scope = CoroutineScope(Dispatchers.Default)
 ) {
     // place code from examples here with replacing of `filter` by `this`
 }
 ```
 
+### Updates
+
+As mentioned in [Telegram Bot API reference](https://core.telegram.org/bots/api#getting-updates), there are two ways for
+updates retrieving:
+
+* Webhooks
+* Long Polling
+
+Both of them you could use in your project using [TelegramBotAPI](../TelegramBotAPI/README.md), but here there are
+several useful extensions for both of them.
+
+Anyway, in both of ways it will be useful to know that it is possible to create `UpdateReceiver` object using function
+`flowsUpdatesFilter`:
+
+```kotlin
+val internalChannelsSizes = 128
+flowsUpdatesFilter(internalChannelsSizes/* default is 64 */) {
+    textMessages().onEach {
+        println("I have received text message: ${it.content}")
+    }.launchIn(someCoroutineScope)
+    /* ... */
+}
+```
+
+#### Long polling
+
+The most simple way is Long Polling and one of the usages was mentioned above:
+
+```kotlin
+val filter = bot.startGettingFlowsUpdatesByLongPolling(
+    scope = CoroutineScope(Dispatchers.Default)
+) {
+    // place code from examples here with replacing of `filter` by `this`
+}
+```
+
+Extension `startGettingFlowsUpdatesByLongPolling` was used in this example, but there are a lot of variations of
+`startGettingOfUpdatesByLongPolling` and others for getting the same result. Usually, it is supposed that you already
+have created `filter` object (or something like this) and will pass it into extension:
+
+```kotlin
+val filter = FlowsUpdatesFilter(64)
+bot.startGettingOfUpdatesByLongPolling(
+    filter
+)
+```
+
+But also there are extensions which allow to pass lambdas directly:
+
+```kotlin
+bot.startGettingOfUpdatesByLongPolling(
+    {
+        println("Received message update: $it")
+    }
+)
+```
+
+Anyway, it is strictly recommended to pass your `CoroutineScope` object to this method at least for more comfortable
+management of updates.
+
+#### WebHooks (currently JVM-only)
+
+For webhooks there are less number of functions and extensions than for Long Polling (but it is still fully automated):
+
+```kotlin
+startListenWebhooks(
+    8081,
+    CIO // require to implement this engine dependency
+) {
+    // here will be all updates one by one in $it
+}
+```
+
+Besides, there are two additional opportunities:
+
+* Extension `Route#includeWebhookHandlingInRoute`, which allow you to include webhook processing inside your ktor
+application without creating of new one server (as it is happening in `startListenWebhooks`)
+    * Also, you can use `Route#includeWebhookHandlingInRouteWithFlows` to use it like `flowUpdatesFilter` fun, but apply
+    `FlowsUpdatesFilter` to the block
+* Extension `RequestsExecutor#setWebhookInfoAndStartListenWebhooks`. It is allow to set up full server (in fact, with
+`startListenWebhooks`), but also send `SetWebhook` request before and check that it was successful
+
 ### Filters
 
 There are several filters for flows.
 
+#### Updates
+
+In the next table it is supposed that you are using some `Flow` with type from `Base type of update` and apply
+extension `Extension` and will get `Flow` with type from `Result type of update` column.
+
+| Base type of update | Extension | Result type of update |
+| ------------------- | --------- | --------------------- |
+| `Update` | `onlyBaseMessageUpdates` | `BaseMessageUpdate` |
+|  |  |  |
+| `BaseMessageUpdate` | `onlySentMessageUpdates` | `BaseSentMessageUpdate` |
+| `BaseMessageUpdate` | `onlyEditMessageUpdates` | `BaseEditMessageUpdate` |
+| `BaseMessageUpdate` | `onlyMediaGroupsUpdates` | `MediaGroupUpdate` |
+|  |  |  |
+| `MediaGroupUpdate` | `onlySentMediaGroupUpdates` | `SentMediaGroupUpdate` |
+| `MediaGroupUpdate` | `onlyEditMediaGroupUpdates` | `EditMediaGroupUpdate` |
+
+All of these extensions was made for more simple work with the others:
+
+```kotlin
+val flow: Flow<BaseMessageUpdate> = ...; // here we are getting flow from somewhere,
+                                        // for example, FlowsUpdatesFilter#messageFlow
+flow.onlySentMessageUpdates().filterExactCommands(Regex("start"))
+```
+
+Here we have used filter `filterExactCommands` which will pass only `ContentMessage` with only one command `start`
+
 #### Sent messages
 
 All sent messages can be filtered for three types:
@@ -136,11 +262,11 @@ filter.messageFlow.asChatEventsFlow().onlySupergroupEvents().onEach {
 )
 ```
 
-## Shortcuts
+### Shortcuts
 
 With shortcuts you are able to use simple factories for several things.
 
-### ScheduledCloseInfo
+#### ScheduledCloseInfo
 
 In case if you are creating some poll, you able to use next shortcuts.
 

TelegramBotAPI-extensions-utils/build.gradle

@@ -40,7 +40,7 @@ kotlin {
                 if ((project.hasProperty('RELEASE_MODE') && project.property('RELEASE_MODE') == "true") || System.getenv('RELEASE_MODE') == "true") {
                     api "${project.group}:TelegramBotAPI:$library_version"
                 } else {
-                    implementation project(":TelegramBotAPI")
+                    api project(":TelegramBotAPI")
                 }
             }
         }

TelegramBotAPI-extensions-utils/maven.publish.gradle

@@ -20,37 +20,33 @@ publishing {
     publications.all {
         artifact javadocsJar
 
-        pom.withXml {
-            asNode().children().last() + {
-                resolveStrategy = Closure.DELEGATE_FIRST
+        pom {
+            description = "Util extensions for more useful work with updates and other things"
+            name = "Telegram Bot API Utility Extensions"
+            url = "https://insanusmokrassar.github.io/TelegramBotAPI/TelegramBotAPI-extensions-utils"
 
-                description "Util extensions for more useful work with updates and other things"
-                name "Telegram Bot API Utility Extensions"
-                url "https://insanusmokrassar.github.io/TelegramBotAPI"
+            scm {
+                developerConnection = "scm:git:[fetch=]https://github.com/insanusmokrassar/TelegramBotAPI.git[push=]https://github.com/insanusmokrassar/TelegramBotAPI.git"
+                url = "https://github.com/insanusmokrassar/TelegramBotAPI.git"
+            }
 
-                scm {
-                    developerConnection "scm:git:[fetch=]https://github.com/insanusmokrassar/TelegramBotAPI.git[push=]https://github.com/insanusmokrassar/TelegramBotAPI.git"
-                    url "https://github.com/insanusmokrassar/TelegramBotAPI.git"
-                }
+            developers {
+                
+                    developer {
+                        id = "InsanusMokrassar"
+                        name = "Ovsiannikov Aleksei"
+                        email = "ovsyannikov.alexey95@gmail.com"
+                    }
+                
+            }
 
-                developers {
-                    
-                        developer {
-                            id "InsanusMokrassar"
-                            name "Ovsiannikov Aleksei"
-                            email "ovsyannikov.alexey95@gmail.com"
-                        }
-                    
-                }
-
-                licenses {
-                    
-                        license {
-                            name "Apache Software License 2.0"
-                            url "https://github.com/InsanusMokrassar/TelegramBotAPI/blob/master/LICENSE"
-                        }
-                    
-                }
+            licenses {
+                
+                    license {
+                        name = "Apache Software License 2.0"
+                        url = "https://github.com/InsanusMokrassar/TelegramBotAPI/blob/master/LICENSE"
+                    }
+                
             }
         }
     }

TelegramBotAPI-extensions-utils/mpp_publish_template.json

@@ -1 +1 @@
-{"bintrayConfig":{"repo":"StandardRepository","packageName":"${project.name}","packageVcs":"https://github.com/InsanusMokrassar/TelegramBotAPI"},"licenses":[{"id":"Apache-2.0","title":"Apache Software License 2.0","url":"https://github.com/InsanusMokrassar/TelegramBotAPI/blob/master/LICENSE"}],"mavenConfig":{"name":"Telegram Bot API Utility Extensions","description":"Util extensions for more useful work with updates and other things","url":"https://insanusmokrassar.github.io/TelegramBotAPI","vcsUrl":"https://github.com/insanusmokrassar/TelegramBotAPI.git","developers":[{"id":"InsanusMokrassar","name":"Ovsiannikov Aleksei","eMail":"ovsyannikov.alexey95@gmail.com"}]},"type":"Multiplatform"}
+{"bintrayConfig":{"repo":"StandardRepository","packageName":"${project.name}","packageVcs":"https://github.com/InsanusMokrassar/TelegramBotAPI"},"licenses":[{"id":"Apache-2.0","title":"Apache Software License 2.0","url":"https://github.com/InsanusMokrassar/TelegramBotAPI/blob/master/LICENSE"}],"mavenConfig":{"name":"Telegram Bot API Utility Extensions","description":"Util extensions for more useful work with updates and other things","url":"https://insanusmokrassar.github.io/TelegramBotAPI/TelegramBotAPI-extensions-utils","vcsUrl":"https://github.com/insanusmokrassar/TelegramBotAPI.git","developers":[{"id":"InsanusMokrassar","name":"Ovsiannikov Aleksei","eMail":"ovsyannikov.alexey95@gmail.com"}]},"type":"Multiplatform"}

TelegramBotAPI-extensions-utils/src/commonMain/kotlin/com/github/insanusmokrassar/TelegramBotAPI/extensions/utils/CommonMessageConversations.kt

@@ -0,0 +1,34 @@
+package com.github.insanusmokrassar.TelegramBotAPI.extensions.utils
+
+import com.github.insanusmokrassar.TelegramBotAPI.types.message.abstracts.CommonMessage
+import com.github.insanusmokrassar.TelegramBotAPI.types.message.abstracts.ContentMessage
+import com.github.insanusmokrassar.TelegramBotAPI.types.message.content.abstracts.MessageContent
+import com.github.insanusmokrassar.TelegramBotAPI.types.message.content.abstracts.PossiblySentViaBotCommonMessage
+import kotlinx.coroutines.flow.*
+
+/**
+ * Simple factory to convert [ContentMessage] to a [CommonMessage]
+ */
+fun <C: MessageContent, T : ContentMessage<C>> Flow<T>.onlyCommonMessages() = filterIsInstance<CommonMessage<C>>()
+
+/**
+ * Filter the messages and checking that incoming [CommonMessage] is [PossiblySentViaBotCommonMessage] and its
+ * [PossiblySentViaBotCommonMessage.senderBot] is not null
+ */
+fun <T : MessageContent> Flow<CommonMessage<T>>.onlySentViaBot() = mapNotNull {
+    (it as? PossiblySentViaBotCommonMessage) ?.let { possiblySentViaBot ->
+        if (possiblySentViaBot.senderBot != null) {
+            possiblySentViaBot
+        } else {
+            null
+        }
+    }
+}
+
+/**
+ * Filter the messages and checking that incoming [CommonMessage] not is [PossiblySentViaBotCommonMessage] or its
+ * [PossiblySentViaBotCommonMessage.senderBot] is null
+ */
+fun <T : MessageContent> Flow<CommonMessage<T>>.withoutSentViaBot() = filter {
+    it !is PossiblySentViaBotCommonMessage || it.senderBot == null
+}

TelegramBotAPI-extensions-utils/src/commonMain/kotlin/com/github/insanusmokrassar/TelegramBotAPI/extensions/utils/FlowsAggregation.kt

@@ -0,0 +1,20 @@
+package com.github.insanusmokrassar.TelegramBotAPI.extensions.utils
+
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.channels.BroadcastChannel
+import kotlinx.coroutines.channels.Channel
+import kotlinx.coroutines.flow.*
+
+fun <T> aggregateFlows(
+    withScope: CoroutineScope,
+    vararg flows: Flow<T>,
+    internalBufferSize: Int = Channel.BUFFERED
+): Flow<T> {
+    val bc = BroadcastChannel<T>(internalBufferSize)
+    flows.forEach {
+        it.onEach {
+            safely { bc.send(it) }
+        }.launchIn(withScope)
+    }
+    return bc.asFlow()
+}

TelegramBotAPI-extensions-utils/src/commonMain/kotlin/com/github/insanusmokrassar/TelegramBotAPI/extensions/utils/JsonFormat.kt

@@ -0,0 +1,11 @@
+package com.github.insanusmokrassar.TelegramBotAPI.extensions.utils
+
+import kotlinx.serialization.json.Json
+
+@Suppress("EXPERIMENTAL_API_USAGE")
+internal val nonstrictJsonFormat = Json {
+    isLenient = true
+    ignoreUnknownKeys = true
+    serializeSpecialFloatingPointValues = true
+    useArrayPolymorphism = true
+}

TelegramBotAPI-extensions-utils/src/commonMain/kotlin/com/github/insanusmokrassar/TelegramBotAPI/extensions/utils/SafelyShortcut.kt

@@ -0,0 +1,16 @@
+package com.github.insanusmokrassar.TelegramBotAPI.extensions.utils
+
+import com.github.insanusmokrassar.TelegramBotAPI.utils.*
+import kotlinx.coroutines.CoroutineScope
+
+/**
+ * Shortcut for [handleSafely]. It was created for more comfortable way of handling different things
+ */
+@PreviewFeature
+suspend inline fun <T> safely(
+    noinline onException: ExceptionHandler<T> = { throw it },
+    noinline block: suspend CoroutineScope.() -> T
+): T = handleSafely(
+    onException,
+    block
+)

TelegramBotAPI-extensions-utils/src/commonMain/kotlin/com/github/insanusmokrassar/TelegramBotAPI/extensions/utils/extensions/venue/Foursquare.kt

@@ -0,0 +1,26 @@
+package com.github.insanusmokrassar.TelegramBotAPI.extensions.utils.extensions.venue
+
+import com.github.insanusmokrassar.TelegramBotAPI.types.*
+import com.github.insanusmokrassar.TelegramBotAPI.types.venue.Venue
+import kotlinx.serialization.SerialName
+import kotlinx.serialization.Serializable
+
+val Venue.foursquare: Foursquare?
+    get() = foursquareId ?.let {
+        Foursquare(it, foursquareType)
+    }
+
+fun Venue(
+    location: Location,
+    title: String,
+    address: String,
+    foursquare: Foursquare
+) = Venue(location, title, address, foursquare.id, foursquare.type)
+
+@Serializable
+data class Foursquare(
+    @SerialName(foursquareIdField)
+    val id: FoursquareId,
+    @SerialName(foursquareTypeField)
+    val type: FoursquareType? = null
+)

TelegramBotAPI-extensions-utils/src/commonMain/kotlin/com/github/insanusmokrassar/TelegramBotAPI/extensions/utils/formatting/LinksFormatting.kt

@@ -0,0 +1,87 @@
+package com.github.insanusmokrassar.TelegramBotAPI.extensions.utils.formatting
+
+import com.github.insanusmokrassar.TelegramBotAPI.types.*
+import com.github.insanusmokrassar.TelegramBotAPI.types.ParseMode.*
+import com.github.insanusmokrassar.TelegramBotAPI.types.chat.abstracts.PrivateChat
+import com.github.insanusmokrassar.TelegramBotAPI.types.chat.abstracts.UsernameChat
+import com.github.insanusmokrassar.TelegramBotAPI.types.chat.abstracts.extended.ExtendedChat
+import com.github.insanusmokrassar.TelegramBotAPI.utils.link
+
+private const val internalLinkBeginning = "https://t.me"
+
+fun makeLinkToMessage(
+    username: String,
+    messageId: MessageIdentifier
+): String = "$internalLinkBeginning/$username/$messageId"
+fun makeLinkToMessage(
+    username: Username,
+    messageId: MessageIdentifier
+): String = makeLinkToMessage(username.username, messageId)
+fun makeLinkToMessage(
+    chat: UsernameChat,
+    messageId: MessageIdentifier
+): String? = chat.username ?.let { makeLinkToMessage(it, messageId) }
+
+private val linkIdRedundantPartRegex = Regex("^-100")
+private val usernameBeginSymbolRegex = Regex("^@")
+
+fun makeLinkToMessage(
+    chat: ExtendedChat,
+    messageId: MessageIdentifier
+): String? {
+    return when {
+        chat is UsernameChat && chat.username != null -> {
+            "$internalLinkBeginning/${chat.username ?.username ?.replace(
+                usernameBeginSymbolRegex, "")}/$messageId"
+        }
+        chat !is PrivateChat -> chat.id.chatId.toString().replace(
+            linkIdRedundantPartRegex,
+            ""
+        ).let { bareId ->
+            "$internalLinkBeginning/c/$bareId/$messageId"
+        }
+        else -> return null
+    }
+}
+
+private const val stickerSetAddingLinkPrefix = "$internalLinkBeginning/addstickers"
+
+/**
+ * Create a link for adding of sticker set with name [stickerSetName]. Was added thanks to user Djaler and based on
+ * https://github.com/Djaler/evil-bot/blob/master/src/main/kotlin/com/github/djaler/evilbot/utils/StickerUtils.kt#L6-L8
+ *
+ * @see [makeLinkToAddStickerSetInMarkdownV2]
+ * @see [makeLinkToAddStickerSetInMarkdown]
+ * @see [makeLinkToAddStickerSetInHtml]
+ */
+fun makeLinkToAddStickerSet(
+    stickerSetName: StickerSetName,
+    parseMode: ParseMode
+) = (stickerSetName to "$stickerSetAddingLinkPrefix/$stickerSetName").link(
+    parseMode
+)
+
+/**
+ * @return Link for adding of sticker set with name [stickerSetName] with formatting for [MarkdownV2]
+ */
+fun makeLinkToAddStickerSetInMarkdownV2(stickerSetName: StickerSetName) =
+    makeLinkToAddStickerSet(
+        stickerSetName,
+        MarkdownV2
+    )
+/**
+ * @return Link for adding of sticker set with name [stickerSetName] with formatting for [Markdown]
+ */
+fun makeLinkToAddStickerSetInMarkdown(stickerSetName: StickerSetName) =
+    makeLinkToAddStickerSet(
+        stickerSetName,
+        Markdown
+    )
+/**
+ * @return Link for adding of sticker set with name [stickerSetName] with formatting for [HTML]
+ */
+fun makeLinkToAddStickerSetInHtml(stickerSetName: StickerSetName) =
+    makeLinkToAddStickerSet(
+        stickerSetName,
+        HTML
+    )

TelegramBotAPI-extensions-utils/src/commonMain/kotlin/com/github/insanusmokrassar/TelegramBotAPI/extensions/utils/formatting/ResendingTextFormatting.kt

@@ -0,0 +1,121 @@
+package com.github.insanusmokrassar.TelegramBotAPI.extensions.utils.formatting
+
+import com.github.insanusmokrassar.TelegramBotAPI.CommonAbstracts.*
+import com.github.insanusmokrassar.TelegramBotAPI.types.*
+import com.github.insanusmokrassar.TelegramBotAPI.types.ParseMode.*
+import com.github.insanusmokrassar.TelegramBotAPI.types.message.content.TextContent
+import com.github.insanusmokrassar.TelegramBotAPI.types.message.content.fullEntitiesList
+
+fun createFormattedText(
+    entities: FullTextSourcesList,
+    partLength: Int = textLength.last,
+    mode: ParseMode = MarkdownParseMode
+): List<String> {
+    val texts = mutableListOf<String>()
+    val textBuilder = StringBuilder(partLength)
+    for (entity in entities) {
+        val string = when (mode) {
+            is MarkdownParseMode -> entity.asMarkdownSource
+            is MarkdownV2ParseMode -> entity.asMarkdownV2Source
+            is HTMLParseMode -> entity.asHtmlSource
+        }
+        if (textBuilder.length + string.length > partLength) {
+            if (textBuilder.isNotEmpty()) {
+                texts.add(textBuilder.toString())
+                textBuilder.clear()
+            }
+            val chunked = string.chunked(partLength)
+            val last = chunked.last()
+            textBuilder.append(last)
+            val listToAdd = if (chunked.size > 1) {
+                chunked.subList(0, chunked.size - 1)
+            } else {
+                emptyList()
+            }
+            listToAdd.forEach {
+                texts.add(it)
+            }
+        } else {
+            textBuilder.append(string)
+        }
+    }
+    if (textBuilder.isNotEmpty()) {
+        texts.add(textBuilder.toString())
+        textBuilder.clear()
+    }
+    return texts
+}
+
+
+fun createMarkdownText(
+    entities: FullTextSourcesList,
+    partLength: Int = textLength.last
+): List<String> = createFormattedText(entities, partLength, MarkdownParseMode)
+
+fun FullTextSourcesList.toMarkdownCaptions(): List<String> = createMarkdownText(
+    this,
+    captionLength.last
+)
+fun CaptionedInput.toMarkdownCaptions(): List<String> = fullEntitiesList().toMarkdownCaptions()
+
+fun FullTextSourcesList.toMarkdownTexts(): List<String> = createMarkdownText(
+    this,
+    textLength.last
+)
+fun TextContent.toMarkdownTexts(): List<String> = fullEntitiesList().toMarkdownTexts()
+
+fun FullTextSourcesList.toMarkdownExplanations(): List<String> = createMarkdownText(
+    this,
+    explanationLimit.last
+)
+fun ExplainedInput.toMarkdownExplanations(): List<String> = fullEntitiesList().toMarkdownTexts()
+
+
+fun createMarkdownV2Text(
+    entities: FullTextSourcesList,
+    partLength: Int = textLength.last
+): List<String> = createFormattedText(entities, partLength, MarkdownV2ParseMode)
+
+fun FullTextSourcesList.toMarkdownV2Captions(): List<String> = createMarkdownV2Text(
+    this,
+    captionLength.last
+)
+fun CaptionedInput.toMarkdownV2Captions(): List<String> = fullEntitiesList().toMarkdownV2Captions()
+
+fun FullTextSourcesList.toMarkdownV2Texts(): List<String> = createMarkdownV2Text(
+    this,
+    textLength.last
+)
+fun TextContent.toMarkdownV2Texts(): List<String> = fullEntitiesList().toMarkdownV2Texts()
+
+fun FullTextSourcesList.toMarkdownV2Explanations(): List<String> = createMarkdownV2Text(
+    this,
+    explanationLimit.last
+)
+fun ExplainedInput.toMarkdownV2Explanations(): List<String> = fullEntitiesList().toMarkdownV2Texts()
+
+
+fun createHtmlText(
+    entities: FullTextSourcesList,
+    partLength: Int = textLength.last
+): List<String> = createFormattedText(entities, partLength, HTMLParseMode)
+
+fun FullTextSourcesList.toHtmlCaptions(): List<String> = createHtmlText(
+    this,
+    captionLength.last
+)
+fun CaptionedInput.toHtmlCaptions(): List<String> = fullEntitiesList().toHtmlCaptions()
+
+fun FullTextSourcesList.toHtmlTexts(): List<String> = createHtmlText(
+    this,
+    textLength.last
+)
+fun TextContent.toHtmlTexts(): List<String> = fullEntitiesList().toHtmlTexts()
+
+fun FullTextSourcesList.toHtmlExplanations(): List<String> = createHtmlText(
+    this,
+    explanationLimit.last
+)
+fun ExplainedInput.toHtmlExplanations(): List<String> = fullEntitiesList().toHtmlTexts()
+
+

TelegramBotAPI-extensions-utils/src/commonMain/kotlin/com/github/insanusmokrassar/TelegramBotAPI/extensions/utils/formatting/StringFormatting.kt

@@ -0,0 +1,243 @@
+package com.github.insanusmokrassar.TelegramBotAPI.extensions.utils.formatting
+
+import com.github.insanusmokrassar.TelegramBotAPI.types.*
+import com.github.insanusmokrassar.TelegramBotAPI.types.ParseMode.*
+import com.github.insanusmokrassar.TelegramBotAPI.utils.extensions.*
+
+const val markdownBoldControl = "*"
+const val markdownItalicControl = "_"
+const val markdownCodeControl = "`"
+const val markdownPreControl = "```"
+
+const val markdownV2ItalicUnderlineDelimiter = "\u0013"
+const val markdownV2StrikethroughControl = "~"
+const val markdownV2UnderlineControl = "__"
+const val markdownV2UnderlineEndControl = "$markdownV2UnderlineControl$markdownV2ItalicUnderlineDelimiter"
+const val markdownV2ItalicEndControl = "$markdownItalicControl$markdownV2ItalicUnderlineDelimiter"
+
+const val htmlBoldControl = "b"
+const val htmlItalicControl = "i"
+const val htmlCodeControl = "code"
+const val htmlPreControl = "pre"
+const val htmlUnderlineControl = "u"
+const val htmlStrikethroughControl = "s"
+
+private fun String.markdownDefault(
+    openControlSymbol: String,
+    closeControlSymbol: String = openControlSymbol
+) = "$openControlSymbol${toMarkdown()}$closeControlSymbol"
+private fun String.markdownV2Default(
+    openControlSymbol: String,
+    closeControlSymbol: String = openControlSymbol,
+    escapeFun: String.() -> String = String::escapeMarkdownV2Common
+) = "$openControlSymbol${escapeFun()}$closeControlSymbol"
+private fun String.htmlDefault(
+    openControlSymbol: String,
+    closeControlSymbol: String = openControlSymbol
+) = "<$openControlSymbol>${toHtml()}</$closeControlSymbol>"
+
+fun String.linkMarkdown(link: String): String = "[${toMarkdown()}](${link.toMarkdown()})"
+fun String.linkMarkdownV2(link: String): String = "[${escapeMarkdownV2Common()}](${link.escapeMarkdownV2Link()})"
+fun String.linkHTML(link: String): String = "<a href=\"$link\">${toHtml()}</a>"
+
+
+fun String.boldMarkdown(): String = markdownDefault(markdownBoldControl)
+fun String.boldMarkdownV2(): String = markdownV2Default(markdownBoldControl)
+fun String.boldHTML(): String = htmlDefault(htmlBoldControl)
+
+
+fun String.italicMarkdown(): String = markdownDefault(markdownItalicControl)
+fun String.italicMarkdownV2(): String = markdownV2Default(markdownItalicControl, markdownV2ItalicEndControl)
+fun String.italicHTML(): String = htmlDefault(htmlItalicControl)
+
+/**
+ * Crutch for support of strikethrough in default markdown. Simply add modifier, but it will not look like correct
+ */
+fun String.strikethroughMarkdown(): String = map { it + "\u0336" }.joinToString("")
+fun String.strikethroughMarkdownV2(): String = markdownV2Default(markdownV2StrikethroughControl)
+fun String.strikethroughHTML(): String = htmlDefault(htmlStrikethroughControl)
+
+
+/**
+ * Crutch for support of underline in default markdown. Simply add modifier, but it will not look like correct
+ */
+fun String.underlineMarkdown(): String = map { it + "\u0347" }.joinToString("")
+fun String.underlineMarkdownV2(): String = markdownV2Default(markdownV2UnderlineControl, markdownV2UnderlineEndControl)
+fun String.underlineHTML(): String = htmlDefault(htmlUnderlineControl)
+
+
+fun String.codeMarkdown(): String = markdownDefault(markdownCodeControl)
+fun String.codeMarkdownV2(): String = markdownV2Default(markdownCodeControl, escapeFun = String::escapeMarkdownV2PreAndCode)
+fun String.codeHTML(): String = htmlDefault(htmlCodeControl)
+
+
+fun String.preMarkdown(language: String? = null): String = markdownDefault(
+    "$markdownPreControl${language ?: ""}\n",
+    "\n$markdownPreControl"
+)
+fun String.preMarkdownV2(language: String? = null): String = markdownV2Default(
+    "$markdownPreControl${language ?: ""}\n",
+    "\n$markdownPreControl",
+    String::escapeMarkdownV2PreAndCode
+)
+fun String.preHTML(language: String? = null): String = htmlDefault(
+    language ?.let {
+        "$htmlPreControl><$htmlCodeControl class=\"language-$language\""
+    } ?: htmlPreControl,
+    language ?.let {
+        "$htmlCodeControl></$htmlPreControl"
+    } ?: htmlPreControl
+)
+
+
+fun String.emailMarkdown(): String = linkMarkdown("mailto://$${toMarkdown()}")
+fun String.emailMarkdownV2(): String = linkMarkdownV2("mailto://$${toMarkdown()}")
+fun String.emailHTML(): String = linkHTML("mailto://$${toHtml()}")
+
+
+private inline fun String.mention(adapt: String.() -> String): String = if (startsWith("@")) {
+    adapt()
+} else {
+    "@${adapt()}"
+}
+
+
+private inline fun String.hashTag(adapt: String.() -> String): String = if (startsWith("#")) {
+    adapt()
+} else {
+    "#${adapt()}"
+}
+
+
+fun String.textMentionMarkdown(userId: UserId): String = linkMarkdown(userId.link)
+fun String.textMentionMarkdownV2(userId: UserId): String = linkMarkdownV2(userId.link)
+fun String.textMentionHTML(userId: UserId): String = linkHTML(userId.link)
+
+
+fun String.mentionMarkdown(): String = mention(String::toMarkdown)
+fun String.mentionMarkdownV2(): String = mention(String::escapeMarkdownV2Common)
+fun String.mentionHTML(): String = mention(String::toHtml)
+
+
+fun String.hashTagMarkdown(): String = hashTag(String::toMarkdown)
+fun String.hashTagMarkdownV2(): String = hashTag(String::escapeMarkdownV2Common).escapeMarkdownV2Common()
+fun String.hashTagHTML(): String = hashTag(String::toHtml)
+
+
+fun String.phoneMarkdown(): String = toMarkdown()
+fun String.phoneMarkdownV2(): String = escapeMarkdownV2Common()
+fun String.phoneHTML(): String = toHtml()
+
+
+fun String.command(adapt: String.() -> String): String = if (startsWith("/")) {
+    adapt()
+} else {
+    "/${adapt()}"
+}
+
+fun String.commandMarkdown(): String = command(String::toMarkdown)
+fun String.commandMarkdownV2(): String = command(String::escapeMarkdownV2Common)
+fun String.commandHTML(): String = command(String::toHtml)
+
+
+fun String.regularMarkdown(): String = toMarkdown()
+fun String.regularMarkdownV2(): String = escapeMarkdownV2Common()
+fun String.regularHtml(): String = toHtml()
+
+
+fun String.cashTagMarkdown(): String = toMarkdown()
+fun String.cashTagMarkdownV2(): String = escapeMarkdownV2Common()
+fun String.cashTagHtml(): String = toHtml()
+
+
+infix fun String.bold(parseMode: ParseMode): String = when (parseMode) {
+    is HTML -> boldHTML()
+    is Markdown -> boldMarkdown()
+    is MarkdownV2 -> boldMarkdownV2()
+}
+
+
+infix fun String.italic(parseMode: ParseMode): String = when (parseMode) {
+    is HTML -> italicHTML()
+    is Markdown -> italicMarkdown()
+    is MarkdownV2 -> italicMarkdownV2()
+}
+
+infix fun String.hashTag(parseMode: ParseMode): String = when (parseMode) {
+    is HTML -> hashTagHTML()
+    is Markdown -> hashTagMarkdown()
+    is MarkdownV2 -> hashTagMarkdownV2()
+}
+
+infix fun String.code(parseMode: ParseMode): String = when (parseMode) {
+    is HTML -> codeHTML()
+    is Markdown -> codeMarkdown()
+    is MarkdownV2 -> codeMarkdownV2()
+}
+
+fun String.pre(parseMode: ParseMode, language: String? = null): String = when (parseMode) {
+    is HTML -> preHTML(language)
+    is Markdown -> preMarkdown(language)
+    is MarkdownV2 -> preMarkdownV2(language)
+}
+infix fun String.pre(parseMode: ParseMode): String = pre(parseMode, null)
+
+infix fun String.email(parseMode: ParseMode): String = when (parseMode) {
+    is HTML -> emailHTML()
+    is Markdown -> emailMarkdown()
+    is MarkdownV2 -> emailMarkdownV2()
+}
+
+infix fun Pair<String, String>.link(parseMode: ParseMode): String = when (parseMode) {
+    is HTML -> first.linkHTML(second)
+    is Markdown -> first.linkMarkdown(second)
+    is MarkdownV2 -> first.linkMarkdownV2(second)
+}
+
+infix fun String.mention(parseMode: ParseMode): String = when (parseMode) {
+    is HTML -> mentionHTML()
+    is Markdown -> mentionMarkdown()
+    is MarkdownV2 -> mentionMarkdownV2()
+}
+
+infix fun Pair<String, ChatId>.mention(parseMode: ParseMode): String = when (parseMode) {
+    is HTML -> first.textMentionHTML(second)
+    is Markdown -> first.textMentionMarkdown(second)
+    is MarkdownV2 -> first.textMentionMarkdownV2(second)
+}
+
+infix fun String.phone(parseMode: ParseMode): String = when (parseMode) {
+    is HTML -> phoneHTML()
+    is Markdown -> phoneMarkdown()
+    is MarkdownV2 -> phoneMarkdownV2()
+}
+
+infix fun String.command(parseMode: ParseMode): String = when (parseMode) {
+    is HTML -> commandHTML()
+    is Markdown -> commandMarkdown()
+    is MarkdownV2 -> commandMarkdownV2()
+}
+
+infix fun String.underline(parseMode: ParseMode): String = when (parseMode) {
+    is HTML -> underlineHTML()
+    is Markdown -> underlineMarkdown()
+    is MarkdownV2 -> underlineMarkdownV2()
+}
+
+infix fun String.strikethrough(parseMode: ParseMode): String = when (parseMode) {
+    is HTML -> strikethroughHTML()
+    is Markdown -> strikethroughMarkdown()
+    is MarkdownV2 -> strikethroughMarkdownV2()
+}
+
+infix fun String.regular(parseMode: ParseMode): String = when (parseMode) {
+    is HTML -> regularHtml()
+    is Markdown -> regularMarkdown()
+    is MarkdownV2 -> regularMarkdownV2()
+}
+
+infix fun String.cashtag(parseMode: ParseMode): String = when (parseMode) {
+    is HTML -> cashTagHtml()
+    is Markdown -> cashTagMarkdown()
+    is MarkdownV2 -> cashTagMarkdownV2()
+}

TelegramBotAPI-extensions-utils/src/commonMain/kotlin/com/github/insanusmokrassar/TelegramBotAPI/extensions/utils/shortcuts/FlowsUpdatesFilter.kt

@@ -0,0 +1,112 @@
+package com.github.insanusmokrassar.TelegramBotAPI.extensions.utils.shortcuts
+
+import com.github.insanusmokrassar.TelegramBotAPI.extensions.utils.aggregateFlows
+import com.github.insanusmokrassar.TelegramBotAPI.extensions.utils.updates.asContentMessagesFlow
+import com.github.insanusmokrassar.TelegramBotAPI.types.message.abstracts.ContentMessage
+import com.github.insanusmokrassar.TelegramBotAPI.types.message.content.*
+import com.github.insanusmokrassar.TelegramBotAPI.types.message.content.abstracts.MessageContent
+import com.github.insanusmokrassar.TelegramBotAPI.types.message.content.media.*
+import com.github.insanusmokrassar.TelegramBotAPI.types.message.payments.InvoiceContent
+import com.github.insanusmokrassar.TelegramBotAPI.updateshandlers.FlowsUpdatesFilter
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.flow.*
+
+inline fun <reified T : MessageContent> filterForContentMessage(): suspend (ContentMessage<*>) -> ContentMessage<T>? = {
+    if (it.content is T) {
+        it as ContentMessage<T>
+    } else {
+        null
+    }
+}
+
+/**
+ * @param scopeToIncludeChannels This parameter is required when you want to include [textMessages] for channels too.
+ * In this case will be created new channel which will agregate messages from [FlowsUpdatesFilter.messageFlow] and
+ * [FlowsUpdatesFilter.channelPostFlow]. In case it is null will be used [Flow]s mapping
+ */
+@Suppress("UNCHECKED_CAST")
+inline fun <reified T: MessageContent> FlowsUpdatesFilter.filterContentMessages(
+    scopeToIncludeChannels: CoroutineScope? = null
+): Flow<ContentMessage<T>> {
+    val filter = filterForContentMessage<T>()
+    return scopeToIncludeChannels ?.let { scope ->
+        aggregateFlows(
+            scope,
+            messageFlow.asContentMessagesFlow().mapNotNull(filter),
+            channelPostFlow.asContentMessagesFlow().mapNotNull(filter)
+        )
+    } ?: messageFlow.asContentMessagesFlow().mapNotNull(filter)
+}
+
+fun FlowsUpdatesFilter.animationMessages(
+    scopeToIncludeChannels: CoroutineScope? = null
+) = filterContentMessages<AnimationContent>(scopeToIncludeChannels)
+
+fun FlowsUpdatesFilter.audioMessages(
+    scopeToIncludeChannels: CoroutineScope? = null
+) = filterContentMessages<AudioContent>(scopeToIncludeChannels)
+
+fun FlowsUpdatesFilter.contactMessages(
+    scopeToIncludeChannels: CoroutineScope? = null
+) = filterContentMessages<ContactContent>(scopeToIncludeChannels)
+
+fun FlowsUpdatesFilter.diceMessages(
+    scopeToIncludeChannels: CoroutineScope? = null
+) = filterContentMessages<DiceContent>(scopeToIncludeChannels)
+
+fun FlowsUpdatesFilter.documentMessages(
+    scopeToIncludeChannels: CoroutineScope? = null
+) = filterContentMessages<DocumentContent>(scopeToIncludeChannels)
+
+fun FlowsUpdatesFilter.gameMessages(
+    scopeToIncludeChannels: CoroutineScope? = null
+) = filterContentMessages<GameContent>(scopeToIncludeChannels)
+
+fun FlowsUpdatesFilter.invoiceMessages(
+    scopeToIncludeChannels: CoroutineScope? = null
+) = filterContentMessages<InvoiceContent>(scopeToIncludeChannels)
+
+fun FlowsUpdatesFilter.locationMessages(
+    scopeToIncludeChannels: CoroutineScope? = null
+) = filterContentMessages<LocationContent>(scopeToIncludeChannels)
+
+fun FlowsUpdatesFilter.photoMessages(
+    scopeToIncludeChannels: CoroutineScope? = null
+) = filterContentMessages<PhotoContent>(scopeToIncludeChannels)
+/**
+ * Shortcut for [photoMessages]
+ */
+@Suppress("NOTHING_TO_INLINE")
+inline fun FlowsUpdatesFilter.imageMessages(
+    scopeToIncludeChannels: CoroutineScope? = null
+) = photoMessages(scopeToIncludeChannels)
+
+fun FlowsUpdatesFilter.pollMessages(
+    scopeToIncludeChannels: CoroutineScope? = null
+) = filterContentMessages<PollContent>(scopeToIncludeChannels)
+
+fun FlowsUpdatesFilter.stickerMessages(
+    scopeToIncludeChannels: CoroutineScope? = null
+) = filterContentMessages<StickerContent>(scopeToIncludeChannels)
+
+fun FlowsUpdatesFilter.textMessages(
+    scopeToIncludeChannels: CoroutineScope? = null
+) = filterContentMessages<TextContent>(scopeToIncludeChannels)
+
+fun FlowsUpdatesFilter.venueMessages(
+    scopeToIncludeChannels: CoroutineScope? = null
+) = filterContentMessages<VenueContent>(scopeToIncludeChannels)
+
+fun FlowsUpdatesFilter.videoMessages(
+    scopeToIncludeChannels: CoroutineScope? = null
+) = filterContentMessages<VideoContent>(scopeToIncludeChannels)
+
+fun FlowsUpdatesFilter.videoNoteMessages(
+    scopeToIncludeChannels: CoroutineScope? = null
+) = filterContentMessages<VideoNoteContent>(scopeToIncludeChannels)
+
+fun FlowsUpdatesFilter.voiceMessages(
+    scopeToIncludeChannels: CoroutineScope? = null
+) = filterContentMessages<VoiceContent>(scopeToIncludeChannels)
+
+

TelegramBotAPI-extensions-utils/src/commonMain/kotlin/com/github/insanusmokrassar/TelegramBotAPI/extensions/utils/shortcuts/MediaGroupsShortcuts.kt

@@ -0,0 +1,57 @@
+package com.github.insanusmokrassar.TelegramBotAPI.extensions.utils.shortcuts
+
+import com.github.insanusmokrassar.TelegramBotAPI.requests.send.media.SendMediaGroup
+import com.github.insanusmokrassar.TelegramBotAPI.types.*
+import com.github.insanusmokrassar.TelegramBotAPI.types.chat.abstracts.Chat
+import com.github.insanusmokrassar.TelegramBotAPI.types.message.ForwardInfo
+import com.github.insanusmokrassar.TelegramBotAPI.types.message.abstracts.MediaGroupMessage
+import com.github.insanusmokrassar.TelegramBotAPI.types.message.abstracts.Message
+import com.github.insanusmokrassar.TelegramBotAPI.types.update.MediaGroupUpdates.SentMediaGroupUpdate
+
+val List<MediaGroupMessage>.forwardInfo: ForwardInfo?
+    get() = firstOrNull() ?.forwardInfo
+val List<MediaGroupMessage>.replyTo: Message?
+    get() = firstOrNull() ?.replyTo
+val List<MediaGroupMessage>.chat: Chat?
+    get() = firstOrNull() ?.chat
+val List<MediaGroupMessage>.mediaGroupId: MediaGroupIdentifier?
+    get() = firstOrNull() ?.mediaGroupId
+
+val SentMediaGroupUpdate.forwardInfo: ForwardInfo?
+    get() = data.first().forwardInfo
+val SentMediaGroupUpdate.replyTo: Message?
+    get() = data.first().replyTo
+val SentMediaGroupUpdate.chat: Chat
+    get() = data.chat!!
+val SentMediaGroupUpdate.mediaGroupId: MediaGroupIdentifier
+    get() = data.mediaGroupId!!
+
+fun List<MediaGroupMessage>.createResend(
+    chatId: ChatId,
+    disableNotification: Boolean = false,
+    replyTo: MessageIdentifier? = null
+) = SendMediaGroup(
+    chatId,
+    map { it.content.toMediaGroupMemberInputMedia() },
+    disableNotification,
+    replyTo
+)
+
+fun List<MediaGroupMessage>.createResend(
+    chat: Chat,
+    disableNotification: Boolean = false,
+    replyTo: MessageIdentifier? = null
+) = createResend(
+    chat.id,
+    disableNotification,
+    replyTo
+)
+
+fun SentMediaGroupUpdate.createResend(
+    disableNotification: Boolean = false,
+    replyTo: MessageIdentifier? = null
+) = data.createResend(
+    chat,
+    disableNotification,
+    replyTo
+)

TelegramBotAPI-extensions-utils/src/commonMain/kotlin/com/github/insanusmokrassar/TelegramBotAPI/extensions/utils/shortcuts/RequestsExecutor.kt

@@ -0,0 +1,45 @@
+package com.github.insanusmokrassar.TelegramBotAPI.extensions.utils.shortcuts
+
+import com.github.insanusmokrassar.TelegramBotAPI.bot.RequestsExecutor
+import com.github.insanusmokrassar.TelegramBotAPI.requests.abstracts.Request
+import com.github.insanusmokrassar.TelegramBotAPI.utils.handleSafely
+import kotlinx.coroutines.*
+
+fun <T: Any> RequestsExecutor.executeAsync(
+    request: Request<T>,
+    scope: CoroutineScope
+): Deferred<T> = scope.async {
+    handleSafely {
+        execute(request)
+    }
+}
+
+suspend fun <T: Any> RequestsExecutor.executeAsync(
+    request: Request<T>
+): Deferred<T> = coroutineScope {
+    executeAsync(request, this)
+}
+
+suspend fun <T: Any> RequestsExecutor.executeUnsafe(
+    request: Request<T>,
+    retries: Int = 0,
+    retriesDelay: Long = 1000L,
+    onAllFailed: (suspend (exceptions: Array<Exception>) -> Unit)? = null
+): T? {
+    var leftRetries = retries
+    val exceptions = onAllFailed ?.let { mutableListOf<Exception>() }
+    do {
+        return handleSafely(
+            {
+                leftRetries--
+                delay(retriesDelay)
+                exceptions ?.add(it)
+                null
+            }
+        ) {
+            execute(request)
+        } ?: continue
+    } while(leftRetries >= 0)
+    onAllFailed ?.invoke(exceptions ?.toTypedArray() ?: emptyArray())
+    return null
+}

TelegramBotAPI-extensions-utils/src/commonMain/kotlin/com/github/insanusmokrassar/TelegramBotAPI/extensions/utils/types/buttons/InlineKeyboardMarkup.kt

@@ -0,0 +1,11 @@
+package com.github.insanusmokrassar.TelegramBotAPI.extensions.utils.types.buttons
+
+import com.github.insanusmokrassar.TelegramBotAPI.types.buttons.InlineKeyboardButtons.InlineKeyboardButton
+import com.github.insanusmokrassar.TelegramBotAPI.types.buttons.InlineKeyboardMarkup
+import com.github.insanusmokrassar.TelegramBotAPI.utils.flatMatrix
+
+fun InlineKeyboardMarkup(
+    vararg buttons: InlineKeyboardButton
+): InlineKeyboardMarkup = InlineKeyboardMarkup(
+    flatMatrix { buttons.forEach { +it } }
+)

TelegramBotAPI-extensions-utils/src/commonMain/kotlin/com/github/insanusmokrassar/TelegramBotAPI/extensions/utils/types/buttons/ReplyKeyboardMarkup.kt

@@ -0,0 +1,17 @@
+package com.github.insanusmokrassar.TelegramBotAPI.extensions.utils.types.buttons
+
+import com.github.insanusmokrassar.TelegramBotAPI.types.buttons.KeyboardButton
+import com.github.insanusmokrassar.TelegramBotAPI.types.buttons.ReplyKeyboardMarkup
+import com.github.insanusmokrassar.TelegramBotAPI.utils.flatMatrix
+
+fun ReplyKeyboardMarkup(
+    vararg buttons: KeyboardButton,
+    resizeKeyboard: Boolean? = null,
+    oneTimeKeyboard: Boolean? = null,
+    selective: Boolean? = null
+): ReplyKeyboardMarkup = ReplyKeyboardMarkup(
+    flatMatrix { buttons.forEach { +it } },
+    resizeKeyboard,
+    oneTimeKeyboard,
+    selective
+)

TelegramBotAPI-extensions-utils/src/commonMain/kotlin/com/github/insanusmokrassar/TelegramBotAPI/extensions/utils/updates/BaseMessagesUpdatesConversations.kt

@@ -0,0 +1,37 @@
+package com.github.insanusmokrassar.TelegramBotAPI.extensions.utils.updates
+
+import com.github.insanusmokrassar.TelegramBotAPI.types.update.MediaGroupUpdates.*
+import com.github.insanusmokrassar.TelegramBotAPI.types.update.abstracts.*
+import kotlinx.coroutines.flow.Flow
+import kotlinx.coroutines.flow.filterIsInstance
+
+fun Flow<Update>.onlyBaseMessageUpdates(): Flow<BaseMessageUpdate> = filterIsInstance()
+
+/**
+ * Converts flow to [Flow] of [BaseSentMessageUpdate]
+ */
+fun Flow<BaseMessageUpdate>.onlySentMessageUpdates(): Flow<BaseSentMessageUpdate> = filterIsInstance()
+
+/**
+ * Converts flow to [Flow] of [BaseSentMessageUpdate]
+ */
+fun Flow<BaseMessageUpdate>.onlyEditMessageUpdates(): Flow<BaseEditMessageUpdate> = filterIsInstance()
+
+/**
+ * Converts flow to [Flow] of [MediaGroupUpdate]. Please, remember that it could be either [EditMediaGroupUpdate]
+ * or [SentMediaGroupUpdate]
+ *
+ * @see onlySentMediaGroupUpdates
+ * @see onlyEditMediaGroupUpdates
+ */
+fun Flow<BaseMessageUpdate>.onlyMediaGroupsUpdates(): Flow<MediaGroupUpdate> = filterIsInstance()
+
+/**
+ * Converts flow to [Flow] of [SentMediaGroupUpdate]
+ */
+fun Flow<MediaGroupUpdate>.onlySentMediaGroupUpdates(): Flow<SentMediaGroupUpdate> = filterIsInstance()
+
+/**
+ * Converts flow to [Flow] of [EditMediaGroupUpdate]
+ */
+fun Flow<MediaGroupUpdate>.onlyEditMediaGroupUpdates(): Flow<EditMediaGroupUpdate> = filterIsInstance()

TelegramBotAPI-extensions-utils/src/commonMain/kotlin/com/github/insanusmokrassar/TelegramBotAPI/extensions/utils/updates/FlowsUpdatesFactory.kt

@@ -0,0 +1,17 @@
+package com.github.insanusmokrassar.TelegramBotAPI.extensions.utils.updates
+
+import com.github.insanusmokrassar.TelegramBotAPI.updateshandlers.FlowsUpdatesFilter
+
+/**
+ * Non-suspendable function for easy-to-use creating of [FlowsUpdatesFilter] and applying the block to it
+ *
+ * @see flowsUpdatesFilter
+ */
+inline fun flowsUpdatesFilter(
+    internalChannelsSizes: Int = 100,
+    block: FlowsUpdatesFilter.() -> Unit
+): FlowsUpdatesFilter {
+    val filter = FlowsUpdatesFilter(internalChannelsSizes)
+    filter.block()
+    return filter
+}

TelegramBotAPI-extensions-utils/src/commonMain/kotlin/com/github/insanusmokrassar/TelegramBotAPI/extensions/utils/updates/SentMessageUpdatesConversations.kt

@@ -12,6 +12,13 @@ fun <T : BaseSentMessageUpdate> Flow<T>.asContentMessagesFlow() = mapNotNull {
     it.data as? ContentMessage<*>
 }
 
+/**
+ * Will map incoming [BaseSentMessageUpdate]s to [CommonMessage] from [BaseSentMessageUpdate.data]
+ */
+fun <T : BaseSentMessageUpdate> Flow<T>.asCommonMessagesFlow() = mapNotNull {
+    it.data as? CommonMessage<*>
+}
+
 /**
  * Will map incoming [BaseSentMessageUpdate]s to [ChatEventMessage] from [BaseSentMessageUpdate.data]
  */

TelegramBotAPI-extensions-utils/src/commonMain/kotlin/com/github/insanusmokrassar/TelegramBotAPI/extensions/utils/updates/UpdateDeserialization.kt

@@ -0,0 +1,31 @@
+package com.github.insanusmokrassar.TelegramBotAPI.extensions.utils.updates
+
+import com.github.insanusmokrassar.TelegramBotAPI.extensions.utils.nonstrictJsonFormat
+import com.github.insanusmokrassar.TelegramBotAPI.types.update.abstracts.UpdateDeserializationStrategy
+import kotlinx.serialization.json.Json
+import kotlinx.serialization.json.JsonElement
+
+/**
+ * @return Deserialize [source] as [com.github.insanusmokrassar.TelegramBotAPI.types.update.abstracts.Update]
+ */
+fun Json.toTelegramUpdate(source: String) = parse(UpdateDeserializationStrategy, source)
+/**
+ * @return Deserialize [source] as [com.github.insanusmokrassar.TelegramBotAPI.types.update.abstracts.Update]
+ */
+fun Json.toTelegramUpdate(source: JsonElement) = fromJson(UpdateDeserializationStrategy, source)
+
+/**
+ * @return Deserialize [this] as [com.github.insanusmokrassar.TelegramBotAPI.types.update.abstracts.Update]. In fact,
+ * it is must be JSON
+ *
+ * @see Json.toTelegramUpdate
+ */
+fun String.toTelegramUpdate() = nonstrictJsonFormat.toTelegramUpdate(this)
+/**
+ * @return Deserialize [this] as [com.github.insanusmokrassar.TelegramBotAPI.types.update.abstracts.Update]
+ *
+ * @see Json.toTelegramUpdate
+ */
+fun JsonElement.toTelegramUpdate() = nonstrictJsonFormat.toTelegramUpdate(this)
+
+

TelegramBotAPI-extensions-utils/src/commonMain/kotlin/com/github/insanusmokrassar/TelegramBotAPI/extensions/utils/updates/UpdatesChatFilters.kt

@@ -10,22 +10,38 @@ import kotlinx.coroutines.flow.filter
 /**
  * [Flow.filter] incoming [BaseMessageUpdate]s by their [ChatId]
  */
-fun <T : BaseMessageUpdate> Flow<T>.filterBaseMessageUpdates(chatId: ChatId): Flow<T> = filter {
-    it.data.chat.id == chatId
-}
+fun <T : BaseMessageUpdate> Flow<T>.filterBaseMessageUpdatesByChatId(chatId: ChatId): Flow<T> = filter { it.data.chat.id == chatId }
 /**
  * [Flow.filter] incoming [BaseMessageUpdate]s by their [ChatId] using [Chat.id] of [chat]
  */
-fun <T : BaseMessageUpdate> Flow<T>.filterBaseMessageUpdates(chat: Chat): Flow<T> = filterBaseMessageUpdates(chat.id)
+fun <T : BaseMessageUpdate> Flow<T>.filterBaseMessageUpdatesByChat(chat: Chat): Flow<T> = filterBaseMessageUpdatesByChatId(chat.id)
+/**
+ * [Flow.filter] incoming [BaseMessageUpdate]s by their [ChatId]
+ */
+@Deprecated("Renamed", ReplaceWith("filterBaseMessageUpdatesByChatId"))
+fun <T : BaseMessageUpdate> Flow<T>.filterBaseMessageUpdates(chatId: ChatId): Flow<T> = filterBaseMessageUpdatesByChatId(chatId)
+/**
+ * [Flow.filter] incoming [BaseMessageUpdate]s by their [ChatId] using [Chat.id] of [chat]
+ */
+@Deprecated("Renamed", ReplaceWith("filterBaseMessageUpdatesByChat"))
+fun <T : BaseMessageUpdate> Flow<T>.filterBaseMessageUpdates(chat: Chat): Flow<T> = filterBaseMessageUpdatesByChatId(chat.id)
 
 
 /**
  * [Flow.filter] incoming [SentMediaGroupUpdate]s by their [ChatId]
  */
-fun <T : SentMediaGroupUpdate> Flow<T>.filterSentMediaGroupUpdates(chatId: ChatId): Flow<T> = filter {
-    it.data.first().chat.id == chatId
-}
+fun <T : SentMediaGroupUpdate> Flow<T>.filterSentMediaGroupUpdatesByChatId(chatId: ChatId): Flow<T> = filter { it.data.first().chat.id == chatId }
 /**
  * [Flow.filter] incoming [SentMediaGroupUpdate]s by their [ChatId] using [Chat.id] of [chat]
  */
-fun <T : SentMediaGroupUpdate> Flow<T>.filterSentMediaGroupUpdates(chat: Chat): Flow<T> = filterSentMediaGroupUpdates(chat.id)
+fun <T : SentMediaGroupUpdate> Flow<T>.filterSentMediaGroupUpdatesByChat(chat: Chat): Flow<T> = filterSentMediaGroupUpdatesByChatId(chat.id)
+/**
+ * [Flow.filter] incoming [SentMediaGroupUpdate]s by their [ChatId]
+ */
+@Deprecated("Renamed", ReplaceWith("filterSentMediaGroupUpdatesByChatId"))
+fun <T : SentMediaGroupUpdate> Flow<T>.filterSentMediaGroupUpdates(chatId: ChatId): Flow<T> = filterSentMediaGroupUpdatesByChatId(chatId)
+/**
+ * [Flow.filter] incoming [SentMediaGroupUpdate]s by their [ChatId] using [Chat.id] of [chat]
+ */
+@Deprecated("Renamed", ReplaceWith("filterSentMediaGroupUpdatesByChat"))
+fun <T : SentMediaGroupUpdate> Flow<T>.filterSentMediaGroupUpdates(chat: Chat): Flow<T> = filterSentMediaGroupUpdatesByChatId(chat.id)

TelegramBotAPI-extensions-utils/src/commonMain/kotlin/com/github/insanusmokrassar/TelegramBotAPI/extensions/utils/updates/UpdatesUtils.kt

@@ -0,0 +1,93 @@
+package com.github.insanusmokrassar.TelegramBotAPI.extensions.utils.updates
+
+import com.github.insanusmokrassar.TelegramBotAPI.types.MediaGroupIdentifier
+import com.github.insanusmokrassar.TelegramBotAPI.types.UpdateIdentifier
+import com.github.insanusmokrassar.TelegramBotAPI.types.message.abstracts.MediaGroupMessage
+import com.github.insanusmokrassar.TelegramBotAPI.types.update.*
+import com.github.insanusmokrassar.TelegramBotAPI.types.update.MediaGroupUpdates.*
+import com.github.insanusmokrassar.TelegramBotAPI.types.update.abstracts.*
+
+/**
+ * @return If [this] is [SentMediaGroupUpdate] - [Update.updateId] of [last] element, or its own [Update.updateId]
+ */
+fun Update.lastUpdateIdentifier(): UpdateIdentifier {
+    return if (this is SentMediaGroupUpdate) {
+        origins.last().updateId
+    } else {
+        updateId
+    }
+}
+
+/**
+ * @return The biggest [UpdateIdentifier] OR null
+ *
+ * @see [Update.lastUpdateIdentifier]
+ */
+fun List<Update>.lastUpdateIdentifier(): UpdateIdentifier? {
+    return maxBy { it.updateId } ?.lastUpdateIdentifier()
+}
+
+/**
+ * Will convert incoming list of updates to list with [MediaGroupUpdate]s
+ */
+fun List<Update>.convertWithMediaGroupUpdates(): List<Update> {
+    val resultUpdates = mutableListOf<Update>()
+    val mediaGroups = mutableMapOf<MediaGroupIdentifier, MutableList<BaseSentMessageUpdate>>()
+    for (update in this) {
+        val data = (update.data as? MediaGroupMessage)
+        if (data == null) {
+            resultUpdates.add(update)
+            continue
+        }
+        when (update) {
+            is BaseEditMessageUpdate -> resultUpdates.add(
+                update.toEditMediaGroupUpdate()
+            )
+            is BaseSentMessageUpdate -> {
+                mediaGroups.getOrPut(data.mediaGroupId) {
+                    mutableListOf()
+                }.add(update)
+            }
+            else -> resultUpdates.add(update)
+        }
+    }
+    mediaGroups.values.map {
+        it.toSentMediaGroupUpdate() ?.let { mediaGroupUpdate ->
+            resultUpdates.add(mediaGroupUpdate)
+        }
+    }
+    resultUpdates.sortBy { it.updateId }
+    return resultUpdates
+}
+
+/**
+ * @receiver List of [BaseSentMessageUpdate] where [BaseSentMessageUpdate.data] is [MediaGroupMessage] and all messages
+ * have the same [MediaGroupMessage.mediaGroupId]
+ * @return [MessageMediaGroupUpdate] in case if [first] object of [this] is [MessageUpdate]. When [first] object is
+ * [ChannelPostUpdate] instance - will return [ChannelPostMediaGroupUpdate]. Otherwise will be returned null
+ */
+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
+    }
+}
+
+/**
+ * @return [EditMessageMediaGroupUpdate] in case if [this] is [EditMessageUpdate]. When [this] object is
+ * [EditChannelPostUpdate] instance - will return [EditChannelPostMediaGroupUpdate]
+ *
+ * @throws IllegalStateException
+ */
+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}")
+    }
+}

TelegramBotAPI-extensions-utils/src/commonMain/kotlin/com/github/insanusmokrassar/TelegramBotAPI/extensions/utils/updates/retrieving/LongPolling.kt

@@ -0,0 +1,180 @@
+package com.github.insanusmokrassar.TelegramBotAPI.extensions.utils.updates.retrieving
+
+import com.github.insanusmokrassar.TelegramBotAPI.bot.RequestsExecutor
+import com.github.insanusmokrassar.TelegramBotAPI.bot.exceptions.RequestException
+import com.github.insanusmokrassar.TelegramBotAPI.extensions.utils.updates.convertWithMediaGroupUpdates
+import com.github.insanusmokrassar.TelegramBotAPI.extensions.utils.updates.lastUpdateIdentifier
+import com.github.insanusmokrassar.TelegramBotAPI.requests.GetUpdates
+import com.github.insanusmokrassar.TelegramBotAPI.types.*
+import com.github.insanusmokrassar.TelegramBotAPI.types.update.*
+import com.github.insanusmokrassar.TelegramBotAPI.types.update.MediaGroupUpdates.*
+import com.github.insanusmokrassar.TelegramBotAPI.types.update.abstracts.Update
+import com.github.insanusmokrassar.TelegramBotAPI.updateshandlers.*
+import com.github.insanusmokrassar.TelegramBotAPI.utils.*
+import kotlinx.coroutines.*
+
+fun RequestsExecutor.startGettingOfUpdatesByLongPolling(
+    timeoutSeconds: Seconds = 30,
+    scope: CoroutineScope = CoroutineScope(Dispatchers.Default),
+    exceptionsHandler: (ExceptionHandler<Unit>)? = null,
+    allowedUpdates: List<String>? = null,
+    updatesReceiver: UpdateReceiver<Update>
+): Job = scope.launch {
+    var lastUpdateIdentifier: UpdateIdentifier? = null
+
+    while (isActive) {
+        handleSafely(
+            { e ->
+                exceptionsHandler ?.invoke(e)
+                if (e is RequestException) {
+                    delay(1000L)
+                }
+            }
+        ) {
+            val updates = execute(
+                GetUpdates(
+                    offset = lastUpdateIdentifier?.plus(1),
+                    timeout = timeoutSeconds,
+                    allowed_updates = allowedUpdates
+                )
+            ).let { originalUpdates ->
+                val converted = originalUpdates.convertWithMediaGroupUpdates()
+                /**
+                 * Dirty hack for cases when the media group was retrieved not fully:
+                 *
+                 * We are throw out the last media group and will reretrieve it again in the next get updates
+                 * and it will guarantee that it is full
+                 */
+                if (originalUpdates.size == getUpdatesLimit.last && converted.last() is SentMediaGroupUpdate) {
+                    converted - converted.last()
+                } else {
+                    converted
+                }
+            }
+
+            handleSafely {
+                for (update in updates) {
+                    updatesReceiver(update)
+
+                    lastUpdateIdentifier = update.lastUpdateIdentifier()
+                }
+            }
+        }
+    }
+}
+
+/**
+ * This method will create a new one [FlowsUpdatesFilter]. This method could be unsafe due to the fact that it will start
+ * getting updates IMMEDIATELY. That means that your bot will be able to skip some of them until you will call
+ * [kotlinx.coroutines.flow.Flow.collect] on one of [FlowsUpdatesFilter] flows. To avoid it, you can pass
+ * [flowUpdatesPreset] lambda - it will be called BEFORE starting updates getting
+ */
+@FlowPreview
+@PreviewFeature
+@Suppress("unused")
+fun RequestsExecutor.startGettingFlowsUpdatesByLongPolling(
+    timeoutSeconds: Seconds = 30,
+    scope: CoroutineScope = CoroutineScope(Dispatchers.Default),
+    exceptionsHandler: ExceptionHandler<Unit>? = null,
+    flowsUpdatesFilterUpdatesKeeperCount: Int = 100,
+    flowUpdatesPreset: FlowsUpdatesFilter.() -> Unit = {}
+): FlowsUpdatesFilter = FlowsUpdatesFilter(flowsUpdatesFilterUpdatesKeeperCount).apply {
+    flowUpdatesPreset()
+    startGettingOfUpdatesByLongPolling(timeoutSeconds, scope, exceptionsHandler, allowedUpdates, asUpdateReceiver)
+}
+
+fun RequestsExecutor.startGettingOfUpdatesByLongPolling(
+    updatesFilter: UpdatesFilter,
+    timeoutSeconds: Seconds = 30,
+    exceptionsHandler: ExceptionHandler<Unit>? = null,
+    scope: CoroutineScope = CoroutineScope(Dispatchers.Default)
+): Job = startGettingOfUpdatesByLongPolling(
+    timeoutSeconds,
+    scope,
+    exceptionsHandler,
+    updatesFilter.allowedUpdates,
+    updatesFilter.asUpdateReceiver
+)
+
+fun RequestsExecutor.startGettingOfUpdatesByLongPolling(
+    messageCallback: UpdateReceiver<MessageUpdate>? = null,
+    messageMediaGroupCallback: UpdateReceiver<MessageMediaGroupUpdate>? = null,
+    editedMessageCallback: UpdateReceiver<EditMessageUpdate>? = null,
+    editedMessageMediaGroupCallback: UpdateReceiver<EditMessageMediaGroupUpdate>? = null,
+    channelPostCallback: UpdateReceiver<ChannelPostUpdate>? = null,
+    channelPostMediaGroupCallback: UpdateReceiver<ChannelPostMediaGroupUpdate>? = null,
+    editedChannelPostCallback: UpdateReceiver<EditChannelPostUpdate>? = null,
+    editedChannelPostMediaGroupCallback: UpdateReceiver<EditChannelPostMediaGroupUpdate>? = null,
+    chosenInlineResultCallback: UpdateReceiver<ChosenInlineResultUpdate>? = null,
+    inlineQueryCallback: UpdateReceiver<InlineQueryUpdate>? = null,
+    callbackQueryCallback: UpdateReceiver<CallbackQueryUpdate>? = null,
+    shippingQueryCallback: UpdateReceiver<ShippingQueryUpdate>? = null,
+    preCheckoutQueryCallback: UpdateReceiver<PreCheckoutQueryUpdate>? = null,
+    pollCallback: UpdateReceiver<PollUpdate>? = null,
+    pollAnswerCallback: UpdateReceiver<PollAnswerUpdate>? = null,
+    timeoutSeconds: Seconds = 30,
+    exceptionsHandler: ExceptionHandler<Unit>? = null,
+    scope: CoroutineScope = GlobalScope
+): Job {
+    return startGettingOfUpdatesByLongPolling(
+        SimpleUpdatesFilter(
+            messageCallback,
+            messageMediaGroupCallback,
+            editedMessageCallback,
+            editedMessageMediaGroupCallback,
+            channelPostCallback,
+            channelPostMediaGroupCallback,
+            editedChannelPostCallback,
+            editedChannelPostMediaGroupCallback,
+            chosenInlineResultCallback,
+            inlineQueryCallback,
+            callbackQueryCallback,
+            shippingQueryCallback,
+            preCheckoutQueryCallback,
+            pollCallback,
+            pollAnswerCallback
+        ),
+        timeoutSeconds,
+        exceptionsHandler,
+        scope
+    )
+}
+
+@Suppress("unused")
+fun RequestsExecutor.startGettingOfUpdatesByLongPolling(
+    messageCallback: UpdateReceiver<MessageUpdate>? = null,
+    mediaGroupCallback: UpdateReceiver<MediaGroupUpdate>? = null,
+    editedMessageCallback: UpdateReceiver<EditMessageUpdate>? = null,
+    channelPostCallback: UpdateReceiver<ChannelPostUpdate>? = null,
+    editedChannelPostCallback: UpdateReceiver<EditChannelPostUpdate>? = null,
+    chosenInlineResultCallback: UpdateReceiver<ChosenInlineResultUpdate>? = null,
+    inlineQueryCallback: UpdateReceiver<InlineQueryUpdate>? = null,
+    callbackQueryCallback: UpdateReceiver<CallbackQueryUpdate>? = null,
+    shippingQueryCallback: UpdateReceiver<ShippingQueryUpdate>? = null,
+    preCheckoutQueryCallback: UpdateReceiver<PreCheckoutQueryUpdate>? = null,
+    pollCallback: UpdateReceiver<PollUpdate>? = null,
+    pollAnswerCallback: UpdateReceiver<PollAnswerUpdate>? = null,
+    timeoutSeconds: Seconds = 30,
+    exceptionsHandler: ExceptionHandler<Unit>? = null,
+    scope: CoroutineScope = CoroutineScope(Dispatchers.Default)
+): Job = startGettingOfUpdatesByLongPolling(
+    messageCallback = messageCallback,
+    messageMediaGroupCallback = mediaGroupCallback,
+    editedMessageCallback = editedMessageCallback,
+    editedMessageMediaGroupCallback = mediaGroupCallback,
+    channelPostCallback = channelPostCallback,
+    channelPostMediaGroupCallback = mediaGroupCallback,
+    editedChannelPostCallback = editedChannelPostCallback,
+    editedChannelPostMediaGroupCallback = mediaGroupCallback,
+    chosenInlineResultCallback = chosenInlineResultCallback,
+    inlineQueryCallback = inlineQueryCallback,
+    callbackQueryCallback = callbackQueryCallback,
+    shippingQueryCallback = shippingQueryCallback,
+    preCheckoutQueryCallback = preCheckoutQueryCallback,
+    pollCallback = pollCallback,
+    pollAnswerCallback = pollAnswerCallback,
+    timeoutSeconds = timeoutSeconds,
+    exceptionsHandler = exceptionsHandler,
+    scope = scope
+)
+

TelegramBotAPI-extensions-utils/src/commonMain/kotlin/com/github/insanusmokrassar/TelegramBotAPI/extensions/utils/updates/retrieving/MediaGroupsIncluder.kt

@@ -0,0 +1,60 @@
+package com.github.insanusmokrassar.TelegramBotAPI.extensions.utils.updates.retrieving
+
+import com.github.insanusmokrassar.TelegramBotAPI.extensions.utils.updates.convertWithMediaGroupUpdates
+import com.github.insanusmokrassar.TelegramBotAPI.types.message.abstracts.MediaGroupMessage
+import com.github.insanusmokrassar.TelegramBotAPI.types.update.abstracts.BaseMessageUpdate
+import com.github.insanusmokrassar.TelegramBotAPI.types.update.abstracts.Update
+import com.github.insanusmokrassar.TelegramBotAPI.updateshandlers.UpdateReceiver
+import com.github.insanusmokrassar.TelegramBotAPI.utils.extensions.accumulateByKey
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.channels.Channel
+import kotlinx.coroutines.launch
+
+
+/**
+ * Create [UpdateReceiver] object which will correctly accumulate updates and send into output updates which INCLUDE
+ * [com.github.insanusmokrassar.TelegramBotAPI.types.update.MediaGroupUpdates.MediaGroupUpdate]s.
+ *
+ * @see UpdateReceiver
+ */
+fun CoroutineScope.updateHandlerWithMediaGroupsAdaptation(
+    output: UpdateReceiver<Update>,
+    debounceTimeMillis: Long = 1000L
+): UpdateReceiver<Update> {
+    val updatesChannel = Channel<Update>(Channel.UNLIMITED)
+    val mediaGroupChannel = Channel<Pair<String, BaseMessageUpdate>>(Channel.UNLIMITED)
+    val mediaGroupAccumulatedChannel = mediaGroupChannel.accumulateByKey(
+        debounceTimeMillis,
+        scope = this
+    )
+
+    launch {
+        launch {
+            for (update in updatesChannel) {
+                when (val data = update.data) {
+                    is MediaGroupMessage -> mediaGroupChannel.send("${data.mediaGroupId}${update::class.simpleName}" to update as BaseMessageUpdate)
+                    else -> output(update)
+                }
+            }
+        }
+        launch {
+            for ((_, mediaGroup) in mediaGroupAccumulatedChannel) {
+                mediaGroup.convertWithMediaGroupUpdates().forEach {
+                    output(it)
+                }
+            }
+        }
+    }
+
+    return { updatesChannel.send(it) }
+}
+
+/**
+ * Create [UpdateReceiver] object which will correctly accumulate updates and send into output updates which INCLUDE
+ * [com.github.insanusmokrassar.TelegramBotAPI.types.update.MediaGroupUpdates.MediaGroupUpdate]s.
+ *
+ * @see UpdateReceiver
+ */
+fun CoroutineScope.updateHandlerWithMediaGroupsAdaptation(
+    output: UpdateReceiver<Update>
+) = updateHandlerWithMediaGroupsAdaptation(output, 1000L)

TelegramBotAPI-extensions-utils/src/jvmMain/kotlin/com/github/insanusmokrassar/TelegramBotAPI/extensions/utils/updates/retrieving/Webhook.kt

@@ -0,0 +1,207 @@
+package com.github.insanusmokrassar.TelegramBotAPI.extensions.utils.updates.retrieving
+
+import com.github.insanusmokrassar.TelegramBotAPI.bot.RequestsExecutor
+import com.github.insanusmokrassar.TelegramBotAPI.extensions.utils.nonstrictJsonFormat
+import com.github.insanusmokrassar.TelegramBotAPI.extensions.utils.updates.flowsUpdatesFilter
+import com.github.insanusmokrassar.TelegramBotAPI.requests.abstracts.MultipartFile
+import com.github.insanusmokrassar.TelegramBotAPI.requests.abstracts.Request
+import com.github.insanusmokrassar.TelegramBotAPI.requests.send.media.base.MultipartRequestImpl
+import com.github.insanusmokrassar.TelegramBotAPI.requests.webhook.SetWebhook
+import com.github.insanusmokrassar.TelegramBotAPI.types.update.abstracts.Update
+import com.github.insanusmokrassar.TelegramBotAPI.types.update.abstracts.UpdateDeserializationStrategy
+import com.github.insanusmokrassar.TelegramBotAPI.updateshandlers.*
+import com.github.insanusmokrassar.TelegramBotAPI.updateshandlers.webhook.WebhookPrivateKeyConfig
+import com.github.insanusmokrassar.TelegramBotAPI.utils.ExceptionHandler
+import com.github.insanusmokrassar.TelegramBotAPI.utils.handleSafely
+import io.ktor.application.call
+import io.ktor.request.receiveText
+import io.ktor.response.respond
+import io.ktor.routing.*
+import io.ktor.server.engine.*
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.asCoroutineDispatcher
+import java.util.concurrent.Executors
+
+
+/**
+ * Allows to include webhook in custom route everywhere in your server
+ *
+ * @param [scope] Will be used for mapping of media groups
+ * @param [exceptionsHandler] Pass this parameter to set custom exception handler for getting updates
+ * @param [block] Some receiver block like [com.github.insanusmokrassar.TelegramBotAPI.updateshandlers.FlowsUpdatesFilter]
+ *
+ * @see com.github.insanusmokrassar.TelegramBotAPI.updateshandlers.FlowsUpdatesFilter
+ * @see UpdatesFilter
+ * @see UpdatesFilter.asUpdateReceiver
+ */
+fun Route.includeWebhookHandlingInRoute(
+    scope: CoroutineScope,
+    exceptionsHandler: ExceptionHandler<Unit>? = null,
+    block: UpdateReceiver<Update>
+) {
+    val transformer = scope.updateHandlerWithMediaGroupsAdaptation(block)
+    post {
+        handleSafely(
+            exceptionsHandler ?: {}
+        ) {
+            val asJson =
+                nonstrictJsonFormat.parseJson(call.receiveText())
+            val update = nonstrictJsonFormat.fromJson(
+                UpdateDeserializationStrategy,
+                asJson
+            )
+            transformer(update)
+        }
+        call.respond("Ok")
+    }
+}
+
+fun Route.includeWebhookHandlingInRouteWithFlows(
+    scope: CoroutineScope,
+    exceptionsHandler: ExceptionHandler<Unit>? = null,
+    block: FlowsUpdatesFilter.() -> Unit
+) = includeWebhookHandlingInRoute(
+    scope,
+    exceptionsHandler,
+    flowsUpdatesFilter(block = block).asUpdateReceiver
+)
+
+/**
+ * Setting up ktor server, set webhook info via [SetWebhook] request.
+ *
+ * @param listenPort port which will be listen by bot
+ * @param listenRoute address to listen by bot. If null - will be set up in root of host
+ * @param scope Scope which will be used for
+ * @param privateKeyConfig If configured - server will be created with [sslConnector]. [connector] will be used otherwise
+ *
+ * @see com.github.insanusmokrassar.TelegramBotAPI.updateshandlers.FlowsUpdatesFilter
+ * @see UpdatesFilter
+ * @see UpdatesFilter.asUpdateReceiver
+ */
+fun startListenWebhooks(
+    listenPort: Int,
+    engineFactory: ApplicationEngineFactory<*, *>,
+    exceptionsHandler: ExceptionHandler<Unit>,
+    listenHost: String = "0.0.0.0",
+    listenRoute: String? = null,
+    privateKeyConfig: WebhookPrivateKeyConfig? = null,
+    scope: CoroutineScope = CoroutineScope(Executors.newFixedThreadPool(4).asCoroutineDispatcher()),
+    block: UpdateReceiver<Update>
+): ApplicationEngine {
+    val env = applicationEngineEnvironment {
+
+        module {
+            routing {
+                listenRoute ?.also {
+                    createRouteFromPath(it).includeWebhookHandlingInRoute(scope, exceptionsHandler, block)
+                } ?: includeWebhookHandlingInRoute(scope, exceptionsHandler, block)
+            }
+        }
+        privateKeyConfig ?.let {
+            sslConnector(
+                privateKeyConfig.keyStore,
+                privateKeyConfig.aliasName,
+                privateKeyConfig::keyStorePassword,
+                privateKeyConfig::aliasPassword
+            ) {
+                host = listenHost
+                port = listenPort
+            }
+        } ?: connector {
+            host = listenHost
+            port = listenPort
+        }
+
+    }
+
+    return embeddedServer(engineFactory, env).also {
+        it.start(false)
+    }
+}
+
+private suspend fun RequestsExecutor.internalSetWebhookInfoAndStartListenWebhooks(
+    listenPort: Int,
+    engineFactory: ApplicationEngineFactory<*, *>,
+    setWebhookRequest: Request<Boolean>,
+    exceptionsHandler: ExceptionHandler<Unit> = {},
+    listenHost: String = "0.0.0.0",
+    listenRoute: String? = null,
+    privateKeyConfig: WebhookPrivateKeyConfig? = null,
+    scope: CoroutineScope = CoroutineScope(Executors.newFixedThreadPool(4).asCoroutineDispatcher()),
+    block: UpdateReceiver<Update>
+): ApplicationEngine {
+    return try {
+        execute(setWebhookRequest)
+        startListenWebhooks(listenPort, engineFactory, exceptionsHandler, listenHost, listenRoute, privateKeyConfig, scope, block)
+    } catch (e: Exception) {
+        throw e
+    }
+}
+
+/**
+ * Setting up ktor server, set webhook info via [SetWebhook] request.
+ *
+ * @param listenPort port which will be listen by bot
+ * @param listenRoute address to listen by bot
+ * @param scope Scope which will be used for
+ *
+ * @see com.github.insanusmokrassar.TelegramBotAPI.updateshandlers.FlowsUpdatesFilter
+ * @see UpdatesFilter
+ * @see UpdatesFilter.asUpdateReceiver
+ */
+@Suppress("unused")
+suspend fun RequestsExecutor.setWebhookInfoAndStartListenWebhooks(
+    listenPort: Int,
+    engineFactory: ApplicationEngineFactory<*, *>,
+    setWebhookRequest: SetWebhook,
+    exceptionsHandler: ExceptionHandler<Unit> = {},
+    listenHost: String = "0.0.0.0",
+    listenRoute: String = "/",
+    privateKeyConfig: WebhookPrivateKeyConfig? = null,
+    scope: CoroutineScope = CoroutineScope(Executors.newFixedThreadPool(4).asCoroutineDispatcher()),
+    block: UpdateReceiver<Update>
+): ApplicationEngine = internalSetWebhookInfoAndStartListenWebhooks(
+    listenPort,
+    engineFactory,
+    setWebhookRequest as Request<Boolean>,
+    exceptionsHandler,
+    listenHost,
+    listenRoute,
+    privateKeyConfig,
+    scope,
+    block
+)
+
+/**
+ * Setting up ktor server, set webhook info via [SetWebhook] request.
+ *
+ * @param listenPort port which will be listen by bot
+ * @param listenRoute address to listen by bot
+ * @param scope Scope which will be used for
+ *
+ * @see com.github.insanusmokrassar.TelegramBotAPI.updateshandlers.FlowsUpdatesFilter
+ * @see UpdatesFilter
+ * @see UpdatesFilter.asUpdateReceiver
+ */
+@Suppress("unused")
+suspend fun RequestsExecutor.setWebhookInfoAndStartListenWebhooks(
+    listenPort: Int,
+    engineFactory: ApplicationEngineFactory<*, *>,
+    setWebhookRequest: MultipartRequestImpl<SetWebhook, Map<String, MultipartFile>, Boolean>,
+    exceptionsHandler: ExceptionHandler<Unit> = {},
+    listenHost: String = "0.0.0.0",
+    listenRoute: String? = null,
+    privateKeyConfig: WebhookPrivateKeyConfig? = null,
+    scope: CoroutineScope = CoroutineScope(Executors.newFixedThreadPool(4).asCoroutineDispatcher()),
+    block: UpdateReceiver<Update>
+): ApplicationEngine = internalSetWebhookInfoAndStartListenWebhooks(
+    listenPort,
+    engineFactory,
+    setWebhookRequest as Request<Boolean>,
+    exceptionsHandler,
+    listenHost,
+    listenRoute,
+    privateKeyConfig,
+    scope,
+    block
+)

TelegramBotAPI.minder

@@ -0,0 +1,81 @@
+<?xml version="1.0"?>
+<minder version="1.8.0">
+  <theme name="default" label="Default" index="-1"/>
+  <styles>
+    <style level="0" isset="true" linktype="curved" linkwidth="5" linkarrow="true" linkdash="solid" nodeborder="bracket" nodewidth="200" nodeborderwidth="3" nodefill="false" nodemargin="11" nodepadding="5" nodefont="Roboto Mono 14" nodemarkup="true" connectiondash="dotted" connectionwidth="2" connectionarrow="fromto" connectionpadding="3" connectionfont="Sans 10"/>
+    <style level="1" isset="true" linktype="curved" linkwidth="5" linkarrow="true" linkdash="solid" nodeborder="bracket" nodewidth="200" nodeborderwidth="3" nodefill="false" nodemargin="11" nodepadding="5" nodefont="Roboto Mono 14" nodemarkup="true" connectiondash="dotted" connectionwidth="2" connectionarrow="fromto" connectionpadding="3" connectionfont="Sans 10"/>
+    <style level="2" isset="true" linktype="curved" linkwidth="5" linkarrow="true" linkdash="solid" nodeborder="bracket" nodewidth="200" nodeborderwidth="3" nodefill="false" nodemargin="11" nodepadding="5" nodefont="Roboto Mono 14" nodemarkup="true" connectiondash="dotted" connectionwidth="2" connectionarrow="fromto" connectionpadding="3" connectionfont="Sans 10"/>
+    <style level="3" isset="true" linktype="curved" linkwidth="5" linkarrow="true" linkdash="solid" nodeborder="bracket" nodewidth="200" nodeborderwidth="3" nodefill="false" nodemargin="11" nodepadding="5" nodefont="Roboto Mono 14" nodemarkup="true" connectiondash="dotted" connectionwidth="2" connectionarrow="fromto" connectionpadding="3" connectionfont="Sans 10"/>
+    <style level="4" isset="true" linktype="curved" linkwidth="5" linkarrow="true" linkdash="solid" nodeborder="bracket" nodewidth="200" nodeborderwidth="3" nodefill="false" nodemargin="11" nodepadding="5" nodefont="Roboto Mono 14" nodemarkup="true" connectiondash="dotted" connectionwidth="2" connectionarrow="fromto" connectionpadding="3" connectionfont="Sans 10"/>
+    <style level="5" isset="true" linktype="curved" linkwidth="5" linkarrow="true" linkdash="solid" nodeborder="bracket" nodewidth="200" nodeborderwidth="3" nodefill="false" nodemargin="11" nodepadding="5" nodefont="Roboto Mono 14" nodemarkup="true" connectiondash="dotted" connectionwidth="2" connectionarrow="fromto" connectionpadding="3" connectionfont="Sans 10"/>
+    <style level="6" isset="true" linktype="curved" linkwidth="5" linkarrow="true" linkdash="solid" nodeborder="bracket" nodewidth="200" nodeborderwidth="3" nodefill="false" nodemargin="11" nodepadding="5" nodefont="Roboto Mono 14" nodemarkup="true" connectiondash="dotted" connectionwidth="2" connectionarrow="fromto" connectionpadding="3" connectionfont="Sans 10"/>
+    <style level="7" isset="true" linktype="curved" linkwidth="5" linkarrow="true" linkdash="solid" nodeborder="bracket" nodewidth="200" nodeborderwidth="3" nodefill="false" nodemargin="11" nodepadding="5" nodefont="Roboto Mono 14" nodemarkup="true" connectiondash="dotted" connectionwidth="2" connectionarrow="fromto" connectionpadding="3" connectionfont="Sans 10"/>
+    <style level="8" isset="true" linktype="curved" linkwidth="5" linkarrow="true" linkdash="solid" nodeborder="bracket" nodewidth="200" nodeborderwidth="3" nodefill="false" nodemargin="11" nodepadding="5" nodefont="Roboto Mono 14" nodemarkup="true" connectiondash="dotted" connectionwidth="2" connectionarrow="fromto" connectionpadding="3" connectionfont="Sans 10"/>
+    <style level="9" isset="true" linktype="curved" linkwidth="5" linkarrow="true" linkdash="solid" nodeborder="bracket" nodewidth="200" nodeborderwidth="3" nodefill="false" nodemargin="11" nodepadding="5" nodefont="Roboto Mono 14" nodemarkup="true" connectiondash="dotted" connectionwidth="2" connectionarrow="fromto" connectionpadding="3" connectionfont="Sans 10"/>
+    <style level="10" isset="true" linktype="curved" linkwidth="5" linkarrow="true" linkdash="solid" nodeborder="bracket" nodewidth="200" nodeborderwidth="3" nodefill="false" nodemargin="11" nodepadding="5" nodefont="Roboto Mono 14" nodemarkup="true" connectiondash="dotted" connectionwidth="2" connectionarrow="fromto" connectionpadding="3" connectionfont="Sans 10"/>
+  </styles>
+  <drawarea x="-53.566975911458371" y="280.97174580891931" scale="1"/>
+  <images/>
+  <nodes>
+    <node id="1" posx="475.27954101562455" posy="-172.96498107910156" maxwidth="489.29239908854163" width="494" height="168" side="top" fold="false" treesize="724" layout="Downwards">
+      <style linktype="curved" linkwidth="5" linkarrow="true" linkdash="solid" nodeborder="bracket" nodewidth="200" nodeborderwidth="3" nodefill="false" nodemargin="11" nodepadding="5" nodefont="Roboto Mono 14" nodemarkup="true"/>
+      <formatting/>
+      <nodename>TelegramBotAPI
+
+Root project with API. It is not recommended to use its requests directly and better to use at least TelegramBotAPI-extensions-api</nodename>
+      <nodenote></nodenote>
+      <nodes>
+        <node id="3" posx="568.77954101562455" posy="95.035018920898438" maxwidth="286.41682942708326" width="307" height="168" side="bottom" fold="false" treesize="724" color="#68b723" colorroot="true" layout="Downwards">
+          <style linktype="curved" linkwidth="5" linkarrow="true" linkdash="solid" nodeborder="none" nodewidth="200" nodeborderwidth="3" nodefill="false" nodemargin="11" nodepadding="5" nodefont="Roboto Mono 14" nodemarkup="true"/>
+          <formatting/>
+          <nodename>TelegramBotAPI-extensions
+
+Family of projects which are fully based on TelegramBotAPI and extend its functionality</nodename>
+          <nodenote></nodenote>
+          <nodes>
+            <node id="5" posx="360.27954101562455" posy="363.03501892089844" maxwidth="322.17146809895831" width="351" height="191" side="bottom" fold="false" treesize="351" color="#68b723" colorroot="true" layout="Downwards">
+              <style linktype="curved" linkwidth="5" linkarrow="true" linkdash="solid" nodeborder="bracket" nodewidth="200" nodeborderwidth="3" nodefill="false" nodemargin="11" nodepadding="5" nodefont="Roboto Mono 14" nodemarkup="true"/>
+              <formatting/>
+              <nodename>TelegramBotAPI-extensions-api
+
+Extensions project for make requests more look like in the Telegram Bot API and give opportunity to use it's easier</nodename>
+              <nodenote></nodenote>
+            </node>
+            <node id="7" posx="711.27954101562455" posy="363.03501892089844" maxwidth="341.10636393229163" width="373" height="145" side="bottom" fold="false" treesize="373" color="#68b723" colorroot="true" layout="Downwards">
+              <style linktype="curved" linkwidth="5" linkarrow="true" linkdash="solid" nodeborder="bracket" nodewidth="200" nodeborderwidth="3" nodefill="false" nodemargin="11" nodepadding="5" nodefont="Roboto Mono 14" nodemarkup="true"/>
+              <formatting/>
+              <nodename>TelegramBotAPI-extensions-utils
+
+Extensions project with utils things which will make easier different operations</nodename>
+              <nodenote></nodenote>
+            </node>
+          </nodes>
+        </node>
+      </nodes>
+    </node>
+    <node id="9" posx="521.83642578124955" posy="645.92375183105469" maxwidth="405.23974609375" width="395" height="213" side="bottom" fold="false" treesize="395" layout="Downwards">
+      <style linktype="curved" linkwidth="5" linkarrow="true" linkdash="solid" nodeborder="bracket" nodewidth="200" nodeborderwidth="3" nodefill="false" nodemargin="11" nodepadding="5" nodefont="Roboto Mono 14" nodemarkup="true"/>
+      <formatting/>
+      <nodename>TelegramBotAPI-all
+
+Here included all available TelegramBotAPI libraries:&#xD;
+&#xD;
+* TelegramBotAPI&#xD;
+* TelegramBotAPI-extensions-api&#xD;
+* TelegramBotAPI-extensions-utils</nodename>
+      <nodenote></nodenote>
+    </node>
+  </nodes>
+  <connections>
+    <connection from_id="5" to_id="9" drag_x="574.8447265625" drag_y="605.20840454101562" color="rgb(119,119,119)">
+      <style connectiondash="dotted" connectionwidth="2" connectionarrow="fromto" connectionpadding="3" connectionfont="Sans 10"/>
+      <title></title>
+      <note></note>
+    </connection>
+    <connection from_id="7" to_id="9" drag_x="856.732666015625" drag_y="600.25286865234375" color="rgb(119,119,119)">
+      <style connectiondash="dotted" connectionwidth="2" connectionarrow="fromto" connectionpadding="3" connectionfont="Sans 10"/>
+      <title></title>
+      <note></note>
+    </connection>
+  </connections>
+</minder>

TelegramBotAPI/README.md

@@ -10,7 +10,7 @@ moments are describing by official [Telegram Bot API](https://core.telegram.org/
 
 ## Compatibility
 
-This version compatible with [24th of April 2020 update of TelegramBotAPI (version 4.8)](https://core.telegram.org/bots/api#april-24-2020).
+This version compatible with [4th of June 2020 update of TelegramBotAPI (version 4.9)](https://core.telegram.org/bots/api#june-4-2020).
 There is only one exception of implemented functionality - Telegram Passport API, which was presented in
 [August 2018 update of TelegramBotAPI](https://core.telegram.org/bots/api-changelog#august-27-2018) update. It will be implemented
 as soon as possible.
@@ -149,53 +149,3 @@ Here was used `okhttp` realisation of client, but there are several others engin
 available on ktor.io site for [client](https://ktor.io/clients/http-client/engines.html) and [server](https://ktor.io/quickstart/artifacts.html)
 engines.
 
-## Getting updates
-
-In this library currently realised two ways to get updates from telegram:
-
-* Polling - in this case bot will request updates from time to time (you can set up delay between requests)
-* Webhook via reverse proxy or something like this
-
-### Updates filters
-
-Currently webhook method contains `UpdatesFilter` as necessary argument for getting updates.
-`UpdatesFilter` will sort updates and throw their into different callbacks. Currently supporting
-separate getting updates for media groups - they are accumulating with debounce in one second
-(for being sure that all objects of media group was received).
-
-Updates polling also support `UpdatesFilter` but it is not required to use it and you can get updates directly
-in `UpdateReceiver`, which you will provide to `startGettingOfUpdates` method
-
-### Webhook set up
-
-If you wish to use webhook method, you will need:
-
-* White IP - your IP address or host, which available for calling. [TelegramBotAPI](https://core.telegram.org/bots/api#setwebhook)
-recommend to use some unique address for each bot which you are using
-* SSL certificate. Usually you can obtain the certificate using your domain provider, [Let'sEncrypt](https://letsencrypt.org/) or [create it](https://core.telegram.org/bots/self-signed)
-* Nginx or something like this
-
-Template for Nginx server config you can find in [this gist](https://gist.github.com/InsanusMokrassar/fcc6e09cebd07e46e8f0fdec234750c4#file-nginxssl-conf).
-
-For webhook you can provide `File` with public part of certificate, `URL` where bot will be available and inner `PORT` which
-will be used to start receiving of updates. Actually, you can skip passing of `File` when you have something like
-nginx for proxy forwarding.
-
-In case of using `nginx` with reverse-proxy config, setting up of Webhook will look like:
-
-```kotlin
-requestsExecutor.setWebhook(
-    WEBHOOK_URL,
-    INTERNAL_PORT,
-    filter,
-    ENGINE_FACTORY
-)
-``` 
-
-Here:
-
-* `WEBHOOK_URL` - the url which will be used by Telegram system to send updates
-* `INTERNAL_PORT` - the port which will be used in bot for listening of updates
-* `filter` - instance of [UpdatesFilter](https://github.com/InsanusMokrassar/TelegramBotAPI/blob/master/TelegramBotAPI/src/commonMain/kotlin/com/github/insanusmokrassar/TelegramBotAPI/updateshandlers/UpdatesFilter.kt),
-which will be used to filter incoming updates
-* `ENGINE_FACTORY` - used factory name, for example, `CIO` in case of usage `io.ktor:ktor-server-cio` as server engine

TelegramBotAPI/build.gradle

@@ -64,6 +64,8 @@ kotlin {
 
                 api "io.ktor:ktor-server-host-common:$ktor_version"
                 api "io.ktor:ktor-client-cio:$ktor_version"
+
+                api "javax.activation:activation:$javax_activation_version"
             }
         }
         jvmTest {
@@ -82,7 +84,6 @@ kotlin {
         }
     }
 
-
     targets.all {
         compilations.all {
             kotlinOptions {

TelegramBotAPI/maven.publish.gradle

@@ -20,37 +20,33 @@ publishing {
     publications.all {
         artifact javadocsJar
 
-        pom.withXml {
-            asNode().children().last() + {
-                resolveStrategy = Closure.DELEGATE_FIRST
+        pom {
+            description = "Library for Object-Oriented and type-safe work with Telegram Bot API"
+            name = "Telegram Bot API"
+            url = "https://insanusmokrassar.github.io/TelegramBotAPI"
 
-                description "Library for Object-Oriented and type-safe work with Telegram Bot API"
-                name "Telegram Bot API"
-                url "https://insanusmokrassar.github.io/TelegramBotAPI"
+            scm {
+                developerConnection = "scm:git:[fetch=]https://github.com/insanusmokrassar/TelegramBotAPI.git[push=]https://github.com/insanusmokrassar/TelegramBotAPI.git"
+                url = "https://github.com/insanusmokrassar/TelegramBotAPI.git"
+            }
 
-                scm {
-                    developerConnection "scm:git:[fetch=]https://github.com/insanusmokrassar/TelegramBotAPI.git[push=]https://github.com/insanusmokrassar/TelegramBotAPI.git"
-                    url "https://github.com/insanusmokrassar/TelegramBotAPI.git"
-                }
+            developers {
+                
+                    developer {
+                        id = "InsanusMokrassar"
+                        name = "Ovsiannikov Aleksei"
+                        email = "ovsyannikov.alexey95@gmail.com"
+                    }
+                
+            }
 
-                developers {
-                    
-                        developer {
-                            id "InsanusMokrassar"
-                            name "Ovsiannikov Aleksei"
-                            email "ovsyannikov.alexey95@gmail.com"
-                        }
-                    
-                }
-
-                licenses {
-                    
-                        license {
-                            name "Apache Software License 2.0"
-                            url "https://github.com/InsanusMokrassar/TelegramBotAPI/blob/master/LICENSE"
-                        }
-                    
-                }
+            licenses {
+                
+                    license {
+                        name = "Apache Software License 2.0"
+                        url = "https://github.com/InsanusMokrassar/TelegramBotAPI/blob/master/LICENSE"
+                    }
+                
             }
         }
     }

TelegramBotAPI/src/commonMain/kotlin/com/github/insanusmokrassar/TelegramBotAPI/bot/RequestsExecutor.kt

@@ -3,9 +3,20 @@ package com.github.insanusmokrassar.TelegramBotAPI.bot
 import com.github.insanusmokrassar.TelegramBotAPI.requests.abstracts.Request
 import io.ktor.utils.io.core.Closeable
 
+/**
+ * Interface for making requests to Telegram Bot API. Currently, there is only one built-in implementation -
+ * [com.github.insanusmokrassar.TelegramBotAPI.bot.Ktor.KtorRequestsExecutor]
+ *
+ * @see Request
+ * @see com.github.insanusmokrassar.TelegramBotAPI.bot.Ktor.KtorRequestsExecutor
+ */
 interface RequestsExecutor : Closeable {
     /**
-     * @throws com.github.insanusmokrassar.TelegramBotAPI.bot.exceptions.RequestException
+     * Unsafe execution of incoming [request]. Can throw almost any exception. So, it is better to use
+     * something like [com.github.insanusmokrassar.TelegramBotAPI.extensions.utils.shortcuts.executeAsync] or
+     * [com.github.insanusmokrassar.TelegramBotAPI.extensions.utils.shortcuts.executeUnsafe]
+     *
+     * @throws Exception
      */
     suspend fun <T : Any> execute(request: Request<T>): T
 }

TelegramBotAPI/src/commonMain/kotlin/com/github/insanusmokrassar/TelegramBotAPI/requests/GetUpdates.kt

@@ -11,6 +11,15 @@ private val updatesListSerializer = ListSerializer(
     UpdateSerializerWithoutSerialization
 )
 
+/**
+ * Request updates from Telegram Bot API system. It is important, that the result updates WILL NOT include
+ * [com.github.insanusmokrassar.TelegramBotAPI.types.update.MediaGroupUpdates.MediaGroupUpdate] objects due to the fact,
+ * that it is internal abstraction and in fact any [com.github.insanusmokrassar.TelegramBotAPI.types.message.abstracts.MediaGroupMessage]
+ * is just a common [com.github.insanusmokrassar.TelegramBotAPI.types.message.abstracts.Message]
+ *
+ * @see com.github.insanusmokrassar.TelegramBotAPI.extensions.utils.updates.retrieving.updateHandlerWithMediaGroupsAdaptation
+ * @see com.github.insanusmokrassar.TelegramBotAPI.utils.convertWithMediaGroupUpdates
+ */
 @Serializable
 data class GetUpdates(
     val offset: UpdateIdentifier? = null,// set `last update id + 1` to receive next part of updates

TelegramBotAPI/src/commonMain/kotlin/com/github/insanusmokrassar/TelegramBotAPI/requests/send/SendMessage.kt

@@ -9,6 +9,7 @@ import com.github.insanusmokrassar.TelegramBotAPI.types.buttons.KeyboardMarkup
 import com.github.insanusmokrassar.TelegramBotAPI.types.message.abstracts.ContentMessage
 import com.github.insanusmokrassar.TelegramBotAPI.types.message.abstracts.TelegramBotAPIMessageDeserializationStrategyClass
 import com.github.insanusmokrassar.TelegramBotAPI.types.message.content.TextContent
+import com.github.insanusmokrassar.TelegramBotAPI.utils.throwRangeError
 import kotlinx.serialization.*
 
 internal val TextContentMessageResultDeserializer: DeserializationStrategy<ContentMessage<TextContent>>
@@ -37,7 +38,7 @@ data class SendTextMessage(
 {
     init {
         if (text.length !in textLength) {
-            throw IllegalArgumentException("Text must be in $textLength range")
+            throwRangeError("Text length", textLength, text.length)
         }
     }
 

TelegramBotAPI/src/commonMain/kotlin/com/github/insanusmokrassar/TelegramBotAPI/requests/send/SendVenue.kt

@@ -6,6 +6,7 @@ import com.github.insanusmokrassar.TelegramBotAPI.types.buttons.KeyboardMarkup
 import com.github.insanusmokrassar.TelegramBotAPI.types.message.abstracts.ContentMessage
 import com.github.insanusmokrassar.TelegramBotAPI.types.message.abstracts.TelegramBotAPIMessageDeserializationStrategyClass
 import com.github.insanusmokrassar.TelegramBotAPI.types.message.content.VenueContent
+import com.github.insanusmokrassar.TelegramBotAPI.types.venue.Venue
 import kotlinx.serialization.*
 
 private val commonResultDeserializer: DeserializationStrategy<ContentMessage<VenueContent>>

TelegramBotAPI/src/commonMain/kotlin/com/github/insanusmokrassar/TelegramBotAPI/requests/send/media/SendAnimation.kt

@@ -11,6 +11,7 @@ import com.github.insanusmokrassar.TelegramBotAPI.types.message.abstracts.Conten
 import com.github.insanusmokrassar.TelegramBotAPI.types.message.abstracts.TelegramBotAPIMessageDeserializationStrategyClass
 import com.github.insanusmokrassar.TelegramBotAPI.types.message.content.media.AnimationContent
 import com.github.insanusmokrassar.TelegramBotAPI.utils.mapOfNotNull
+import com.github.insanusmokrassar.TelegramBotAPI.utils.throwRangeError
 import kotlinx.serialization.*
 
 fun SendAnimation(
@@ -93,7 +94,7 @@ data class SendAnimationData internal constructor(
     init {
         text ?.let {
             if (it.length !in captionLength) {
-                throw IllegalArgumentException("Caption must be in $captionLength range")
+                throwRangeError("Caption length", captionLength, it.length)
             }
         }
     }

TelegramBotAPI/src/commonMain/kotlin/com/github/insanusmokrassar/TelegramBotAPI/requests/send/media/SendAudio.kt

@@ -12,6 +12,7 @@ import com.github.insanusmokrassar.TelegramBotAPI.types.message.abstracts.Conten
 import com.github.insanusmokrassar.TelegramBotAPI.types.message.abstracts.TelegramBotAPIMessageDeserializationStrategyClass
 import com.github.insanusmokrassar.TelegramBotAPI.types.message.content.media.AudioContent
 import com.github.insanusmokrassar.TelegramBotAPI.utils.mapOfNotNull
+import com.github.insanusmokrassar.TelegramBotAPI.utils.throwRangeError
 import kotlinx.serialization.*
 
 fun SendAudio(
@@ -95,7 +96,7 @@ data class SendAudioData internal constructor(
     init {
         text ?.let {
             if (it.length !in captionLength) {
-                throw IllegalArgumentException("Caption must be in $captionLength range")
+                throwRangeError("Caption length", captionLength, it.length)
             }
         }
     }

TelegramBotAPI/src/commonMain/kotlin/com/github/insanusmokrassar/TelegramBotAPI/requests/send/media/SendDocument.kt

@@ -11,6 +11,7 @@ import com.github.insanusmokrassar.TelegramBotAPI.types.message.abstracts.Conten
 import com.github.insanusmokrassar.TelegramBotAPI.types.message.abstracts.TelegramBotAPIMessageDeserializationStrategyClass
 import com.github.insanusmokrassar.TelegramBotAPI.types.message.content.media.DocumentContent
 import com.github.insanusmokrassar.TelegramBotAPI.utils.mapOfNotNull
+import com.github.insanusmokrassar.TelegramBotAPI.utils.throwRangeError
 import kotlinx.serialization.*
 
 fun SendDocument(
@@ -79,7 +80,7 @@ data class SendDocumentData internal constructor(
     init {
         text ?.let {
             if (it.length !in captionLength) {
-                throw IllegalArgumentException("Caption must be in $captionLength range")
+                throwRangeError("Caption length", captionLength, it.length)
             }
         }
     }

TelegramBotAPI/src/commonMain/kotlin/com/github/insanusmokrassar/TelegramBotAPI/requests/send/media/SendMediaGroup.kt

@@ -8,12 +8,15 @@ import com.github.insanusmokrassar.TelegramBotAPI.types.*
 import com.github.insanusmokrassar.TelegramBotAPI.types.InputMedia.*
 import com.github.insanusmokrassar.TelegramBotAPI.types.message.abstracts.MediaGroupMessage
 import com.github.insanusmokrassar.TelegramBotAPI.types.message.abstracts.TelegramBotAPIMessageDeserializeOnlySerializerClass
+import com.github.insanusmokrassar.TelegramBotAPI.utils.throwRangeError
 import com.github.insanusmokrassar.TelegramBotAPI.utils.toJsonWithoutNulls
 import kotlinx.serialization.*
 import kotlinx.serialization.builtins.ListSerializer
 import kotlinx.serialization.json.jsonArray
 
-val membersCountInMediaGroup: IntRange = 2 .. 10
+@Deprecated("Replaced and renamed", ReplaceWith("mediaCountInMediaGroup", "com.github.insanusmokrassar.TelegramBotAPI.types.mediaCountInMediaGroup"))
+val membersCountInMediaGroup
+    get() = mediaCountInMediaGroup
 
 fun SendMediaGroup(
     chatId: ChatIdentifier,
@@ -21,8 +24,8 @@ fun SendMediaGroup(
     disableNotification: Boolean = false,
     replyToMessageId: MessageIdentifier? = null
 ): Request<List<MediaGroupMessage>> {
-    if (media.size !in membersCountInMediaGroup) {
-        throw IllegalArgumentException("Count of members for media group must be in $membersCountInMediaGroup range")
+    if (media.size !in mediaCountInMediaGroup) {
+        throwRangeError("Count of members in media group", mediaCountInMediaGroup, media.size)
     }
 
     val files: List<MultipartFile> = media.flatMap {

TelegramBotAPI/src/commonMain/kotlin/com/github/insanusmokrassar/TelegramBotAPI/requests/send/media/SendPhoto.kt

@@ -10,6 +10,7 @@ import com.github.insanusmokrassar.TelegramBotAPI.types.buttons.KeyboardMarkup
 import com.github.insanusmokrassar.TelegramBotAPI.types.message.abstracts.ContentMessage
 import com.github.insanusmokrassar.TelegramBotAPI.types.message.abstracts.TelegramBotAPIMessageDeserializationStrategyClass
 import com.github.insanusmokrassar.TelegramBotAPI.types.message.content.media.PhotoContent
+import com.github.insanusmokrassar.TelegramBotAPI.utils.throwRangeError
 import kotlinx.serialization.*
 
 fun SendPhoto(
@@ -65,7 +66,7 @@ data class SendPhotoData internal constructor(
     init {
         text ?.let {
             if (it.length !in captionLength) {
-                throw IllegalArgumentException("Caption must be in $captionLength range")
+                throwRangeError("Caption length", captionLength, it.length)
             }
         }
     }

TelegramBotAPI/src/commonMain/kotlin/com/github/insanusmokrassar/TelegramBotAPI/requests/send/media/SendVideo.kt

@@ -11,6 +11,7 @@ import com.github.insanusmokrassar.TelegramBotAPI.types.message.abstracts.Conten
 import com.github.insanusmokrassar.TelegramBotAPI.types.message.abstracts.TelegramBotAPIMessageDeserializationStrategyClass
 import com.github.insanusmokrassar.TelegramBotAPI.types.message.content.media.VideoContent
 import com.github.insanusmokrassar.TelegramBotAPI.utils.mapOfNotNull
+import com.github.insanusmokrassar.TelegramBotAPI.utils.throwRangeError
 import kotlinx.serialization.*
 
 fun SendVideo(
@@ -97,7 +98,7 @@ data class SendVideoData internal constructor(
     init {
         text ?.let {
             if (it.length !in captionLength) {
-                throw IllegalArgumentException("Caption must be in $captionLength range")
+                throwRangeError("Caption length", captionLength, it.length)
             }
         }
     }

TelegramBotAPI/src/commonMain/kotlin/com/github/insanusmokrassar/TelegramBotAPI/requests/send/media/SendVideoNote.kt

@@ -11,6 +11,7 @@ import com.github.insanusmokrassar.TelegramBotAPI.types.message.abstracts.Conten
 import com.github.insanusmokrassar.TelegramBotAPI.types.message.abstracts.TelegramBotAPIMessageDeserializationStrategyClass
 import com.github.insanusmokrassar.TelegramBotAPI.types.message.content.media.VideoNoteContent
 import com.github.insanusmokrassar.TelegramBotAPI.utils.mapOfNotNull
+import com.github.insanusmokrassar.TelegramBotAPI.utils.throwRangeError
 import kotlinx.serialization.*
 
 fun SendVideoNote(
@@ -92,7 +93,7 @@ data class SendVideoNoteData internal constructor(
     init {
         text ?.let {
             if (it.length !in captionLength) {
-                throw IllegalArgumentException("Caption must be in $captionLength range")
+                throwRangeError("Caption length", captionLength, it.length)
             }
         }
     }

TelegramBotAPI/src/commonMain/kotlin/com/github/insanusmokrassar/TelegramBotAPI/requests/send/media/SendVoice.kt

@@ -11,6 +11,7 @@ import com.github.insanusmokrassar.TelegramBotAPI.types.message.abstracts.Conten
 import com.github.insanusmokrassar.TelegramBotAPI.types.message.abstracts.TelegramBotAPIMessageDeserializationStrategyClass
 import com.github.insanusmokrassar.TelegramBotAPI.types.message.content.media.VoiceContent
 import com.github.insanusmokrassar.TelegramBotAPI.utils.mapOfNotNull
+import com.github.insanusmokrassar.TelegramBotAPI.utils.throwRangeError
 import kotlinx.serialization.*
 
 fun SendVoice(
@@ -84,7 +85,7 @@ data class SendVoiceData internal constructor(
     init {
         text ?.let {
             if (it.length !in captionLength) {
-                throw IllegalArgumentException("Caption must be in $captionLength range")
+                throwRangeError("Caption length", captionLength, it.length)
             }
         }
     }

TelegramBotAPI/src/commonMain/kotlin/com/github/insanusmokrassar/TelegramBotAPI/requests/webhook/SetWebhook.kt

@@ -7,33 +7,56 @@ import com.github.insanusmokrassar.TelegramBotAPI.types.*
 import kotlinx.serialization.*
 import kotlinx.serialization.builtins.serializer
 
+private fun correctWebhookUrl(sourceUrl: String) = if (sourceUrl.contains("://")) {
+    sourceUrl
+} else {
+    "https://$sourceUrl"
+}
+
+fun SetWebhook(
+    url: String,
+    certificate: MultipartFile,
+    maxAllowedConnections: Int? = null,
+    allowedUpdates: List<String>? = null
+): MultipartRequestImpl<SetWebhook, Map<String, MultipartFile>, Boolean> = MultipartRequestImpl(
+    SetWebhook(
+        correctWebhookUrl(url),
+        null,
+        maxAllowedConnections,
+        allowedUpdates
+    ),
+    mapOf(certificateField to certificate)
+)
+
+fun SetWebhook(
+    url: String,
+    certificate: FileId,
+    maxAllowedConnections: Int? = null,
+    allowedUpdates: List<String>? = null
+): SetWebhook = SetWebhook(
+    correctWebhookUrl(url),
+    certificate.fileId,
+    maxAllowedConnections,
+    allowedUpdates
+)
+
+@Suppress("USELESS_CAST")
 fun SetWebhook(
     url: String,
     certificate: InputFile,
     maxAllowedConnections: Int? = null,
     allowedUpdates: List<String>? = null
-) : Request<Boolean> {
-    val data = SetWebhook(
-        url,
-        (certificate as? FileId) ?.fileId,
-        maxAllowedConnections,
-        allowedUpdates
-    )
-    return when (certificate) {
-        is FileId -> data
-        is MultipartFile -> MultipartRequestImpl(
-            data,
-            mapOf(certificateField to certificate)
-        )
-    }
+): Request<Boolean> = when (certificate) {
+    is MultipartFile -> SetWebhook(correctWebhookUrl(url), certificate as MultipartFile, maxAllowedConnections, allowedUpdates)
+    is FileId -> SetWebhook(correctWebhookUrl(url), certificate as FileId, maxAllowedConnections, allowedUpdates)
 }
 
 fun SetWebhook(
     url: String,
     maxAllowedConnections: Int? = null,
     allowedUpdates: List<String>? = null
-) : Request<Boolean> = SetWebhook(
-    url,
+) = SetWebhook(
+    correctWebhookUrl(url),
     null,
     maxAllowedConnections,
     allowedUpdates

TelegramBotAPI/src/commonMain/kotlin/com/github/insanusmokrassar/TelegramBotAPI/types/BotCommand.kt

@@ -1,8 +1,11 @@
 package com.github.insanusmokrassar.TelegramBotAPI.types
 
+import com.github.insanusmokrassar.TelegramBotAPI.utils.throwRangeError
 import kotlinx.serialization.SerialName
 import kotlinx.serialization.Serializable
 
+val BotCommandNameRegex = Regex("^[a-z_0-9]{${botCommandLengthLimit.first},${botCommandLengthLimit.last}}$")
+
 @Serializable
 data class BotCommand(
     @SerialName(botCommandField)
@@ -12,10 +15,13 @@ data class BotCommand(
 ) {
     init {
         if (command.length !in botCommandLengthLimit) {
-            error("Command size must be in range $botCommandLengthLimit, but actually have length ${command.length}")
+            throwRangeError("Command name size", botCommandLengthLimit, command.length)
+        }
+        if (!command.matches(BotCommandNameRegex)) {
+            error("Bot command must contains only lowercase English letters, digits and underscores, but incoming command was $command")
         }
         if (description.length !in botCommandDescriptionLimit) {
-            error("Command description size must be in range $botCommandDescriptionLimit, but actually have length ${description.length}")
+            throwRangeError("Command description size", botCommandDescriptionLimit, description.length)
         }
     }
 }

TelegramBotAPI/src/commonMain/kotlin/com/github/insanusmokrassar/TelegramBotAPI/types/Common.kt

@@ -1,5 +1,7 @@
 package com.github.insanusmokrassar.TelegramBotAPI.types
 
+import com.github.insanusmokrassar.TelegramBotAPI.utils.BuiltinMimeTypes
+
 typealias Identifier = Long
 typealias MessageIdentifier = Long
 typealias InlineQueryIdentifier = String
@@ -20,14 +22,16 @@ typealias PollIdentifier = String
 typealias StickerSetName = String
 typealias FileUniqueId = String
 typealias DiceResult = Int
+typealias FoursquareId = String
+typealias FoursquareType = String
 
 typealias Seconds = Int
 typealias LongSeconds = Long
 
 val getUpdatesLimit = 1 .. 100
 val callbackQueryAnswerLength = 0 until 200
-val captionLength = 0 until 1024
-val textLength = 0 until 4096
+val captionLength = 0 .. 1024
+val textLength = 1 .. 4096
 val userProfilePhotosRequestLimit = 0 .. 100
 val chatTitleLength = 1 until 255
 val chatDescriptionLength = 0 until 256
@@ -55,12 +59,20 @@ val botCommandLimit = botCommandLengthLimit
 val botCommandDescriptionLimit = 3 .. 256
 val botCommandsLimit = 0 .. 100
 
+val mediaCountInMediaGroup: IntRange = 2 .. 10
+
 val explanationLimit = 0 .. 200
 @Deprecated("Will be removed in near updates", ReplaceWith("explanationLimit"))
 val quizPollExplanationLimit = explanationLimit
 
 val openPeriodPollSecondsLimit = 5 .. 600
 
+val telegramInlineModeGifPermittedMimeTypes = listOf(
+    BuiltinMimeTypes.Image.Jpg,
+    BuiltinMimeTypes.Image.Gif,
+    BuiltinMimeTypes.Video.MP4
+)
+
 const val chatIdField = "chat_id"
 const val messageIdField = "message_id"
 const val updateIdField = "update_id"
@@ -175,6 +187,7 @@ const val stickerFileIdField = "sticker_file_id"
 const val gameShortNameField = "game_short_name"
 
 const val thumbUrlField = "thumb_url"
+const val thumbMimeTypeField = "thumb_mime_type"
 const val thumbWidthField = "thumb_width"
 const val thumbHeightField = "thumb_height"
 

TelegramBotAPI/src/commonMain/kotlin/com/github/insanusmokrassar/TelegramBotAPI/types/InlineQueries/InlineQueryResult/InlineQueryResultGifImpl.kt

@@ -7,6 +7,7 @@ import com.github.insanusmokrassar.TelegramBotAPI.types.InlineQueries.abstracts.
 import com.github.insanusmokrassar.TelegramBotAPI.types.ParseMode.ParseMode
 import com.github.insanusmokrassar.TelegramBotAPI.types.ParseMode.parseModeField
 import com.github.insanusmokrassar.TelegramBotAPI.types.buttons.InlineKeyboardMarkup
+import com.github.insanusmokrassar.TelegramBotAPI.utils.MimeType
 import kotlinx.serialization.SerialName
 import kotlinx.serialization.Serializable
 
@@ -18,6 +19,8 @@ data class InlineQueryResultGifImpl(
     override val url: String,
     @SerialName(thumbUrlField)
     override val thumbUrl: String,
+    @SerialName(thumbMimeTypeField)
+    override val thumbMimeType: MimeType? = null,
     @SerialName(gifWidthField)
     override val width: Int? = null,
     @SerialName(gifHeightField)
@@ -36,4 +39,10 @@ data class InlineQueryResultGifImpl(
     override val inputMessageContent: InputMessageContent? = null
 ) : InlineQueryResultGif {
     override val type: String = inlineQueryResultGifType
+
+    init {
+        if (thumbMimeType != null && thumbMimeType !in telegramInlineModeGifPermittedMimeTypes) {
+            error("Passed thumb mime type is not permitted in Telegram Bot API. Passed $thumbMimeType, but permitted $telegramInlineModeGifPermittedMimeTypes")
+        }
+    }
 }

TelegramBotAPI/src/commonMain/kotlin/com/github/insanusmokrassar/TelegramBotAPI/types/InlineQueries/InlineQueryResult/InlineQueryResultMpeg4GifImpl.kt

@@ -7,6 +7,7 @@ import com.github.insanusmokrassar.TelegramBotAPI.types.InlineQueries.abstracts.
 import com.github.insanusmokrassar.TelegramBotAPI.types.ParseMode.ParseMode
 import com.github.insanusmokrassar.TelegramBotAPI.types.ParseMode.parseModeField
 import com.github.insanusmokrassar.TelegramBotAPI.types.buttons.InlineKeyboardMarkup
+import com.github.insanusmokrassar.TelegramBotAPI.utils.MimeType
 import kotlinx.serialization.SerialName
 import kotlinx.serialization.Serializable
 
@@ -18,6 +19,8 @@ data class InlineQueryResultMpeg4GifImpl(
     override val url: String,
     @SerialName(thumbUrlField)
     override val thumbUrl: String,
+    @SerialName(thumbMimeTypeField)
+    override val thumbMimeType: MimeType? = null,
     @SerialName(mpeg4GifWidthField)
     override val width: Int? = null,
     @SerialName(mpeg4GifHeightField)
@@ -36,4 +39,10 @@ data class InlineQueryResultMpeg4GifImpl(
     override val inputMessageContent: InputMessageContent? = null
 ) : InlineQueryResultMpeg4Gif {
     override val type: String = inlineQueryResultMpeg4GifType
+
+    init {
+        if (thumbMimeType != null && thumbMimeType !in telegramInlineModeGifPermittedMimeTypes) {
+            error("Passed thumb mime type is not permitted in Telegram Bot API. Passed $thumbMimeType, but permitted $telegramInlineModeGifPermittedMimeTypes")
+        }
+    }
 }

TelegramBotAPI/src/commonMain/kotlin/com/github/insanusmokrassar/TelegramBotAPI/types/InlineQueries/InlineQueryResult/abstracts/PositionedInlineQueryResult.kt

@@ -2,4 +2,5 @@ package com.github.insanusmokrassar.TelegramBotAPI.types.InlineQueries.InlineQue
 
 import com.github.insanusmokrassar.TelegramBotAPI.CommonAbstracts.Locationed
 
+@Deprecated("Will be removed due to useless")
 interface PositionedInlineQueryResult : InlineQueryResult, Locationed

TelegramBotAPI/src/commonMain/kotlin/com/github/insanusmokrassar/TelegramBotAPI/types/InlineQueries/InlineQueryResult/abstracts/ThumbedInlineQueryResult.kt

@@ -1,5 +1,11 @@
 package com.github.insanusmokrassar.TelegramBotAPI.types.InlineQueries.InlineQueryResult.abstracts
 
+import com.github.insanusmokrassar.TelegramBotAPI.utils.MimeType
+
 interface ThumbedInlineQueryResult : InlineQueryResult {
     val thumbUrl: String?
+}
+
+interface ThumbedWithMimeTypeInlineQueryResult : ThumbedInlineQueryResult {
+    val thumbMimeType: MimeType?
 }

TelegramBotAPI/src/commonMain/kotlin/com/github/insanusmokrassar/TelegramBotAPI/types/InlineQueries/InlineQueryResult/abstracts/results/gif/InlineQueryResultGif.kt

@@ -2,4 +2,4 @@ package com.github.insanusmokrassar.TelegramBotAPI.types.InlineQueries.InlineQue
 
 import com.github.insanusmokrassar.TelegramBotAPI.types.InlineQueries.InlineQueryResult.abstracts.*
 
-interface InlineQueryResultGif : InlineQueryResultGifCommon, UrlInlineQueryResult, ThumbedInlineQueryResult, SizedInlineQueryResult, DuratedInlineResultQuery
+interface InlineQueryResultGif : InlineQueryResultGifCommon, UrlInlineQueryResult, ThumbedWithMimeTypeInlineQueryResult, SizedInlineQueryResult, DuratedInlineResultQuery

TelegramBotAPI/src/commonMain/kotlin/com/github/insanusmokrassar/TelegramBotAPI/types/InlineQueries/InlineQueryResult/abstracts/results/mpeg4gif/InlineQueryResultMpeg4Gif.kt

@@ -2,4 +2,4 @@ package com.github.insanusmokrassar.TelegramBotAPI.types.InlineQueries.InlineQue
 
 import com.github.insanusmokrassar.TelegramBotAPI.types.InlineQueries.InlineQueryResult.abstracts.*
 
-interface InlineQueryResultMpeg4Gif : InlineQueryResultMpeg4GifCommon, UrlInlineQueryResult, ThumbedInlineQueryResult, SizedInlineQueryResult, DuratedInlineResultQuery
+interface InlineQueryResultMpeg4Gif : InlineQueryResultMpeg4GifCommon, UrlInlineQueryResult, ThumbedWithMimeTypeInlineQueryResult, SizedInlineQueryResult, DuratedInlineResultQuery

TelegramBotAPI/src/commonMain/kotlin/com/github/insanusmokrassar/TelegramBotAPI/types/Venue.kt

@@ -1,19 +1,6 @@
 package com.github.insanusmokrassar.TelegramBotAPI.types
 
-import com.github.insanusmokrassar.TelegramBotAPI.CommonAbstracts.CommonVenueData
-import kotlinx.serialization.SerialName
-import kotlinx.serialization.Serializable
+import com.github.insanusmokrassar.TelegramBotAPI.types.venue.Venue
 
-@Serializable
-data class Venue(
-    @SerialName(locationField)
-    val location: Location,
-    @SerialName(titleField)
-    override val title: String,
-    @SerialName(addressField)
-    override val address: String,
-    @SerialName(foursquareIdField)
-    override val foursquareId: String? = null,
-    @SerialName(foursquareTypeField)
-    override val foursquareType: String? = null
-) : CommonVenueData
+@Deprecated("Replaced", ReplaceWith("Venue", "com.github.insanusmokrassar.TelegramBotAPI.types.venue.Venue"))
+typealias Venue = Venue

TelegramBotAPI/src/commonMain/kotlin/com/github/insanusmokrassar/TelegramBotAPI/types/WebhookInfo.kt

@@ -7,7 +7,7 @@ data class WebhookInfo(
     @SerialName(urlField)
     val url: String,
     @SerialName(pendingUpdateCountField)
-    val awaitDeliery: Int,
+    val awaitDelivery: Int,
     @SerialName(maxAllowedConnectionsField)
     val maxConnections: Int = 40, // default count according to documentation
     @SerialName(hasCustomCertificateField)

TelegramBotAPI/src/commonMain/kotlin/com/github/insanusmokrassar/TelegramBotAPI/types/dice/DiceAnimationType.kt

@@ -15,9 +15,15 @@ object DartsDiceAnimationType : DiceAnimationType() {
     override val emoji: String = "\uD83C\uDFAF"
 }
 @Serializable(DiceAnimationTypeSerializer::class)
-class UnknownDiceAnimationType(
+object BasketballDiceAnimationType : DiceAnimationType() {
+    override val emoji: String = "\uD83C\uDFC0"
+}
+@Serializable(DiceAnimationTypeSerializer::class)
+data class CustomDiceAnimationType(
     override val emoji: String
 ) : DiceAnimationType()
+@Deprecated("Renamed", ReplaceWith("CustomDiceAnimationType"))
+typealias UnknownDiceAnimationType = CustomDiceAnimationType
 
 @Serializer(DiceAnimationType::class)
 internal object DiceAnimationTypeSerializer : KSerializer<DiceAnimationType> {
@@ -26,7 +32,8 @@ internal object DiceAnimationTypeSerializer : KSerializer<DiceAnimationType> {
         return when (val type = decoder.decodeString()) {
             CubeDiceAnimationType.emoji -> CubeDiceAnimationType
             DartsDiceAnimationType.emoji -> DartsDiceAnimationType
-            else -> UnknownDiceAnimationType(type)
+            BasketballDiceAnimationType.emoji -> BasketballDiceAnimationType
+            else -> CustomDiceAnimationType(type)
         }
     }
 

TelegramBotAPI/src/commonMain/kotlin/com/github/insanusmokrassar/TelegramBotAPI/types/message/ChannelMessage.kt

@@ -1,12 +1,11 @@
 package com.github.insanusmokrassar.TelegramBotAPI.types.message
 
-import com.github.insanusmokrassar.TelegramBotAPI.types.AuthorSignature
-import com.github.insanusmokrassar.TelegramBotAPI.types.MessageIdentifier
+import com.github.insanusmokrassar.TelegramBotAPI.types.*
 import com.github.insanusmokrassar.TelegramBotAPI.types.buttons.InlineKeyboardMarkup
 import com.github.insanusmokrassar.TelegramBotAPI.types.chat.abstracts.Chat
-import com.github.insanusmokrassar.TelegramBotAPI.types.message.abstracts.CommonMessage
 import com.github.insanusmokrassar.TelegramBotAPI.types.message.abstracts.Message
 import com.github.insanusmokrassar.TelegramBotAPI.types.message.content.abstracts.MessageContent
+import com.github.insanusmokrassar.TelegramBotAPI.types.message.content.abstracts.PossiblySentViaBotCommonMessage
 import com.soywiz.klock.DateTime
 
 data class ChannelMessage<T: MessageContent>(
@@ -18,5 +17,6 @@ data class ChannelMessage<T: MessageContent>(
     override val forwardInfo: ForwardInfo?,
     override val replyTo: Message?,
     override val replyMarkup: InlineKeyboardMarkup?,
+    override val senderBot: CommonBot?,
     val authorSignature: AuthorSignature?
-) : CommonMessage<T>
+) : PossiblySentViaBotCommonMessage<T>

TelegramBotAPI/src/commonMain/kotlin/com/github/insanusmokrassar/TelegramBotAPI/types/message/CommonMessageImpl.kt

@@ -1,11 +1,12 @@
 package com.github.insanusmokrassar.TelegramBotAPI.types.message
 
-import com.github.insanusmokrassar.TelegramBotAPI.types.MessageIdentifier
-import com.github.insanusmokrassar.TelegramBotAPI.types.User
+import com.github.insanusmokrassar.TelegramBotAPI.types.*
 import com.github.insanusmokrassar.TelegramBotAPI.types.buttons.InlineKeyboardMarkup
 import com.github.insanusmokrassar.TelegramBotAPI.types.chat.abstracts.Chat
-import com.github.insanusmokrassar.TelegramBotAPI.types.message.abstracts.*
+import com.github.insanusmokrassar.TelegramBotAPI.types.message.abstracts.FromUserMessage
+import com.github.insanusmokrassar.TelegramBotAPI.types.message.abstracts.Message
 import com.github.insanusmokrassar.TelegramBotAPI.types.message.content.abstracts.MessageContent
+import com.github.insanusmokrassar.TelegramBotAPI.types.message.content.abstracts.PossiblySentViaBotCommonMessage
 import com.github.insanusmokrassar.TelegramBotAPI.types.message.payments.SuccessfulPaymentInfo
 import com.soywiz.klock.DateTime
 
@@ -19,5 +20,6 @@ data class CommonMessageImpl<T: MessageContent>(
     override val forwardInfo: ForwardInfo?,
     override val replyTo: Message?,
     override val replyMarkup: InlineKeyboardMarkup?,
+    override val senderBot: CommonBot?,
     val paymentInfo: SuccessfulPaymentInfo?
-) : Message, CommonMessage<T>, FromUserMessage
+) : PossiblySentViaBotCommonMessage<T>, FromUserMessage

TelegramBotAPI/src/commonMain/kotlin/com/github/insanusmokrassar/TelegramBotAPI/types/message/RawMessage.kt

@@ -20,6 +20,7 @@ import com.github.insanusmokrassar.TelegramBotAPI.types.message.payments.Success
 import com.github.insanusmokrassar.TelegramBotAPI.types.payments.Invoice
 import com.github.insanusmokrassar.TelegramBotAPI.types.payments.SuccessfulPayment
 import com.github.insanusmokrassar.TelegramBotAPI.types.polls.Poll
+import com.github.insanusmokrassar.TelegramBotAPI.types.venue.Venue
 import kotlinx.serialization.SerialName
 import kotlinx.serialization.Serializable
 import kotlin.reflect.KClass
@@ -42,6 +43,7 @@ internal data class RawMessage(
     private val forward_sender_name: ForwardSenderName? = null,
     private val forward_date: TelegramDate? = null,
     private val reply_to_message: RawMessage? = null,
+    private val via_bot: CommonBot? = null,
     private val edit_date: TelegramDate? = null,
     private val media_group_id: MediaGroupIdentifier? = null,
     private val author_signature: AuthorSignature? = null,
@@ -147,7 +149,7 @@ internal data class RawMessage(
             )
             forward_from_chat is ChannelChat -> ForwardFromChannelInfo(
                 forward_date,
-                forward_from_message_id ?: throw IllegalStateException("Channel forwarded message must contain message id, but was not"),
+                forward_from_message_id ?: error("Channel forwarded message must contain message id, but was not"),
                 forward_from_chat,
                 forward_signature
             )
@@ -208,7 +210,7 @@ internal data class RawMessage(
                         chatEvent as? ChannelEvent ?: throwWrongChatEvent(ChannelEvent::class, chatEvent),
                         date.asDate
                     )
-                    else -> throw IllegalStateException("Expected one of the public chats, but was $chat (in extracting of chat event message)")
+                    else -> error("Expected one of the public chats, but was $chat (in extracting of chat event message)")
                 }
             } ?: content?.let { content ->
                 media_group_id?.let {
@@ -221,7 +223,7 @@ internal data class RawMessage(
                             when (content) {
                                 is PhotoContent -> content
                                 is VideoContent -> content
-                                else -> throw IllegalStateException("Unsupported content for media group")
+                                else -> error("Unsupported content for media group")
                             },
                             edit_date?.asDate,
                             forwarded,
@@ -237,7 +239,7 @@ internal data class RawMessage(
                             when (content) {
                                 is PhotoContent -> content
                                 is VideoContent -> content
-                                else -> throw IllegalStateException("Unsupported content for media group")
+                                else -> error("Unsupported content for media group")
                             },
                             edit_date?.asDate,
                             forwarded,
@@ -255,12 +257,12 @@ internal data class RawMessage(
                         forwarded,
                         reply_to_message?.asMessage,
                         reply_markup,
+                        via_bot,
                         author_signature
                     )
                     else -> CommonMessageImpl(
                         messageId,
-                        from
-                            ?: throw IllegalStateException("Was detected common message, but owner (sender) of the message was not found"),
+                        from ?: error("Was detected common message, but owner (sender) of the message was not found"),
                         chat,
                         content,
                         date.asDate,
@@ -268,10 +270,11 @@ internal data class RawMessage(
                         forwarded,
                         reply_to_message?.asMessage,
                         reply_markup,
+                        via_bot,
                         paymentInfo
                     )
                 }
-            } ?: throw IllegalStateException("Was not found supported type of data")
+            } ?: error("Was not found supported type of data")
         } catch (e: Exception) {
             UnknownMessageType(
                 messageId,
@@ -283,6 +286,6 @@ internal data class RawMessage(
     }
 
     private fun throwWrongChatEvent(expected: KClass<*>, but: ChatEvent): CommonEvent {
-        throw IllegalStateException("Wrong type of chat event: expected $expected, but was $but")
+        error("Wrong type of chat event: expected $expected, but was $but")
     }
 }

TelegramBotAPI/src/commonMain/kotlin/com/github/insanusmokrassar/TelegramBotAPI/types/message/abstracts/PossiblySentViaBot.kt

@@ -0,0 +1,7 @@
+package com.github.insanusmokrassar.TelegramBotAPI.types.message.abstracts
+
+import com.github.insanusmokrassar.TelegramBotAPI.types.CommonBot
+
+interface PossiblySentViaBot {
+    val senderBot: CommonBot?
+}

TelegramBotAPI/src/commonMain/kotlin/com/github/insanusmokrassar/TelegramBotAPI/types/message/content/VenueContent.kt

@@ -2,10 +2,12 @@ package com.github.insanusmokrassar.TelegramBotAPI.types.message.content
 
 import com.github.insanusmokrassar.TelegramBotAPI.requests.abstracts.Request
 import com.github.insanusmokrassar.TelegramBotAPI.requests.send.SendVenue
-import com.github.insanusmokrassar.TelegramBotAPI.types.*
+import com.github.insanusmokrassar.TelegramBotAPI.types.ChatIdentifier
+import com.github.insanusmokrassar.TelegramBotAPI.types.MessageIdentifier
 import com.github.insanusmokrassar.TelegramBotAPI.types.buttons.KeyboardMarkup
 import com.github.insanusmokrassar.TelegramBotAPI.types.message.abstracts.ContentMessage
 import com.github.insanusmokrassar.TelegramBotAPI.types.message.content.abstracts.MessageContent
+import com.github.insanusmokrassar.TelegramBotAPI.types.venue.Venue
 
 data class VenueContent(
     val venue: Venue

TelegramBotAPI/src/commonMain/kotlin/com/github/insanusmokrassar/TelegramBotAPI/types/message/content/abstracts/PossiblySentViaBotCommonMessage.kt

@@ -0,0 +1,6 @@
+package com.github.insanusmokrassar.TelegramBotAPI.types.message.content.abstracts
+
+import com.github.insanusmokrassar.TelegramBotAPI.types.message.abstracts.CommonMessage
+import com.github.insanusmokrassar.TelegramBotAPI.types.message.abstracts.PossiblySentViaBot
+
+interface PossiblySentViaBotCommonMessage<T: MessageContent> : CommonMessage<T>, PossiblySentViaBot

TelegramBotAPI/src/commonMain/kotlin/com/github/insanusmokrassar/TelegramBotAPI/types/update/MediaGroupUpdates/MediaGroupUpdate.kt

@@ -3,6 +3,13 @@ package com.github.insanusmokrassar.TelegramBotAPI.types.update.MediaGroupUpdate
 import com.github.insanusmokrassar.TelegramBotAPI.types.message.abstracts.MediaGroupMessage
 import com.github.insanusmokrassar.TelegramBotAPI.types.update.abstracts.*
 
+/**
+ * By default there is no instances of objects which could be deserialized from raw updates. If you want to get objects
+ * with this type, you should use something like [com.github.insanusmokrassar.TelegramBotAPI.extensions.api.SetWebhookKt.includeWebhookInRoute]
+ *
+ * @see com.github.insanusmokrassar.TelegramBotAPI.extensions.api.SetWebhookKt.includeWebhookInRoute
+ * @see com.github.insanusmokrassar.TelegramBotAPI.extensions.api.updates.UpdatesPollingKt.startGettingOfUpdates
+ */
 interface MediaGroupUpdate : Update
 
 interface SentMediaGroupUpdate: MediaGroupUpdate {

TelegramBotAPI/src/commonMain/kotlin/com/github/insanusmokrassar/TelegramBotAPI/types/update/RawUpdate.kt

@@ -9,7 +9,7 @@ import com.github.insanusmokrassar.TelegramBotAPI.types.payments.PreCheckoutQuer
 import com.github.insanusmokrassar.TelegramBotAPI.types.payments.ShippingQuery
 import com.github.insanusmokrassar.TelegramBotAPI.types.polls.Poll
 import com.github.insanusmokrassar.TelegramBotAPI.types.polls.PollAnswer
-import com.github.insanusmokrassar.TelegramBotAPI.types.update.abstracts.UnknownUpdateType
+import com.github.insanusmokrassar.TelegramBotAPI.types.update.abstracts.UnknownUpdate
 import com.github.insanusmokrassar.TelegramBotAPI.types.update.abstracts.Update
 import com.github.insanusmokrassar.TelegramBotAPI.types.updateIdField
 import kotlinx.serialization.*
@@ -57,7 +57,7 @@ internal data class RawUpdate constructor(
                 pre_checkout_query != null -> PreCheckoutQueryUpdate(updateId, pre_checkout_query)
                 poll != null -> PollUpdate(updateId, poll)
                 poll_answer != null -> PollAnswerUpdate(updateId, poll_answer)
-                else -> UnknownUpdateType(
+                else -> UnknownUpdate(
                     updateId,
                     raw.toString(),
                     raw
@@ -66,7 +66,7 @@ internal data class RawUpdate constructor(
         } catch (e: Error) {
             when (e) {
                 is SerializationException,
-                is NotImplementedError -> UnknownUpdateType(
+                is NotImplementedError -> UnknownUpdate(
                     updateId,
                     raw.toString(),
                     raw

TelegramBotAPI/src/commonMain/kotlin/com/github/insanusmokrassar/TelegramBotAPI/types/update/abstracts/Update.kt

@@ -12,11 +12,13 @@ interface Update {
     val data: Any
 }
 
-data class UnknownUpdateType(
+data class UnknownUpdate(
     override val updateId: UpdateIdentifier,
     override val data: String,
     val rawJson: JsonElement
 ) : Update
+@Deprecated("Renamed", ReplaceWith("UnknownUpdate"))
+typealias UnknownUpdateType = UnknownUpdate
 
 internal object UpdateSerializerWithoutSerialization : KSerializer<Update> {
     override val descriptor: SerialDescriptor = JsonElementSerializer.descriptor
@@ -26,7 +28,14 @@ internal object UpdateSerializerWithoutSerialization : KSerializer<Update> {
     override fun serialize(encoder: Encoder, value: Update) = throw UnsupportedOperationException()
 }
 
-internal object UpdateDeserializationStrategy : DeserializationStrategy<Update> {
+/**
+ * Use this object to deserialize objects with type [Update]. Currently it is restricted to use this
+ * [DeserializationStrategy] only with JSON
+ *
+ * @see StringFormat.parse
+ * @see kotlinx.serialization.json.Json.parse
+ */
+object UpdateDeserializationStrategy : DeserializationStrategy<Update> {
     override val descriptor: SerialDescriptor = JsonElementSerializer.descriptor
 
     override fun patch(decoder: Decoder, old: Update): Update = throw UpdateNotSupportedException("Update")

TelegramBotAPI/src/commonMain/kotlin/com/github/insanusmokrassar/TelegramBotAPI/types/venue/Venue.kt

@@ -0,0 +1,21 @@
+package com.github.insanusmokrassar.TelegramBotAPI.types.venue
+
+import com.github.insanusmokrassar.TelegramBotAPI.CommonAbstracts.CommonVenueData
+import com.github.insanusmokrassar.TelegramBotAPI.CommonAbstracts.Locationed
+import com.github.insanusmokrassar.TelegramBotAPI.types.*
+import kotlinx.serialization.SerialName
+import kotlinx.serialization.Serializable
+
+@Serializable
+data class Venue(
+    @SerialName(locationField)
+    val location: Location,
+    @SerialName(titleField)
+    override val title: String,
+    @SerialName(addressField)
+    override val address: String,
+    @SerialName(foursquareIdField)
+    override val foursquareId: FoursquareId? = null,
+    @SerialName(foursquareTypeField)
+    override val foursquareType: FoursquareType? = null
+) : CommonVenueData, Locationed by location

TelegramBotAPI/src/commonMain/kotlin/com/github/insanusmokrassar/TelegramBotAPI/updateshandlers/FlowsUpdatesFilter.kt

@@ -1,75 +1,41 @@
 package com.github.insanusmokrassar.TelegramBotAPI.updateshandlers
 
+import com.github.insanusmokrassar.TelegramBotAPI.types.ALL_UPDATES_LIST
 import com.github.insanusmokrassar.TelegramBotAPI.types.update.*
 import com.github.insanusmokrassar.TelegramBotAPI.types.update.MediaGroupUpdates.*
+import com.github.insanusmokrassar.TelegramBotAPI.types.update.abstracts.UnknownUpdate
 import com.github.insanusmokrassar.TelegramBotAPI.types.update.abstracts.Update
-import kotlinx.coroutines.FlowPreview
 import kotlinx.coroutines.channels.BroadcastChannel
-import kotlinx.coroutines.channels.Channel
-import kotlinx.coroutines.flow.Flow
-import kotlinx.coroutines.flow.asFlow
+import kotlinx.coroutines.flow.*
 
-private fun <T> BroadcastChannel<T>.createUpdateReceiver(): UpdateReceiver<T> = ::send
-
-@FlowPreview
+@Suppress("EXPERIMENTAL_API_USAGE", "unused")
 class FlowsUpdatesFilter(
-    broadcastChannelsSize: Int = Channel.CONFLATED
+    broadcastChannelsSize: Int = 100
 ): UpdatesFilter {
-    private val messageChannel: BroadcastChannel<MessageUpdate> = BroadcastChannel(broadcastChannelsSize)
-    private val messageMediaGroupChannel: BroadcastChannel<MessageMediaGroupUpdate> = BroadcastChannel(broadcastChannelsSize)
-    private val editedMessageChannel: BroadcastChannel<EditMessageUpdate> = BroadcastChannel(broadcastChannelsSize)
-    private val editedMessageMediaGroupChannel: BroadcastChannel<EditMessageMediaGroupUpdate> = BroadcastChannel(broadcastChannelsSize)
-    private val channelPostChannel: BroadcastChannel<ChannelPostUpdate> = BroadcastChannel(broadcastChannelsSize)
-    private val channelPostMediaGroupChannel: BroadcastChannel<ChannelPostMediaGroupUpdate> = BroadcastChannel(broadcastChannelsSize)
-    private val editedChannelPostChannel: BroadcastChannel<EditChannelPostUpdate> = BroadcastChannel(broadcastChannelsSize)
-    private val editedChannelPostMediaGroupChannel: BroadcastChannel<EditChannelPostMediaGroupUpdate> = BroadcastChannel(broadcastChannelsSize)
-    private val chosenInlineResultChannel: BroadcastChannel<ChosenInlineResultUpdate> = BroadcastChannel(broadcastChannelsSize)
-    private val inlineQueryChannel: BroadcastChannel<InlineQueryUpdate> = BroadcastChannel(broadcastChannelsSize)
-    private val callbackQueryChannel: BroadcastChannel<CallbackQueryUpdate> = BroadcastChannel(broadcastChannelsSize)
-    private val shippingQueryChannel: BroadcastChannel<ShippingQueryUpdate> = BroadcastChannel(broadcastChannelsSize)
-    private val preCheckoutQueryChannel: BroadcastChannel<PreCheckoutQueryUpdate> = BroadcastChannel(broadcastChannelsSize)
-    private val pollChannel: BroadcastChannel<PollUpdate> = BroadcastChannel(broadcastChannelsSize)
-    private val pollAnswerChannel: BroadcastChannel<PollAnswerUpdate> = BroadcastChannel(broadcastChannelsSize)
-    private val unknownUpdateChannel: BroadcastChannel<Update> = BroadcastChannel(broadcastChannelsSize)
+    private val updatesReceivingChannel = BroadcastChannel<Update>(broadcastChannelsSize)
+    @Suppress("MemberVisibilityCanBePrivate")
+    val allUpdatesFlow: Flow<Update> = updatesReceivingChannel.asFlow()
 
     override val allowedUpdates: List<String>
-        get() = filter.allowedUpdates
-    override val asUpdateReceiver: UpdateReceiver<Update>
-        get() = filter.asUpdateReceiver
+        get() = ALL_UPDATES_LIST
+    override val asUpdateReceiver: UpdateReceiver<Update> = {
+        updatesReceivingChannel.send(it)
+    }
 
-    val filter = SimpleUpdatesFilter(
-        messageChannel.createUpdateReceiver(),
-        messageMediaGroupChannel.createUpdateReceiver(),
-        editedMessageChannel.createUpdateReceiver(),
-        editedMessageMediaGroupChannel.createUpdateReceiver(),
-        channelPostChannel.createUpdateReceiver(),
-        channelPostMediaGroupChannel.createUpdateReceiver(),
-        editedChannelPostChannel.createUpdateReceiver(),
-        editedChannelPostMediaGroupChannel.createUpdateReceiver(),
-        chosenInlineResultChannel.createUpdateReceiver(),
-        inlineQueryChannel.createUpdateReceiver(),
-        callbackQueryChannel.createUpdateReceiver(),
-        shippingQueryChannel.createUpdateReceiver(),
-        preCheckoutQueryChannel.createUpdateReceiver(),
-        pollChannel.createUpdateReceiver(),
-        pollAnswerChannel.createUpdateReceiver(),
-        unknownUpdateChannel.createUpdateReceiver()
-    )
-
-    val messageFlow: Flow<MessageUpdate> = messageChannel.asFlow()
-    val messageMediaGroupFlow: Flow<MessageMediaGroupUpdate> = messageMediaGroupChannel.asFlow()
-    val editedMessageFlow: Flow<EditMessageUpdate> = editedMessageChannel.asFlow()
-    val editedMessageMediaGroupFlow: Flow<EditMessageMediaGroupUpdate> = editedMessageMediaGroupChannel.asFlow()
-    val channelPostFlow: Flow<ChannelPostUpdate> = channelPostChannel.asFlow()
-    val channelPostMediaGroupFlow: Flow<ChannelPostMediaGroupUpdate> = channelPostMediaGroupChannel.asFlow()
-    val editedChannelPostFlow: Flow<EditChannelPostUpdate> = editedChannelPostChannel.asFlow()
-    val editedChannelPostMediaGroupFlow: Flow<EditChannelPostMediaGroupUpdate> = editedChannelPostMediaGroupChannel.asFlow()
-    val chosenInlineResultFlow: Flow<ChosenInlineResultUpdate> = chosenInlineResultChannel.asFlow()
-    val inlineQueryFlow: Flow<InlineQueryUpdate> = inlineQueryChannel.asFlow()
-    val callbackQueryFlow: Flow<CallbackQueryUpdate> = callbackQueryChannel.asFlow()
-    val shippingQueryFlow: Flow<ShippingQueryUpdate> = shippingQueryChannel.asFlow()
-    val preCheckoutQueryFlow: Flow<PreCheckoutQueryUpdate> = preCheckoutQueryChannel.asFlow()
-    val pollFlow: Flow<PollUpdate> = pollChannel.asFlow()
-    val pollAnswerFlow: Flow<PollAnswerUpdate> = pollAnswerChannel.asFlow()
-    val unknownUpdateTypeFlow: Flow<Update> = unknownUpdateChannel.asFlow()
+    val messageFlow: Flow<MessageUpdate> = allUpdatesFlow.filterIsInstance()
+    val messageMediaGroupFlow: Flow<MessageMediaGroupUpdate> = allUpdatesFlow.filterIsInstance()
+    val editedMessageFlow: Flow<EditMessageUpdate> = allUpdatesFlow.filterIsInstance()
+    val editedMessageMediaGroupFlow: Flow<EditMessageMediaGroupUpdate> = allUpdatesFlow.filterIsInstance()
+    val channelPostFlow: Flow<ChannelPostUpdate> = allUpdatesFlow.filterIsInstance()
+    val channelPostMediaGroupFlow: Flow<ChannelPostMediaGroupUpdate> = allUpdatesFlow.filterIsInstance()
+    val editedChannelPostFlow: Flow<EditChannelPostUpdate> = allUpdatesFlow.filterIsInstance()
+    val editedChannelPostMediaGroupFlow: Flow<EditChannelPostMediaGroupUpdate> = allUpdatesFlow.filterIsInstance()
+    val chosenInlineResultFlow: Flow<ChosenInlineResultUpdate> = allUpdatesFlow.filterIsInstance()
+    val inlineQueryFlow: Flow<InlineQueryUpdate> = allUpdatesFlow.filterIsInstance()
+    val callbackQueryFlow: Flow<CallbackQueryUpdate> = allUpdatesFlow.filterIsInstance()
+    val shippingQueryFlow: Flow<ShippingQueryUpdate> = allUpdatesFlow.filterIsInstance()
+    val preCheckoutQueryFlow: Flow<PreCheckoutQueryUpdate> = allUpdatesFlow.filterIsInstance()
+    val pollFlow: Flow<PollUpdate> = allUpdatesFlow.filterIsInstance()
+    val pollAnswerFlow: Flow<PollAnswerUpdate> = allUpdatesFlow.filterIsInstance()
+    val unknownUpdateTypeFlow: Flow<UnknownUpdate> = allUpdatesFlow.filterIsInstance()
 }

TelegramBotAPI/src/commonMain/kotlin/com/github/insanusmokrassar/TelegramBotAPI/updateshandlers/UpdatesFilter.kt

@@ -3,7 +3,7 @@ package com.github.insanusmokrassar.TelegramBotAPI.updateshandlers
 import com.github.insanusmokrassar.TelegramBotAPI.types.*
 import com.github.insanusmokrassar.TelegramBotAPI.types.update.*
 import com.github.insanusmokrassar.TelegramBotAPI.types.update.MediaGroupUpdates.*
-import com.github.insanusmokrassar.TelegramBotAPI.types.update.abstracts.UnknownUpdateType
+import com.github.insanusmokrassar.TelegramBotAPI.types.update.abstracts.UnknownUpdate
 import com.github.insanusmokrassar.TelegramBotAPI.types.update.abstracts.Update
 
 typealias UpdateReceiver<T> = suspend (T) -> Unit
@@ -29,7 +29,7 @@ data class SimpleUpdatesFilter(
     private val preCheckoutQueryCallback: UpdateReceiver<PreCheckoutQueryUpdate>? = null,
     private val pollUpdateCallback: UpdateReceiver<PollUpdate>? = null,
     private val pollAnswerUpdateCallback: UpdateReceiver<PollAnswerUpdate>? = null,
-    private val unknownUpdateTypeCallback: UpdateReceiver<UnknownUpdateType>? = null
+    private val unknownUpdateTypeCallback: UpdateReceiver<UnknownUpdate>? = null
 ) : UpdatesFilter {
     override val asUpdateReceiver: UpdateReceiver<Update> = this::invoke
     override val allowedUpdates = listOfNotNull(
@@ -83,7 +83,7 @@ data class SimpleUpdatesFilter(
             is PreCheckoutQueryUpdate -> preCheckoutQueryCallback ?.invoke(update)
             is PollUpdate -> pollUpdateCallback ?.invoke(update)
             is PollAnswerUpdate -> pollAnswerUpdateCallback ?.invoke(update)
-            is UnknownUpdateType -> unknownUpdateTypeCallback ?.invoke(update)
+            is UnknownUpdate -> unknownUpdateTypeCallback ?.invoke(update)
         }
     }
 }
@@ -101,7 +101,7 @@ fun createSimpleUpdateFilter(
     preCheckoutQueryCallback: UpdateReceiver<PreCheckoutQueryUpdate>? = null,
     pollCallback: UpdateReceiver<PollUpdate>? = null,
     pollAnswerCallback: UpdateReceiver<PollAnswerUpdate>? = null,
-    unknownCallback: UpdateReceiver<UnknownUpdateType>? = null
+    unknownCallback: UpdateReceiver<UnknownUpdate>? = null
 ): UpdatesFilter = SimpleUpdatesFilter(
     messageCallback = messageCallback,
     messageMediaGroupCallback = mediaGroupCallback,

TelegramBotAPI/src/commonMain/kotlin/com/github/insanusmokrassar/TelegramBotAPI/utils/Annotations.kt

@@ -1,7 +1,7 @@
 package com.github.insanusmokrassar.TelegramBotAPI.utils
 
 @RequiresOptIn(
-    "It is possible, that behaviour of this thing will be changed later",
+    "It is possible, that behaviour of this thing will be changed later or this feature will be removed",
     RequiresOptIn.Level.WARNING
 )
 @Target(

TelegramBotAPI/src/commonMain/kotlin/com/github/insanusmokrassar/TelegramBotAPI/utils/BuiltinMimeTypes.kt

@@ -0,0 +1,11 @@
+package com.github.insanusmokrassar.TelegramBotAPI.utils
+
+object BuiltinMimeTypes {
+    object Image {
+        val Jpg = buildMimeType("image/jpeg")
+        val Gif = buildMimeType("image/gif")
+    }
+    object Video {
+        val MP4 = buildMimeType("video/mp4")
+    }
+}

TelegramBotAPI/src/commonMain/kotlin/com/github/insanusmokrassar/TelegramBotAPI/utils/CaptionAndTextSourcesToText.kt

@@ -6,9 +6,10 @@ import com.github.insanusmokrassar.TelegramBotAPI.types.ParseMode.*
 import com.github.insanusmokrassar.TelegramBotAPI.types.message.content.TextContent
 import com.github.insanusmokrassar.TelegramBotAPI.types.message.content.fullEntitiesList
 
+@Deprecated("Replaced into TelegramBotAPI-extensions-utils")
 fun createFormattedText(
     entities: FullTextSourcesList,
-    partLength: Int = 4096,
+    partLength: Int = textLength.last,
     mode: ParseMode = MarkdownParseMode
 ): List<String> {
     val texts = mutableListOf<String>()
@@ -47,75 +48,96 @@ fun createFormattedText(
 }
 
 
+@Deprecated("Replaced into TelegramBotAPI-extensions-utils")
 fun createMarkdownText(
     entities: FullTextSourcesList,
-    partLength: Int = 4096
+    partLength: Int = textLength.last
 ): List<String> = createFormattedText(entities, partLength, MarkdownParseMode)
 
+@Deprecated("Replaced into TelegramBotAPI-extensions-utils")
 fun FullTextSourcesList.toMarkdownCaptions(): List<String> = createMarkdownText(
     this,
-    captionLength.last + 1
+    captionLength.last
 )
+@Deprecated("Replaced into TelegramBotAPI-extensions-utils")
 fun CaptionedInput.toMarkdownCaptions(): List<String> = fullEntitiesList().toMarkdownCaptions()
 
+@Deprecated("Replaced into TelegramBotAPI-extensions-utils")
 fun FullTextSourcesList.toMarkdownTexts(): List<String> = createMarkdownText(
     this,
-    textLength.last + 1
+    textLength.last
 )
+@Deprecated("Replaced into TelegramBotAPI-extensions-utils")
 fun TextContent.toMarkdownTexts(): List<String> = fullEntitiesList().toMarkdownTexts()
 
+@Deprecated("Replaced into TelegramBotAPI-extensions-utils")
 fun FullTextSourcesList.toMarkdownExplanations(): List<String> = createMarkdownText(
     this,
-    explanationLimit.last + 1
+    explanationLimit.last
 )
+@Deprecated("Replaced into TelegramBotAPI-extensions-utils")
 fun ExplainedInput.toMarkdownExplanations(): List<String> = fullEntitiesList().toMarkdownTexts()
 
 
+@Deprecated("Replaced into TelegramBotAPI-extensions-utils")
 fun createMarkdownV2Text(
     entities: FullTextSourcesList,
-    partLength: Int = 4096
+    partLength: Int = textLength.last
 ): List<String> = createFormattedText(entities, partLength, MarkdownV2ParseMode)
 
+@Deprecated("Replaced into TelegramBotAPI-extensions-utils")
 fun FullTextSourcesList.toMarkdownV2Captions(): List<String> = createMarkdownV2Text(
     this,
-    captionLength.last + 1
+    captionLength.last
 )
+@Deprecated("Replaced into TelegramBotAPI-extensions-utils")
 fun CaptionedInput.toMarkdownV2Captions(): List<String> = fullEntitiesList().toMarkdownV2Captions()
 
+@Deprecated("Replaced into TelegramBotAPI-extensions-utils")
 fun FullTextSourcesList.toMarkdownV2Texts(): List<String> = createMarkdownV2Text(
     this,
-    textLength.last + 1
+    textLength.last
 )
+@Deprecated("Replaced into TelegramBotAPI-extensions-utils")
 fun TextContent.toMarkdownV2Texts(): List<String> = fullEntitiesList().toMarkdownV2Texts()
 
+@Deprecated("Replaced into TelegramBotAPI-extensions-utils")
 fun FullTextSourcesList.toMarkdownV2Explanations(): List<String> = createMarkdownV2Text(
     this,
-    explanationLimit.last + 1
+    explanationLimit.last
 )
+@Deprecated("Replaced into TelegramBotAPI-extensions-utils")
 fun ExplainedInput.toMarkdownV2Explanations(): List<String> = fullEntitiesList().toMarkdownV2Texts()
 
 
+@Deprecated("Replaced into TelegramBotAPI-extensions-utils")
 fun createHtmlText(
     entities: FullTextSourcesList,
-    partLength: Int = 4096
+    partLength: Int = textLength.last
 ): List<String> = createFormattedText(entities, partLength, HTMLParseMode)
 
+@Deprecated("Replaced into TelegramBotAPI-extensions-utils")
 fun FullTextSourcesList.toHtmlCaptions(): List<String> = createHtmlText(
     this,
-    captionLength.last + 1
+    captionLength.last
 )
+@Deprecated("Replaced into TelegramBotAPI-extensions-utils")
 fun CaptionedInput.toHtmlCaptions(): List<String> = fullEntitiesList().toHtmlCaptions()
 
+@Deprecated("Replaced into TelegramBotAPI-extensions-utils")
 fun FullTextSourcesList.toHtmlTexts(): List<String> = createHtmlText(
     this,
-    textLength.last + 1
+    textLength.last
 )
+@Deprecated("Replaced into TelegramBotAPI-extensions-utils")
 fun TextContent.toHtmlTexts(): List<String> = fullEntitiesList().toHtmlTexts()
 
+@Deprecated("Replaced into TelegramBotAPI-extensions-utils")
 fun FullTextSourcesList.toHtmlExplanations(): List<String> = createHtmlText(
     this,
-    explanationLimit.last + 1
+    explanationLimit.last
 )
+@Deprecated("Replaced into TelegramBotAPI-extensions-utils")
 fun ExplainedInput.toHtmlExplanations(): List<String> = fullEntitiesList().toHtmlTexts()
 
 

TelegramBotAPI/src/commonMain/kotlin/com/github/insanusmokrassar/TelegramBotAPI/utils/HandleSafely.kt

@@ -3,6 +3,8 @@ package com.github.insanusmokrassar.TelegramBotAPI.utils
 import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.supervisorScope
 
+
+typealias ExceptionHandler<T> = suspend (Exception) -> T
 /**
  * It will run [block] inside of [supervisorScope] to avoid problems with catching of exceptions
  *
@@ -10,7 +12,7 @@ import kotlinx.coroutines.supervisorScope
  * exception will be available for catching
  */
 suspend inline fun <T> handleSafely(
-    noinline onException: suspend (Exception) -> T = { throw it },
+    noinline onException: ExceptionHandler<T> = { throw it },
     noinline block: suspend CoroutineScope.() -> T
 ): T {
     return try {

TelegramBotAPI/src/commonMain/kotlin/com/github/insanusmokrassar/TelegramBotAPI/utils/LinksFormatting.kt

@@ -7,6 +7,7 @@ import com.github.insanusmokrassar.TelegramBotAPI.types.chat.abstracts.extended.
 
 private const val internalLinkBeginning = "https://t.me"
 
+@Deprecated("Replaced into TelegramBotAPI-extensions-utils project")
 fun makeLinkToMessage(
     username: String,
     messageId: MessageIdentifier
@@ -15,6 +16,7 @@ fun makeLinkToMessage(
 private val linkIdRedundantPartRegex = Regex("^-100")
 private val usernameBeginSymbolRegex = Regex("^@")
 
+@Deprecated("Replaced into TelegramBotAPI-extensions-utils project")
 fun makeLinkToMessage(
     chat: ExtendedChat,
     messageId: MessageIdentifier

TelegramBotAPI/src/commonMain/kotlin/com/github/insanusmokrassar/TelegramBotAPI/utils/Matrix.kt

@@ -10,16 +10,35 @@ fun <T> MatrixBuilder<T>.row(block: RowBuilder<T>.() -> Unit) {
     add(RowBuilder<T>().also(block).row)
 }
 
+fun <T> MatrixBuilder<T>.row(vararg elements: T) {
+    add(elements.toList())
+}
+
 fun <T> matrix(block: MatrixBuilder<T>.() -> Unit): Matrix<T> {
     return MatrixBuilder<T>().also(block).matrix
 }
 
+fun <T> flatMatrix(block: RowBuilder<T>.() -> Unit): Matrix<T> {
+    return MatrixBuilder<T>().apply {
+        row(block)
+    }.matrix
+}
+
+fun <T> flatMatrix(vararg elements: T): Matrix<T> {
+    return MatrixBuilder<T>().apply {
+        row { elements.forEach { +it } }
+    }.matrix
+}
+
+operator fun <T> RowBuilder<T>.plus(t: T) = add(t)
+
 class RowBuilder<T> {
     private val mutRow: MutableList<T> = ArrayList()
     val row: List<T>
         get() = mutRow
 
     fun add(t: T) = mutRow.add(t)
+    operator fun T.unaryPlus() = add(this)
 }
 
 class MatrixBuilder<T> {

TelegramBotAPI/src/commonMain/kotlin/com/github/insanusmokrassar/TelegramBotAPI/utils/MediaGroupList.kt

@@ -6,18 +6,22 @@ import com.github.insanusmokrassar.TelegramBotAPI.types.message.ForwardInfo
 import com.github.insanusmokrassar.TelegramBotAPI.types.message.abstracts.*
 import com.github.insanusmokrassar.TelegramBotAPI.types.update.abstracts.BaseMessageUpdate
 
+@Deprecated("Replaced and updated inside of TelegramBotAPI-extensions-utils")
 val List<BaseMessageUpdate>.forwarded: ForwardInfo?
     get() = first().let {
         (it as? PossiblyForwardedMessage) ?.forwardInfo
     }
 
+@Deprecated("Replaced and updated inside of TelegramBotAPI-extensions-utils")
 val List<BaseMessageUpdate>.replyTo: Message?
     get() = first().let {
         (it as? PossiblyReplyMessage) ?.replyTo
     }
 
+@Deprecated("Replaced and updated inside of TelegramBotAPI-extensions-utils")
 val List<BaseMessageUpdate>.chat: Chat?
     get() = first().data.chat
 
+@Deprecated("Replaced and updated inside of TelegramBotAPI-extensions-utils")
 val List<BaseMessageUpdate>.mediaGroupId: MediaGroupIdentifier?
     get() = (first().data as? MediaGroupMessage) ?.mediaGroupId

TelegramBotAPI/src/commonMain/kotlin/com/github/insanusmokrassar/TelegramBotAPI/utils/MimeType.kt

@@ -7,5 +7,7 @@ expect class MimeType {
     val raw: String
 }
 
+expect fun buildMimeType(raw: String): MimeType
+
 @Serializer(MimeType::class)
 internal expect object MimeTypeSerializer : KSerializer<MimeType>

TelegramBotAPI/src/commonMain/kotlin/com/github/insanusmokrassar/TelegramBotAPI/utils/StringFormatting.kt

@@ -36,50 +36,71 @@ private fun String.htmlDefault(
     closeControlSymbol: String = openControlSymbol
 ) = "<$openControlSymbol>${toHtml()}</$closeControlSymbol>"
 
+@Deprecated("Replaced into project TelegramBotAPI-extensions-utils")
 fun String.linkMarkdown(link: String): String = "[${toMarkdown()}](${link.toMarkdown()})"
+@Deprecated("Replaced into project TelegramBotAPI-extensions-utils")
 fun String.linkMarkdownV2(link: String): String = "[${escapeMarkdownV2Common()}](${link.escapeMarkdownV2Link()})"
+@Deprecated("Replaced into project TelegramBotAPI-extensions-utils")
 fun String.linkHTML(link: String): String = "<a href=\"$link\">${toHtml()}</a>"
 
 
+@Deprecated("Replaced into project TelegramBotAPI-extensions-utils")
 fun String.boldMarkdown(): String = markdownDefault(markdownBoldControl)
+@Deprecated("Replaced into project TelegramBotAPI-extensions-utils")
 fun String.boldMarkdownV2(): String = markdownV2Default(markdownBoldControl)
+@Deprecated("Replaced into project TelegramBotAPI-extensions-utils")
 fun String.boldHTML(): String = htmlDefault(htmlBoldControl)
 
 
+@Deprecated("Replaced into project TelegramBotAPI-extensions-utils")
 fun String.italicMarkdown(): String = markdownDefault(markdownItalicControl)
+@Deprecated("Replaced into project TelegramBotAPI-extensions-utils")
 fun String.italicMarkdownV2(): String = markdownV2Default(markdownItalicControl, markdownV2ItalicEndControl)
+@Deprecated("Replaced into project TelegramBotAPI-extensions-utils")
 fun String.italicHTML(): String = htmlDefault(htmlItalicControl)
 
 /**
  * Crutch for support of strikethrough in default markdown. Simply add modifier, but it will not look like correct
  */
+@Deprecated("Replaced into project TelegramBotAPI-extensions-utils")
 fun String.strikethroughMarkdown(): String = map { it + "\u0336" }.joinToString("")
+@Deprecated("Replaced into project TelegramBotAPI-extensions-utils")
 fun String.strikethroughMarkdownV2(): String = markdownV2Default(markdownV2StrikethroughControl)
+@Deprecated("Replaced into project TelegramBotAPI-extensions-utils")
 fun String.strikethroughHTML(): String = htmlDefault(htmlStrikethroughControl)
 
 
 /**
  * Crutch for support of underline in default markdown. Simply add modifier, but it will not look like correct
  */
+@Deprecated("Replaced into project TelegramBotAPI-extensions-utils")
 fun String.underlineMarkdown(): String = map { it + "\u0347" }.joinToString("")
+@Deprecated("Replaced into project TelegramBotAPI-extensions-utils")
 fun String.underlineMarkdownV2(): String = markdownV2Default(markdownV2UnderlineControl, markdownV2UnderlineEndControl)
+@Deprecated("Replaced into project TelegramBotAPI-extensions-utils")
 fun String.underlineHTML(): String = htmlDefault(htmlUnderlineControl)
 
 
+@Deprecated("Replaced into project TelegramBotAPI-extensions-utils")
 fun String.codeMarkdown(): String = markdownDefault(markdownCodeControl)
+@Deprecated("Replaced into project TelegramBotAPI-extensions-utils")
 fun String.codeMarkdownV2(): String = markdownV2Default(markdownCodeControl, escapeFun = String::escapeMarkdownV2PreAndCode)
+@Deprecated("Replaced into project TelegramBotAPI-extensions-utils")
 fun String.codeHTML(): String = htmlDefault(htmlCodeControl)
 
 
+@Deprecated("Replaced into project TelegramBotAPI-extensions-utils")
 fun String.preMarkdown(language: String? = null): String = markdownDefault(
     "$markdownPreControl${language ?: ""}\n",
     "\n$markdownPreControl"
 )
+@Deprecated("Replaced into project TelegramBotAPI-extensions-utils")
 fun String.preMarkdownV2(language: String? = null): String = markdownV2Default(
     "$markdownPreControl${language ?: ""}\n",
     "\n$markdownPreControl",
     String::escapeMarkdownV2PreAndCode
 )
+@Deprecated("Replaced into project TelegramBotAPI-extensions-utils")
 fun String.preHTML(language: String? = null): String = htmlDefault(
     language ?.let {
         "$htmlPreControl><$htmlCodeControl class=\"language-$language\""
@@ -90,11 +111,15 @@ fun String.preHTML(language: String? = null): String = htmlDefault(
 )
 
 
+@Deprecated("Replaced into project TelegramBotAPI-extensions-utils")
 fun String.emailMarkdown(): String = linkMarkdown("mailto://$${toMarkdown()}")
+@Deprecated("Replaced into project TelegramBotAPI-extensions-utils")
 fun String.emailMarkdownV2(): String = linkMarkdownV2("mailto://$${toMarkdown()}")
+@Deprecated("Replaced into project TelegramBotAPI-extensions-utils")
 fun String.emailHTML(): String = linkHTML("mailto://$${toHtml()}")
 
 
+@Deprecated("Replaced into project TelegramBotAPI-extensions-utils")
 private inline fun String.mention(adapt: String.() -> String): String = if (startsWith("@")) {
     adapt()
 } else {
@@ -102,6 +127,7 @@ private inline fun String.mention(adapt: String.() -> String): String = if (star
 }
 
 
+@Deprecated("Replaced into project TelegramBotAPI-extensions-utils")
 private inline fun String.hashTag(adapt: String.() -> String): String = if (startsWith("#")) {
     adapt()
 } else {
@@ -109,47 +135,70 @@ private inline fun String.hashTag(adapt: String.() -> String): String = if (star
 }
 
 
+@Deprecated("Replaced into project TelegramBotAPI-extensions-utils")
 fun String.textMentionMarkdown(userId: UserId): String = linkMarkdown(userId.link)
+@Deprecated("Replaced into project TelegramBotAPI-extensions-utils")
 fun String.textMentionMarkdownV2(userId: UserId): String = linkMarkdownV2(userId.link)
+@Deprecated("Replaced into project TelegramBotAPI-extensions-utils")
 fun String.textMentionHTML(userId: UserId): String = linkHTML(userId.link)
 
 
+@Deprecated("Replaced into project TelegramBotAPI-extensions-utils")
 fun String.mentionMarkdown(): String = mention(String::toMarkdown)
+@Deprecated("Replaced into project TelegramBotAPI-extensions-utils")
 fun String.mentionMarkdownV2(): String = mention(String::escapeMarkdownV2Common)
+@Deprecated("Replaced into project TelegramBotAPI-extensions-utils")
 fun String.mentionHTML(): String = mention(String::toHtml)
 
 
+@Deprecated("Replaced into project TelegramBotAPI-extensions-utils")
 fun String.hashTagMarkdown(): String = hashTag(String::toMarkdown)
+@Deprecated("Replaced into project TelegramBotAPI-extensions-utils")
 fun String.hashTagMarkdownV2(): String = hashTag(String::escapeMarkdownV2Common).escapeMarkdownV2Common()
+@Deprecated("Replaced into project TelegramBotAPI-extensions-utils")
 fun String.hashTagHTML(): String = hashTag(String::toHtml)
 
 
+@Deprecated("Replaced into project TelegramBotAPI-extensions-utils")
 fun String.phoneMarkdown(): String = toMarkdown()
+@Deprecated("Replaced into project TelegramBotAPI-extensions-utils")
 fun String.phoneMarkdownV2(): String = escapeMarkdownV2Common()
+@Deprecated("Replaced into project TelegramBotAPI-extensions-utils")
 fun String.phoneHTML(): String = toHtml()
 
 
+@Deprecated("Replaced into project TelegramBotAPI-extensions-utils")
 fun String.command(adapt: String.() -> String): String = if (startsWith("/")) {
     adapt()
 } else {
     "/${adapt()}"
 }
 
+@Deprecated("Replaced into project TelegramBotAPI-extensions-utils")
 fun String.commandMarkdown(): String = command(String::toMarkdown)
+@Deprecated("Replaced into project TelegramBotAPI-extensions-utils")
 fun String.commandMarkdownV2(): String = command(String::escapeMarkdownV2Common)
+@Deprecated("Replaced into project TelegramBotAPI-extensions-utils")
 fun String.commandHTML(): String = command(String::toHtml)
 
 
+@Deprecated("Replaced into project TelegramBotAPI-extensions-utils")
 fun String.regularMarkdown(): String = toMarkdown()
+@Deprecated("Replaced into project TelegramBotAPI-extensions-utils")
 fun String.regularMarkdownV2(): String = escapeMarkdownV2Common()
+@Deprecated("Replaced into project TelegramBotAPI-extensions-utils")
 fun String.regularHtml(): String = toHtml()
 
 
+@Deprecated("Replaced into project TelegramBotAPI-extensions-utils")
 fun String.cashTagMarkdown(): String = toMarkdown()
+@Deprecated("Replaced into project TelegramBotAPI-extensions-utils")
 fun String.cashTagMarkdownV2(): String = escapeMarkdownV2Common()
+@Deprecated("Replaced into project TelegramBotAPI-extensions-utils")
 fun String.cashTagHtml(): String = toHtml()
 
 
+@Deprecated("Replaced into project TelegramBotAPI-extensions-utils")
 infix fun String.bold(parseMode: ParseMode): String = when (parseMode) {
     is HTML -> boldHTML()
     is Markdown -> boldMarkdown()
@@ -157,85 +206,100 @@ infix fun String.bold(parseMode: ParseMode): String = when (parseMode) {
 }
 
 
+@Deprecated("Replaced into project TelegramBotAPI-extensions-utils")
 infix fun String.italic(parseMode: ParseMode): String = when (parseMode) {
     is HTML -> italicHTML()
     is Markdown -> italicMarkdown()
     is MarkdownV2 -> italicMarkdownV2()
 }
 
+@Deprecated("Replaced into project TelegramBotAPI-extensions-utils")
 infix fun String.hashTag(parseMode: ParseMode): String = when (parseMode) {
     is HTML -> hashTagHTML()
     is Markdown -> hashTagMarkdown()
     is MarkdownV2 -> hashTagMarkdownV2()
 }
 
+@Deprecated("Replaced into project TelegramBotAPI-extensions-utils")
 infix fun String.code(parseMode: ParseMode): String = when (parseMode) {
     is HTML -> codeHTML()
     is Markdown -> codeMarkdown()
     is MarkdownV2 -> codeMarkdownV2()
 }
 
+@Deprecated("Replaced into project TelegramBotAPI-extensions-utils")
 fun String.pre(parseMode: ParseMode, language: String? = null): String = when (parseMode) {
     is HTML -> preHTML(language)
     is Markdown -> preMarkdown(language)
     is MarkdownV2 -> preMarkdownV2(language)
 }
+@Deprecated("Replaced into project TelegramBotAPI-extensions-utils")
 infix fun String.pre(parseMode: ParseMode): String = pre(parseMode, null)
 
+@Deprecated("Replaced into project TelegramBotAPI-extensions-utils")
 infix fun String.email(parseMode: ParseMode): String = when (parseMode) {
     is HTML -> emailHTML()
     is Markdown -> emailMarkdown()
     is MarkdownV2 -> emailMarkdownV2()
 }
 
+@Deprecated("Replaced into project TelegramBotAPI-extensions-utils")
 infix fun Pair<String, String>.link(parseMode: ParseMode): String = when (parseMode) {
     is HTML -> first.linkHTML(second)
     is Markdown -> first.linkMarkdown(second)
     is MarkdownV2 -> first.linkMarkdownV2(second)
 }
 
+@Deprecated("Replaced into project TelegramBotAPI-extensions-utils")
 infix fun String.mention(parseMode: ParseMode): String = when (parseMode) {
     is HTML -> mentionHTML()
     is Markdown -> mentionMarkdown()
     is MarkdownV2 -> mentionMarkdownV2()
 }
 
+@Deprecated("Replaced into project TelegramBotAPI-extensions-utils")
 infix fun Pair<String, ChatId>.mention(parseMode: ParseMode): String = when (parseMode) {
     is HTML -> first.textMentionHTML(second)
     is Markdown -> first.textMentionMarkdown(second)
     is MarkdownV2 -> first.textMentionMarkdownV2(second)
 }
 
+@Deprecated("Replaced into project TelegramBotAPI-extensions-utils")
 infix fun String.phone(parseMode: ParseMode): String = when (parseMode) {
     is HTML -> phoneHTML()
     is Markdown -> phoneMarkdown()
     is MarkdownV2 -> phoneMarkdownV2()
 }
 
+@Deprecated("Replaced into project TelegramBotAPI-extensions-utils")
 infix fun String.command(parseMode: ParseMode): String = when (parseMode) {
     is HTML -> commandHTML()
     is Markdown -> commandMarkdown()
     is MarkdownV2 -> commandMarkdownV2()
 }
 
+@Deprecated("Replaced into project TelegramBotAPI-extensions-utils")
 infix fun String.underline(parseMode: ParseMode): String = when (parseMode) {
     is HTML -> underlineHTML()
     is Markdown -> underlineMarkdown()
     is MarkdownV2 -> underlineMarkdownV2()
 }
 
+@Deprecated("Replaced into project TelegramBotAPI-extensions-utils")
 infix fun String.strikethrough(parseMode: ParseMode): String = when (parseMode) {
     is HTML -> strikethroughHTML()
     is Markdown -> strikethroughMarkdown()
     is MarkdownV2 -> strikethroughMarkdownV2()
 }
 
+@Deprecated("Replaced into project TelegramBotAPI-extensions-utils")
 infix fun String.regular(parseMode: ParseMode): String = when (parseMode) {
     is HTML -> regularHtml()
     is Markdown -> regularMarkdown()
     is MarkdownV2 -> regularMarkdownV2()
 }
 
+@Deprecated("Replaced into project TelegramBotAPI-extensions-utils")
 infix fun String.cashtag(parseMode: ParseMode): String = when (parseMode) {
     is HTML -> cashTagHtml()
     is Markdown -> cashTagMarkdown()

TelegramBotAPI/src/commonMain/kotlin/com/github/insanusmokrassar/TelegramBotAPI/utils/ThrowErrorWithRange.kt

@@ -0,0 +1,7 @@
+package com.github.insanusmokrassar.TelegramBotAPI.utils
+
+internal fun throwRangeError(
+    valueName: String,
+    range: IntRange,
+    actualValue: Int
+): Nothing = error("$valueName must be in range $range, but was $actualValue")

TelegramBotAPI/src/commonMain/kotlin/com/github/insanusmokrassar/TelegramBotAPI/utils/extensions/Executes.kt

@@ -4,9 +4,10 @@ import com.github.insanusmokrassar.TelegramBotAPI.bot.RequestsExecutor
 import com.github.insanusmokrassar.TelegramBotAPI.bot.exceptions.RequestException
 import com.github.insanusmokrassar.TelegramBotAPI.requests.abstracts.Request
 import com.github.insanusmokrassar.TelegramBotAPI.types.Response
+import com.github.insanusmokrassar.TelegramBotAPI.utils.handleSafely
 import kotlinx.coroutines.*
 
-
+@Deprecated("Will be removed in next major update")
 fun <T: Any> RequestsExecutor.executeAsync(
     request: Request<T>,
     onFail: (suspend (Response) -> Unit)? = null,
@@ -23,6 +24,7 @@ fun <T: Any> RequestsExecutor.executeAsync(
     }
 }
 
+@Deprecated("Replaced and modified inside of TelegramBotAPI-extensions-utils")
 fun <T: Any> RequestsExecutor.executeAsync(
     request: Request<T>,
     scope: CoroutineScope = GlobalScope
@@ -30,19 +32,27 @@ fun <T: Any> RequestsExecutor.executeAsync(
     return scope.async { execute(request) }
 }
 
+@Deprecated("Replaced and modified inside of TelegramBotAPI-extensions-utils")
 suspend fun <T: Any> RequestsExecutor.executeUnsafe(
     request: Request<T>,
     retries: Int = 0,
-    retriesDelay: Long = 1000L
+    retriesDelay: Long = 1000L,
+    onAllFailed: (suspend (exceptions: Array<Exception>) -> Unit)? = null
 ): T? {
     var leftRetries = retries
+    val exceptions = onAllFailed ?.let { mutableListOf<Exception>() }
     do {
-        try {
-            return execute(request)
-        } catch (e: RequestException) {
-            leftRetries--
-            delay(retriesDelay)
-        }
+        handleSafely(
+            {
+                leftRetries--
+                delay(retriesDelay)
+                exceptions ?.add(it)
+                null
+            }
+        ) {
+            execute(request)
+        } ?.let { return it }
     } while(leftRetries >= 0)
+    onAllFailed ?.invoke(exceptions ?.toTypedArray() ?: emptyArray())
     return null
 }