optimize imports

0.22.1

CHANGELOG.md

@@ -1,5 +1,252 @@
 # TelegramBotAPI changelog
 
+## 0.22.0
+
+* **`KtorCallFactory` must return `HttpStatement` instead of `HttpClientCall`**
+* `SendMessage` was renamed to `SendTextMessage` and previous `SendMessage` is deprecated
+* All `AbleToBe*` interfaces was renamed to `Possibly*`
+    * `AbleToBeEditedMessage` -> `PossiblyEditedMessage`
+    * `AbleToBeForwardedMessage` -> `PossiblyForwardedMessage`
+    * `AbleToBeMarkedUp` -> `PossiblyMarkedUp`
+    * `AbleToBeEditedMessage` -> `PossiblyEditedMessage`
+* `ForwardedMessage` type was renamed to `ForwardInfo`
+    * `AnonymousForwardedMessage` -> `AnonymousForwardInfo`
+    * `UserForwardedMessage` -> `UserForwardInfo`
+    * `ForwardedFromChannelMessage` -> `ForwardFromChannelInfo`
+    * `PossiblyForwardedMessage#forwarded` field now renamed to `forwardInfo`
+* All serializers in library now are `internal`. **If you have used some of them or I have marked as internal by a
+mistake - don't hesitate to say this.**
+* `EditChatMessage` now have generic type and extends `SimpleRequest<ContentMessage<GenericType>>`
+* `ResendableContent` now extends `Request<out Message>` instead of `Request<Message>`
+* Most part of requests have changed return type. They are listed below:
+    <details>
+    
+    * `ForwardMessage`
+    * `GetChatAdministrators`
+    * `EditChatMessageLiveLocation`
+    * `StopChatMessageLiveLocation`
+    * `EditChatMessageText`
+    * `EditChatMessageCaption`
+    * `EditChatMessageMedia`
+    * `EditChatMessageReplyMarkup`
+    * `SendAnimation`
+    * `SendAudio`
+    * `SendContact`
+    * `SendLocation`
+    * `SendTextMessage`
+    * `SendPoll`
+    * `SendVenue`
+    * `SendGame`
+    * `SendDocument`
+    * `SendMediaGroup`
+    * `SendPhoto`
+    * `SendVideo`
+    * `SendVideoNote`
+    * `SendVoice`
+    * `SendSticker`
+    
+    </details>
+* Changed type of `createResend`
+    <details>
+    
+    * `GameContent`
+    * `LocationContent`
+    * `PollContent`
+    * `TextContent`
+    * `VenueContent`
+    * `AnimationContent`
+    * `AudioContent`
+    * `DocumentContent`
+    * `ContactContent`
+    * `PhotoContent`
+    * `VideoContent`
+    * `VideoNoteContent`
+    * `VoiceContent`
+    * `StickerContent`
+    
+    </details>
+* Version updates:
+    * Ktor `1.2.6` -> `1.3.0`
+
+### 0.22.1 MediaContent#asInputMedia
+
+* All `MediaContent` instances now can create their `InputMedia` analog
+* New annotation `PreviewFeature` was added to mark new thing as preview for the time
+while they can work incorrectly
+* Added links utils:
+    * `makeLinkToMessage` have two signatures - for direct creating using username and for abstract creating using
+    chat id
+
+### 0.22.2 CashTag and independent updates handling
+
+* `cashtag` entity type was added
+* Several `Unknown*` realizations was added:
+    * `UnknownUpdateType`
+    * `UnknownMessageType`
+    * `UnknownChatType`
+    * `UnknownCallbackQueryType`
+* `UpdatesFilter` now have one additional income callback: `unknownUpdateTypeCallback`
+    * `createSimpleUpdateFilter` can receive one more callback: `unknownCallback` (for `unknownUpdateTypeCallback`)
+
+## 0.21.0 TelegramBotAPI 4.5
+
+* _**All `MessageEntity`'es now are replaced with `TextPart`**_
+* Added support of strikethrough and underline
+    * Added `UnderlineTextSource`
+    * Added `StrikethroughTextSource`
+    * Added support in `RawMessageEntity`
+* Added support of `MarkdownV2`
+* Now will not be thrown exception when there is income unknown type of `RawMessageEntity`. Instead of this will be
+created `RegularTextSource` with the same text
+* Fixed problem that usually string formatting did not trigger escaping of control characters
+* Actualized work with `pre` type of text - now it is possible to use `language` for formatting of text
+* Removed constructor of `TextMentionTextSource`, which was deprecated previously
+* All `TelegramMediaFile` instances now have field `fileUniqueId`, which represents `file_unique_id` field from API
+* Now `ChatPhoto` have two additional fields: `smallFileUniqueId` and `bigFileUniqueId`
+* Now any administrator object instance have `customTitle` nullable field
+* Added the new request `SetChatAdministratorCustomTitle` to manage the custom titles of administrators promoted by the
+bot.
+* Added the field `slowModeDelay` to the `ExtendedSupergroupChat` objects.
+
+* `CaptionedInput` now have extension `fullEntitiesList` which will return list of `TextPart` with `RegularSource`'s
+* `TextPart` added - it will be used as part of some text and can be not related to telegram bot
+* `MultilevelTextSource` was added - it is type of `TextSource`, which can have subsources as parts of this text
+* In all `TextSource`s all fields now are lazy for avoiding of potential risk for performance issues
+
+* Updates in versions:
+    * Coroutines `1.3.2` -> `1.3.3`
+    * Klock `1.8.0` -> `1.8.6`
+    * UUID `0.0.6` -> `0.0.7`
+
+## 0.20.0 MPP Migration
+
+* Time library change: `joda-time` -> `com.soywiz.korlibs.klock:klock`
+* `Currencied` now using as `currency` value with type `String`
+    * For `Java` there is `Currencied#javaCurrency` extension function, which will give an old currency work way
+* `User` now have no field `userLocale`
+    * For `Java` there is `User#javaLocale` extension function, which will give an old locale work way
+
+### 0.20.1
+
+* `User` now implement `PrivateChat`
+* `TextMentionMessageEntity` now accept `PrivateChat` instead of `User` in main constructor
+    * `TextMentionMessageEntity` now contains not user, but contains `PrivateChat`
+    * Fixed: `TextMentionMessageEntity#asHtmlSource` previously worked incorrect
+* Abstraction `TextSource`
+    * `MessageEntity` now extends `TextSource`
+    * `createFormattedText` method now accept `List<TextSource>`
+    * `createHtmlText` method now accept `List<TextSource>`
+    * `createMarkdownText` method now accept `List<TextSource>`
+    * A lot of `TextSource` implementors was added. More info [here](src/commonMain/kotlin/com/github/insanusmokrassar/TelegramBotAPI/types/MessageEntity/textsources/)
+        * All `MessageEntity` implementations now are using new `TextSource` analogues as delegates
+
+### 0.20.2
+
+* New exception type `MessageIsNotModifierException` was added
+* New exception type `MessageToEditNotFoundException` was added
+* Now exceptions in requests will be caught correctly
+
+### 0.20.3
+
+* Now `LeftChatMamber` is a `CommonEvent`
+
+### 0.20.4
+
+* Now `setWebhook` supports setting up of path for listening
+* Now `setWebhook` supports custom listen address even if certificate was not provided
+
+## 0.19.0 ImplicitReflection removing
+
+* Total rework of serialization for requests. Now all `SimpleRequest` children have:
+    * `requestSerializer` - field, which must provide serializer of current type
+    * `resultDeserializer` - field, which must provide opportunity to deserializer result. Previously it was a function
+* Removed deprecations:
+    * `com.github.insanusmokrassar.TelegramBotAPI.utils.extensions.WebhookPrivateKeyConfig`
+    * `com.github.insanusmokrassar.TelegramBotAPI.utils.extensions.UpdatesFilter`
+    * `com.github.insanusmokrassar.TelegramBotAPI.utils.extensions.createSimpleUpdateFilter`
+    * `com.github.insanusmokrassar.TelegramBotAPI.utils.createMarkdownText`
+    * `com.github.insanusmokrassar.TelegramBotAPI.utils.toMarkdownCaption`
+    * `com.github.insanusmokrassar.TelegramBotAPI.utils.toMarkdownText`
+    * `com.github.insanusmokrassar.TelegramBotAPI.updateshandlers.KtorUpdatesPoller`
+    * `com.github.insanusmokrassar.TelegramBotAPI.types.message.content.abstracts.CaptionedMediaContent`
+    * `com.github.insanusmokrassar.TelegramBotAPI.types.message.CommonForwardedMessage`
+    * `com.github.insanusmokrassar.TelegramBotAPI.types.InputMedia.CaptionedInputMedia`
+    * `com.github.insanusmokrassar.TelegramBotAPI.types.games.Game#text`
+    * `com.github.insanusmokrassar.TelegramBotAPI.types.games.Game#textEntities`
+    * `com.github.insanusmokrassar.TelegramBotAPI.types.files.PathedFileKt.makeFileUrl`
+    * `com.github.insanusmokrassar.TelegramBotAPI.types.files.PathedFileKt.downloadingFilesBaseUrl`
+    * `com.github.insanusmokrassar.TelegramBotAPI.requests.send.media.base.Data`
+    * `com.github.insanusmokrassar.TelegramBotAPI.CommonAbstracts.types.ByInlineMessageId`
+    * `com.github.insanusmokrassar.TelegramBotAPI.CommonAbstracts.types.ByMessageId`
+    * `com.github.insanusmokrassar.TelegramBotAPI.bot.RequestException`
+    * `com.github.insanusmokrassar.TelegramBotAPI.bot.exceptions.ReplyMessageNotFound`
+    * `com.github.insanusmokrassar.TelegramBotAPI.bot.BaseRequestsExecutor#baseUrl`
+    * `com.github.insanusmokrassar.TelegramBotAPI.bot.BaseRequestsExecutor#constructor(token, hostUrl)`
+    * `com.github.insanusmokrassar.TelegramBotAPI.bot.Ktor.KtorRequestsExecutor#constructor(token, client, hostUrl, callsFactories, excludeDefaultFactories, requestsLimiter, jsonFormatter)`
+    * `com.github.insanusmokrassar.TelegramBotAPI.bot.Ktor.KtorRequestsExecutor#constructor(token, engine, hostUrl)`
+
+## 0.18.0 Raws cleaning
+
+* Made internal and not available outside of library:
+    * `RawMessage`
+    * `RawUpdate`
+    * `RawChatMember`
+    * `RawMessageEntity`
+    * `RawInlineQuery`
+    * `RawCallbackQuery`
+    * `RawChosenInlineResult`
+
+* All `RawMessage` usages was replaced with `Message` interface (with some of other raw classes was made the same things)
+    * `TelegramBotAPIMessageDeserializationStrategy` was created. It was used for deserialization of Telegram Bot API
+    incoming messages
+    * `TelegramBotAPIMessageDeserializeOnlySerializer` was created. It **MUST NOT** be used to serialize messages
+* Update of description
+* Make `Game` object a little bit more standartizated
+* `Game` now is not serializable and have no additional trash, related to serialization
+* `TelegramFile` was removed
+
+### 0.18.1 Libraries update
+
+* Update libraries:
+    * `kotlin`: 1.3.41 -> 1.3.61
+    * `kotlin coroutines`: 1.2.2 -> 1.3.2
+    * `kotlin serialization`: 0.11.1 -> 0.14.0
+    * `joda time`: 2.10.3 -> 2.10.5
+    * `ktor`: 1.2.3 -> 1.2.6
+* `BotAction` now will be deserialized in a little bit other way
+    * `BotActionSerializer` now is internal
+* Most part of serializers now are objects (instead of classes as was previously)
+
+## 0.17.0 July 29, 2019 API Update
+
+Libraries updates:
+
+* Kotlin version `1.3.31` -> `1.3.41`
+* Kotlin Coroutines version `1.2.1` -> `1.2.2`
+* Kotlin Serialization version `0.11.0` -> `0.11.1`
+* Joda Time version `2.10.1` -> `2.10.3`
+* ktor version `1.1.4` -> `1.2.3`
+
+Changes according to [July 29, 2019 Telegram Bot API update](https://core.telegram.org/bots/api#july-29-2019):
+
+* `Sticker` and `StickerSet` now have field `isAnimated`
+* `ChatPermissions` object was added, `GroupChat` interface got `permissions` field, request `SetChatPermissions` was added
+* `GroupChat` object now have no field `allMembersAreAdmins`
+* `SpecialRightsChatMember` was added for administrators and restricted members rights union, chat members abstractions
+was replaced into `abstracts` package and available permissions was updated
+* `RestrictChatMember` request now accept `permissions` object instead of separated permissions
+* All `GroupChat` instances have description
+
+Other important changes:
+
+* Totally reworked chats hierarchy. `Extended` abstractions was added for cases when called `GetChat` request
+* `RawChat` boilerplate was removed and replaced by serializers
+* `BotCommandMessageEntity#command` will not contain `/`/`!` parts and also will cut outside of command begin token (`/`
+or `!`) and username token (`@`) or end of command (any space character)
+* `RequestsExecutor` now is `Closeable`
+* `TelegramAPIUrlsKeeper` was added to provide more comfortable work with file urls and other things
+like this
+
 ## 0.16.0 Bot API 4.3
 
 * `LoginURL` and `LoginURLInlineKeyboardButton` has been added

README.md

@@ -1,20 +1,20 @@
 # TelegramBotAPI
 
 [![Download](https://api.bintray.com/packages/insanusmokrassar/StandardRepository/TelegramBotAPI/images/download.svg) ](https://bintray.com/insanusmokrassar/StandardRepository/TelegramBotAPI/_latestVersion)
-[![Build Status](https://jenkins.insanusmokrassar.space/buildStatus/icon?job=TelegramBotAPI_master__publishing)](https://jenkins.insanusmokrassar.space/job/TelegramBotAPI_master__publishing/)
+[![Build Status](https://jenkins.insanusmokrassar.com/buildStatus/icon?job=TelegramBotAPI_master__publishing)](https://jenkins.insanusmokrassar.com/job/TelegramBotAPI_master__publishing/)
 
 ## What is it?
 
-It is one more project which wish to be useful and full Telegram Bots API bridge for Kotlin. Most part of some specific
-solves or unuseful moments are describing by official [Telegram Bot API](https://core.telegram.org/bots/api).
+Library for Object-Oriented and type-safe work with Telegram Bot API. Most part of some specific solves or unuseful
+moments are describing by official [Telegram Bot API](https://core.telegram.org/bots/api).
 
 ## Compatibility
 
-This version compatible with [31st of May 2019 update of TelegramBotAPI](https://core.telegram.org/bots/api#may-31-2019).
-There is one exception of implemented functionality. It is Telegram Passport API, which was presented in
+This version compatible with [31th of December 2019 update of TelegramBotAPI (version 4.5)](https://core.telegram.org/bots/api#december-31-2019).
+There is Telegram Passport API exception of implemented functionality, which was presented in
 [August 2018 update of TelegramBotAPI](https://core.telegram.org/bots/api#august-27-2018) update. It will be implemented
-as soon as possible. All included and supported API can be found on
-[wiki](https://github.com/InsanusMokrassar/TelegramBotAPI/wiki/Included-API).
+as soon as possible. All APIs that are not included are presented
+[wiki](https://github.com/InsanusMokrassar/TelegramBotAPI/wiki/Not-included-API).
 
 ## How to implement library?
 
@@ -25,8 +25,17 @@ like inserting of additional libraries (like `kotlin stdlib`). In the examples w
 
 [![Download](https://api.bintray.com/packages/insanusmokrassar/StandardRepository/TelegramBotAPI/images/download.svg) ](https://bintray.com/insanusmokrassar/StandardRepository/TelegramBotAPI/_latestVersion)
 
+Currently, last versions of library can be available from the Maven repository with errors (for the reason difficult in publishing
+of signed artifacts in Bintray). You can:
+
+* Use earlier version (available version you can find
+[here](https://mvnrepository.com/artifact/com.github.insanusmokrassar/TelegramBotAPI))
+* Add `jCenter` repository in build config
+
 ### Maven
 
+Dependency config presented here:
+
 ```xml
 <dependency>
   <groupId>com.github.insanusmokrassar</groupId>
@@ -37,14 +46,20 @@ like inserting of additional libraries (like `kotlin stdlib`). In the examples w
 
 ### Gradle
 
+To use last versions you will need to add one line in repositories block of your `build.gradle`:
+
+`jcenter()` or `mavenCentral()`
+
+And add next line to your dependencies block:
+
 ```groovy
-implementation "com.github.insanusmokrassar:TelegramBotAPI:${telegrambotapi.version}"
+implementation "com.github.insanusmokrassar:TelegramBotAPI:$telegrambotapi_version"
 ```
 
-### Gradle (old)
+or for old gradle:
 
 ```groovy
-compile "com.github.insanusmokrassar:TelegramBotAPI:${telegrambotapi.version}"
+compile "com.github.insanusmokrassar:TelegramBotAPI:$telegrambotapi_version"
 ```
 
 ## How to work with library?
@@ -52,9 +67,9 @@ compile "com.github.insanusmokrassar:TelegramBotAPI:${telegrambotapi.version}"
 For now, this library have no some API god-object. Instead of this, this library has several
 important objects:
 
-* [RequestsExecutor](src/main/kotlin/com/github/insanusmokrassar/TelegramBotAPI/bot/RequestsExecutor.kt)
-* [Requests](src/main/kotlin/com/github/insanusmokrassar/TelegramBotAPI/requests)
-* [Types](src/main/kotlin/com/github/insanusmokrassar/TelegramBotAPI/types)
+* [RequestsExecutor](https://github.com/InsanusMokrassar/TelegramBotAPI/blob/master/src/commonMain/kotlin/com/github/insanusmokrassar/TelegramBotAPI/bot/RequestsExecutor.kt)
+* [Requests](https://github.com/InsanusMokrassar/TelegramBotAPI/blob/master/src/commonMain/kotlin/com/github/insanusmokrassar/TelegramBotAPI/requests)
+* [Types](https://github.com/InsanusMokrassar/TelegramBotAPI/blob/master/src/commonMain/kotlin/com/github/insanusmokrassar/TelegramBotAPI/types)
 
 ### Types
 
@@ -81,8 +96,8 @@ val requestsExecutor: RequestsExecutor = ...
 requestsExecutor.execute(GetMe())
 ``` 
 
-The result type of [GetMe](src/main/kotlin/com/github/insanusmokrassar/TelegramBotAPI/requests/GetMe) request is
-[User](src/main/kotlin/com/github/insanusmokrassar/TelegramBotAPI/types/User). In fact, in this result must contain
+The result type of [GetMe](https://github.com/InsanusMokrassar/TelegramBotAPI/blob/master/src/commonMain/kotlin/com/github/insanusmokrassar/TelegramBotAPI/requests/GetMe.kt) request is
+[User](https://github.com/InsanusMokrassar/TelegramBotAPI/blob/master/src/commonMain/kotlin/com/github/insanusmokrassar/TelegramBotAPI/types/User.kt). In fact, in this result must contain
 `isBot` equal to `true` always.
 
 
@@ -140,7 +155,7 @@ Currently webhook method contains `UpdatesFilter` as necessary argument for gett
 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 you must not use it and can get updates directly
+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
@@ -173,6 +188,6 @@ 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](src/main/kotlin/com/github/insanusmokrassar/TelegramBotAPI/utils/extensions/UpdatesFilter.kt),
+* `filter` - instance of [UpdatesFilter](https://github.com/InsanusMokrassar/TelegramBotAPI/blob/master/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

_config.yml

@@ -0,0 +1 @@
+theme: jekyll-theme-cayman

build.gradle

@@ -1,6 +1,3 @@
-project.version = "0.16.1"
-project.group = "com.github.insanusmokrassar"
-
 buildscript {
     repositories {
         mavenLocal()
@@ -15,9 +12,13 @@ buildscript {
     }
 }
 
-apply plugin: 'java-library'
-apply plugin: 'kotlin'
-apply plugin: 'kotlinx-serialization'
+plugins {
+    id "org.jetbrains.kotlin.multiplatform" version "$kotlin_version"
+    id "org.jetbrains.kotlin.plugin.serialization" version "$kotlin_version"
+}
+
+project.version = "0.22.2"
+project.group = "com.github.insanusmokrassar"
 
 apply from: "publish.gradle"
 
@@ -28,21 +29,53 @@ repositories {
     maven { url "https://kotlin.bintray.com/kotlinx" }
 }
 
-dependencies {
-    implementation "org.jetbrains.kotlin:kotlin-stdlib:$kotlin_version"
-    implementation "org.jetbrains.kotlinx:kotlinx-coroutines-core:$kotlin_coroutines_version"
-    implementation "org.jetbrains.kotlinx:kotlinx-serialization-runtime:$kotlin_serialisation_runtime_version"
-    implementation "joda-time:joda-time:$joda_time_version"
+kotlin {
+    jvm()
+    js()
 
-    implementation "io.ktor:ktor-client:$ktor_version"
-    implementation "io.ktor:ktor-client-cio:$ktor_version"
+    sourceSets {
+        commonMain {
+            dependencies {
+                implementation kotlin('stdlib')
+                api "org.jetbrains.kotlinx:kotlinx-coroutines-core-common:$kotlin_coroutines_version"
+                api "org.jetbrains.kotlinx:kotlinx-serialization-runtime-common:$kotlin_serialisation_runtime_version"
 
-    implementation "io.ktor:ktor-server:$ktor_version"
-    implementation "io.ktor:ktor-server-host-common:$ktor_version"
-}
+                api "com.soywiz.korlibs.klock:klock:$klock_version"
+                api "com.benasher44:uuid:$uuid_version"
 
-compileKotlin {
-    kotlinOptions {
-        freeCompilerArgs = [ disableImplicitReflectionSerializerAnnotation ]
+                api "io.ktor:ktor-client-core:$ktor_version"
+            }
+        }
+        commonTest {
+            dependencies {
+                implementation kotlin('test-common')
+                implementation kotlin('test-annotations-common')
+            }
+        }
+
+        jvmMain {
+            dependencies {
+                api "org.jetbrains.kotlinx:kotlinx-serialization-runtime:$kotlin_serialisation_runtime_version"
+
+                api "io.ktor:ktor-client:$ktor_version"
+                api "io.ktor:ktor-server:$ktor_version"
+
+                api "io.ktor:ktor-server-host-common:$ktor_version"
+                api "io.ktor:ktor-client-cio:$ktor_version"
+            }
+        }
+        jvmTest {
+            dependencies {
+                implementation kotlin('test-junit')
+            }
+        }
+
+        jsMain {
+            dependencies {
+                api "org.jetbrains.kotlinx:kotlinx-serialization-runtime-js:$kotlin_serialisation_runtime_version"
+                api "org.jetbrains.kotlinx:kotlinx-coroutines-core-js:$kotlin_coroutines_version"
+                api "io.ktor:ktor-client-js:$ktor_version"
+            }
+        }
     }
 }

gradle.properties

@@ -1,13 +1,9 @@
 kotlin.code.style=official
-kotlin_version=1.3.31
-kotlin_coroutines_version=1.2.1
-kotlin_serialisation_runtime_version=0.11.0
-joda_time_version=2.10.1
-ktor_version=1.1.4
+kotlin_version=1.3.61
+kotlin_coroutines_version=1.3.3
+kotlin_serialisation_runtime_version=0.14.0
+klock_version=1.8.6
+uuid_version=0.0.7
+ktor_version=1.3.0
 
 gradle_bintray_plugin_version=1.8.4
-
-project_public_name=Telegram Bot API
-project_public_description=It is one more project which wish to be useful and full Telegram Bots API bridge for Kotlin
-
-disableImplicitReflectionSerializerAnnotation=-Xexperimental=kotlinx.serialization.ImplicitReflectionSerializer

gradle/wrapper/gradle-wrapper.properties

@@ -1,6 +1,6 @@
-#Thu Feb 21 12:05:40 HKT 2019
+#Fri Nov 29 12:11:00 HKT 2019
 distributionBase=GRADLE_USER_HOME
 distributionPath=wrapper/dists
 zipStoreBase=GRADLE_USER_HOME
 zipStorePath=wrapper/dists
-distributionUrl=https\://services.gradle.org/distributions/gradle-5.2.1-bin.zip
+distributionUrl=https\://services.gradle.org/distributions/gradle-6.0.1-all.zip

maven.publish.gradle

@@ -1,63 +1,57 @@
 apply plugin: 'maven-publish'
-apply plugin: 'signing'
 
-task sourcesJar(type: Jar) {
-    from sourceSets.main.allSource
-    classifier = 'sources'
-}
-
-task javadocJar(type: Jar) {
-    from javadoc
+task javadocsJar(type: Jar) {
     classifier = 'javadoc'
 }
 
-publishing {
-    publications {
-        maven(MavenPublication) {
-            from components.java
-            groupId "${project.group}"
-            artifactId "${project.name}"
-            version "${project.version}"
-
-            artifact sourcesJar
-            artifact javadocJar
-            
-            pom.withXml {
-                asNode().children().last() + {
-                    resolveStrategy = Closure.DELEGATE_FIRST
-                    name "${project_public_name}"
-                    description "${project_public_description}"
-                    url "https://insanusmokrassar.github.io/${project.name}"
-
-                    scm {
-                        connection "scm:git:git://github.com/insanusmokrassar/${project.name}.git"
-                        developerConnection "scm:git:[fetch=]https://github.com/insanusmokrassar/${project.name}.git[push=]ssh:git@github.com:insanusmokrassar/${project.name}.git"
-                        url "https://github.com/insanusmokrassar/${project.name}"
-
-                    }
-
-                    developers {
-                        developer {
-                            id "InsanusMokrassar"
-                            name "Ovsyannikov Alexey"
-                            email "ovsyannikov.alexey95@gmail.com"
-                        }
-                    }
-
-                    licenses {
-                        license {
-                            name 'The Apache Software License, Version 2.0'
-                            url 'https://github.com/InsanusMokrassar/TelegramBotAPI/blob/master/LICENSE'
-                            distribution 'repo'
-                        }
-                    }
-                }
-            }
+afterEvaluate {
+    project.publishing.publications.all {
+        // rename artifacts
+        groupId "${project.group}"
+        if (it.name.contains('kotlinMultiplatform')) {
+            artifactId = "${project.name}"
+        } else {
+            artifactId = "${project.name}-$name"
         }
     }
 }
 
-signing {
-    useGpgCmd()
-    sign publishing.publications.maven
-}
+publishing {
+    publications.all {
+        artifact javadocsJar
+
+        pom.withXml {
+            asNode().children().last() + {
+                resolveStrategy = Closure.DELEGATE_FIRST
+
+                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"
+                }
+
+                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"
+                        }
+                    
+                }
+            }
+        }
+    }
+}

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","description":"Library for Object-Oriented and type-safe work with Telegram Bot API","url":"https://insanusmokrassar.github.io/TelegramBotAPI","vcsUrl":"https://github.com/insanusmokrassar/TelegramBotAPI.git","developers":[{"id":"InsanusMokrassar","name":"Ovsiannikov Aleksei","eMail":"ovsyannikov.alexey95@gmail.com"}]}}

publish.gradle

@@ -1,33 +1,55 @@
 apply plugin: 'com.jfrog.bintray'
 
-ext {
-    projectBintrayDir = "${project.group}/".replace(".", "/") + "${project.name}/${project.version}"
-}
+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')
-    publications = ["maven"]
     filesSpec {
-        into "$projectBintrayDir"
-        from("build/libs") {
-            include "**/*.asc"
-        }
-        from("build/publications/maven") {
-            rename 'pom-default.xml(.*)', "${project.name}-${project.version}.pom\$1"
+        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'
+        repo = "StandardRepository"
         name = "${project.name}"
-        vcsUrl = "https://github.com/InsanusMokrassar/${project.name}"
-        licenses = ['Apache-2.0']
+        vcsUrl = "https://github.com/InsanusMokrassar/TelegramBotAPI"
+        licenses = ["Apache-2.0"]
         version {
             name = "${project.version}"
             released = new Date()
-            vcsTag = name
+            vcsTag = "${project.version}"
+            gpg {
+                sign = true
+                passphrase = project.hasProperty('signing.gnupg.passphrase') ? project.property('signing.gnupg.passphrase') : System.getenv('signing.gnupg.passphrase')
+            }
         }
     }
 }
 
-apply from: "maven.publish.gradle"
+bintrayUpload.doFirst {
+    publications = publishing.publications.collect {
+        if (it.name.contains('kotlinMultiplatform')) {
+            null
+        } else {
+            it.name
+        }
+    } - null
+}
+
+bintrayUpload.dependsOn publishToMavenLocal

settings.gradle

@@ -1,18 +1 @@
-/*
- * This settings file was generated by the Gradle 'init' task.
- *
- * The settings file is used to specify which projects to include in your build.
- * In a single project build this file can be empty or even removed.
- *
- * Detailed information about configuring a multi-project build in Gradle can be found
- * in the user guide at https://docs.gradle.org/3.4.1/userguide/multi_project_builds.html
- */
-
-/*
-// To declare projects as part of a multi-project build use the 'include' method
-include 'shared'
-include 'api'
-include 'services:webservice'
-*/
-
 rootProject.name = 'TelegramBotAPI'

src/commonMain/kotlin/com/github/insanusmokrassar/TelegramBotAPI/CommonAbstracts/Captioned.kt

@@ -1,7 +1,7 @@
 package com.github.insanusmokrassar.TelegramBotAPI.CommonAbstracts
 
-import com.github.insanusmokrassar.TelegramBotAPI.types.MessageEntity.MessageEntity
 import com.github.insanusmokrassar.TelegramBotAPI.types.ParseMode.ParseMode
+import com.github.insanusmokrassar.TelegramBotAPI.utils.fullListOfSubSource
 
 interface Captioned {
     val caption: String?
@@ -12,5 +12,7 @@ interface CaptionedOutput : Captioned {
 }
 
 interface CaptionedInput : Captioned {
-    val captionEntities: List<MessageEntity>
+    val captionEntities: List<TextPart>
 }
+
+fun CaptionedInput.fullEntitiesList() = caption ?.fullListOfSubSource(captionEntities) ?.map { it.source } ?: emptyList()

src/commonMain/kotlin/com/github/insanusmokrassar/TelegramBotAPI/CommonAbstracts/TextSource.kt

@@ -0,0 +1,17 @@
+package com.github.insanusmokrassar.TelegramBotAPI.CommonAbstracts
+
+interface TextSource {
+    val asMarkdownSource: String
+    val asMarkdownV2Source: String
+    val asHtmlSource: String
+}
+
+
+interface MultilevelTextSource : TextSource {
+    val textParts: List<TextPart>
+}
+
+data class TextPart(
+    val range: IntRange,
+    val source: TextSource
+)

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

@@ -0,0 +1,7 @@
+package com.github.insanusmokrassar.TelegramBotAPI.bot
+
+import com.github.insanusmokrassar.TelegramBotAPI.utils.TelegramAPIUrlsKeeper
+
+abstract class BaseRequestsExecutor(
+    protected val telegramAPIUrlsKeeper: TelegramAPIUrlsKeeper
+) : RequestsExecutor

src/commonMain/kotlin/com/github/insanusmokrassar/TelegramBotAPI/bot/Ktor/KtorCallFactory.kt

@@ -2,12 +2,12 @@ package com.github.insanusmokrassar.TelegramBotAPI.bot.Ktor
 
 import com.github.insanusmokrassar.TelegramBotAPI.requests.abstracts.Request
 import io.ktor.client.HttpClient
-import io.ktor.client.call.HttpClientCall
+import io.ktor.client.statement.HttpStatement
 
 interface KtorCallFactory {
     suspend fun <T: Any> prepareCall(
         client: HttpClient,
         baseUrl: String,
         request: Request<T>
-    ) : HttpClientCall?
+    ) : HttpStatement?
 }

src/commonMain/kotlin/com/github/insanusmokrassar/TelegramBotAPI/bot/Ktor/KtorRequestsExecutor.kt

@@ -9,32 +9,23 @@ import com.github.insanusmokrassar.TelegramBotAPI.bot.settings.limiters.RequestL
 import com.github.insanusmokrassar.TelegramBotAPI.requests.abstracts.Request
 import com.github.insanusmokrassar.TelegramBotAPI.types.Response
 import com.github.insanusmokrassar.TelegramBotAPI.types.RetryAfterError
+import com.github.insanusmokrassar.TelegramBotAPI.utils.TelegramAPIUrlsKeeper
 import io.ktor.client.HttpClient
-import io.ktor.client.call.HttpClientCall
-import io.ktor.client.engine.HttpClientEngine
-import io.ktor.util.cio.toByteArray
+import io.ktor.client.call.receive
+import io.ktor.client.features.ClientRequestException
+import io.ktor.client.statement.HttpStatement
+import io.ktor.client.statement.readText
 import kotlinx.coroutines.delay
 import kotlinx.serialization.json.Json
 
 class KtorRequestsExecutor(
-    token: String,
+    telegramAPIUrlsKeeper: TelegramAPIUrlsKeeper,
     private val client: HttpClient = HttpClient(),
-    hostUrl: String = "https://api.telegram.org",
     callsFactories: List<KtorCallFactory> = emptyList(),
     excludeDefaultFactories: Boolean = false,
     private val requestsLimiter: RequestLimiter = EmptyLimiter,
     private val jsonFormatter: Json = Json.nonstrict
-) : BaseRequestsExecutor(token, hostUrl) {
-    constructor(
-        token: String,
-        engine: HttpClientEngine? = null,
-        hostUrl: String = "https://api.telegram.org"
-    ) : this(
-        token,
-        engine ?.let { HttpClient(engine) } ?: HttpClient(),
-        hostUrl
-    )
-
+) : BaseRequestsExecutor(telegramAPIUrlsKeeper) {
     private val callsFactories: List<KtorCallFactory> = callsFactories.run {
         if (!excludeDefaultFactories) {
             asSequence().plus(SimpleRequestCallFactory()).plus(MultipartRequestCallFactory()).toList()
@@ -45,36 +36,42 @@ class KtorRequestsExecutor(
 
     override suspend fun <T : Any> execute(request: Request<T>): T {
         return requestsLimiter.limit {
-            var call: HttpClientCall? = null
+            var statement: HttpStatement? = null
             for (factory in callsFactories) {
-                call = factory.prepareCall(
+                statement = factory.prepareCall(
                     client,
-                    baseUrl,
+                    telegramAPIUrlsKeeper.commonAPIUrl,
                     request
                 )
-                if (call != null) {
+                if (statement != null) {
                     break
                 }
             }
-            if (call == null) {
-                throw IllegalArgumentException("Can't execute request: $request")
-            }
-            val content = call.response.use {
-                it.content.toByteArray().toString(Charsets.UTF_8)
-            }
-            val responseObject = jsonFormatter.parse(
-                Response.serializer(request.resultSerializer()),
-                content
-            )
-            responseObject.result ?: responseObject.parameters ?.let {
-                val error = it.error
-                if (error is RetryAfterError) {
-                    delay(error.leftToRetry)
-                    execute(request)
-                } else {
-                    null
-                }
-            } ?: call.let {
+            try {
+                val response = statement ?.execute() ?: throw IllegalArgumentException("Can't execute request: $request")
+                val content = response.receive<String>()
+                val responseObject = jsonFormatter.parse(Response.serializer(), content)
+
+                (responseObject.result?.let {
+                    jsonFormatter.fromJson(request.resultDeserializer, it)
+                } ?: responseObject.parameters?.let {
+                    val error = it.error
+                    if (error is RetryAfterError) {
+                        delay(error.leftToRetry)
+                        execute(request)
+                    } else {
+                        null
+                    }
+                } ?: response.let {
+                    throw newRequestException(
+                        responseObject,
+                        content,
+                        "Can't get result object from $content"
+                    )
+                })
+            } catch (e: ClientRequestException) {
+                val content = e.response.readText()
+                val responseObject = jsonFormatter.parse(Response.serializer(), content)
                 throw newRequestException(
                     responseObject,
                     content,
@@ -83,4 +80,8 @@ class KtorRequestsExecutor(
             }
         }
     }
+
+    override fun close() {
+        client.close()
+    }
 }

src/commonMain/kotlin/com/github/insanusmokrassar/TelegramBotAPI/bot/Ktor/base/AbstractRequestCallFactory.kt

@@ -3,12 +3,11 @@ package com.github.insanusmokrassar.TelegramBotAPI.bot.Ktor.base
 import com.github.insanusmokrassar.TelegramBotAPI.bot.Ktor.KtorCallFactory
 import com.github.insanusmokrassar.TelegramBotAPI.requests.abstracts.Request
 import io.ktor.client.HttpClient
-import io.ktor.client.call.HttpClientCall
-import io.ktor.client.call.call
-import io.ktor.client.request.accept
-import io.ktor.client.request.url
+import io.ktor.client.request.*
+import io.ktor.client.statement.HttpStatement
 import io.ktor.http.ContentType
 import io.ktor.http.HttpMethod
+import kotlin.collections.set
 
 abstract class AbstractRequestCallFactory : KtorCallFactory {
     private val methodsCache: MutableMap<String, String> = mutableMapOf()
@@ -16,21 +15,23 @@ abstract class AbstractRequestCallFactory : KtorCallFactory {
         client: HttpClient,
         baseUrl: String,
         request: Request<T>
-    ): HttpClientCall? {
+    ): HttpStatement? {
         val preparedBody = prepareCallBody(client, baseUrl, request) ?: return null
 
-        return client.call {
-            url(
-                methodsCache[request.method()] ?: "$baseUrl/${request.method()}".also {
-                    methodsCache[request.method()] = it
-                }
-            )
-            method = HttpMethod.Post
-            accept(ContentType.Application.Json)
+        return HttpStatement(
+            HttpRequestBuilder().apply {
+                url(
+                    methodsCache[request.method()] ?: "$baseUrl/${request.method()}".also {
+                        methodsCache[request.method()] = it
+                    }
+                )
+                method = HttpMethod.Post
+                accept(ContentType.Application.Json)
 
-            body = preparedBody
-            build()
-        }
+                body = preparedBody
+            },
+            client
+        )
     }
 
     protected abstract fun <T : Any> prepareCallBody(

src/commonMain/kotlin/com/github/insanusmokrassar/TelegramBotAPI/bot/Ktor/base/MultipartRequestCallFactory.kt

@@ -20,14 +20,15 @@ class MultipartRequestCallFactory : AbstractRequestCallFactory() {
                 val params = castedRequest.paramsJson.mapWithCommonValues()
                 for ((key, value) in castedRequest.mediaMap + params) {
                     when (value) {
-                        is MultipartFile -> append(
+                        is MultipartFile -> appendInput(
                             key,
-                            value.file.asInput(),
                             Headers.build {
                                 append(HttpHeaders.ContentType, value.mimeType)
                                 append(HttpHeaders.ContentDisposition, "filename=${value.fileId}")
                             }
-                        )
+                        ) {
+                            value.file.asInput()
+                        }
                         is FileId -> append(key, value.fileId)
                         else -> append(key, value.toString())
                     }

src/commonMain/kotlin/com/github/insanusmokrassar/TelegramBotAPI/bot/Ktor/base/SimpleRequestCallFactory.kt

@@ -1,7 +1,6 @@
 package com.github.insanusmokrassar.TelegramBotAPI.bot.Ktor.base
 
 import com.github.insanusmokrassar.TelegramBotAPI.requests.abstracts.*
-import com.github.insanusmokrassar.TelegramBotAPI.utils.toJsonWithoutNulls
 import io.ktor.client.HttpClient
 import io.ktor.http.ContentType
 import io.ktor.http.content.TextContent
@@ -12,12 +11,11 @@ class SimpleRequestCallFactory : AbstractRequestCallFactory() {
         baseUrl: String,
         request: Request<T>
     ): Any? = (request as? SimpleRequest<T>) ?.let { _ ->
-        val content = request.toJsonWithoutNulls(SimpleRequestSerializer).toString()
+        val content = request.json().toString()
 
         TextContent(
             content,
             ContentType.Application.Json
         )
     }
-
 }

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

@@ -1,9 +1,11 @@
 package com.github.insanusmokrassar.TelegramBotAPI.bot
 
-import com.github.insanusmokrassar.TelegramBotAPI.bot.exceptions.RequestException
 import com.github.insanusmokrassar.TelegramBotAPI.requests.abstracts.Request
+import io.ktor.utils.io.core.Closeable
 
-interface RequestsExecutor {
-    @Throws(RequestException::class)
+interface RequestsExecutor : Closeable {
+    /**
+     * @throws com.github.insanusmokrassar.TelegramBotAPI.bot.exceptions.RequestException
+     */
     suspend fun <T : Any> execute(request: Request<T>): T
 }

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

@@ -1,7 +1,8 @@
 package com.github.insanusmokrassar.TelegramBotAPI.bot
 
-import kotlinx.coroutines.*
-import kotlinx.io.core.Closeable
+import io.ktor.utils.io.core.Closeable
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Dispatchers
 
 interface UpdatesPoller : Closeable {
     fun start(scope: CoroutineScope = CoroutineScope(Dispatchers.Default))

src/commonMain/kotlin/com/github/insanusmokrassar/TelegramBotAPI/bot/exceptions/RequestException.kt

@@ -0,0 +1,43 @@
+package com.github.insanusmokrassar.TelegramBotAPI.bot.exceptions
+
+import com.github.insanusmokrassar.TelegramBotAPI.types.Response
+import kotlinx.io.IOException
+
+fun newRequestException(
+    response: Response,
+    plainAnswer: String,
+    message: String? = null,
+    cause: Throwable? = null
+) = response.description ?.let { description ->
+    when {
+        description == "Bad Request: reply message not found" -> ReplyMessageNotFoundException(response, plainAnswer, message, cause)
+        description == "Bad Request: message to edit not found" -> MessageToEditNotFoundException(response, plainAnswer, message, cause)
+        description.contains("Bad Request: message is not modified") -> MessageIsNotModifiedException(response, plainAnswer, message, cause)
+        description == "Unauthorized" -> UnauthorizedException(response, plainAnswer, message, cause)
+        else -> null
+    }
+} ?: CommonRequestException(response, plainAnswer, message, cause)
+
+sealed class RequestException constructor(
+    val response: Response,
+    val plainAnswer: String,
+    message: String? = null,
+    override val cause: Throwable? = null
+) : IOException(
+    message ?: "Something went wrong"
+)
+
+class CommonRequestException(response: Response, plainAnswer: String, message: String?, cause: Throwable?) :
+    RequestException(response, plainAnswer, message, cause)
+
+class UnauthorizedException(response: Response, plainAnswer: String, message: String?, cause: Throwable?) :
+    RequestException(response, plainAnswer, message, cause)
+
+class ReplyMessageNotFoundException(response: Response, plainAnswer: String, message: String?, cause: Throwable?) :
+    RequestException(response, plainAnswer, message, cause)
+
+class MessageIsNotModifiedException(response: Response, plainAnswer: String, message: String?, cause: Throwable?) :
+    RequestException(response, plainAnswer, message, cause)
+
+class MessageToEditNotFoundException(response: Response, plainAnswer: String, message: String?, cause: Throwable?) :
+    RequestException(response, plainAnswer, message, cause)

src/commonMain/kotlin/com/github/insanusmokrassar/TelegramBotAPI/bot/settings/limiters/CommonLimiter.kt

@@ -1,9 +1,10 @@
 package com.github.insanusmokrassar.TelegramBotAPI.bot.settings.limiters
 
+import com.soywiz.klock.DateTime
 import kotlinx.coroutines.*
 import kotlinx.coroutines.channels.Channel
 
-private fun now(): Long = System.currentTimeMillis()
+private fun now(): Long = DateTime.nowUnixLong()
 
 class CommonLimiter(
     private val lockCount: Int = 10,

src/commonMain/kotlin/com/github/insanusmokrassar/TelegramBotAPI/bot/settings/limiters/PowLimiter.kt

@@ -4,8 +4,8 @@ import kotlinx.coroutines.*
 import kotlinx.coroutines.channels.Channel
 import kotlinx.serialization.Serializable
 import kotlinx.serialization.Transient
-import java.util.concurrent.Executors
 import kotlin.coroutines.*
+import kotlin.math.pow
 
 private sealed class RequestEvent
 private class AddRequest(
@@ -21,9 +21,7 @@ data class PowLimiter(
     private val powK: Double = 0.0016
 ) : RequestLimiter {
     @Transient
-    private val scope = CoroutineScope(
-        Executors.newFixedThreadPool(3).asCoroutineDispatcher()
-    )
+    private val scope = CoroutineScope(Dispatchers.Default)
     @Transient
     private val eventsChannel = Channel<RequestEvent>(Channel.UNLIMITED)
     @Transient
@@ -35,7 +33,7 @@ data class PowLimiter(
             for (event in eventsChannel) {
                 when (event) {
                     is AddRequest -> {
-                        val awaitTime = ((Math.pow(requestsInWork, powValue) * powK) * 1000L).toLong()
+                        val awaitTime = (((requestsInWork.pow(powValue) * powK) * 1000L).toLong())
                         requestsInWork++
 
                         event.continuation.resume(

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

@@ -15,5 +15,8 @@ data class DeleteMessage(
 ) : SimpleRequest<Boolean>, MessageAction {
     override fun method(): String = "deleteMessage"
 
-    override fun resultSerializer(): KSerializer<Boolean> = BooleanSerializer
+    override val resultDeserializer: DeserializationStrategy<Boolean>
+        get() = BooleanSerializer
+    override val requestSerializer: SerializationStrategy<*>
+        get() = serializer()
 }

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

@@ -3,9 +3,12 @@ package com.github.insanusmokrassar.TelegramBotAPI.requests
 import com.github.insanusmokrassar.TelegramBotAPI.CommonAbstracts.types.MessageAction
 import com.github.insanusmokrassar.TelegramBotAPI.requests.abstracts.SimpleRequest
 import com.github.insanusmokrassar.TelegramBotAPI.types.*
-import com.github.insanusmokrassar.TelegramBotAPI.types.message.RawMessage
+import com.github.insanusmokrassar.TelegramBotAPI.types.message.abstracts.PossiblyForwardedMessage
+import com.github.insanusmokrassar.TelegramBotAPI.types.message.abstracts.TelegramBotAPIMessageDeserializationStrategyClass
 import kotlinx.serialization.*
 
+private val AbleToBeForwardedMessageDeserializer = TelegramBotAPIMessageDeserializationStrategyClass<PossiblyForwardedMessage>()
+
 @Serializable
 data class ForwardMessage(
     @SerialName(fromChatIdField)
@@ -16,12 +19,14 @@ data class ForwardMessage(
     override val messageId: MessageIdentifier,
     @SerialName(disableNotificationField)
     val disableNotification: Boolean = false
-): SimpleRequest<RawMessage>, MessageAction {
-    @Transient
+): SimpleRequest<PossiblyForwardedMessage>, MessageAction {
     override val chatId: ChatIdentifier
         get() = fromChatId
 
     override fun method(): String = "forwardMessage"
 
-    override fun resultSerializer(): KSerializer<RawMessage> = RawMessage.serializer()
+    override val resultDeserializer: DeserializationStrategy<PossiblyForwardedMessage>
+        get() = AbleToBeForwardedMessageDeserializer
+    override val requestSerializer: SerializationStrategy<*>
+        get() = serializer()
 }

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

@@ -2,11 +2,13 @@ package com.github.insanusmokrassar.TelegramBotAPI.requests
 
 import com.github.insanusmokrassar.TelegramBotAPI.requests.abstracts.SimpleRequest
 import com.github.insanusmokrassar.TelegramBotAPI.types.User
-import kotlinx.serialization.KSerializer
-import kotlinx.serialization.Serializable
+import kotlinx.serialization.*
 
 @Serializable
 class GetMe : SimpleRequest<User> {
     override fun method(): String = "getMe"
-    override fun resultSerializer(): KSerializer<User> = User.serializer()
+    override val resultDeserializer: DeserializationStrategy<User>
+        get() = User.serializer()
+    override val requestSerializer: SerializationStrategy<*>
+        get() = serializer()
 }

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

@@ -0,0 +1,29 @@
+package com.github.insanusmokrassar.TelegramBotAPI.requests
+
+import com.github.insanusmokrassar.TelegramBotAPI.requests.abstracts.SimpleRequest
+import com.github.insanusmokrassar.TelegramBotAPI.types.ALL_UPDATES_LIST
+import com.github.insanusmokrassar.TelegramBotAPI.types.UpdateIdentifier
+import com.github.insanusmokrassar.TelegramBotAPI.types.update.abstracts.Update
+import com.github.insanusmokrassar.TelegramBotAPI.types.update.abstracts.UpdateSerializerWithoutDeserialization
+import kotlinx.serialization.*
+import kotlinx.serialization.internal.ArrayListSerializer
+
+private val updatesListSerializer = ArrayListSerializer(
+    UpdateSerializerWithoutDeserialization
+)
+
+@Serializable
+data class GetUpdates(
+    val offset: UpdateIdentifier? = null,// set `last update id + 1` to receive next part of updates
+    val limit: Int? = null,
+    val timeout: Int? = null,
+    val allowed_updates: List<String>? = ALL_UPDATES_LIST
+): SimpleRequest<List<Update>> {
+    override fun method(): String = "getUpdates"
+
+    override val resultDeserializer: DeserializationStrategy<List<Update>>
+        get() = updatesListSerializer
+
+    override val requestSerializer: SerializationStrategy<*>
+        get() = serializer()
+}

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

@@ -18,5 +18,8 @@ data class StopPoll(
     override val replyMarkup: InlineKeyboardMarkup? = null
 ) : MessageAction, SimpleRequest<Poll>, ReplyMarkup {
     override fun method(): String = "stopPoll"
-    override fun resultSerializer(): KSerializer<Poll> = Poll.serializer()
+    override val resultDeserializer: DeserializationStrategy<Poll>
+        get() = Poll.serializer()
+    override val requestSerializer: SerializationStrategy<*>
+        get() = serializer()
 }

src/commonMain/kotlin/com/github/insanusmokrassar/TelegramBotAPI/requests/abstracts/InputFile.kt

@@ -3,7 +3,6 @@ package com.github.insanusmokrassar.TelegramBotAPI.requests.abstracts
 import com.github.insanusmokrassar.TelegramBotAPI.utils.StorageFile
 import kotlinx.serialization.*
 import kotlinx.serialization.internal.StringDescriptor
-import java.io.File
 
 @Serializable(InputFileSerializer::class)
 sealed class InputFile {
@@ -22,7 +21,7 @@ data class FileId(
 fun String.toInputFile(): InputFile = FileId(this)
 
 @Serializer(InputFile::class)
-object InputFileSerializer : KSerializer<InputFile> {
+internal object InputFileSerializer : KSerializer<InputFile> {
     override val descriptor: SerialDescriptor = StringDescriptor.withName(FileId::class.toString())
     override fun serialize(encoder: Encoder, obj: InputFile) = encoder.encodeString(obj.fileId)
     override fun deserialize(decoder: Decoder): FileId = FileId(decoder.decodeString())
@@ -40,7 +39,3 @@ data class MultipartFile (
 ) : InputFile() {
     override val fileId: String = file.generateCustomName()
 }
-
-fun File.toInputFile(): InputFile = MultipartFile(
-    StorageFile(this)
-)

src/commonMain/kotlin/com/github/insanusmokrassar/TelegramBotAPI/requests/abstracts/Request.kt

@@ -0,0 +1,8 @@
+package com.github.insanusmokrassar.TelegramBotAPI.requests.abstracts
+
+import kotlinx.serialization.DeserializationStrategy
+
+interface Request<T: Any> {
+    fun method(): String
+    val resultDeserializer: DeserializationStrategy<T>
+}

src/commonMain/kotlin/com/github/insanusmokrassar/TelegramBotAPI/requests/abstracts/SimpleRequest.kt

@@ -0,0 +1,12 @@
+package com.github.insanusmokrassar.TelegramBotAPI.requests.abstracts
+
+import com.github.insanusmokrassar.TelegramBotAPI.utils.toJsonWithoutNulls
+import kotlinx.serialization.SerializationStrategy
+import kotlinx.serialization.json.JsonObject
+
+interface SimpleRequest<T: Any> : Request<T> {
+    val requestSerializer: SerializationStrategy<*>
+}
+
+@Suppress("UNCHECKED_CAST")
+inline fun <T: Any, K: SimpleRequest<T>> K.json(): JsonObject = toJsonWithoutNulls(requestSerializer as SerializationStrategy<K>)

src/commonMain/kotlin/com/github/insanusmokrassar/TelegramBotAPI/requests/answers/AnswerCallbackQuery.kt

@@ -20,7 +20,10 @@ data class AnswerCallbackQuery(
     val cachedTimeSeconds: Int? = null
 ) : SimpleRequest<Boolean> {
     override fun method(): String = "answerCallbackQuery"
-    override fun resultSerializer(): KSerializer<Boolean> = BooleanSerializer
+    override val resultDeserializer: DeserializationStrategy<Boolean>
+        get() = BooleanSerializer
+    override val requestSerializer: SerializationStrategy<*>
+        get() = serializer()
 }
 
 fun CallbackQuery.createAnswer(

src/commonMain/kotlin/com/github/insanusmokrassar/TelegramBotAPI/requests/answers/AnswerInlineQuery.kt

@@ -28,7 +28,10 @@ data class AnswerInlineQuery(
     val switchPmParameter: String? = null
 ): SimpleRequest<Boolean> {
     override fun method(): String = "answerInlineQuery"
-    override fun resultSerializer(): KSerializer<Boolean> = BooleanSerializer
+    override val resultDeserializer: DeserializationStrategy<Boolean>
+        get() = BooleanSerializer
+    override val requestSerializer: SerializationStrategy<*>
+        get() = serializer()
 }
 
 fun InlineQuery.createAnswer(
@@ -48,6 +51,6 @@ fun InlineQuery.createAnswer(
     switchPmParameter
 )
 
-object InlineQueryAnswersResultsSerializer: KSerializer<List<InlineQueryResult>> by ArrayListSerializer(
+internal object InlineQueryAnswersResultsSerializer: KSerializer<List<InlineQueryResult>> by ArrayListSerializer(
     InlineQueryResultSerializer
 )

src/commonMain/kotlin/com/github/insanusmokrassar/TelegramBotAPI/requests/answers/payments/AnswerPreCheckoutQuery.kt

@@ -3,8 +3,7 @@ package com.github.insanusmokrassar.TelegramBotAPI.requests.answers.payments
 import com.github.insanusmokrassar.TelegramBotAPI.requests.answers.payments.abstracts.AnswerPreCheckoutQuery
 import com.github.insanusmokrassar.TelegramBotAPI.types.*
 import com.github.insanusmokrassar.TelegramBotAPI.types.payments.PreCheckoutQuery
-import kotlinx.serialization.SerialName
-import kotlinx.serialization.Serializable
+import kotlinx.serialization.*
 
 @Serializable
 data class AnswerPreCheckoutQueryOk(
@@ -13,6 +12,8 @@ data class AnswerPreCheckoutQueryOk(
 ) : AnswerPreCheckoutQuery {
     @SerialName(okField)
     override val isOk: Boolean = true
+    override val requestSerializer: SerializationStrategy<*>
+        get() = serializer()
 }
 
 
@@ -25,6 +26,8 @@ data class AnswerPreCheckoutQueryError(
 ) : AnswerPreCheckoutQuery {
     @SerialName(okField)
     override val isOk: Boolean = false
+    override val requestSerializer: SerializationStrategy<*>
+        get() = serializer()
 }
 
 fun PreCheckoutQuery.createAnswerOk(): AnswerPreCheckoutQueryOk = AnswerPreCheckoutQueryOk(

src/commonMain/kotlin/com/github/insanusmokrassar/TelegramBotAPI/requests/answers/payments/AnswerShippingQuery.kt

@@ -17,9 +17,11 @@ data class AnswerShippingQueryOk(
 ) : AnswerShippingQuery {
     @SerialName(okField)
     override val isOk: Boolean = true
+    override val requestSerializer: SerializationStrategy<*>
+        get() = serializer()
 }
 
-object ShippingOptionsSerializer : KSerializer<List<ShippingOption>> by ArrayListSerializer(
+internal object ShippingOptionsSerializer : KSerializer<List<ShippingOption>> by ArrayListSerializer(
     ShippingOption.serializer()
 )
 
@@ -32,6 +34,8 @@ data class AnswerShippingQueryError(
 ) : AnswerShippingQuery {
     @SerialName(okField)
     override val isOk: Boolean = false
+    override val requestSerializer: SerializationStrategy<*>
+        get() = serializer()
 }
 
 fun ShippingQuery.createAnswerOk(

src/commonMain/kotlin/com/github/insanusmokrassar/TelegramBotAPI/requests/answers/payments/abstracts/AnswerPreCheckoutQuery.kt

@@ -3,11 +3,12 @@ package com.github.insanusmokrassar.TelegramBotAPI.requests.answers.payments.abs
 import com.github.insanusmokrassar.TelegramBotAPI.requests.abstracts.SimpleRequest
 import com.github.insanusmokrassar.TelegramBotAPI.types.PreCheckoutQueryId
 import kotlinx.serialization.KSerializer
-import kotlinx.serialization.serializer
+import kotlinx.serialization.internal.BooleanSerializer
 
 interface AnswerPreCheckoutQuery : SimpleRequest<Boolean> {
     override fun method(): String = "answerPreCheckoutQuery"
-    override fun resultSerializer(): KSerializer<Boolean> = Boolean.serializer()
+    override val resultDeserializer: KSerializer<Boolean>
+        get() = BooleanSerializer
 
     val preCheckoutQueryId: PreCheckoutQueryId
     val isOk: Boolean

src/commonMain/kotlin/com/github/insanusmokrassar/TelegramBotAPI/requests/answers/payments/abstracts/AnswerShippingQuery.kt

@@ -2,12 +2,13 @@ package com.github.insanusmokrassar.TelegramBotAPI.requests.answers.payments.abs
 
 import com.github.insanusmokrassar.TelegramBotAPI.requests.abstracts.SimpleRequest
 import com.github.insanusmokrassar.TelegramBotAPI.types.ShippingQueryIdentifier
-import kotlinx.serialization.KSerializer
-import kotlinx.serialization.serializer
+import kotlinx.serialization.DeserializationStrategy
+import kotlinx.serialization.internal.BooleanSerializer
 
 interface AnswerShippingQuery : SimpleRequest<Boolean> {
     override fun method(): String = "answerShippingQuery"
-    override fun resultSerializer(): KSerializer<Boolean> = Boolean.serializer()
+    override val resultDeserializer: DeserializationStrategy<Boolean>
+        get() = BooleanSerializer
 
     val shippingQueryId: ShippingQueryIdentifier
     val isOk: Boolean

src/commonMain/kotlin/com/github/insanusmokrassar/TelegramBotAPI/requests/chat/ExportChatInviteLink.kt

@@ -13,5 +13,8 @@ data class ExportChatInviteLink(
     override val chatId: ChatIdentifier
 ): ChatRequest, SimpleRequest<String> {
     override fun method(): String = "exportChatInviteLink"
-    override fun resultSerializer(): KSerializer<String> = StringSerializer
+    override val resultDeserializer: DeserializationStrategy<String>
+        get() = StringSerializer
+    override val requestSerializer: SerializationStrategy<*>
+        get() = serializer()
 }

src/commonMain/kotlin/com/github/insanusmokrassar/TelegramBotAPI/requests/chat/LeaveChat.kt

@@ -13,5 +13,8 @@ data class LeaveChat(
     override val chatId: ChatIdentifier
 ): ChatRequest, SimpleRequest<Boolean> {
     override fun method(): String = "leaveChat"
-    override fun resultSerializer(): KSerializer<Boolean> = BooleanSerializer
+    override val resultDeserializer: DeserializationStrategy<Boolean>
+        get() = BooleanSerializer
+    override val requestSerializer: SerializationStrategy<*>
+        get() = serializer()
 }

src/commonMain/kotlin/com/github/insanusmokrassar/TelegramBotAPI/requests/chat/get/GetChat.kt

@@ -3,7 +3,8 @@ package com.github.insanusmokrassar.TelegramBotAPI.requests.chat.get
 import com.github.insanusmokrassar.TelegramBotAPI.CommonAbstracts.types.ChatRequest
 import com.github.insanusmokrassar.TelegramBotAPI.requests.abstracts.SimpleRequest
 import com.github.insanusmokrassar.TelegramBotAPI.types.ChatIdentifier
-import com.github.insanusmokrassar.TelegramBotAPI.types.chat.RawChat
+import com.github.insanusmokrassar.TelegramBotAPI.types.chat.ExtendedChatSerializer
+import com.github.insanusmokrassar.TelegramBotAPI.types.chat.abstracts.extended.ExtendedChat
 import com.github.insanusmokrassar.TelegramBotAPI.types.chatIdField
 import kotlinx.serialization.*
 
@@ -11,7 +12,10 @@ import kotlinx.serialization.*
 data class GetChat(
     @SerialName(chatIdField)
     override val chatId: ChatIdentifier
-): ChatRequest, SimpleRequest<RawChat> {
+): ChatRequest, SimpleRequest<ExtendedChat> {
     override fun method(): String = "getChat"
-    override fun resultSerializer(): KSerializer<RawChat> = RawChat.serializer()
+    override val resultDeserializer: DeserializationStrategy<ExtendedChat>
+        get() = ExtendedChatSerializer
+    override val requestSerializer: SerializationStrategy<*>
+        get() = serializer()
 }

src/commonMain/kotlin/com/github/insanusmokrassar/TelegramBotAPI/requests/chat/get/GetChatAdministrators.kt

@@ -3,16 +3,24 @@ package com.github.insanusmokrassar.TelegramBotAPI.requests.chat.get
 import com.github.insanusmokrassar.TelegramBotAPI.CommonAbstracts.types.ChatRequest
 import com.github.insanusmokrassar.TelegramBotAPI.requests.abstracts.SimpleRequest
 import com.github.insanusmokrassar.TelegramBotAPI.types.ChatIdentifier
-import com.github.insanusmokrassar.TelegramBotAPI.types.ChatMember.RawChatMember
+import com.github.insanusmokrassar.TelegramBotAPI.types.ChatMember.abstracts.AdministratorChatMember
+import com.github.insanusmokrassar.TelegramBotAPI.types.ChatMember.abstracts.AdministratorChatMemberSerializerWithoutDeserialization
 import com.github.insanusmokrassar.TelegramBotAPI.types.chatIdField
 import kotlinx.serialization.*
 import kotlinx.serialization.internal.ArrayListSerializer
 
+private val chatMembersListSerializer = ArrayListSerializer(
+    AdministratorChatMemberSerializerWithoutDeserialization
+)
+
 @Serializable
 data class GetChatAdministrators(
     @SerialName(chatIdField)
     override val chatId: ChatIdentifier
-): ChatRequest, SimpleRequest<List<RawChatMember>> {
+): ChatRequest, SimpleRequest<List<AdministratorChatMember>> {
     override fun method(): String = "getChatAdministrators"
-    override fun resultSerializer(): KSerializer<List<RawChatMember>> = ArrayListSerializer(RawChatMember.serializer())
+    override val resultDeserializer: DeserializationStrategy<List<AdministratorChatMember>>
+        get() = chatMembersListSerializer
+    override val requestSerializer: SerializationStrategy<*>
+        get() = serializer()
 }

src/commonMain/kotlin/com/github/insanusmokrassar/TelegramBotAPI/requests/chat/get/GetChatMembersCount.kt

@@ -13,5 +13,8 @@ data class GetChatMembersCount(
     override val chatId: ChatIdentifier
 ): ChatRequest, SimpleRequest<Int> {
     override fun method(): String = "getChatMembersCount"
-    override fun resultSerializer(): KSerializer<Int> = IntSerializer
+    override val resultDeserializer: DeserializationStrategy<Int>
+        get() = IntSerializer
+    override val requestSerializer: SerializationStrategy<*>
+        get() = serializer()
 }

src/commonMain/kotlin/com/github/insanusmokrassar/TelegramBotAPI/requests/chat/members/GetChatMember.kt

@@ -2,7 +2,8 @@ package com.github.insanusmokrassar.TelegramBotAPI.requests.chat.members
 
 import com.github.insanusmokrassar.TelegramBotAPI.requests.chat.abstracts.ChatMemberRequest
 import com.github.insanusmokrassar.TelegramBotAPI.types.*
-import com.github.insanusmokrassar.TelegramBotAPI.types.ChatMember.RawChatMember
+import com.github.insanusmokrassar.TelegramBotAPI.types.ChatMember.abstracts.ChatMember
+import com.github.insanusmokrassar.TelegramBotAPI.types.ChatMember.abstracts.ChatMemberDeserializationStrategy
 import kotlinx.serialization.*
 
 @Serializable
@@ -11,7 +12,10 @@ data class GetChatMember(
     override val chatId: ChatIdentifier,
     @SerialName(userIdField)
     override val userId: UserId
-) : ChatMemberRequest<RawChatMember> {
+) : ChatMemberRequest<ChatMember> {
     override fun method(): String = "getChatMember"
-    override fun resultSerializer(): KSerializer<RawChatMember> = RawChatMember.serializer()
+    override val resultDeserializer: DeserializationStrategy<ChatMember>
+        get() = ChatMemberDeserializationStrategy
+    override val requestSerializer: SerializationStrategy<*>
+        get() = serializer()
 }

src/commonMain/kotlin/com/github/insanusmokrassar/TelegramBotAPI/requests/chat/members/KickChatMember.kt

@@ -16,5 +16,8 @@ data class KickChatMember(
     override val untilDate: TelegramDate? = null
 ) : ChatMemberRequest<Boolean>, UntilDate {
     override fun method(): String = "kickChatMember"
-    override fun resultSerializer(): KSerializer<Boolean> = BooleanSerializer
+    override val resultDeserializer: DeserializationStrategy<Boolean>
+        get() = BooleanSerializer
+    override val requestSerializer: SerializationStrategy<*>
+        get() = serializer()
 }

src/commonMain/kotlin/com/github/insanusmokrassar/TelegramBotAPI/requests/chat/members/PromoteChatMember.kt

@@ -32,5 +32,8 @@ data class PromoteChatMember(
     private val canPromoteMembers: Boolean? = null
 ) : ChatMemberRequest<Boolean>, UntilDate {
     override fun method(): String = "promoteChatMember"
-    override fun resultSerializer(): KSerializer<Boolean> = BooleanSerializer
+    override val resultDeserializer: DeserializationStrategy<Boolean>
+        get() = BooleanSerializer
+    override val requestSerializer: SerializationStrategy<*>
+        get() = serializer()
 }

src/commonMain/kotlin/com/github/insanusmokrassar/TelegramBotAPI/requests/chat/members/RestrictChatMember.kt

@@ -3,6 +3,7 @@ package com.github.insanusmokrassar.TelegramBotAPI.requests.chat.members
 import com.github.insanusmokrassar.TelegramBotAPI.CommonAbstracts.types.UntilDate
 import com.github.insanusmokrassar.TelegramBotAPI.requests.chat.abstracts.ChatMemberRequest
 import com.github.insanusmokrassar.TelegramBotAPI.types.*
+import com.github.insanusmokrassar.TelegramBotAPI.types.chat.ChatPermissions
 import kotlinx.serialization.*
 import kotlinx.serialization.internal.BooleanSerializer
 
@@ -14,15 +15,12 @@ data class RestrictChatMember(
     override val userId: UserId,
     @SerialName(untilDateField)
     override val untilDate: TelegramDate? = null,
-    @SerialName(canSendMessagesField)
-    private val canSendMessages: Boolean? = null,
-    @SerialName(canSendMediaMessagesField)
-    private val canSendMediaMessages: Boolean? = null,
-    @SerialName(canSendOtherMessagesField)
-    private val canSendOtherMessages: Boolean? = null,
-    @SerialName(canAddWebPagePreviewsField)
-    private val canAddWebPagePreviews: Boolean? = null
+    @SerialName(permissionsField)
+    val permissions: ChatPermissions
 ) : ChatMemberRequest<Boolean>, UntilDate {
     override fun method(): String = "restrictChatMember"
-    override fun resultSerializer(): KSerializer<Boolean> = BooleanSerializer
+    override val resultDeserializer: DeserializationStrategy<Boolean>
+        get() = BooleanSerializer
+    override val requestSerializer: SerializationStrategy<*>
+        get() = serializer()
 }

src/commonMain/kotlin/com/github/insanusmokrassar/TelegramBotAPI/requests/chat/members/SetChatAdministratorCustomTitle.kt

@@ -0,0 +1,33 @@
+package com.github.insanusmokrassar.TelegramBotAPI.requests.chat.members
+
+import com.github.insanusmokrassar.TelegramBotAPI.requests.chat.abstracts.ChatMemberRequest
+import com.github.insanusmokrassar.TelegramBotAPI.types.*
+import kotlinx.serialization.*
+import kotlinx.serialization.internal.BooleanSerializer
+
+/**
+ * Representation of https://core.telegram.org/bots/api#setchatadministratorcustomtitle
+ *
+ * Please, remember about restrictions for characters in custom title
+ */
+@Serializable
+data class SetChatAdministratorCustomTitle(
+    @SerialName(chatIdField)
+    override val chatId: ChatId,
+    @SerialName(userIdField)
+    override val userId: UserId,
+    @SerialName(customTitleField)
+    val customTitle: String
+) : ChatMemberRequest<Boolean> {
+    override fun method(): String = "setChatAdministratorCustomTitle"
+    override val resultDeserializer: DeserializationStrategy<Boolean>
+        get() = BooleanSerializer
+    override val requestSerializer: SerializationStrategy<*>
+        get() = RestrictChatMember.serializer()
+
+    init {
+        if (customTitle.length !in customTitleLength) {
+            throw IllegalArgumentException("Custom title length must be in range $customTitleLength, but was ${customTitle.length}")
+        }
+    }
+}

src/commonMain/kotlin/com/github/insanusmokrassar/TelegramBotAPI/requests/chat/members/UnbanChatMember.kt

@@ -13,5 +13,8 @@ data class UnbanChatMember(
     override val userId: UserId
 ) : ChatMemberRequest<Boolean> {
     override fun method(): String = "unbanChatMember"
-    override fun resultSerializer(): KSerializer<Boolean> = BooleanSerializer
+    override val resultDeserializer: DeserializationStrategy<Boolean>
+        get() = BooleanSerializer
+    override val requestSerializer: SerializationStrategy<*>
+        get() = serializer()
 }

src/commonMain/kotlin/com/github/insanusmokrassar/TelegramBotAPI/requests/chat/modify/DeleteChatPhoto.kt

@@ -13,5 +13,8 @@ data class DeleteChatPhoto(
     override val chatId: ChatIdentifier
 ): ChatRequest, SimpleRequest<Boolean> {
     override fun method(): String = "deleteChatPhoto"
-    override fun resultSerializer(): KSerializer<Boolean> = BooleanSerializer
+    override val resultDeserializer: DeserializationStrategy<Boolean>
+        get() = BooleanSerializer
+    override val requestSerializer: SerializationStrategy<*>
+        get() = serializer()
 }

src/commonMain/kotlin/com/github/insanusmokrassar/TelegramBotAPI/requests/chat/modify/PinChatMessage.kt

@@ -16,5 +16,8 @@ data class PinChatMessage (
     override val disableNotification: Boolean = false
 ): ChatRequest, SimpleRequest<Boolean>, MessageAction, DisableNotification {
     override fun method(): String = "pinChatMessage"
-    override fun resultSerializer(): KSerializer<Boolean> = BooleanSerializer
+    override val resultDeserializer: DeserializationStrategy<Boolean>
+        get() = BooleanSerializer
+    override val requestSerializer: SerializationStrategy<*>
+        get() = serializer()
 }

src/commonMain/kotlin/com/github/insanusmokrassar/TelegramBotAPI/requests/chat/modify/SetChatDescription.kt

@@ -20,5 +20,8 @@ data class SetChatDescription (
     }
 
     override fun method(): String = "setChatDescription"
-    override fun resultSerializer(): KSerializer<Boolean> = BooleanSerializer
+    override val resultDeserializer: DeserializationStrategy<Boolean>
+        get() = BooleanSerializer
+    override val requestSerializer: SerializationStrategy<*>
+        get() = serializer()
 }

src/commonMain/kotlin/com/github/insanusmokrassar/TelegramBotAPI/requests/chat/modify/SetChatPermissions.kt

@@ -0,0 +1,22 @@
+package com.github.insanusmokrassar.TelegramBotAPI.requests.chat.modify
+
+import com.github.insanusmokrassar.TelegramBotAPI.CommonAbstracts.types.ChatRequest
+import com.github.insanusmokrassar.TelegramBotAPI.requests.abstracts.SimpleRequest
+import com.github.insanusmokrassar.TelegramBotAPI.types.*
+import com.github.insanusmokrassar.TelegramBotAPI.types.chat.ChatPermissions
+import kotlinx.serialization.*
+import kotlinx.serialization.internal.BooleanSerializer
+
+@Serializable
+data class SetChatPermissions (
+    @SerialName(chatIdField)
+    override val chatId: ChatIdentifier,
+    @SerialName(permissionsField)
+    val permissions: ChatPermissions
+): ChatRequest, SimpleRequest<Boolean> {
+    override fun method(): String = "setChatPermissions"
+    override val resultDeserializer: DeserializationStrategy<Boolean>
+        get() = BooleanSerializer
+    override val requestSerializer: SerializationStrategy<*>
+        get() = serializer()
+}

src/commonMain/kotlin/com/github/insanusmokrassar/TelegramBotAPI/requests/chat/modify/SetChatPhoto.kt

@@ -16,7 +16,8 @@ data class SetChatPhoto (
     val photo: MultipartFile = throw IllegalArgumentException("Unfortunately, this type of objects can't be parsed automatically")
 ): ChatRequest, MultipartRequest<Boolean> {
     override fun method(): String = "setChatPhoto"
-    override fun resultSerializer(): KSerializer<Boolean> = BooleanSerializer
+    override val resultDeserializer: DeserializationStrategy<Boolean>
+        get() = BooleanSerializer
     override val mediaMap: Map<String, MultipartFile> = mapOf(photoField to photo)
     override val paramsJson: JsonObject = toJson(serializer())
 }

src/commonMain/kotlin/com/github/insanusmokrassar/TelegramBotAPI/requests/chat/modify/SetChatTitle.kt

@@ -20,5 +20,8 @@ data class SetChatTitle (
     }
 
     override fun method(): String = "setChatTitle"
-    override fun resultSerializer(): KSerializer<Boolean> = BooleanSerializer
+    override val resultDeserializer: DeserializationStrategy<Boolean>
+        get() = BooleanSerializer
+    override val requestSerializer: SerializationStrategy<*>
+        get() = serializer()
 }

src/commonMain/kotlin/com/github/insanusmokrassar/TelegramBotAPI/requests/chat/modify/UnpinChatMessage.kt

@@ -13,5 +13,8 @@ data class UnpinChatMessage(
     override val chatId: ChatIdentifier
 ): ChatRequest, SimpleRequest<Boolean> {
     override fun method(): String = "unpinChatMessage"
-    override fun resultSerializer(): KSerializer<Boolean> = BooleanSerializer
+    override val resultDeserializer: DeserializationStrategy<Boolean>
+        get() = BooleanSerializer
+    override val requestSerializer: SerializationStrategy<*>
+        get() = serializer()
 }

src/commonMain/kotlin/com/github/insanusmokrassar/TelegramBotAPI/requests/chat/stickers/DeleteChatStickerSet.kt

@@ -13,5 +13,8 @@ data class DeleteChatStickerSet(
     override val chatId: ChatIdentifier
 ): ChatRequest, SimpleRequest<Boolean> {
     override fun method(): String = "deleteChatStickerSet"
-    override fun resultSerializer(): KSerializer<Boolean> = BooleanSerializer
+    override val resultDeserializer: DeserializationStrategy<Boolean>
+        get() = BooleanSerializer
+    override val requestSerializer: SerializationStrategy<*>
+        get() = serializer()
 }

src/commonMain/kotlin/com/github/insanusmokrassar/TelegramBotAPI/requests/chat/stickers/SetChatStickerSet.kt

@@ -11,8 +11,11 @@ data class SetChatStickerSet(
     @SerialName(chatIdField)
     override val chatId: ChatIdentifier,
     @SerialName(stickerSetNameField)
-    val stickerSetName: String
+    val stickerSetName: StickerSetName
 ): ChatRequest, SimpleRequest<Boolean> {
     override fun method(): String = "setChatStickerSet"
-    override fun resultSerializer(): KSerializer<Boolean> = BooleanSerializer
+    override val resultDeserializer: DeserializationStrategy<Boolean>
+        get() = BooleanSerializer
+    override val requestSerializer: SerializationStrategy<*>
+        get() = serializer()
 }

src/commonMain/kotlin/com/github/insanusmokrassar/TelegramBotAPI/requests/common/CommonMultipartFileRequest.kt

@@ -4,7 +4,7 @@ import com.github.insanusmokrassar.TelegramBotAPI.requests.abstracts.*
 import kotlinx.serialization.json.JsonObject
 
 data class CommonMultipartFileRequest<T: Any>(
-    val data: Request<T>,
+    val data: SimpleRequest<T>,
     override val mediaMap: Map<String, MultipartFile>
 ) : MultipartRequest<T>, Request<T> by data {
     override val paramsJson: JsonObject = data.json()

src/commonMain/kotlin/com/github/insanusmokrassar/TelegramBotAPI/requests/edit/LiveLocation/EditChatMessageLiveLocation.kt

@@ -3,9 +3,13 @@ package com.github.insanusmokrassar.TelegramBotAPI.requests.edit.LiveLocation
 import com.github.insanusmokrassar.TelegramBotAPI.requests.edit.abstracts.*
 import com.github.insanusmokrassar.TelegramBotAPI.types.*
 import com.github.insanusmokrassar.TelegramBotAPI.types.buttons.InlineKeyboardMarkup
-import com.github.insanusmokrassar.TelegramBotAPI.types.message.RawMessage
+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.LocationContent
 import kotlinx.serialization.*
 
+private val commonResultDeserializer = TelegramBotAPIMessageDeserializationStrategyClass<ContentMessage<LocationContent>>()
+
 @Serializable
 data class EditChatMessageLiveLocation(
     @SerialName(chatIdField)
@@ -18,7 +22,10 @@ data class EditChatMessageLiveLocation(
     override val longitude: Double,
     @SerialName(replyMarkupField)
     override val replyMarkup: InlineKeyboardMarkup? = null
-) : EditChatMessage, EditReplyMessage, EditLocationMessage {
+) : EditChatMessage<LocationContent>, EditReplyMessage, EditLocationMessage {
     override fun method(): String = "editMessageLiveLocation"
-    override fun resultSerializer(): KSerializer<RawMessage> = RawMessage.serializer()
+    override val resultDeserializer: DeserializationStrategy<ContentMessage<LocationContent>>
+        get() = commonResultDeserializer
+    override val requestSerializer: SerializationStrategy<*>
+        get() = serializer()
 }

src/commonMain/kotlin/com/github/insanusmokrassar/TelegramBotAPI/requests/edit/LiveLocation/EditInlineMessageLiveLocation.kt

@@ -3,8 +3,7 @@ package com.github.insanusmokrassar.TelegramBotAPI.requests.edit.LiveLocation
 import com.github.insanusmokrassar.TelegramBotAPI.requests.edit.abstracts.*
 import com.github.insanusmokrassar.TelegramBotAPI.types.*
 import com.github.insanusmokrassar.TelegramBotAPI.types.buttons.InlineKeyboardMarkup
-import kotlinx.serialization.SerialName
-import kotlinx.serialization.Serializable
+import kotlinx.serialization.*
 
 @Serializable
 data class EditInlineMessageLiveLocation(
@@ -18,4 +17,6 @@ data class EditInlineMessageLiveLocation(
     override val replyMarkup: InlineKeyboardMarkup? = null
 ) : EditInlineMessage, EditReplyMessage, EditLocationMessage {
     override fun method(): String = "editMessageLiveLocation"
+    override val requestSerializer: SerializationStrategy<*>
+        get() = serializer()
 }

src/commonMain/kotlin/com/github/insanusmokrassar/TelegramBotAPI/requests/edit/LiveLocation/StopChatMessageLiveLocation.kt

@@ -4,9 +4,13 @@ import com.github.insanusmokrassar.TelegramBotAPI.requests.edit.abstracts.EditCh
 import com.github.insanusmokrassar.TelegramBotAPI.requests.edit.abstracts.EditReplyMessage
 import com.github.insanusmokrassar.TelegramBotAPI.types.*
 import com.github.insanusmokrassar.TelegramBotAPI.types.buttons.InlineKeyboardMarkup
-import com.github.insanusmokrassar.TelegramBotAPI.types.message.RawMessage
+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.LocationContent
 import kotlinx.serialization.*
 
+private val commonResultDeserializer = TelegramBotAPIMessageDeserializationStrategyClass<ContentMessage<LocationContent>>()
+
 @Serializable
 data class StopChatMessageLiveLocation(
     @SerialName(chatIdField)
@@ -15,7 +19,10 @@ data class StopChatMessageLiveLocation(
     override val messageId: MessageIdentifier,
     @SerialName(replyMarkupField)
     override val replyMarkup: InlineKeyboardMarkup? = null
-) : EditChatMessage, EditReplyMessage {
+) : EditChatMessage<LocationContent>, EditReplyMessage {
     override fun method(): String = "stopMessageLiveLocation"
-    override fun resultSerializer(): KSerializer<RawMessage> = RawMessage.serializer()
+    override val resultDeserializer: DeserializationStrategy<ContentMessage<LocationContent>>
+        get() = commonResultDeserializer
+    override val requestSerializer: SerializationStrategy<*>
+        get() = serializer()
 }

src/commonMain/kotlin/com/github/insanusmokrassar/TelegramBotAPI/requests/edit/LiveLocation/StopInlineMessageLiveLocation.kt

@@ -4,8 +4,7 @@ import com.github.insanusmokrassar.TelegramBotAPI.requests.edit.abstracts.EditIn
 import com.github.insanusmokrassar.TelegramBotAPI.requests.edit.abstracts.EditReplyMessage
 import com.github.insanusmokrassar.TelegramBotAPI.types.*
 import com.github.insanusmokrassar.TelegramBotAPI.types.buttons.InlineKeyboardMarkup
-import kotlinx.serialization.SerialName
-import kotlinx.serialization.Serializable
+import kotlinx.serialization.*
 
 @Serializable
 data class StopInlineMessageLiveLocation(
@@ -15,4 +14,6 @@ data class StopInlineMessageLiveLocation(
     override val replyMarkup: InlineKeyboardMarkup? = null
 ) : EditInlineMessage, EditReplyMessage {
     override fun method(): String = "stopMessageLiveLocation"
+    override val requestSerializer: SerializationStrategy<*>
+        get() = serializer()
 }

src/commonMain/kotlin/com/github/insanusmokrassar/TelegramBotAPI/requests/edit/ReplyMarkup/EditChatMessageReplyMarkup.kt

@@ -4,11 +4,15 @@ import com.github.insanusmokrassar.TelegramBotAPI.requests.edit.abstracts.EditCh
 import com.github.insanusmokrassar.TelegramBotAPI.requests.edit.abstracts.EditReplyMessage
 import com.github.insanusmokrassar.TelegramBotAPI.types.*
 import com.github.insanusmokrassar.TelegramBotAPI.types.buttons.InlineKeyboardMarkup
-import com.github.insanusmokrassar.TelegramBotAPI.types.message.RawMessage
+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.abstracts.MessageContent
 import kotlinx.serialization.*
 
 const val editMessageReplyMarkupMethod = "editMessageReplyMarkup"
 
+private val commonResultDeserializer = TelegramBotAPIMessageDeserializationStrategyClass<ContentMessage<MessageContent>>()
+
 @Serializable
 data class EditChatMessageReplyMarkup(
     @SerialName(chatIdField)
@@ -17,8 +21,11 @@ data class EditChatMessageReplyMarkup(
     override val messageId: MessageIdentifier,
     @SerialName(replyMarkupField)
     override val replyMarkup: InlineKeyboardMarkup? = null
-) : EditChatMessage, EditReplyMessage {
+) : EditChatMessage<MessageContent>, EditReplyMessage {
 
     override fun method(): String = editMessageReplyMarkupMethod
-    override fun resultSerializer(): KSerializer<RawMessage> = RawMessage.serializer()
+    override val resultDeserializer: DeserializationStrategy<ContentMessage<MessageContent>>
+        get() = commonResultDeserializer
+    override val requestSerializer: SerializationStrategy<*>
+        get() = serializer()
 }

src/commonMain/kotlin/com/github/insanusmokrassar/TelegramBotAPI/requests/edit/ReplyMarkup/EditInlineMessageReplyMarkup.kt

@@ -4,8 +4,7 @@ import com.github.insanusmokrassar.TelegramBotAPI.requests.edit.abstracts.EditIn
 import com.github.insanusmokrassar.TelegramBotAPI.requests.edit.abstracts.EditReplyMessage
 import com.github.insanusmokrassar.TelegramBotAPI.types.*
 import com.github.insanusmokrassar.TelegramBotAPI.types.buttons.InlineKeyboardMarkup
-import kotlinx.serialization.SerialName
-import kotlinx.serialization.Serializable
+import kotlinx.serialization.*
 
 @Serializable
 data class EditInlineMessageReplyMarkup(
@@ -15,4 +14,6 @@ data class EditInlineMessageReplyMarkup(
     override val replyMarkup: InlineKeyboardMarkup? = null
 ) : EditInlineMessage, EditReplyMessage {
     override fun method(): String = editMessageReplyMarkupMethod
+    override val requestSerializer: SerializationStrategy<*>
+        get() = serializer()
 }

src/commonMain/kotlin/com/github/insanusmokrassar/TelegramBotAPI/requests/edit/abstracts/EditChatMessage.kt

@@ -2,6 +2,7 @@ package com.github.insanusmokrassar.TelegramBotAPI.requests.edit.abstracts
 
 import com.github.insanusmokrassar.TelegramBotAPI.CommonAbstracts.types.MessageAction
 import com.github.insanusmokrassar.TelegramBotAPI.requests.abstracts.SimpleRequest
-import com.github.insanusmokrassar.TelegramBotAPI.types.message.RawMessage
+import com.github.insanusmokrassar.TelegramBotAPI.types.message.abstracts.ContentMessage
+import com.github.insanusmokrassar.TelegramBotAPI.types.message.content.abstracts.MessageContent
 
-interface EditChatMessage : SimpleRequest<RawMessage>, MessageAction
+interface EditChatMessage<MT: MessageContent> : SimpleRequest<ContentMessage<MT>>, MessageAction

src/commonMain/kotlin/com/github/insanusmokrassar/TelegramBotAPI/requests/edit/abstracts/EditInlineMessage.kt

@@ -2,10 +2,11 @@ package com.github.insanusmokrassar.TelegramBotAPI.requests.edit.abstracts
 
 import com.github.insanusmokrassar.TelegramBotAPI.requests.abstracts.SimpleRequest
 import com.github.insanusmokrassar.TelegramBotAPI.types.InlineMessageIdentifier
-import kotlinx.serialization.KSerializer
+import kotlinx.serialization.DeserializationStrategy
 import kotlinx.serialization.internal.BooleanSerializer
 
 interface EditInlineMessage : SimpleRequest<Boolean> {
     val inlineMessageId: InlineMessageIdentifier
-    override fun resultSerializer(): KSerializer<Boolean> = BooleanSerializer
+    override val resultDeserializer: DeserializationStrategy<Boolean>
+        get() = BooleanSerializer
 }

src/commonMain/kotlin/com/github/insanusmokrassar/TelegramBotAPI/requests/edit/caption/EditChatMessageCaption.kt

@@ -1,11 +1,13 @@
 package com.github.insanusmokrassar.TelegramBotAPI.requests.edit.caption
 
 import com.github.insanusmokrassar.TelegramBotAPI.requests.edit.abstracts.*
+import com.github.insanusmokrassar.TelegramBotAPI.requests.edit.media.MediaContentMessageResultDeserializer
 import com.github.insanusmokrassar.TelegramBotAPI.types.*
 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.types.message.RawMessage
+import com.github.insanusmokrassar.TelegramBotAPI.types.message.abstracts.ContentMessage
+import com.github.insanusmokrassar.TelegramBotAPI.types.message.content.abstracts.MediaContent
 import kotlinx.serialization.*
 
 const val editMessageCaptionMethod = "editMessageCaption"
@@ -22,8 +24,11 @@ data class EditChatMessageCaption(
     override val parseMode: ParseMode? = null,
     @SerialName(replyMarkupField)
     override val replyMarkup: InlineKeyboardMarkup? = null
-) : EditChatMessage, EditTextChatMessage, EditReplyMessage {
+) : EditChatMessage<MediaContent>, EditTextChatMessage, EditReplyMessage {
 
     override fun method(): String = editMessageCaptionMethod
-    override fun resultSerializer(): KSerializer<RawMessage> = RawMessage.serializer()
+    override val resultDeserializer: DeserializationStrategy<ContentMessage<MediaContent>>
+        get() = MediaContentMessageResultDeserializer
+    override val requestSerializer: SerializationStrategy<*>
+        get() = serializer()
 }

src/commonMain/kotlin/com/github/insanusmokrassar/TelegramBotAPI/requests/edit/caption/EditInlineMessageCaption.kt

@@ -5,8 +5,7 @@ import com.github.insanusmokrassar.TelegramBotAPI.types.*
 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 kotlinx.serialization.SerialName
-import kotlinx.serialization.Serializable
+import kotlinx.serialization.*
 
 @Serializable
 data class EditInlineMessageCaption(
@@ -20,4 +19,6 @@ data class EditInlineMessageCaption(
     override val replyMarkup: InlineKeyboardMarkup? = null
 ) : EditInlineMessage, EditTextChatMessage, EditReplyMessage {
     override fun method(): String = editMessageCaptionMethod
+    override val requestSerializer: SerializationStrategy<*>
+        get() = serializer()
 }

src/commonMain/kotlin/com/github/insanusmokrassar/TelegramBotAPI/requests/edit/media/EditChatMessageMedia.kt

@@ -5,11 +5,15 @@ import com.github.insanusmokrassar.TelegramBotAPI.requests.edit.abstracts.*
 import com.github.insanusmokrassar.TelegramBotAPI.types.*
 import com.github.insanusmokrassar.TelegramBotAPI.types.InputMedia.InputMedia
 import com.github.insanusmokrassar.TelegramBotAPI.types.buttons.InlineKeyboardMarkup
-import com.github.insanusmokrassar.TelegramBotAPI.types.message.RawMessage
+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.abstracts.MediaContent
 import kotlinx.serialization.*
 
 const val editMessageMediaMethod = "editMessageMedia"
 
+internal val MediaContentMessageResultDeserializer = TelegramBotAPIMessageDeserializationStrategyClass<ContentMessage<MediaContent>>()
+
 @Serializable
 data class EditChatMessageMedia(
     @SerialName(chatIdField)
@@ -20,7 +24,7 @@ data class EditChatMessageMedia(
     override val media: InputMedia,
     @SerialName(replyMarkupField)
     override val replyMarkup: InlineKeyboardMarkup? = null
-) : EditChatMessage, EditReplyMessage, EditMediaMessage {
+) : EditChatMessage<MediaContent>, EditReplyMessage, EditMediaMessage {
 
     init {
         if (media.file is MultipartFile) {
@@ -29,5 +33,8 @@ data class EditChatMessageMedia(
     }
 
     override fun method(): String = editMessageMediaMethod
-    override fun resultSerializer(): KSerializer<RawMessage> = RawMessage.serializer()
+    override val resultDeserializer: DeserializationStrategy<ContentMessage<MediaContent>>
+        get() = MediaContentMessageResultDeserializer
+    override val requestSerializer: SerializationStrategy<*>
+        get() = serializer()
 }

src/commonMain/kotlin/com/github/insanusmokrassar/TelegramBotAPI/requests/edit/media/EditInlineMessageMedia.kt

@@ -5,8 +5,7 @@ import com.github.insanusmokrassar.TelegramBotAPI.requests.edit.abstracts.*
 import com.github.insanusmokrassar.TelegramBotAPI.types.*
 import com.github.insanusmokrassar.TelegramBotAPI.types.InputMedia.InputMedia
 import com.github.insanusmokrassar.TelegramBotAPI.types.buttons.InlineKeyboardMarkup
-import kotlinx.serialization.SerialName
-import kotlinx.serialization.Serializable
+import kotlinx.serialization.*
 
 @Serializable
 data class EditInlineMessageMedia(
@@ -23,6 +22,8 @@ data class EditInlineMessageMedia(
             throw IllegalArgumentException("For editing of media messages you MUST use file id (according to documentation)")
         }
     }
+    override val requestSerializer: SerializationStrategy<*>
+        get() = serializer()
 
     override fun method(): String = editMessageMediaMethod
 }

src/commonMain/kotlin/com/github/insanusmokrassar/TelegramBotAPI/requests/edit/text/EditChatMessageText.kt

@@ -1,11 +1,13 @@
 package com.github.insanusmokrassar.TelegramBotAPI.requests.edit.text
 
 import com.github.insanusmokrassar.TelegramBotAPI.requests.edit.abstracts.*
+import com.github.insanusmokrassar.TelegramBotAPI.requests.send.TextContentMessageResultDeserializer
 import com.github.insanusmokrassar.TelegramBotAPI.types.*
 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.types.message.RawMessage
+import com.github.insanusmokrassar.TelegramBotAPI.types.message.abstracts.ContentMessage
+import com.github.insanusmokrassar.TelegramBotAPI.types.message.content.TextContent
 import kotlinx.serialization.*
 
 const val editMessageTextMethod = "editMessageText"
@@ -24,8 +26,11 @@ data class EditChatMessageText(
     override val disableWebPagePreview: Boolean? = null,
     @SerialName(replyMarkupField)
     override val replyMarkup: InlineKeyboardMarkup? = null
-) : EditChatMessage, EditTextChatMessage, EditReplyMessage, EditDisableWebPagePreviewMessage {
+) : EditChatMessage<TextContent>, EditTextChatMessage, EditReplyMessage, EditDisableWebPagePreviewMessage {
 
     override fun method(): String = editMessageTextMethod
-    override fun resultSerializer(): KSerializer<RawMessage> = RawMessage.serializer()
+    override val resultDeserializer: DeserializationStrategy<ContentMessage<TextContent>>
+        get() = TextContentMessageResultDeserializer
+    override val requestSerializer: SerializationStrategy<*>
+        get() = serializer()
 }

src/commonMain/kotlin/com/github/insanusmokrassar/TelegramBotAPI/requests/edit/text/EditInlineMessageText.kt

@@ -6,8 +6,7 @@ import com.github.insanusmokrassar.TelegramBotAPI.types.*
 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 kotlinx.serialization.SerialName
-import kotlinx.serialization.Serializable
+import kotlinx.serialization.*
 
 @Serializable
 data class EditInlineMessageText(
@@ -23,4 +22,6 @@ data class EditInlineMessageText(
     override val replyMarkup: InlineKeyboardMarkup? = null
 ) : EditInlineMessage, EditTextChatMessage, EditReplyMessage, EditDisableWebPagePreviewMessage {
     override fun method(): String = editMessageMediaMethod
+    override val requestSerializer: SerializationStrategy<*>
+        get() = serializer()
 }

src/commonMain/kotlin/com/github/insanusmokrassar/TelegramBotAPI/requests/games/GetGameHighScoresByChat.kt

@@ -3,8 +3,7 @@ package com.github.insanusmokrassar.TelegramBotAPI.requests.games
 import com.github.insanusmokrassar.TelegramBotAPI.CommonAbstracts.types.MessageAction
 import com.github.insanusmokrassar.TelegramBotAPI.requests.games.abstracts.GetGameHighScores
 import com.github.insanusmokrassar.TelegramBotAPI.types.*
-import kotlinx.serialization.SerialName
-import kotlinx.serialization.Serializable
+import kotlinx.serialization.*
 
 @Serializable
 data class GetGameHighScoresByChat (
@@ -14,4 +13,7 @@ data class GetGameHighScoresByChat (
     override val chatId: ChatId,
     @SerialName(messageIdField)
     override val messageId: MessageIdentifier
-) : GetGameHighScores, MessageAction
+) : GetGameHighScores, MessageAction {
+    override val requestSerializer: SerializationStrategy<*>
+        get() = serializer()
+}

src/commonMain/kotlin/com/github/insanusmokrassar/TelegramBotAPI/requests/games/GetGameHighScoresByInlineMessageId.kt

@@ -3,8 +3,7 @@ package com.github.insanusmokrassar.TelegramBotAPI.requests.games
 import com.github.insanusmokrassar.TelegramBotAPI.CommonAbstracts.types.InlineMessageAction
 import com.github.insanusmokrassar.TelegramBotAPI.requests.games.abstracts.GetGameHighScores
 import com.github.insanusmokrassar.TelegramBotAPI.types.*
-import kotlinx.serialization.SerialName
-import kotlinx.serialization.Serializable
+import kotlinx.serialization.*
 
 @Serializable
 data class GetGameHighScoresByInlineMessageId (
@@ -12,4 +11,7 @@ data class GetGameHighScoresByInlineMessageId (
     override val userId: UserId,
     @SerialName(inlineMessageIdField)
     override val inlineMessageId: InlineMessageIdentifier
-) : GetGameHighScores, InlineMessageAction
+) : GetGameHighScores, InlineMessageAction {
+    override val requestSerializer: SerializationStrategy<*>
+        get() = serializer()
+}

src/commonMain/kotlin/com/github/insanusmokrassar/TelegramBotAPI/requests/games/SetGameScoreByChatId.kt

@@ -3,8 +3,7 @@ package com.github.insanusmokrassar.TelegramBotAPI.requests.games
 import com.github.insanusmokrassar.TelegramBotAPI.CommonAbstracts.types.MessageAction
 import com.github.insanusmokrassar.TelegramBotAPI.requests.games.abstracts.SetGameScore
 import com.github.insanusmokrassar.TelegramBotAPI.types.*
-import kotlinx.serialization.SerialName
-import kotlinx.serialization.Serializable
+import kotlinx.serialization.*
 
 @Serializable
 data class SetGameScoreByChatId (
@@ -20,4 +19,7 @@ data class SetGameScoreByChatId (
     override val force: Boolean = false,
     @SerialName(disableEditMessageField)
     override val disableEditMessage: Boolean = false
-) : SetGameScore, MessageAction
+) : SetGameScore, MessageAction {
+    override val requestSerializer: SerializationStrategy<*>
+        get() = serializer()
+}