add additional onDataCallbackQuery variants with regex filters

This reverts commit ab5937449c.

.github/FUNDING.yml

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

.github/dependabot.yml

@@ -0,0 +1,11 @@
+# To get started with Dependabot version updates, you'll need to specify which
+# package ecosystems to update and where the package manifests are located.
+# Please see the documentation for all configuration options:
+# https://help.github.com/github/administering-a-repository/configuration-options-for-dependency-updates
+
+version: 2
+updates:
+  - package-ecosystem: "gradle" # See documentation for possible values
+    directory: "/tgbotapi.core" # Location of package manifests
+    schedule:
+      interval: "daily"

.github/labeler.yml

@@ -0,0 +1,12 @@
+api: "TelegramBotAPI-api/**"
+utils: "TelegramBotAPI-utils/**"
+behaviour-builder: "TelegramBotAPI-behaviour_builder/**"
+behaviour-builder_fsm: "TelegramBotAPI-behaviour_builder-fsm/**"
+core: "TelegramBotAPI-core/**" # currently not work
+
+code: "**/*.kt"
+gradle: "**/*.gradle"
+versions: "**/gradle.properties"
+markdown:
+  - "**/*.md"
+  - "!CHANGELOG.md"

.github/pull_request_template.md

@@ -0,0 +1,2 @@
+* Please, be sure that you have read [Contributing](https://github.com/InsanusMokrassar/TelegramBotAPI/blob/master/CONTRIBUTING.md) file. Of course, this line must be removed during PR preparation :)
+* Describe your changes, shortly. As example (or format) you can look at the body of any [Project releases](https://github.com/InsanusMokrassar/TelegramBotAPI/releases)

.github/workflows/greetings.yml

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

.github/workflows/kdocs.yml

@@ -0,0 +1,21 @@
+name: Publish KDocs
+on:
+  push:
+    branches:
+      - master
+jobs:
+  publishing:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v2
+      - uses: actions/setup-java@v1
+        with:
+          java-version: 11
+      - name: Build
+        run: ./gradlew dokkaHtml
+      - name: Publish KDocs
+        uses: peaceiris/actions-gh-pages@v3
+        with:
+          github_token: ${{ secrets.GITHUB_TOKEN }}
+          publish_dir: ./docs/build/dokka/html
+          publish_branch: kdocs

.github/workflows/label.yml

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

.github/workflows/packages_publishing.yml

@@ -0,0 +1,24 @@
+name: Publish package to GitHub Packages
+on: [push]
+jobs:
+  publishing:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v2
+      - uses: actions/setup-java@v1
+        with:
+          java-version: 11
+      - name: Rewrite version
+        run: |
+          branch="`echo "${{ github.ref }}" | grep -o "[^/]*$"`"
+          cat gradle.properties | sed -e "s/^library_version=\([0-9\.]*\)/library_version=\1-branch_$branch-build${{ github.run_number }}/" > gradle.properties.tmp
+          rm gradle.properties
+          mv gradle.properties.tmp gradle.properties
+      - name: Build
+        run: ./gradlew build
+      - name: Publish
+        continue-on-error: true
+        run: ./gradlew publishAllPublicationsToGithubPackagesRepository --no-parallel
+        env:
+          GITHUBPACKAGES_USER: ${{ github.actor }}
+          GITHUBPACKAGES_PASSWORD: ${{ secrets.GITHUB_TOKEN }}

.gitignore

@@ -8,3 +8,7 @@ settings.xml
 .gradle/
 build/
 out/
+
+local.properties
+kotlin-js-store/
+secret.gradle

.travis.yml

@@ -0,0 +1,15 @@
+language: java
+install: true
+
+os: linux
+dist: trusty
+jdk: oraclejdk8
+
+jobs:
+  include:
+    - stage: build
+      script: ./gradlew build -s -x jvmTest -x jsIrTest -x jsIrBrowserTest -x jsIrNodeTest -x jsLegacyTest -x jsLegacyBrowserTest -x jsLegacyNodeTest
+    - state: test
+      script: ./gradlew allTests
+    - state: dokka
+      script: ./gradlew dokkaHtml

CONTRIBUTING.md

@@ -0,0 +1,10 @@
+# Contributing
+
+In case you wish to contribute this project, there are several small things you must remember:
+
+* Give maintainers opportunity to manage your Pull request. It is required for two reasons
+    * For more efficient Pull Requests handling (it is much easier for me to fix something small directly in your pull request than ask to fix some small things after each review)
+    * Usually, you will set as a target `master` branch, but I prefer to include code into separated version branch firstly. So, if you will give me opporunity to change Pull Request, I will be available to change base branch
+* Currently in Pull Requests there are several bots. The most important is Travis bot and it must always successfuly build code from your Pull Request
+
+This project was built on the idea of strongly-typed declaration of TelegramBotAPI. So, do not worry if maintaners will change your pull requests: you are already cool because you have contributed this project:)

LICENSE

@@ -178,7 +178,7 @@
    APPENDIX: How to apply the Apache License to your work.
 
       To apply the Apache License to your work, attach the following
-      boilerplate notice, with the fields enclosed by brackets "{}"
+      boilerplate notice, with the fields enclosed by brackets "[]"
       replaced with your own identifying information. (Don't include
       the brackets!)  The text should be enclosed in the appropriate
       comment syntax for the file format. We also recommend that a
@@ -186,7 +186,7 @@
       same "printed page" as the copyright notice for easier
       identification within third-party archives.
 
-   Copyright 2018 Insanus
+   Copyright [yyyy] [name of copyright owner]
 
    Licensed under the Apache License, Version 2.0 (the "License");
    you may not use this file except in compliance with the License.

README.md

@@ -1,206 +1,111 @@
-# TelegramBotAPI
+# TelegramBotAPI [![Maven Central](https://maven-badges.herokuapp.com/maven-central/dev.inmo/tgbotapi/badge.svg)](https://maven-badges.herokuapp.com/maven-central/dev.inmo/tgbotapi) [![Supported version](https://img.shields.io/badge/Telegram%20Bot%20API-6.0-blue)](https://core.telegram.org/bots/api-changelog#april-16-2022)
 
-[![Download](https://api.bintray.com/packages/insanusmokrassar/StandardRepository/TelegramBotAPI/images/download.svg) ](https://bintray.com/insanusmokrassar/StandardRepository/TelegramBotAPI/_latestVersion)
-[![Build Status](https://jenkins.insanusmokrassar.com/buildStatus/icon?job=TelegramBotAPI_master__publishing)](https://jenkins.insanusmokrassar.com/job/TelegramBotAPI_master__publishing/)
+| [![Awesome Kotlin Badge](https://kotlin.link/awesome-kotlin.svg)](https://github.com/KotlinBy/awesome-kotlin) [![Build Status](https://github.com/InsanusMokrassar/TelegramBotAPI/workflows/Build/badge.svg)](https://github.com/InsanusMokrassar/TelegramBotAPI/actions) [![Small survey](https://img.shields.io/static/v1?label=Google&message=Survey&color=blue&logo=google-sheets)](https://docs.google.com/forms/d/e/1FAIpQLSctdJHT_aEniyYT0-IUAEfo1hsIlezX2owlkEAYX4KPl2V2_A/viewform?usp=sf_link) [![Chat in Telegram](https://img.shields.io/static/v1?label=Telegram&message=Chat&color=blue&logo=telegram)](https://t.me/InMoTelegramBotAPI) |
+|:---:|
+| [![Create bot](https://img.shields.io/static/v1?label=Github&message=Template&color=blue&logo=github)](https://github.com/InsanusMokrassar/TelegramBotAPI-bot_template/generate) [![Examples](https://img.shields.io/static/v1?label=Github&message=Examples&color=blue&logo=github)](https://github.com/InsanusMokrassar/TelegramBotAPI-examples/) [![KDocs](https://img.shields.io/static/v1?label=Dokka&message=KDocs&color=blue&logo=kotlin)](https://tgbotapi.inmo.dev/index.html) [![Mini tutorial](https://img.shields.io/static/v1?label=Bookstack&message=Tutorial&color=blue&logo=bookstack)](https://bookstack.inmo.dev/books/telegrambotapi/chapter/introduction-tutorial) |
 
-## What is it?
+Hello! This is a set of libraries for working with Telegram Bot 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).
+## Examples
 
-## Compatibility
+There are several things you need to do to launch examples below:
 
-This version compatible with [23th of January 2020 update of TelegramBotAPI (version 4.6)](https://core.telegram.org/bots/api#january-23-2020).
-There is Telegram Passport API exception of implemented functionality, which was presented in
-[August 2018 update of TelegramBotAPI](https://core.telegram.org/bots/api-changelog#august-27-2018) update. It will be implemented
-as soon as possible. All APIs that are not included are presented
-[wiki](https://github.com/InsanusMokrassar/TelegramBotAPI/wiki/Not-included-API).
+* Add `mavenCentral()` to your project repositories
+    * [Maven variant](https://github.com/InsanusMokrassar/TelegramBotAPI/wiki/Including-in-your-project#pomxml)
+* Add dependency `implementation "dev.inmo:tgbotapi:$tgbotapi_version"` 
+    * Replace `tgbotapi_version` with exact version (see last one in the table above) or put variable with this name in project
+    * Alternative variant for maven [here](https://github.com/InsanusMokrassar/TelegramBotAPI/wiki/Including-in-your-project#telegrambotapi)
 
-## How to implement library?
+More including instructions [available here](https://github.com/InsanusMokrassar/TelegramBotAPI/wiki/Including-in-your-project).
+Other configuration examples:
 
-Common ways to implement this library are presented here. In some cases it will require additional steps
-like inserting of additional libraries (like `kotlin stdlib`). In the examples will be used variable
-`telegrambotapi.version`, which must be set up by developer. Available versions are presented on
-[bintray](https://bintray.com/insanusmokrassar/StandardRepository/TelegramBotAPI), next version is last published:
+* [For multiplatform](https://github.com/InsanusMokrassar/TelegramBotAPI-examples/tree/master/ResenderBot)
+* [For JVM](https://github.com/InsanusMokrassar/TelegramBotAPI-examples/blob/master/GetMeBot/build.gradle)
 
-[![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>
-  <artifactId>TelegramBotAPI</artifactId>
-  <version>${telegrambotapi.version}</version>
-</dependency>
-```
-
-### 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"
-```
-
-or for old gradle:
-
-```groovy
-compile "com.github.insanusmokrassar:TelegramBotAPI:$telegrambotapi_version"
-```
-
-## How to work with library?
-
-For now, this library have no some API god-object. Instead of this, this library has several
-important objects:
-
-* [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
-
-Types declare different objects representation. For example, `Chat` for now represented as
-interface and has several realisations:
-
-* `PrivateChat`
-* `GroupChat`
-* `SupergroupChat`
-* `ChannelChat`
-
-Instead of common garbage with all information as in original [Chat](https://core.telegram.org/bots/api#chat),
-here it was separated for more obvious difference between chats types and their possible content.
-
-The same principle work with a lot of others things in this Telegram bot API. 
-
-### Requests
-
-Requests usually are very simple objects, but some of them are using their own
-build factories. For example, the next code show, how to get information about bot:
+### Most common example
 
 ```kotlin
-val requestsExecutor: RequestsExecutor = ...
-requestsExecutor.execute(GetMe())
-``` 
+suspend fun main() {
+  val bot = telegramBot(TOKEN)
 
-Or you can use new syntax:
-
-```kotlin
-val bot: RequestsExecutor = ...
-bot.getMe()
-```
-
-The result type of [GetMe (and getMe extension)](https://github.com/InsanusMokrassar/TelegramBotAPI/blob/master/src/commonMain/kotlin/com/github/insanusmokrassar/TelegramBotAPI/requests/GetMe.kt)
-request is
-[ExtendedBot](https://github.com/InsanusMokrassar/TelegramBotAPI/blob/master/src/commonMain/kotlin/com/github/insanusmokrassar/TelegramBotAPI/types/User.kt).
-
-### RequestsExecutor
-
-It is base object which can be used to execute requests in API. For now by default included Ktor
-realisation of `RequestsExecutor`, but it is possible, that in future it will be extracted in separated
-project. How to create `RequestsExecutor`:
-
-```kotlin
-val requestsExecutor = KtorRequestsExecutor(
-    TelegramAPIUrlsKeeper(TOKEN)
-)
-```
-
-Here:
-
-* `KtorRequestsExecutor` - default realisation with [ktor](https://ktor.io)
-* `TelegramAPIUrlsKeeper` - special keeper, which  you can save and use for getting files full urls (`resolveFileURL`
-extension inside of `PathedFile.kt`)
-* `TOKEN` is just a token of bot which was retrieved according to
-[instruction](https://core.telegram.org/bots#3-how-do-i-create-a-bot).
-
-By default, for JVM there is implemented `CIO` client engine, but there is not server engine. Both can be changed like
-here:
-
-```groovy
-dependencies {
-    // ...
-    implementation "io.ktor:ktor-server-cio:$ktor_version" // for implementing of server engine
-    implementation "io.ktor:ktor-client-okhttp:$ktor_version" // for implementing of additional client engine
-    // ...
+  bot.buildBehaviourWithLongPolling {
+    println(getMe())
+  
+    onCommand("start") {
+      reply(it, "Hi:)")
+    }
+  }.join()
 }
 ```
 
-You can avoid using of `server` dependency in case if you will not use `Webhook`s. In this case,
-dependencies list will be simplify:
+In this example you will see information about this bot at the moment of starting and answer with `Hi:)` every time it
+gets message `/start`
 
-```groovy
-dependencies {
-    // ...
-    implementation "io.ktor:ktor-client-okhttp:$ktor_version" // for implementing of additional client engine
-    // ...
+### Handling only last messages
+
+```kotlin
+suspend fun main() {
+  val bot = telegramBot(TOKEN)
+
+  val flowsUpdatesFilter = FlowsUpdatesFilter()
+  bot.buildBehaviour(flowUpdatesFilter = flowsUpdatesFilter) {
+    println(getMe())
+  
+    onCommand("start") {
+      reply(it, "Hi:)")
+    }
+
+    retrieveAccumulatedUpdates(this).join()
+  }
 }
 ```
 
-Here was used `okhttp` realisation of client, but there are several others engines for Ktor. More information
-available on ktor.io site for [client](https://ktor.io/clients/http-client/engines.html) and [server](https://ktor.io/quickstart/artifacts.html)
-engines.
+The main difference with the previous example is that bot will get only last updates (accumulated before bot launch
+and maybe some updates it got after launch)
 
-## Getting updates
-
-In this library currently realised two ways to get updates from telegram:
-
-* Polling - in this case bot will request updates from time to time (you can set up delay between requests)
-* Webhook via reverse proxy or something like this
-
-### Updates filters
-
-Currently webhook method contains `UpdatesFilter` as necessary argument for getting updates.
-`UpdatesFilter` will sort updates and throw their into different callbacks. Currently supporting
-separate getting updates for media groups - they are accumulating with debounce in one second
-(for being sure that all objects of media group was received).
-
-Updates polling also support `UpdatesFilter` but it is not required to use it and you can get updates directly
-in `UpdateReceiver`, which you will provide to `startGettingOfUpdates` method
-
-### Webhook set up
-
-If you wish to use webhook method, you will need:
-
-* White IP - your IP address or host, which available for calling. [TelegramBotAPI](https://core.telegram.org/bots/api#setwebhook)
-recommend to use some unique address for each bot which you are using
-* SSL certificate. Usually you can obtain the certificate using your domain provider, [Let'sEncrypt](https://letsencrypt.org/) or [create it](https://core.telegram.org/bots/self-signed)
-* Nginx or something like this
-
-Template for Nginx server config you can find in [this gist](https://gist.github.com/InsanusMokrassar/fcc6e09cebd07e46e8f0fdec234750c4#file-nginxssl-conf).
-
-For webhook you can provide `File` with public part of certificate, `URL` where bot will be available and inner `PORT` which
-will be used to start receiving of updates. Actually, you can skip passing of `File` when you have something like
-nginx for proxy forwarding.
-
-In case of using `nginx` with reverse-proxy config, setting up of Webhook will look like:
+### Build a little bit more complex behaviour
 
 ```kotlin
-requestsExecutor.setWebhook(
-    WEBHOOK_URL,
-    INTERNAL_PORT,
-    filter,
-    ENGINE_FACTORY
-)
-``` 
+suspend fun main() {
+  val bot = telegramBot(TOKEN)
 
-Here:
+  bot.buildBehaviourWithLongPolling {
+    println(getMe())
 
-* `WEBHOOK_URL` - the url which will be used by Telegram system to send updates
-* `INTERNAL_PORT` - the port which will be used in bot for listening of updates
-* `filter` - instance of [UpdatesFilter](https://github.com/InsanusMokrassar/TelegramBotAPI/blob/master/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
+    val nameReplyMarkup = ReplyKeyboardMarkup(
+      matrix {
+        row {
+          +SimpleKeyboardButton("nope")
+        }
+      }
+    )
+    onCommand("start") {
+      val photo = waitPhoto(
+        SendTextMessage(it.chat.id, "Send me your photo please")
+      ).first()
+
+      val name = waitText(
+        SendTextMessage(
+          it.chat.id,
+          "Send me your name or choose \"nope\"",
+          replyMarkup = nameReplyMarkup
+        )
+      ).first().text.takeIf { it != "nope" }
+
+      sendPhoto(
+        it.chat,
+        photo.mediaCollection,
+        entities = buildEntities {
+          if (name != null) regular(name) // may be collapsed up to name ?.let(::regular)
+        }
+      )
+    }
+  }.join()
+}
+```
+
+### More examples
+
+You may find examples in [this project](https://github.com/InsanusMokrassar/TelegramBotAPI-examples). Besides, you are
+always welcome in our [wiki](https://github.com/InsanusMokrassar/TelegramBotAPI/wiki/About-this-project) and
+[chat](https://t.me/InMoTelegramBotAPIChat).

build.gradle

@@ -1,81 +1,57 @@
 buildscript {
     repositories {
         mavenLocal()
-        jcenter()
         mavenCentral()
+        maven { url "https://plugins.gradle.org/m2/" }
     }
 
     dependencies {
         classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:$kotlin_version"
         classpath "org.jetbrains.kotlin:kotlin-serialization:$kotlin_version"
-        classpath "com.jfrog.bintray.gradle:gradle-bintray-plugin:$gradle_bintray_plugin_version"
+        classpath "com.github.breadmoirai:github-release:$github_release_plugin_version"
     }
 }
 
 plugins {
-    id "org.jetbrains.kotlin.multiplatform" version "$kotlin_version"
-    id "org.jetbrains.kotlin.plugin.serialization" version "$kotlin_version"
+    id "org.jetbrains.kotlin.multiplatform" version "$kotlin_version" apply false
+    id "org.jetbrains.kotlin.plugin.serialization" version "$kotlin_version" apply false
 }
 
-project.version = "0.23.1"
-project.group = "com.github.insanusmokrassar"
-
-apply from: "publish.gradle"
-
-repositories {
-    mavenLocal()
-    jcenter()
-    mavenCentral()
-    maven { url "https://kotlin.bintray.com/kotlinx" }
-}
-
-kotlin {
-    jvm()
-    js()
-
-    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"
-
-                api "com.soywiz.korlibs.klock:klock:$klock_version"
-                api "com.benasher44:uuid:$uuid_version"
-
-                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"
+// temporal crutch until legacy tests will be stabled or legacy target will be removed
+allprojects {
+    if (it != rootProject.findProject("docs")) {
+        tasks.whenTaskAdded { task ->
+            if(task.name == "jsLegacyBrowserTest" || task.name == "jsLegacyNodeTest") {
+                task.enabled = false
             }
         }
     }
 }
+
+private String getCurrentVersionChangelog() {
+    OutputStream changelogDataOS = new ByteArrayOutputStream()
+    exec {
+        standardOutput = changelogDataOS
+        commandLine './changelog_info_retriever', "$library_version", 'CHANGELOG.md'
+    }
+
+    return changelogDataOS.toString().trim()
+}
+
+if (new File(projectDir, "secret.gradle").exists()) {
+    apply from: './secret.gradle'
+    apply plugin: "com.github.breadmoirai.github-release"
+
+    githubRelease {
+        token "${project.property('GITHUB_RELEASE_TOKEN')}"
+
+        owner "InsanusMokrassar"
+        repo "TelegramBotAPI"
+
+        tagName "$library_version"
+        releaseName "$library_version"
+        targetCommitish "$library_version"
+
+        body getCurrentVersionChangelog()
+    }
+}

changelog_info_retriever

@@ -0,0 +1,24 @@
+#!/bin/bash
+
+function parse() {
+    version=$1
+
+    while IFS= read -r line && [ -z "`echo $line | grep -e "^#\+ $version"`" ]
+    do
+        : # do nothing
+    done
+
+    while IFS= read -r line && [ -z "`echo $line | grep -e "^#\+"`" ]
+    do
+        echo "$line"
+    done
+}
+
+version=$1
+file=$2
+
+if [ -n "$file" ]; then
+  parse $version < "$file"
+else
+  parse $version
+fi

docs/build.gradle

@@ -0,0 +1,110 @@
+buildscript {
+    repositories {
+        mavenLocal()
+        mavenCentral()
+    }
+
+    dependencies {
+        classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:$kotlin_version"
+        classpath "org.jetbrains.kotlin:kotlin-serialization:$kotlin_version"
+        classpath "org.jetbrains.dokka:dokka-gradle-plugin:$dokka_version"
+    }
+}
+
+plugins {
+    id "org.jetbrains.kotlin.multiplatform"
+    id "org.jetbrains.kotlin.plugin.serialization"
+    id "org.jetbrains.dokka" version "$dokka_version"
+}
+
+repositories {
+    mavenLocal()
+    mavenCentral()
+}
+
+kotlin {
+    jvm {
+        compilations.main {
+            kotlinOptions {
+                jvmTarget = "1.8"
+            }
+        }
+    }
+    js(IR) {
+        browser()
+        nodejs()
+    }
+
+    sourceSets {
+        commonMain {
+            dependencies {
+                implementation kotlin('stdlib')
+
+                api project(":tgbotapi.core")
+                api project(":tgbotapi.api")
+                api project(":tgbotapi.utils")
+                api project(":tgbotapi.behaviour_builder")
+                api project(":tgbotapi.behaviour_builder.fsm")
+                api project(":tgbotapi")
+            }
+        }
+        jsMain {
+            dependencies {
+                api project(":tgbotapi.webapps")
+            }
+        }
+    }
+}
+
+private List<SourceDirectorySet> findSourcesWithName(String... approximateNames) {
+    return parent.subprojects
+        .findAll { it != project }
+        .collectMany { it.kotlin.sourceSets }
+        .findAll { sourceSet -> approximateNames.any {
+            nameToFilter -> sourceSet.name.contains(nameToFilter)
+            }
+        }.collect { it.kotlin }
+}
+
+Object callback = {
+    switch (true) {
+        case project.hasProperty("DOKKA_PATH"):
+            outputDirectory = project.property("DOKKA_PATH").toString()
+            break
+        case System.getenv("DOKKA_PATH") != null:
+            outputDirectory = System.getenv("DOKKA_PATH")
+            break
+    }
+
+    dokkaSourceSets {
+        configureEach {
+            skipDeprecated.set(true)
+
+            sourceLink {
+                localDirectory.set(file("./"))
+                remoteUrl.set(new URL("https://github.com/InsanusMokrassar/TelegramBotAPI/blob/master/"))
+                remoteLineSuffix.set("#L")
+            }
+        }
+
+        named("commonMain") {
+            sourceRoots.setFrom(findSourcesWithName("commonMain"))
+        }
+
+        named("jsMain") {
+            sourceRoots.setFrom(findSourcesWithName("jsMain"))
+        }
+
+        named("jvmMain") {
+            sourceRoots.setFrom(findSourcesWithName("jvmMain"))
+        }
+    }
+}
+
+tasks.dokkaGfm(callback)
+tasks.dokkaHtml(callback)
+
+java {
+    sourceCompatibility = JavaVersion.VERSION_1_8
+    targetCompatibility = JavaVersion.VERSION_1_8
+}

docs/gradle.properties

@@ -0,0 +1 @@
+org.gradle.jvmargs=-Xmx1024m

gradle.properties

@@ -1,9 +1,25 @@
+org.gradle.jvmargs=-Xmx2048m
 kotlin.code.style=official
-kotlin_version=1.3.61
-kotlin_coroutines_version=1.3.3
-kotlin_serialisation_runtime_version=0.14.0
-klock_version=1.8.7
-uuid_version=0.0.7
-ktor_version=1.3.1
+org.gradle.parallel=true
+kotlin.js.generate.externals=true
+kotlin.incremental=true
+kotlin.incremental.js=true
 
-gradle_bintray_plugin_version=1.8.4
+kotlin_version=1.6.10
+kotlin_coroutines_version=1.6.1
+kotlin_serialisation_runtime_version=1.3.2
+klock_version=2.7.0
+uuid_version=0.4.0
+ktor_version=1.6.8
+
+micro_utils_version=0.9.24
+
+javax_activation_version=1.1.1
+
+
+dokka_version=1.6.10
+
+library_group=dev.inmo
+library_version=0.38.15
+
+github_release_plugin_version=2.3.7

gradle/wrapper/gradle-wrapper.properties

@@ -1,6 +1,5 @@
-#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-6.0.1-all.zip
+distributionUrl=https\://services.gradle.org/distributions/gradle-7.4.2-bin.zip

maven.publish.gradle

@@ -1,57 +0,0 @@
-apply plugin: 'maven-publish'
-
-task javadocsJar(type: Jar) {
-    classifier = 'javadoc'
-}
-
-afterEvaluate {
-    project.publishing.publications.all {
-        // rename artifacts
-        groupId "${project.group}"
-        if (it.name.contains('kotlinMultiplatform')) {
-            artifactId = "${project.name}"
-        } else {
-            artifactId = "${project.name}-$name"
-        }
-    }
-}
-
-publishing {
-    publications.all {
-        artifact javadocsJar
-
-        pom.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

@@ -1 +0,0 @@
-{"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,55 +1,79 @@
-apply plugin: 'com.jfrog.bintray'
+apply plugin: 'maven-publish'
 
-apply from: "maven.publish.gradle"
+task javadocsJar(type: Jar) {
+    classifier = 'javadoc'
+}
 
-bintray {
-    user = project.hasProperty('BINTRAY_USER') ? project.property('BINTRAY_USER') : System.getenv('BINTRAY_USER')
-    key = project.hasProperty('BINTRAY_KEY') ? project.property('BINTRAY_KEY') : System.getenv('BINTRAY_KEY')
-    filesSpec {
-        from "${buildDir}/publications/"
-        eachFile {
-            String directorySubname = it.getFile().parentFile.name
-            if (it.getName() == "module.json") {
-                if (directorySubname == "kotlinMultiplatform") {
-                    it.setPath("${project.name}/${project.version}/${project.name}-${project.version}.module")
-                } else {
-                    it.setPath("${project.name}-${directorySubname}/${project.version}/${project.name}-${directorySubname}-${project.version}.module")
-                }
-            } else {
-                if (directorySubname == "kotlinMultiplatform" && it.getName() == "pom-default.xml") {
-                    it.setPath("${project.name}/${project.version}/${project.name}-${project.version}.pom")
-                } else {
-                    it.exclude()
-                }
+publishing {
+    publications.all {
+        artifact javadocsJar
+
+        pom {
+            description = "${project.description}"
+            name = "${project.name}"
+            url = "https://insanusmokrassar.github.io/TelegramBotAPI/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"
+                    }
+                
             }
         }
-        into "${project.group}".replace(".", "/")
-    }
-    pkg {
-        repo = "StandardRepository"
-        name = "${project.name}"
-        vcsUrl = "https://github.com/InsanusMokrassar/TelegramBotAPI"
-        licenses = ["Apache-2.0"]
-        version {
-            name = "${project.version}"
-            released = new Date()
-            vcsTag = "${project.version}"
-            gpg {
-                sign = true
-                passphrase = project.hasProperty('signing.gnupg.passphrase') ? project.property('signing.gnupg.passphrase') : System.getenv('signing.gnupg.passphrase')
+        repositories {
+            if ((project.hasProperty('GITHUBPACKAGES_USER') || System.getenv('GITHUBPACKAGES_USER') != null) && (project.hasProperty('GITHUBPACKAGES_PASSWORD') || System.getenv('GITHUBPACKAGES_PASSWORD') != null)) {
+                maven {
+                    name = "GithubPackages"
+                    url = uri("https://maven.pkg.github.com/InsanusMokrassar/TelegramBotAPI")
+                    credentials {
+                        username = project.hasProperty('GITHUBPACKAGES_USER') ? project.property('GITHUBPACKAGES_USER') : System.getenv('GITHUBPACKAGES_USER')
+                        password = project.hasProperty('GITHUBPACKAGES_PASSWORD') ? project.property('GITHUBPACKAGES_PASSWORD') : System.getenv('GITHUBPACKAGES_PASSWORD')
+                    }
+                }
+            }
+            if ((project.hasProperty('SONATYPE_USER') || System.getenv('SONATYPE_USER') != null) && (project.hasProperty('SONATYPE_PASSWORD') || System.getenv('SONATYPE_PASSWORD') != null)) {
+                maven {
+                    name = "sonatype"
+                    url = uri("https://oss.sonatype.org/service/local/staging/deploy/maven2/")
+                    credentials {
+                        username = project.hasProperty('SONATYPE_USER') ? project.property('SONATYPE_USER') : System.getenv('SONATYPE_USER')
+                        password = project.hasProperty('SONATYPE_PASSWORD') ? project.property('SONATYPE_PASSWORD') : System.getenv('SONATYPE_PASSWORD')
+                    }
+                }
             }
         }
     }
 }
-
-bintrayUpload.doFirst {
-    publications = publishing.publications.collect {
-        if (it.name.contains('kotlinMultiplatform')) {
-            null
-        } else {
-            it.name
+    
+if (project.hasProperty("signing.gnupg.keyName")) {
+    apply plugin: 'signing'
+    
+    signing {
+        useGpgCmd()
+    
+        sign publishing.publications
+    }
+    
+    task signAll {
+        tasks.withType(Sign).forEach {
+            dependsOn(it)
         }
-    } - null
+    }
 }
-
-bintrayUpload.dependsOn publishToMavenLocal

publish.kpsb

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

readmes/exceptions_handling.md

@@ -0,0 +1,97 @@
+# Exceptions handling
+
+Unfortunatelly, exceptions handling in this library is a bit difficult in some places, but that have at least two reasons: flexibility and usability.
+
+## "In place" handling
+
+In case you know, where exceptions are happening, you may use several tools for exceptions catching:
+
+* Catching with result
+* Catching with callback
+
+### Catching with result
+
+If you prefer to receive `Result` objects instead of some weird callbacks, you may use the next syntax:
+
+```kotlin
+safelyWithResult {
+    // do something
+}.onSuccess { // will be called if everything is right
+    // handle success
+}.onFailure { // will be called if something went wrong
+    // handle error
+    it.printStackTrace()
+}.getOrThrow() // will return value or throw exception
+```
+
+### Catching with callback
+
+Also there is more simple (in some cases) way to handle exceptions with callbacks:
+
+```kotlin
+safely(
+  {
+      // handle error
+      it.printStackTrace()
+      null // return value
+  }
+) {
+    // do something
+}
+```
+
+### Bonus: different types of handling
+
+There are two types of handling:
+
+* Just safely - when you are using something to obviously retrieve value or throw exception. When handling callback has been skipped, it will throw exception by default. For example:
+```kotlin
+safely(
+    {
+        it.printStackTrace()
+        "error"
+    }
+) {
+    error("Hi :)") // emulate exception throwing
+    "ok"
+} // result will be with type String
+```
+* Safely without exceptions - almost the same as `safely`, but this type by default allow to return nullable value (when exception was thrown) instead of just throwing (as with `safely`):
+```kotlin
+safelyWithouExceptions {
+    // do something
+} // will returns nullable result type
+```
+
+## Global exceptions handling
+
+The most simple way to configure exceptions handling is to change `CoroutineContext` when you are creating your `CoroutineScope` for bot processing:
+
+```kotlin
+val bot = telegramBot("TOKEN")
+
+bot.buildBehaviour (
+    scope = scope,
+    defaultExceptionsHandler = {
+        it.printStackTrace()
+    }
+) {
+    // ...
+}
+```
+
+OR
+
+```kotlin
+val bot = telegramBotWithBehaviour (
+    "TOKEN",
+    scope = scope,
+    defaultExceptionsHandler = {
+        it.printStackTrace()
+    }
+) {
+    // ...
+}
+```
+
+Here we have used `ContextSafelyExceptionHandler` class. It will pass default handling of exceptions and will call the block in most cases when something inside of your bot logic has thrown exception.

renovate.json

@@ -0,0 +1,5 @@
+{
+  "extends": [
+    "config:base"
+  ]
+}

settings.gradle

@@ -1 +1,25 @@
-rootProject.name = 'TelegramBotAPI'
+pluginManagement {
+    resolutionStrategy {
+        eachPlugin {
+            if (requested.id.id == "org.jetbrains.dokka") {
+                useModule("org.jetbrains.dokka:dokka-gradle-plugin:${requested.version}")
+            }
+        }
+    }
+    repositories {
+        gradlePluginPortal()
+    }
+}
+
+include ":tgbotapi.core"
+include ":tgbotapi.api"
+include ":tgbotapi.utils"
+include ":tgbotapi.behaviour_builder"
+include ":tgbotapi.behaviour_builder.fsm"
+include ":tgbotapi.extensions.api"
+include ":tgbotapi.extensions.utils"
+include ":tgbotapi.extensions.behaviour_builder"
+include ":tgbotapi.extensions.behaviour_builder.fsm"
+include ":tgbotapi"
+include ":tgbotapi.webapps"
+include ":docs"

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

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

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

@@ -1,8 +0,0 @@
-package com.github.insanusmokrassar.TelegramBotAPI.CommonAbstracts
-
-interface CommonVenueData : Titled {
-    override val title: String
-    val address: String
-    val foursquareId: String?
-    val foursquareType: String? // TODO:: Rewrite with enum or interface
-}

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

@@ -1,8 +0,0 @@
-package com.github.insanusmokrassar.TelegramBotAPI.CommonAbstracts
-
-interface Livable {
-    /**
-     * Period in SECONDS
-     */
-    val livePeriod: Int?
-}

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

@@ -1,5 +0,0 @@
-package com.github.insanusmokrassar.TelegramBotAPI.CommonAbstracts
-
-interface MimeTyped {
-    val mimeType: String? // TODO::replace by something like enum or interface
-}

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

@@ -1,5 +0,0 @@
-package com.github.insanusmokrassar.TelegramBotAPI.CommonAbstracts
-
-interface Performerable {
-    val performer: String?
-}

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

@@ -1,17 +0,0 @@
-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/CommonAbstracts/Titled.kt

@@ -1,5 +0,0 @@
-package com.github.insanusmokrassar.TelegramBotAPI.CommonAbstracts
-
-interface Titled {
-    val title: String?
-}

src/commonMain/kotlin/com/github/insanusmokrassar/TelegramBotAPI/CommonAbstracts/types/ChatRequest.kt

@@ -1,7 +0,0 @@
-package com.github.insanusmokrassar.TelegramBotAPI.CommonAbstracts.types
-
-import com.github.insanusmokrassar.TelegramBotAPI.types.ChatIdentifier
-
-interface ChatRequest {
-    val chatId: ChatIdentifier
-}

src/commonMain/kotlin/com/github/insanusmokrassar/TelegramBotAPI/CommonAbstracts/types/DisableNotification.kt

@@ -1,5 +0,0 @@
-package com.github.insanusmokrassar.TelegramBotAPI.CommonAbstracts.types
-
-interface DisableNotification {
-    val disableNotification: Boolean
-}

src/commonMain/kotlin/com/github/insanusmokrassar/TelegramBotAPI/CommonAbstracts/types/InlineMessageAction.kt

@@ -1,7 +0,0 @@
-package com.github.insanusmokrassar.TelegramBotAPI.CommonAbstracts.types
-
-import com.github.insanusmokrassar.TelegramBotAPI.types.InlineMessageIdentifier
-
-interface InlineMessageAction {
-    val inlineMessageId: InlineMessageIdentifier
-}

src/commonMain/kotlin/com/github/insanusmokrassar/TelegramBotAPI/CommonAbstracts/types/MessageAction.kt

@@ -1,7 +0,0 @@
-package com.github.insanusmokrassar.TelegramBotAPI.CommonAbstracts.types
-
-import com.github.insanusmokrassar.TelegramBotAPI.types.MessageIdentifier
-
-interface MessageAction: ChatRequest {
-    val messageId: MessageIdentifier
-}

src/commonMain/kotlin/com/github/insanusmokrassar/TelegramBotAPI/CommonAbstracts/types/ReplyMarkup.kt

@@ -1,7 +0,0 @@
-package com.github.insanusmokrassar.TelegramBotAPI.CommonAbstracts.types
-
-import com.github.insanusmokrassar.TelegramBotAPI.types.buttons.KeyboardMarkup
-
-interface ReplyMarkup {
-    val replyMarkup: KeyboardMarkup?
-}

src/commonMain/kotlin/com/github/insanusmokrassar/TelegramBotAPI/CommonAbstracts/types/ReplyMessageId.kt

@@ -1,7 +0,0 @@
-package com.github.insanusmokrassar.TelegramBotAPI.CommonAbstracts.types
-
-import com.github.insanusmokrassar.TelegramBotAPI.types.MessageIdentifier
-
-interface ReplyMessageId {
-    val replyToMessageId: MessageIdentifier?
-}

src/commonMain/kotlin/com/github/insanusmokrassar/TelegramBotAPI/CommonAbstracts/types/UntilDate.kt

@@ -1,7 +0,0 @@
-package com.github.insanusmokrassar.TelegramBotAPI.CommonAbstracts.types
-
-import com.github.insanusmokrassar.TelegramBotAPI.types.TelegramDate
-
-interface UntilDate {
-    val untilDate: TelegramDate?
-}

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

@@ -1,7 +0,0 @@
-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

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

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

@@ -1,87 +0,0 @@
-package com.github.insanusmokrassar.TelegramBotAPI.bot.Ktor
-
-import com.github.insanusmokrassar.TelegramBotAPI.bot.BaseRequestsExecutor
-import com.github.insanusmokrassar.TelegramBotAPI.bot.Ktor.base.MultipartRequestCallFactory
-import com.github.insanusmokrassar.TelegramBotAPI.bot.Ktor.base.SimpleRequestCallFactory
-import com.github.insanusmokrassar.TelegramBotAPI.bot.exceptions.newRequestException
-import com.github.insanusmokrassar.TelegramBotAPI.bot.settings.limiters.EmptyLimiter
-import com.github.insanusmokrassar.TelegramBotAPI.bot.settings.limiters.RequestLimiter
-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.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(
-    telegramAPIUrlsKeeper: TelegramAPIUrlsKeeper,
-    private val client: HttpClient = HttpClient(),
-    callsFactories: List<KtorCallFactory> = emptyList(),
-    excludeDefaultFactories: Boolean = false,
-    private val requestsLimiter: RequestLimiter = EmptyLimiter,
-    private val jsonFormatter: Json = Json.nonstrict
-) : BaseRequestsExecutor(telegramAPIUrlsKeeper) {
-    private val callsFactories: List<KtorCallFactory> = callsFactories.run {
-        if (!excludeDefaultFactories) {
-            asSequence().plus(SimpleRequestCallFactory()).plus(MultipartRequestCallFactory()).toList()
-        } else {
-            this
-        }
-    }
-
-    override suspend fun <T : Any> execute(request: Request<T>): T {
-        return requestsLimiter.limit {
-            var statement: HttpStatement? = null
-            for (factory in callsFactories) {
-                statement = factory.prepareCall(
-                    client,
-                    telegramAPIUrlsKeeper.commonAPIUrl,
-                    request
-                )
-                if (statement != null) {
-                    break
-                }
-            }
-            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,
-                    "Can't get result object from $content"
-                )
-            }
-        }
-    }
-
-    override fun close() {
-        client.close()
-    }
-}

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

@@ -1,42 +0,0 @@
-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.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()
-    override suspend fun <T : Any> prepareCall(
-        client: HttpClient,
-        baseUrl: String,
-        request: Request<T>
-    ): HttpStatement? {
-        val preparedBody = prepareCallBody(client, baseUrl, request) ?: return null
-
-        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
-            },
-            client
-        )
-    }
-
-    protected abstract fun <T : Any> prepareCallBody(
-        client: HttpClient,
-        baseUrl: String,
-        request: Request<T>
-    ): Any?
-}

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

@@ -1,11 +0,0 @@
-package com.github.insanusmokrassar.TelegramBotAPI.bot
-
-import com.github.insanusmokrassar.TelegramBotAPI.requests.abstracts.Request
-import io.ktor.utils.io.core.Closeable
-
-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,9 +0,0 @@
-package com.github.insanusmokrassar.TelegramBotAPI.bot
-
-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

@@ -1,43 +0,0 @@
-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,67 +0,0 @@
-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 = DateTime.nowUnixLong()
-
-class CommonLimiter(
-    private val lockCount: Int = 10,
-    private val regenTime: Long = 20 * 1000L // 20 seconds for full regen of opportunity to send message
-) : RequestLimiter {
-    private var doLimit: Boolean = false
-
-    private val counterChannel = Channel<Unit>(Channel.UNLIMITED)
-    private val scope = CoroutineScope(Dispatchers.Default)
-    private val counterJob = scope.launch {
-        var wasLastSecond = 0
-        var lastCountTime = now()
-        var limitManagementJob: Job? = null
-        var removeLimitTime: Long = lastCountTime
-        for (counter in counterChannel) {
-            val now = now()
-            if (now - lastCountTime > 1000) {
-                lastCountTime = now
-                wasLastSecond = 1
-            } else {
-                wasLastSecond++
-            }
-            if (wasLastSecond >= lockCount) {
-                removeLimitTime = now + regenTime
-                if (limitManagementJob == null) {
-                    limitManagementJob = launch {
-                        doLimit = true
-                        var internalNow = now()
-                        while (internalNow < removeLimitTime) {
-                            delay(removeLimitTime - internalNow)
-                            internalNow = now()
-                        }
-                        doLimit = false
-                    }
-                }
-            }
-            if (now > removeLimitTime) {
-                limitManagementJob = null
-            }
-        }
-    }
-
-    private val quoterChannel = Channel<Unit>(Channel.CONFLATED)
-    private val tickerJob = scope.launch {
-        while (isActive) {
-            quoterChannel.send(Unit)
-            delay(1000L)
-        }
-    }
-
-    override suspend fun <T> limit(block: suspend () -> T): T {
-        counterChannel.send(Unit)
-        return if (!doLimit) {
-            block()
-        } else {
-            quoterChannel.receive()
-            block()
-        }
-    }
-}

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

@@ -1,5 +0,0 @@
-package com.github.insanusmokrassar.TelegramBotAPI.bot.settings.limiters
-
-object EmptyLimiter : RequestLimiter {
-    override suspend fun <T> limit(block: suspend () -> T): T = block()
-}

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

@@ -1,70 +0,0 @@
-package com.github.insanusmokrassar.TelegramBotAPI.bot.settings.limiters
-
-import kotlinx.coroutines.*
-import kotlinx.coroutines.channels.Channel
-import kotlinx.serialization.Serializable
-import kotlinx.serialization.Transient
-import kotlin.coroutines.*
-import kotlin.math.pow
-
-private sealed class RequestEvent
-private class AddRequest(
-    val continuation: Continuation<Long>
-) : RequestEvent()
-private object CompleteRequest : RequestEvent()
-
-@Serializable
-data class PowLimiter(
-    private val minAwaitTime: Long = 0L,
-    private val maxAwaitTime: Long = 10000L,
-    private val powValue: Double = 4.0,
-    private val powK: Double = 0.0016
-) : RequestLimiter {
-    @Transient
-    private val scope = CoroutineScope(Dispatchers.Default)
-    @Transient
-    private val eventsChannel = Channel<RequestEvent>(Channel.UNLIMITED)
-    @Transient
-    private val awaitTimeRange = minAwaitTime .. maxAwaitTime
-
-    init {
-        scope.launch {
-            var requestsInWork: Double = 0.0
-            for (event in eventsChannel) {
-                when (event) {
-                    is AddRequest -> {
-                        val awaitTime = (((requestsInWork.pow(powValue) * powK) * 1000L).toLong())
-                        requestsInWork++
-
-                        event.continuation.resume(
-                            if (awaitTime in awaitTimeRange) {
-                                awaitTime
-                            } else {
-                                if (awaitTime < minAwaitTime) {
-                                    minAwaitTime
-                                } else {
-                                    maxAwaitTime
-                                }
-                            }
-                        )
-                    }
-                    is CompleteRequest -> requestsInWork--
-                }
-            }
-        }
-    }
-
-    override suspend fun <T> limit(
-        block: suspend () -> T
-    ): T {
-        val delayMillis = suspendCoroutine<Long> {
-            scope.launch { eventsChannel.send(AddRequest(it)) }
-        }
-        delay(delayMillis)
-        return try {
-            block()
-        } finally {
-            eventsChannel.send(CompleteRequest)
-        }
-    }
-}

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

@@ -1,45 +0,0 @@
-package com.github.insanusmokrassar.TelegramBotAPI.requests
-
-import com.github.insanusmokrassar.TelegramBotAPI.CommonAbstracts.types.MessageAction
-import com.github.insanusmokrassar.TelegramBotAPI.bot.RequestsExecutor
-import com.github.insanusmokrassar.TelegramBotAPI.requests.abstracts.SimpleRequest
-import com.github.insanusmokrassar.TelegramBotAPI.types.*
-import com.github.insanusmokrassar.TelegramBotAPI.types.chat.abstracts.Chat
-import com.github.insanusmokrassar.TelegramBotAPI.types.message.abstracts.Message
-import kotlinx.serialization.*
-import kotlinx.serialization.internal.BooleanSerializer
-
-@Serializable
-data class DeleteMessage(
-    @SerialName(chatIdField)
-    override val chatId: ChatIdentifier,
-    @SerialName(messageIdField)
-    override val messageId: MessageIdentifier
-) : SimpleRequest<Boolean>, MessageAction {
-    override fun method(): String = "deleteMessage"
-
-    override val resultDeserializer: DeserializationStrategy<Boolean>
-        get() = BooleanSerializer
-    override val requestSerializer: SerializationStrategy<*>
-        get() = serializer()
-}
-
-suspend fun RequestsExecutor.deleteMessage(
-    chatId: ChatIdentifier,
-    messageId: MessageIdentifier
-) = execute(
-    DeleteMessage(chatId, messageId)
-)
-
-suspend fun RequestsExecutor.deleteMessage(
-    chat: Chat,
-    messageId: MessageIdentifier
-) = deleteMessage(chat.id, messageId)
-
-suspend fun RequestsExecutor.deleteMessage(
-    message: Message
-) = deleteMessage(message.chat, message.messageId)
-
-suspend fun Message.delete(
-    requestsExecutor: RequestsExecutor
-) = requestsExecutor.deleteMessage(this)

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

@@ -1,76 +0,0 @@
-package com.github.insanusmokrassar.TelegramBotAPI.requests
-
-import com.github.insanusmokrassar.TelegramBotAPI.CommonAbstracts.types.MessageAction
-import com.github.insanusmokrassar.TelegramBotAPI.bot.RequestsExecutor
-import com.github.insanusmokrassar.TelegramBotAPI.requests.abstracts.SimpleRequest
-import com.github.insanusmokrassar.TelegramBotAPI.types.*
-import com.github.insanusmokrassar.TelegramBotAPI.types.chat.abstracts.Chat
-import com.github.insanusmokrassar.TelegramBotAPI.types.message.abstracts.*
-import com.github.insanusmokrassar.TelegramBotAPI.types.message.abstracts.TelegramBotAPIMessageDeserializationStrategyClass
-import kotlinx.serialization.*
-
-private val AbleToBeForwardedMessageDeserializer = TelegramBotAPIMessageDeserializationStrategyClass<PossiblyForwardedMessage>()
-
-@Serializable
-data class ForwardMessage(
-    @SerialName(fromChatIdField)
-    val fromChatId: ChatIdentifier,
-    @SerialName(chatIdField)
-    val toChatId: ChatIdentifier,
-    @SerialName(messageIdField)
-    override val messageId: MessageIdentifier,
-    @SerialName(disableNotificationField)
-    val disableNotification: Boolean = false
-): SimpleRequest<PossiblyForwardedMessage>, MessageAction {
-    override val chatId: ChatIdentifier
-        get() = fromChatId
-
-    override fun method(): String = "forwardMessage"
-
-    override val resultDeserializer: DeserializationStrategy<PossiblyForwardedMessage>
-        get() = AbleToBeForwardedMessageDeserializer
-    override val requestSerializer: SerializationStrategy<*>
-        get() = serializer()
-}
-
-suspend fun RequestsExecutor.forwardMessage(
-    fromChatId: ChatIdentifier,
-    toChatId: ChatIdentifier,
-    messageId: MessageIdentifier,
-    disableNotification: Boolean = false
-) = execute(
-    ForwardMessage(fromChatId, toChatId, messageId, disableNotification)
-)
-
-suspend fun RequestsExecutor.forwardMessage(
-    fromChat: Chat,
-    toChatId: ChatIdentifier,
-    messageId: MessageIdentifier,
-    disableNotification: Boolean = false
-) = forwardMessage(fromChat.id, toChatId, messageId, disableNotification)
-
-suspend fun RequestsExecutor.forwardMessage(
-    fromChatId: ChatIdentifier,
-    toChat: Chat,
-    messageId: MessageIdentifier,
-    disableNotification: Boolean = false
-) = forwardMessage(fromChatId, toChat.id, messageId, disableNotification)
-
-suspend fun RequestsExecutor.forwardMessage(
-    fromChat: Chat,
-    toChat: Chat,
-    messageId: MessageIdentifier,
-    disableNotification: Boolean = false
-) = forwardMessage(fromChat.id, toChat.id, messageId, disableNotification)
-
-suspend fun RequestsExecutor.forwardMessage(
-    toChatId: ChatIdentifier,
-    message: Message,
-    disableNotification: Boolean = false
-) = forwardMessage(message.chat, toChatId, message.messageId, disableNotification)
-
-suspend fun RequestsExecutor.forwardMessage(
-    toChat: Chat,
-    message: Message,
-    disableNotification: Boolean = false
-) = forwardMessage(message.chat, toChat, message.messageId, disableNotification)

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

@@ -1,17 +0,0 @@
-package com.github.insanusmokrassar.TelegramBotAPI.requests
-
-import com.github.insanusmokrassar.TelegramBotAPI.bot.RequestsExecutor
-import com.github.insanusmokrassar.TelegramBotAPI.requests.abstracts.SimpleRequest
-import com.github.insanusmokrassar.TelegramBotAPI.types.*
-import kotlinx.serialization.*
-
-@Serializable
-class GetMe : SimpleRequest<ExtendedBot> {
-    override fun method(): String = "getMe"
-    override val resultDeserializer: DeserializationStrategy<ExtendedBot>
-        get() = ExtendedBot.serializer()
-    override val requestSerializer: SerializationStrategy<*>
-        get() = serializer()
-}
-
-suspend fun RequestsExecutor.getMe() = execute(GetMe())

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

@@ -1,50 +0,0 @@
-package com.github.insanusmokrassar.TelegramBotAPI.requests
-
-import com.github.insanusmokrassar.TelegramBotAPI.bot.RequestsExecutor
-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()
-}
-
-suspend fun RequestsExecutor.getUpdates(
-    offset: UpdateIdentifier? = null,
-    limit: Int? = null,
-    timeout: Int? = null,
-    allowed_updates: List<String>? = ALL_UPDATES_LIST
-) = execute(
-    GetUpdates(
-        offset, limit, timeout, allowed_updates
-    )
-)
-
-suspend fun RequestsExecutor.getUpdates(
-    lastUpdate: Update,
-    limit: Int? = null,
-    timeout: Int? = null,
-    allowed_updates: List<String>? = ALL_UPDATES_LIST
-) = getUpdates(
-    lastUpdate.updateId + 1, limit, timeout, allowed_updates
-)

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

@@ -1,133 +0,0 @@
-package com.github.insanusmokrassar.TelegramBotAPI.requests
-
-import com.github.insanusmokrassar.TelegramBotAPI.bot.RequestsExecutor
-import com.github.insanusmokrassar.TelegramBotAPI.requests.edit.LiveLocation.*
-import com.github.insanusmokrassar.TelegramBotAPI.requests.send.SendLocation
-import com.github.insanusmokrassar.TelegramBotAPI.types.*
-import com.github.insanusmokrassar.TelegramBotAPI.types.buttons.InlineKeyboardMarkup
-import com.github.insanusmokrassar.TelegramBotAPI.types.buttons.KeyboardMarkup
-import com.github.insanusmokrassar.TelegramBotAPI.types.chat.abstracts.Chat
-import com.github.insanusmokrassar.TelegramBotAPI.types.message.abstracts.ContentMessage
-import com.github.insanusmokrassar.TelegramBotAPI.types.message.content.LocationContent
-import com.soywiz.klock.DateTime
-import com.soywiz.klock.TimeSpan
-import io.ktor.utils.io.core.Closeable
-import kotlinx.coroutines.*
-import kotlin.math.ceil
-
-private val livePeriodDelayMillis = (livePeriodLimit.last - 60L) * 1000L
-class LiveLocation internal constructor(
-    private val requestsExecutor: RequestsExecutor,
-    scope: CoroutineScope,
-    autoCloseTimeDelay: Double,
-    initMessage: ContentMessage<LocationContent>
-) : Closeable {
-    private val doWhenClose = {
-        scope.launch {
-            requestsExecutor.stopLiveLocation(message)
-        }
-    }
-    private val autoCloseTime = DateTime.now() + TimeSpan(autoCloseTimeDelay)
-    val leftUntilCloseMillis: TimeSpan
-        get() = autoCloseTime - DateTime.now()
-
-    var isClosed: Boolean = false
-        private set
-        get() = field || leftUntilCloseMillis.millisecondsLong < 0L
-
-    private var message: ContentMessage<LocationContent> = initMessage
-    val lastLocation: Location
-        get() = message.content.location
-
-    suspend fun updateLocation(
-        location: Location,
-        replyMarkup: InlineKeyboardMarkup? = null
-    ): Location {
-        if (!isClosed) {
-            message = requestsExecutor.editLiveLocation(
-                message,
-                location,
-                replyMarkup
-            )
-            return lastLocation
-        } else {
-            error("LiveLocation is closed")
-        }
-    }
-
-    override fun close() {
-        if (isClosed) {
-            return
-        }
-        isClosed = true
-        doWhenClose()
-    }
-}
-
-suspend fun RequestsExecutor.startLiveLocation(
-    scope: CoroutineScope,
-    chatId: ChatIdentifier,
-    latitude: Double,
-    longitude: Double,
-    liveTimeMillis: Long = livePeriodDelayMillis,
-    disableNotification: Boolean = false,
-    replyToMessageId: MessageIdentifier? = null,
-    replyMarkup: KeyboardMarkup? = null
-): LiveLocation {
-    val liveTimeAsDouble = liveTimeMillis.toDouble()
-    val locationMessage = execute(
-        SendLocation(
-            chatId,
-            latitude,
-            longitude,
-            ceil(liveTimeAsDouble / 1000).toLong(),
-            disableNotification,
-            replyToMessageId,
-            replyMarkup
-        )
-    )
-
-    return LiveLocation(
-        this,
-        scope,
-        liveTimeAsDouble,
-        locationMessage
-    )
-}
-
-suspend fun RequestsExecutor.startLiveLocation(
-    scope: CoroutineScope,
-    chat: Chat,
-    latitude: Double,
-    longitude: Double,
-    liveTimeMillis: Long = livePeriodDelayMillis,
-    disableNotification: Boolean = false,
-    replyToMessageId: MessageIdentifier? = null,
-    replyMarkup: KeyboardMarkup? = null
-): LiveLocation = startLiveLocation(
-    scope, chat.id, latitude, longitude, liveTimeMillis, disableNotification, replyToMessageId, replyMarkup
-)
-
-suspend fun RequestsExecutor.startLiveLocation(
-    scope: CoroutineScope,
-    chatId: ChatId,
-    location: Location,
-    liveTimeMillis: Long = livePeriodDelayMillis,
-    disableNotification: Boolean = false,
-    replyToMessageId: MessageIdentifier? = null,
-    replyMarkup: KeyboardMarkup? = null
-): LiveLocation = startLiveLocation(
-    scope, chatId, location.latitude, location.longitude, liveTimeMillis, disableNotification, replyToMessageId, replyMarkup
-)
-
-suspend fun RequestsExecutor.startLiveLocation(
-    scope: CoroutineScope,
-    chat: Chat,
-    location: Location,
-    liveTimeMillis: Long = livePeriodDelayMillis,
-    disableNotification: Boolean = false,
-    replyToMessageId: MessageIdentifier? = null,
-    replyMarkup: KeyboardMarkup? = null
-): LiveLocation = startLiveLocation(
-    scope, chat.id, location.latitude, location.longitude, liveTimeMillis, disableNotification, replyToMessageId, replyMarkup
-)

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

@@ -1,55 +0,0 @@
-package com.github.insanusmokrassar.TelegramBotAPI.requests
-
-import com.github.insanusmokrassar.TelegramBotAPI.CommonAbstracts.types.MessageAction
-import com.github.insanusmokrassar.TelegramBotAPI.CommonAbstracts.types.ReplyMarkup
-import com.github.insanusmokrassar.TelegramBotAPI.bot.RequestsExecutor
-import com.github.insanusmokrassar.TelegramBotAPI.requests.abstracts.SimpleRequest
-import com.github.insanusmokrassar.TelegramBotAPI.requests.edit.ReplyMarkup.EditChatMessageReplyMarkup
-import com.github.insanusmokrassar.TelegramBotAPI.types.*
-import com.github.insanusmokrassar.TelegramBotAPI.types.buttons.InlineKeyboardMarkup
-import com.github.insanusmokrassar.TelegramBotAPI.types.chat.abstracts.Chat
-import com.github.insanusmokrassar.TelegramBotAPI.types.message.abstracts.Message
-import com.github.insanusmokrassar.TelegramBotAPI.types.polls.Poll
-import kotlinx.serialization.*
-
-@Serializable
-data class StopPoll(
-    @SerialName(chatIdField)
-    override val chatId: ChatIdentifier,
-    @SerialName(messageIdField)
-    override val messageId: MessageIdentifier,
-    @SerialName(replyMarkupField)
-    override val replyMarkup: InlineKeyboardMarkup? = null
-) : MessageAction, SimpleRequest<Poll>, ReplyMarkup {
-    override fun method(): String = "stopPoll"
-    override val resultDeserializer: DeserializationStrategy<Poll>
-        get() = Poll.serializer()
-    override val requestSerializer: SerializationStrategy<*>
-        get() = serializer()
-}
-
-suspend fun RequestsExecutor.stopPoll(
-    chatId: ChatIdentifier,
-    messageId: MessageIdentifier,
-    replyMarkup: InlineKeyboardMarkup? = null
-) = execute(
-    StopPoll(chatId, messageId, replyMarkup)
-)
-
-suspend fun RequestsExecutor.stopPoll(
-    chat: Chat,
-    messageId: MessageIdentifier,
-    replyMarkup: InlineKeyboardMarkup? = null
-) = stopPoll(chat.id, messageId, replyMarkup)
-
-suspend fun RequestsExecutor.stopPoll(
-    chatId: ChatId,
-    message: Message,
-    replyMarkup: InlineKeyboardMarkup? = null
-) = stopPoll(chatId, message.messageId, replyMarkup)
-
-suspend fun RequestsExecutor.stopPoll(
-    chat: Chat,
-    message: Message,
-    replyMarkup: InlineKeyboardMarkup? = null
-) = stopPoll(chat.id, message.messageId, replyMarkup)

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

@@ -1,41 +0,0 @@
-package com.github.insanusmokrassar.TelegramBotAPI.requests.abstracts
-
-import com.github.insanusmokrassar.TelegramBotAPI.utils.StorageFile
-import kotlinx.serialization.*
-import kotlinx.serialization.internal.StringDescriptor
-
-@Serializable(InputFileSerializer::class)
-sealed class InputFile {
-    abstract val fileId: String
-}
-
-// TODO:: add checks for file url/file id regex
-/**
- * Contains file id or file url
- */
-@Serializable(InputFileSerializer::class)
-data class FileId(
-    override val fileId: String
-) : InputFile()
-
-fun String.toInputFile() = FileId(this)
-
-@Serializer(InputFile::class)
-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())
-}
-
-// TODO:: add checks for files size
-/**
- * Contains info about file for sending
- */
-@Serializable(InputFileSerializer::class)
-data class MultipartFile (
-    val file: StorageFile,
-    val mimeType: String = file.contentType,
-    val filename: String = file.fileName
-) : InputFile() {
-    override val fileId: String = file.generateCustomName()
-}

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

@@ -1,12 +0,0 @@
-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

@@ -1,51 +0,0 @@
-package com.github.insanusmokrassar.TelegramBotAPI.requests.answers
-
-import com.github.insanusmokrassar.TelegramBotAPI.bot.RequestsExecutor
-import com.github.insanusmokrassar.TelegramBotAPI.requests.abstracts.SimpleRequest
-import com.github.insanusmokrassar.TelegramBotAPI.types.*
-import com.github.insanusmokrassar.TelegramBotAPI.types.CallbackQuery.CallbackQuery
-import kotlinx.serialization.*
-import kotlinx.serialization.internal.BooleanSerializer
-
-@Serializable
-data class AnswerCallbackQuery(
-    @SerialName(callbackQueryIdField)
-    val callbackQueryId: CallbackQueryIdentifier,
-    @SerialName(textField)
-    val text: String? = null,
-    @SerialName(showAlertField)
-    val showAlert: Boolean? = null,
-    @SerialName(urlField)
-    val url: String? = null,
-    @SerialName(cachedTimeField)
-    val cachedTimeSeconds: Int? = null
-) : SimpleRequest<Boolean> {
-    override fun method(): String = "answerCallbackQuery"
-    override val resultDeserializer: DeserializationStrategy<Boolean>
-        get() = BooleanSerializer
-    override val requestSerializer: SerializationStrategy<*>
-        get() = serializer()
-}
-
-fun CallbackQuery.createAnswer(
-    text: String? = null,
-    showAlert: Boolean? = null,
-    url: String? = null,
-    cachedTimeSeconds: Int? = null
-): AnswerCallbackQuery = AnswerCallbackQuery(id, text, showAlert, url, cachedTimeSeconds)
-
-suspend fun RequestsExecutor.answerCallbackQuery(
-    callbackQueryId: CallbackQueryIdentifier,
-    text: String? = null,
-    showAlert: Boolean? = null,
-    url: String? = null,
-    cachedTimeSeconds: Int? = null
-) = execute(AnswerCallbackQuery(callbackQueryId, text, showAlert, url, cachedTimeSeconds))
-
-suspend fun RequestsExecutor.answerCallbackQuery(
-    callbackQuery: CallbackQuery,
-    text: String? = null,
-    showAlert: Boolean? = null,
-    url: String? = null,
-    cachedTimeSeconds: Int? = null
-) = answerCallbackQuery(callbackQuery.id, text, showAlert, url, cachedTimeSeconds)

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

@@ -1,79 +0,0 @@
-package com.github.insanusmokrassar.TelegramBotAPI.requests.answers
-
-import com.github.insanusmokrassar.TelegramBotAPI.bot.RequestsExecutor
-import com.github.insanusmokrassar.TelegramBotAPI.requests.abstracts.SimpleRequest
-import com.github.insanusmokrassar.TelegramBotAPI.types.*
-import com.github.insanusmokrassar.TelegramBotAPI.types.InlineQueries.InlineQueryResult.abstracts.InlineQueryResult
-import com.github.insanusmokrassar.TelegramBotAPI.types.InlineQueries.InlineQueryResult.serializers.InlineQueryResultSerializer
-import com.github.insanusmokrassar.TelegramBotAPI.types.InlineQueries.abstracts.InlineQuery
-import kotlinx.serialization.*
-import kotlinx.serialization.internal.ArrayListSerializer
-import kotlinx.serialization.internal.BooleanSerializer
-
-@Serializable
-data class AnswerInlineQuery(
-    @SerialName(inlineQueryIdField)
-    val inlineQueryID: InlineQueryIdentifier,
-    @Serializable(InlineQueryAnswersResultsSerializer::class)
-    @SerialName(resultsField)
-    val results: List<InlineQueryResult> = emptyList(),
-    @SerialName(cachedTimeField)
-    val cachedTime: Int? = null,
-    @SerialName(isPersonalField)
-    val isPersonal: Boolean? = null,
-    @SerialName(nextOffsetField)
-    val nextOffset: String? = null,
-    @SerialName(switchPmTextField)
-    val switchPmText: String? = null,
-    @SerialName(switchPmParameterField)
-    val switchPmParameter: String? = null
-): SimpleRequest<Boolean> {
-    override fun method(): String = "answerInlineQuery"
-    override val resultDeserializer: DeserializationStrategy<Boolean>
-        get() = BooleanSerializer
-    override val requestSerializer: SerializationStrategy<*>
-        get() = serializer()
-}
-
-fun InlineQuery.createAnswer(
-    results: List<InlineQueryResult> = emptyList(),
-    cachedTime: Int? = null,
-    isPersonal: Boolean? = null,
-    nextOffset: String? = null,
-    switchPmText: String? = null,
-    switchPmParameter: String? = null
-) = AnswerInlineQuery(
-    id,
-    results,
-    cachedTime,
-    isPersonal,
-    nextOffset,
-    switchPmText,
-    switchPmParameter
-)
-
-suspend fun RequestsExecutor.answerInlineQuery(
-    inlineQueryID: InlineQueryIdentifier,
-    results: List<InlineQueryResult> = emptyList(),
-    cachedTime: Int? = null,
-    isPersonal: Boolean? = null,
-    nextOffset: String? = null,
-    switchPmText: String? = null,
-    switchPmParameter: String? = null
-) = execute(
-    AnswerInlineQuery(inlineQueryID, results, cachedTime, isPersonal, nextOffset, switchPmText, switchPmParameter)
-)
-
-suspend fun RequestsExecutor.answerInlineQuery(
-    inlineQuery: InlineQuery,
-    results: List<InlineQueryResult> = emptyList(),
-    cachedTime: Int? = null,
-    isPersonal: Boolean? = null,
-    nextOffset: String? = null,
-    switchPmText: String? = null,
-    switchPmParameter: String? = null
-) = answerInlineQuery(inlineQuery.id, results, cachedTime, isPersonal, nextOffset, switchPmText, switchPmParameter)
-
-internal object InlineQueryAnswersResultsSerializer: KSerializer<List<InlineQueryResult>> by ArrayListSerializer(
-    InlineQueryResultSerializer
-)

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

@@ -1,74 +0,0 @@
-package com.github.insanusmokrassar.TelegramBotAPI.requests.answers.payments
-
-import com.github.insanusmokrassar.TelegramBotAPI.bot.RequestsExecutor
-import com.github.insanusmokrassar.TelegramBotAPI.requests.answers.payments.abstracts.AnswerShippingQuery
-import com.github.insanusmokrassar.TelegramBotAPI.types.*
-import com.github.insanusmokrassar.TelegramBotAPI.types.payments.ShippingOption
-import com.github.insanusmokrassar.TelegramBotAPI.types.payments.ShippingQuery
-import kotlinx.serialization.*
-import kotlinx.serialization.internal.ArrayListSerializer
-
-@Serializable
-data class AnswerShippingQueryOk(
-    @SerialName(shippingQueryIdField)
-    override val shippingQueryId: ShippingQueryIdentifier,
-    @Serializable(ShippingOptionsSerializer::class)
-    @SerialName(shippingOptionsField)
-    val shippingOptions: List<ShippingOption>
-) : AnswerShippingQuery {
-    @SerialName(okField)
-    override val isOk: Boolean = true
-    override val requestSerializer: SerializationStrategy<*>
-        get() = serializer()
-}
-
-internal object ShippingOptionsSerializer : KSerializer<List<ShippingOption>> by ArrayListSerializer(
-    ShippingOption.serializer()
-)
-
-@Serializable
-data class AnswerShippingQueryError(
-    @SerialName(shippingQueryIdField)
-    override val shippingQueryId: ShippingQueryIdentifier,
-    @SerialName(errorMessageField)
-    val error: String
-) : AnswerShippingQuery {
-    @SerialName(okField)
-    override val isOk: Boolean = false
-    override val requestSerializer: SerializationStrategy<*>
-        get() = serializer()
-}
-
-fun ShippingQuery.createAnswerOk(
-    shippingOptions: List<ShippingOption>
-): AnswerShippingQueryOk = AnswerShippingQueryOk(
-    id,
-    shippingOptions
-)
-
-fun ShippingQuery.createAnswerError(
-    error: String
-): AnswerShippingQueryError = AnswerShippingQueryError(
-    id,
-    error
-)
-
-suspend fun RequestsExecutor.answerShippingQueryOk(
-    id: ShippingQueryIdentifier,
-    shippingOptions: List<ShippingOption>
-) = execute(AnswerShippingQueryOk(id, shippingOptions))
-suspend fun RequestsExecutor.answerShippingQueryOk(
-    shippingQuery: ShippingQuery,
-    shippingOptions: List<ShippingOption>
-) = answerShippingQueryOk(shippingQuery.id, shippingOptions)
-
-suspend fun RequestsExecutor.answerShippingQueryError(
-    id: ShippingQueryIdentifier,
-    error: String
-) = execute(AnswerShippingQueryError(id, error))
-suspend fun RequestsExecutor.answerShippingQueryError(
-    shippingQuery: ShippingQuery,
-    error: String
-) = answerShippingQueryError(shippingQuery.id, error)
-
-

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

@@ -1,15 +0,0 @@
-package com.github.insanusmokrassar.TelegramBotAPI.requests.answers.payments.abstracts
-
-import com.github.insanusmokrassar.TelegramBotAPI.requests.abstracts.SimpleRequest
-import com.github.insanusmokrassar.TelegramBotAPI.types.PreCheckoutQueryId
-import kotlinx.serialization.KSerializer
-import kotlinx.serialization.internal.BooleanSerializer
-
-interface AnswerPreCheckoutQuery : SimpleRequest<Boolean> {
-    override fun method(): String = "answerPreCheckoutQuery"
-    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

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

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

@@ -1,31 +0,0 @@
-package com.github.insanusmokrassar.TelegramBotAPI.requests.chat
-
-import com.github.insanusmokrassar.TelegramBotAPI.CommonAbstracts.types.ChatRequest
-import com.github.insanusmokrassar.TelegramBotAPI.bot.RequestsExecutor
-import com.github.insanusmokrassar.TelegramBotAPI.requests.abstracts.SimpleRequest
-import com.github.insanusmokrassar.TelegramBotAPI.types.ChatIdentifier
-import com.github.insanusmokrassar.TelegramBotAPI.types.chat.abstracts.Chat
-import com.github.insanusmokrassar.TelegramBotAPI.types.chat.abstracts.PublicChat
-import com.github.insanusmokrassar.TelegramBotAPI.types.chatIdField
-import kotlinx.serialization.*
-import kotlinx.serialization.internal.StringSerializer
-
-@Serializable
-data class ExportChatInviteLink(
-    @SerialName(chatIdField)
-    override val chatId: ChatIdentifier
-): ChatRequest, SimpleRequest<String> {
-    override fun method(): String = "exportChatInviteLink"
-    override val resultDeserializer: DeserializationStrategy<String>
-        get() = StringSerializer
-    override val requestSerializer: SerializationStrategy<*>
-        get() = serializer()
-}
-
-suspend fun RequestsExecutor.exportChatInviteLink(
-    chatId: ChatIdentifier
-) = execute(ExportChatInviteLink(chatId))
-
-suspend fun RequestsExecutor.exportChatInviteLink(
-    chat: PublicChat
-) = exportChatInviteLink(chat.id)

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

@@ -1,31 +0,0 @@
-package com.github.insanusmokrassar.TelegramBotAPI.requests.chat
-
-import com.github.insanusmokrassar.TelegramBotAPI.CommonAbstracts.types.ChatRequest
-import com.github.insanusmokrassar.TelegramBotAPI.bot.RequestsExecutor
-import com.github.insanusmokrassar.TelegramBotAPI.requests.abstracts.SimpleRequest
-import com.github.insanusmokrassar.TelegramBotAPI.types.ChatIdentifier
-import com.github.insanusmokrassar.TelegramBotAPI.types.chat.abstracts.Chat
-import com.github.insanusmokrassar.TelegramBotAPI.types.chat.abstracts.PublicChat
-import com.github.insanusmokrassar.TelegramBotAPI.types.chatIdField
-import kotlinx.serialization.*
-import kotlinx.serialization.internal.BooleanSerializer
-
-@Serializable
-data class LeaveChat(
-    @SerialName(chatIdField)
-    override val chatId: ChatIdentifier
-): ChatRequest, SimpleRequest<Boolean> {
-    override fun method(): String = "leaveChat"
-    override val resultDeserializer: DeserializationStrategy<Boolean>
-        get() = BooleanSerializer
-    override val requestSerializer: SerializationStrategy<*>
-        get() = serializer()
-}
-
-suspend fun RequestsExecutor.leaveChat(
-    chatId: ChatIdentifier
-) = execute(LeaveChat(chatId))
-
-suspend fun RequestsExecutor.leaveChat(
-    chat: PublicChat
-) = leaveChat(chat.id)

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

@@ -1,9 +0,0 @@
-package com.github.insanusmokrassar.TelegramBotAPI.requests.chat.abstracts
-
-import com.github.insanusmokrassar.TelegramBotAPI.CommonAbstracts.types.ChatRequest
-import com.github.insanusmokrassar.TelegramBotAPI.requests.abstracts.SimpleRequest
-import com.github.insanusmokrassar.TelegramBotAPI.types.UserId
-
-interface ChatMemberRequest<T: Any> : ChatRequest, SimpleRequest<T> {
-    val userId: UserId
-}

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

@@ -1,31 +0,0 @@
-package com.github.insanusmokrassar.TelegramBotAPI.requests.chat.get
-
-import com.github.insanusmokrassar.TelegramBotAPI.CommonAbstracts.types.ChatRequest
-import com.github.insanusmokrassar.TelegramBotAPI.bot.RequestsExecutor
-import com.github.insanusmokrassar.TelegramBotAPI.requests.abstracts.SimpleRequest
-import com.github.insanusmokrassar.TelegramBotAPI.types.ChatIdentifier
-import com.github.insanusmokrassar.TelegramBotAPI.types.chat.ExtendedChatSerializer
-import com.github.insanusmokrassar.TelegramBotAPI.types.chat.abstracts.Chat
-import com.github.insanusmokrassar.TelegramBotAPI.types.chat.abstracts.extended.ExtendedChat
-import com.github.insanusmokrassar.TelegramBotAPI.types.chatIdField
-import kotlinx.serialization.*
-
-@Serializable
-data class GetChat(
-    @SerialName(chatIdField)
-    override val chatId: ChatIdentifier
-): ChatRequest, SimpleRequest<ExtendedChat> {
-    override fun method(): String = "getChat"
-    override val resultDeserializer: DeserializationStrategy<ExtendedChat>
-        get() = ExtendedChatSerializer
-    override val requestSerializer: SerializationStrategy<*>
-        get() = serializer()
-}
-
-suspend fun RequestsExecutor.getChat(
-    chatId: ChatIdentifier
-) = execute(GetChat(chatId))
-
-suspend fun RequestsExecutor.getChat(
-    chat: Chat
-) = getChat(chat.id)

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

@@ -1,37 +0,0 @@
-package com.github.insanusmokrassar.TelegramBotAPI.requests.chat.get
-
-import com.github.insanusmokrassar.TelegramBotAPI.CommonAbstracts.types.ChatRequest
-import com.github.insanusmokrassar.TelegramBotAPI.bot.RequestsExecutor
-import com.github.insanusmokrassar.TelegramBotAPI.requests.abstracts.SimpleRequest
-import com.github.insanusmokrassar.TelegramBotAPI.types.ChatIdentifier
-import com.github.insanusmokrassar.TelegramBotAPI.types.ChatMember.abstracts.AdministratorChatMember
-import com.github.insanusmokrassar.TelegramBotAPI.types.ChatMember.abstracts.AdministratorChatMemberSerializerWithoutDeserialization
-import com.github.insanusmokrassar.TelegramBotAPI.types.chat.abstracts.Chat
-import com.github.insanusmokrassar.TelegramBotAPI.types.chat.abstracts.PublicChat
-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<AdministratorChatMember>> {
-    override fun method(): String = "getChatAdministrators"
-    override val resultDeserializer: DeserializationStrategy<List<AdministratorChatMember>>
-        get() = chatMembersListSerializer
-    override val requestSerializer: SerializationStrategy<*>
-        get() = serializer()
-}
-
-suspend fun RequestsExecutor.getChatAdministrators(
-    chatId: ChatIdentifier
-) = execute(GetChatAdministrators(chatId))
-
-suspend fun RequestsExecutor.getChatAdministrators(
-    chat: PublicChat
-) = getChatAdministrators(chat.id)

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

@@ -1,31 +0,0 @@
-package com.github.insanusmokrassar.TelegramBotAPI.requests.chat.get
-
-import com.github.insanusmokrassar.TelegramBotAPI.CommonAbstracts.types.ChatRequest
-import com.github.insanusmokrassar.TelegramBotAPI.bot.RequestsExecutor
-import com.github.insanusmokrassar.TelegramBotAPI.requests.abstracts.SimpleRequest
-import com.github.insanusmokrassar.TelegramBotAPI.types.ChatIdentifier
-import com.github.insanusmokrassar.TelegramBotAPI.types.chat.abstracts.Chat
-import com.github.insanusmokrassar.TelegramBotAPI.types.chat.abstracts.PublicChat
-import com.github.insanusmokrassar.TelegramBotAPI.types.chatIdField
-import kotlinx.serialization.*
-import kotlinx.serialization.internal.IntSerializer
-
-@Serializable
-data class GetChatMembersCount(
-    @SerialName(chatIdField)
-    override val chatId: ChatIdentifier
-): ChatRequest, SimpleRequest<Int> {
-    override fun method(): String = "getChatMembersCount"
-    override val resultDeserializer: DeserializationStrategy<Int>
-        get() = IntSerializer
-    override val requestSerializer: SerializationStrategy<*>
-        get() = serializer()
-}
-
-suspend fun RequestsExecutor.getChatMembersCount(
-    chatId: ChatIdentifier
-) = execute(GetChatMembersCount(chatId))
-
-suspend fun RequestsExecutor.getChatMembersCount(
-    chat: PublicChat
-) = getChatMembersCount(chat.id)

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

@@ -1,45 +0,0 @@
-package com.github.insanusmokrassar.TelegramBotAPI.requests.chat.members
-
-import com.github.insanusmokrassar.TelegramBotAPI.bot.RequestsExecutor
-import com.github.insanusmokrassar.TelegramBotAPI.requests.chat.abstracts.ChatMemberRequest
-import com.github.insanusmokrassar.TelegramBotAPI.requests.chat.get.getChatMembersCount
-import com.github.insanusmokrassar.TelegramBotAPI.types.*
-import com.github.insanusmokrassar.TelegramBotAPI.types.ChatMember.abstracts.ChatMember
-import com.github.insanusmokrassar.TelegramBotAPI.types.ChatMember.abstracts.ChatMemberDeserializationStrategy
-import com.github.insanusmokrassar.TelegramBotAPI.types.chat.abstracts.Chat
-import com.github.insanusmokrassar.TelegramBotAPI.types.chat.abstracts.PublicChat
-import kotlinx.serialization.*
-
-@Serializable
-data class GetChatMember(
-    @SerialName(chatIdField)
-    override val chatId: ChatIdentifier,
-    @SerialName(userIdField)
-    override val userId: UserId
-) : ChatMemberRequest<ChatMember> {
-    override fun method(): String = "getChatMember"
-    override val resultDeserializer: DeserializationStrategy<ChatMember>
-        get() = ChatMemberDeserializationStrategy
-    override val requestSerializer: SerializationStrategy<*>
-        get() = serializer()
-}
-
-suspend fun RequestsExecutor.getChatMember(
-    chatId: ChatIdentifier,
-    userId: UserId
-) = execute(GetChatMember(chatId, userId))
-
-suspend fun RequestsExecutor.getChatMember(
-    chat: PublicChat,
-    userId: UserId
-) = getChatMember(chat.id, userId)
-
-suspend fun RequestsExecutor.getChatMember(
-    chatId: ChatId,
-    user: User
-) = getChatMember(chatId, user.id)
-
-suspend fun RequestsExecutor.getChatMember(
-    chat: PublicChat,
-    user: User
-) = getChatMember(chat.id, user.id)

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

@@ -1,50 +0,0 @@
-package com.github.insanusmokrassar.TelegramBotAPI.requests.chat.members
-
-import com.github.insanusmokrassar.TelegramBotAPI.CommonAbstracts.types.UntilDate
-import com.github.insanusmokrassar.TelegramBotAPI.bot.RequestsExecutor
-import com.github.insanusmokrassar.TelegramBotAPI.requests.chat.abstracts.ChatMemberRequest
-import com.github.insanusmokrassar.TelegramBotAPI.types.*
-import com.github.insanusmokrassar.TelegramBotAPI.types.chat.abstracts.Chat
-import com.github.insanusmokrassar.TelegramBotAPI.types.chat.abstracts.PublicChat
-import kotlinx.serialization.*
-import kotlinx.serialization.internal.BooleanSerializer
-
-@Serializable
-data class KickChatMember(
-    @SerialName(chatIdField)
-    override val chatId: ChatIdentifier,
-    @SerialName(userIdField)
-    override val userId: UserId,
-    @SerialName(untilDateField)
-    override val untilDate: TelegramDate? = null
-) : ChatMemberRequest<Boolean>, UntilDate {
-    override fun method(): String = "kickChatMember"
-    override val resultDeserializer: DeserializationStrategy<Boolean>
-        get() = BooleanSerializer
-    override val requestSerializer: SerializationStrategy<*>
-        get() = serializer()
-}
-
-suspend fun RequestsExecutor.kickChatMember(
-    chatId: ChatIdentifier,
-    userId: UserId,
-    untilDate: TelegramDate? = null
-) = execute(KickChatMember(chatId, userId, untilDate))
-
-suspend fun RequestsExecutor.kickChatMember(
-    chat: PublicChat,
-    userId: UserId,
-    untilDate: TelegramDate? = null
-) = kickChatMember(chat.id, userId, untilDate)
-
-suspend fun RequestsExecutor.kickChatMember(
-    chatId: ChatId,
-    user: User,
-    untilDate: TelegramDate? = null
-) = kickChatMember(chatId, user.id, untilDate)
-
-suspend fun RequestsExecutor.kickChatMember(
-    chat: PublicChat,
-    user: User,
-    untilDate: TelegramDate? = null
-) = kickChatMember(chat.id, user.id, untilDate)

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

@@ -1,148 +0,0 @@
-package com.github.insanusmokrassar.TelegramBotAPI.requests.chat.members
-
-import com.github.insanusmokrassar.TelegramBotAPI.CommonAbstracts.types.UntilDate
-import com.github.insanusmokrassar.TelegramBotAPI.bot.RequestsExecutor
-import com.github.insanusmokrassar.TelegramBotAPI.requests.chat.abstracts.ChatMemberRequest
-import com.github.insanusmokrassar.TelegramBotAPI.types.*
-import com.github.insanusmokrassar.TelegramBotAPI.types.chat.abstracts.Chat
-import com.github.insanusmokrassar.TelegramBotAPI.types.chat.abstracts.PublicChat
-import kotlinx.serialization.*
-import kotlinx.serialization.internal.BooleanSerializer
-
-@Serializable
-data class PromoteChatMember(
-    @SerialName(chatIdField)
-    override val chatId: ChatIdentifier,
-    @SerialName(userIdField)
-    override val userId: UserId,
-    @SerialName(untilDateField)
-    override val untilDate: TelegramDate? = null,
-    @SerialName(canChangeInfoField)
-    private val canChangeInfo: Boolean? = null,
-    @SerialName(canPostMessagesField)
-    private val canPostMessages: Boolean? = null,
-    @SerialName(canEditMessagesField)
-    private val canEditMessages: Boolean? = null,
-    @SerialName(canDeleteMessagesField)
-    private val canDeleteMessages: Boolean? = null,
-    @SerialName(canInviteUsersField)
-    private val canInviteUsers: Boolean? = null,
-    @SerialName(canRestrictMembersField)
-    private val canRestrictMembers: Boolean? = null,
-    @SerialName(canPinMessagesField)
-    private val canPinMessages: Boolean? = null,
-    @SerialName(canPromoteMembersField)
-    private val canPromoteMembers: Boolean? = null
-) : ChatMemberRequest<Boolean>, UntilDate {
-    override fun method(): String = "promoteChatMember"
-    override val resultDeserializer: DeserializationStrategy<Boolean>
-        get() = BooleanSerializer
-    override val requestSerializer: SerializationStrategy<*>
-        get() = serializer()
-}
-
-suspend fun RequestsExecutor.promoteChatMember(
-    chatId: ChatIdentifier,
-    userId: UserId,
-    untilDate: TelegramDate? = null,
-    canChangeInfo: Boolean? = null,
-    canPostMessages: Boolean? = null,
-    canEditMessages: Boolean? = null,
-    canDeleteMessages: Boolean? = null,
-    canInviteUsers: Boolean? = null,
-    canRestrictMembers: Boolean? = null,
-    canPinMessages: Boolean? = null,
-    canPromoteMembers: Boolean? = null
-) = execute(
-    PromoteChatMember(
-        chatId,
-        userId,
-        untilDate,
-        canChangeInfo,
-        canPostMessages,
-        canEditMessages,
-        canDeleteMessages,
-        canInviteUsers,
-        canRestrictMembers,
-        canPinMessages,
-        canPromoteMembers
-    )
-)
-
-suspend fun RequestsExecutor.promoteChatMember(
-    chat: PublicChat,
-    userId: UserId,
-    untilDate: TelegramDate? = null,
-    canChangeInfo: Boolean? = null,
-    canPostMessages: Boolean? = null,
-    canEditMessages: Boolean? = null,
-    canDeleteMessages: Boolean? = null,
-    canInviteUsers: Boolean? = null,
-    canRestrictMembers: Boolean? = null,
-    canPinMessages: Boolean? = null,
-    canPromoteMembers: Boolean? = null
-) = promoteChatMember(
-    chat.id,
-    userId,
-    untilDate,
-    canChangeInfo,
-    canPostMessages,
-    canEditMessages,
-    canDeleteMessages,
-    canInviteUsers,
-    canRestrictMembers,
-    canPinMessages,
-    canPromoteMembers
-)
-
-suspend fun RequestsExecutor.promoteChatMember(
-    chatId: ChatId,
-    user: User,
-    untilDate: TelegramDate? = null,
-    canChangeInfo: Boolean? = null,
-    canPostMessages: Boolean? = null,
-    canEditMessages: Boolean? = null,
-    canDeleteMessages: Boolean? = null,
-    canInviteUsers: Boolean? = null,
-    canRestrictMembers: Boolean? = null,
-    canPinMessages: Boolean? = null,
-    canPromoteMembers: Boolean? = null
-) = promoteChatMember(
-    chatId,
-    user.id,
-    untilDate,
-    canChangeInfo,
-    canPostMessages,
-    canEditMessages,
-    canDeleteMessages,
-    canInviteUsers,
-    canRestrictMembers,
-    canPinMessages,
-    canPromoteMembers
-)
-
-suspend fun RequestsExecutor.promoteChatMember(
-    chat: PublicChat,
-    user: User,
-    untilDate: TelegramDate? = null,
-    canChangeInfo: Boolean? = null,
-    canPostMessages: Boolean? = null,
-    canEditMessages: Boolean? = null,
-    canDeleteMessages: Boolean? = null,
-    canInviteUsers: Boolean? = null,
-    canRestrictMembers: Boolean? = null,
-    canPinMessages: Boolean? = null,
-    canPromoteMembers: Boolean? = null
-) = promoteChatMember(
-    chat.id,
-    user.id,
-    untilDate,
-    canChangeInfo,
-    canPostMessages,
-    canEditMessages,
-    canDeleteMessages,
-    canInviteUsers,
-    canRestrictMembers,
-    canPinMessages,
-    canPromoteMembers
-)

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

@@ -1,58 +0,0 @@
-package com.github.insanusmokrassar.TelegramBotAPI.requests.chat.members
-
-import com.github.insanusmokrassar.TelegramBotAPI.CommonAbstracts.types.UntilDate
-import com.github.insanusmokrassar.TelegramBotAPI.bot.RequestsExecutor
-import com.github.insanusmokrassar.TelegramBotAPI.requests.chat.abstracts.ChatMemberRequest
-import com.github.insanusmokrassar.TelegramBotAPI.types.*
-import com.github.insanusmokrassar.TelegramBotAPI.types.chat.ChatPermissions
-import com.github.insanusmokrassar.TelegramBotAPI.types.chat.abstracts.Chat
-import com.github.insanusmokrassar.TelegramBotAPI.types.chat.abstracts.PublicChat
-import kotlinx.serialization.*
-import kotlinx.serialization.internal.BooleanSerializer
-
-@Serializable
-data class RestrictChatMember(
-    @SerialName(chatIdField)
-    override val chatId: ChatIdentifier,
-    @SerialName(userIdField)
-    override val userId: UserId,
-    @SerialName(untilDateField)
-    override val untilDate: TelegramDate? = null,
-    @SerialName(permissionsField)
-    val permissions: ChatPermissions = ChatPermissions()
-) : ChatMemberRequest<Boolean>, UntilDate {
-    override fun method(): String = "restrictChatMember"
-    override val resultDeserializer: DeserializationStrategy<Boolean>
-        get() = BooleanSerializer
-    override val requestSerializer: SerializationStrategy<*>
-        get() = serializer()
-}
-
-suspend fun RequestsExecutor.restrictChatMember(
-    chatId: ChatIdentifier,
-    userId: UserId,
-    untilDate: TelegramDate? = null,
-    permissions: ChatPermissions = ChatPermissions()
-) = execute(RestrictChatMember(chatId, userId, untilDate, permissions))
-
-suspend fun RequestsExecutor.restrictChatMember(
-    chat: PublicChat,
-    userId: UserId,
-    untilDate: TelegramDate? = null,
-    permissions: ChatPermissions = ChatPermissions()
-) = restrictChatMember(chat.id, userId, untilDate, permissions)
-
-suspend fun RequestsExecutor.restrictChatMember(
-    chatId: ChatId,
-    user: User,
-    untilDate: TelegramDate? = null,
-    permissions: ChatPermissions = ChatPermissions()
-) = restrictChatMember(chatId, user.id, untilDate, permissions)
-
-suspend fun RequestsExecutor.restrictChatMember(
-    chat: PublicChat,
-    user: User,
-    untilDate: TelegramDate? = null,
-    permissions: ChatPermissions = ChatPermissions()
-) = restrictChatMember(chat.id, user.id, untilDate, permissions)
-

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

@@ -1,60 +0,0 @@
-package com.github.insanusmokrassar.TelegramBotAPI.requests.chat.members
-
-import com.github.insanusmokrassar.TelegramBotAPI.bot.RequestsExecutor
-import com.github.insanusmokrassar.TelegramBotAPI.requests.chat.abstracts.ChatMemberRequest
-import com.github.insanusmokrassar.TelegramBotAPI.types.*
-import com.github.insanusmokrassar.TelegramBotAPI.types.chat.abstracts.Chat
-import com.github.insanusmokrassar.TelegramBotAPI.types.chat.abstracts.PublicChat
-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: ChatIdentifier,
-    @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}")
-        }
-    }
-}
-
-suspend fun RequestsExecutor.setChatAdministratorCustomTitle(
-    chatId: ChatId,
-    userId: UserId,
-    customTitle: String
-) = execute(SetChatAdministratorCustomTitle(chatId, userId, customTitle))
-
-suspend fun RequestsExecutor.setChatAdministratorCustomTitle(
-    chat: PublicChat,
-    userId: UserId,
-    customTitle: String
-) = setChatAdministratorCustomTitle(chat.id, userId, customTitle)
-
-suspend fun RequestsExecutor.setChatAdministratorCustomTitle(
-    chatId: ChatId,
-    user: User,
-    customTitle: String
-) = setChatAdministratorCustomTitle(chatId, user.id, customTitle)
-
-suspend fun RequestsExecutor.setChatAdministratorCustomTitle(
-    chat: PublicChat,
-    user: User,
-    customTitle: String
-) = setChatAdministratorCustomTitle(chat.id, user.id, customTitle)

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

@@ -1,44 +0,0 @@
-package com.github.insanusmokrassar.TelegramBotAPI.requests.chat.members
-
-import com.github.insanusmokrassar.TelegramBotAPI.bot.RequestsExecutor
-import com.github.insanusmokrassar.TelegramBotAPI.requests.chat.abstracts.ChatMemberRequest
-import com.github.insanusmokrassar.TelegramBotAPI.types.*
-import com.github.insanusmokrassar.TelegramBotAPI.types.chat.abstracts.Chat
-import com.github.insanusmokrassar.TelegramBotAPI.types.chat.abstracts.PublicChat
-import kotlinx.serialization.*
-import kotlinx.serialization.internal.BooleanSerializer
-
-@Serializable
-data class UnbanChatMember(
-    @SerialName(chatIdField)
-    override val chatId: ChatIdentifier,
-    @SerialName(userIdField)
-    override val userId: UserId
-) : ChatMemberRequest<Boolean> {
-    override fun method(): String = "unbanChatMember"
-    override val resultDeserializer: DeserializationStrategy<Boolean>
-        get() = BooleanSerializer
-    override val requestSerializer: SerializationStrategy<*>
-        get() = serializer()
-}
-
-suspend fun RequestsExecutor.unbanChatMember(
-    chatId: ChatIdentifier,
-    userId: UserId
-) = execute(UnbanChatMember(chatId, userId))
-
-suspend fun RequestsExecutor.unbanChatMember(
-    chat: PublicChat,
-    userId: UserId
-) = unbanChatMember(chat.id, userId)
-
-suspend fun RequestsExecutor.unbanChatMember(
-    chatId: ChatId,
-    user: User
-) = unbanChatMember(chatId, user.id)
-
-suspend fun RequestsExecutor.unbanChatMember(
-    chat: PublicChat,
-    user: User
-) = unbanChatMember(chat.id, user.id)
-

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

@@ -1,32 +0,0 @@
-package com.github.insanusmokrassar.TelegramBotAPI.requests.chat.modify
-
-import com.github.insanusmokrassar.TelegramBotAPI.CommonAbstracts.types.ChatRequest
-import com.github.insanusmokrassar.TelegramBotAPI.bot.RequestsExecutor
-import com.github.insanusmokrassar.TelegramBotAPI.requests.abstracts.SimpleRequest
-import com.github.insanusmokrassar.TelegramBotAPI.requests.chat.get.GetChat
-import com.github.insanusmokrassar.TelegramBotAPI.types.ChatIdentifier
-import com.github.insanusmokrassar.TelegramBotAPI.types.chat.abstracts.Chat
-import com.github.insanusmokrassar.TelegramBotAPI.types.chat.abstracts.PublicChat
-import com.github.insanusmokrassar.TelegramBotAPI.types.chatIdField
-import kotlinx.serialization.*
-import kotlinx.serialization.internal.BooleanSerializer
-
-@Serializable
-data class DeleteChatPhoto(
-    @SerialName(chatIdField)
-    override val chatId: ChatIdentifier
-): ChatRequest, SimpleRequest<Boolean> {
-    override fun method(): String = "deleteChatPhoto"
-    override val resultDeserializer: DeserializationStrategy<Boolean>
-        get() = BooleanSerializer
-    override val requestSerializer: SerializationStrategy<*>
-        get() = serializer()
-}
-
-suspend fun RequestsExecutor.deleteChatPhoto(
-    chatId: ChatIdentifier
-) = execute(DeleteChatPhoto(chatId))
-
-suspend fun RequestsExecutor.deleteChatPhoto(
-    chat: PublicChat
-) = deleteChatPhoto(chat.id)

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

@@ -1,48 +0,0 @@
-package com.github.insanusmokrassar.TelegramBotAPI.requests.chat.modify
-
-import com.github.insanusmokrassar.TelegramBotAPI.CommonAbstracts.types.*
-import com.github.insanusmokrassar.TelegramBotAPI.bot.RequestsExecutor
-import com.github.insanusmokrassar.TelegramBotAPI.requests.abstracts.SimpleRequest
-import com.github.insanusmokrassar.TelegramBotAPI.types.*
-import com.github.insanusmokrassar.TelegramBotAPI.types.chat.abstracts.Chat
-import com.github.insanusmokrassar.TelegramBotAPI.types.chat.abstracts.PublicChat
-import com.github.insanusmokrassar.TelegramBotAPI.types.message.abstracts.Message
-import kotlinx.serialization.*
-import kotlinx.serialization.internal.BooleanSerializer
-
-@Serializable
-data class PinChatMessage (
-    @SerialName(chatIdField)
-    override val chatId: ChatIdentifier,
-    @SerialName(messageIdField)
-    override val messageId: MessageIdentifier,
-    @SerialName(disableNotificationField)
-    override val disableNotification: Boolean = false
-): ChatRequest, SimpleRequest<Boolean>, MessageAction, DisableNotification {
-    override fun method(): String = "pinChatMessage"
-    override val resultDeserializer: DeserializationStrategy<Boolean>
-        get() = BooleanSerializer
-    override val requestSerializer: SerializationStrategy<*>
-        get() = serializer()
-}
-
-suspend fun RequestsExecutor.pinChatMessage(
-    chatId: ChatIdentifier,
-    messageId: MessageIdentifier,
-    disableNotification: Boolean = false
-) = execute(PinChatMessage(chatId, messageId, disableNotification))
-
-suspend fun RequestsExecutor.pinChatMessage(
-    chat: PublicChat,
-    messageId: MessageIdentifier,
-    disableNotification: Boolean = false
-) = pinChatMessage(chat.id, messageId, disableNotification)
-
-suspend fun RequestsExecutor.pinChatMessage(
-    message: Message,
-    disableNotification: Boolean = false
-) = if (message.chat is PublicChat) {
-    pinChatMessage(message.chat.id, message.messageId, disableNotification)
-} else {
-    error("It is possible to pin messages only in non one-to-one chats")
-}

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

@@ -1,40 +0,0 @@
-package com.github.insanusmokrassar.TelegramBotAPI.requests.chat.modify
-
-import com.github.insanusmokrassar.TelegramBotAPI.CommonAbstracts.types.ChatRequest
-import com.github.insanusmokrassar.TelegramBotAPI.bot.RequestsExecutor
-import com.github.insanusmokrassar.TelegramBotAPI.requests.abstracts.SimpleRequest
-import com.github.insanusmokrassar.TelegramBotAPI.types.*
-import com.github.insanusmokrassar.TelegramBotAPI.types.chat.abstracts.Chat
-import com.github.insanusmokrassar.TelegramBotAPI.types.chat.abstracts.PublicChat
-import kotlinx.serialization.*
-import kotlinx.serialization.internal.BooleanSerializer
-
-@Serializable
-data class SetChatDescription (
-    @SerialName(chatIdField)
-    override val chatId: ChatIdentifier,
-    @SerialName(descriptionField)
-    val description: String
-): ChatRequest, SimpleRequest<Boolean> {
-    init {
-        if (description.length !in chatDescriptionLength) {
-            throw IllegalArgumentException("Chat description must be in $chatDescriptionLength range")
-        }
-    }
-
-    override fun method(): String = "setChatDescription"
-    override val resultDeserializer: DeserializationStrategy<Boolean>
-        get() = BooleanSerializer
-    override val requestSerializer: SerializationStrategy<*>
-        get() = serializer()
-}
-
-suspend fun RequestsExecutor.setChatDescription(
-    chatId: ChatIdentifier,
-    description: String
-) = execute(SetChatDescription(chatId, description))
-
-suspend fun RequestsExecutor.setChatDescription(
-    chat: PublicChat,
-    description: String
-) = setChatDescription(chat.id, description)

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

@@ -1,34 +0,0 @@
-package com.github.insanusmokrassar.TelegramBotAPI.requests.chat.modify
-
-import com.github.insanusmokrassar.TelegramBotAPI.CommonAbstracts.types.ChatRequest
-import com.github.insanusmokrassar.TelegramBotAPI.bot.RequestsExecutor
-import com.github.insanusmokrassar.TelegramBotAPI.requests.abstracts.SimpleRequest
-import com.github.insanusmokrassar.TelegramBotAPI.types.*
-import com.github.insanusmokrassar.TelegramBotAPI.types.chat.ChatPermissions
-import com.github.insanusmokrassar.TelegramBotAPI.types.chat.abstracts.PublicChat
-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()
-}
-
-suspend fun RequestsExecutor.setDefaultChatMembersPermissions(
-    chatId: ChatIdentifier,
-    permissions: ChatPermissions
-) = execute(SetChatPermissions(chatId, permissions))
-
-suspend fun RequestsExecutor.setDefaultChatMembersPermissions(
-    chat: PublicChat,
-    permissions: ChatPermissions
-) = setDefaultChatMembersPermissions(chat.id, permissions)

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

@@ -1,37 +0,0 @@
-package com.github.insanusmokrassar.TelegramBotAPI.requests.chat.modify
-
-import com.github.insanusmokrassar.TelegramBotAPI.CommonAbstracts.types.ChatRequest
-import com.github.insanusmokrassar.TelegramBotAPI.bot.RequestsExecutor
-import com.github.insanusmokrassar.TelegramBotAPI.requests.abstracts.MultipartFile
-import com.github.insanusmokrassar.TelegramBotAPI.requests.abstracts.MultipartRequest
-import com.github.insanusmokrassar.TelegramBotAPI.types.*
-import com.github.insanusmokrassar.TelegramBotAPI.types.chat.ChatPermissions
-import com.github.insanusmokrassar.TelegramBotAPI.types.chat.abstracts.Chat
-import com.github.insanusmokrassar.TelegramBotAPI.types.chat.abstracts.PublicChat
-import com.github.insanusmokrassar.TelegramBotAPI.utils.toJson
-import kotlinx.serialization.*
-import kotlinx.serialization.internal.BooleanSerializer
-import kotlinx.serialization.json.JsonObject
-
-@Serializable
-data class SetChatPhoto (
-    @SerialName(chatIdField)
-    override val chatId: ChatIdentifier,
-    val photo: MultipartFile = throw IllegalArgumentException("Unfortunately, this type of objects can't be parsed automatically")
-): ChatRequest, MultipartRequest<Boolean> {
-    override fun method(): String = "setChatPhoto"
-    override val resultDeserializer: DeserializationStrategy<Boolean>
-        get() = BooleanSerializer
-    override val mediaMap: Map<String, MultipartFile> = mapOf(photoField to photo)
-    override val paramsJson: JsonObject = toJson(serializer())
-}
-
-suspend fun RequestsExecutor.setChatPhoto(
-    chatId: ChatIdentifier,
-    photo: MultipartFile
-) = execute(SetChatPhoto(chatId, photo))
-
-suspend fun RequestsExecutor.setChatPhoto(
-    chat: PublicChat,
-    photo: MultipartFile
-) = setChatPhoto(chat.id, photo)

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

@@ -1,41 +0,0 @@
-package com.github.insanusmokrassar.TelegramBotAPI.requests.chat.modify
-
-import com.github.insanusmokrassar.TelegramBotAPI.CommonAbstracts.types.ChatRequest
-import com.github.insanusmokrassar.TelegramBotAPI.bot.RequestsExecutor
-import com.github.insanusmokrassar.TelegramBotAPI.requests.abstracts.MultipartFile
-import com.github.insanusmokrassar.TelegramBotAPI.requests.abstracts.SimpleRequest
-import com.github.insanusmokrassar.TelegramBotAPI.types.*
-import com.github.insanusmokrassar.TelegramBotAPI.types.chat.abstracts.Chat
-import com.github.insanusmokrassar.TelegramBotAPI.types.chat.abstracts.PublicChat
-import kotlinx.serialization.*
-import kotlinx.serialization.internal.BooleanSerializer
-
-@Serializable
-data class SetChatTitle (
-    @SerialName(chatIdField)
-    override val chatId: ChatIdentifier,
-    @SerialName(titleField)
-    val title: String
-): ChatRequest, SimpleRequest<Boolean> {
-    init {
-        if (title.length !in chatTitleLength) {
-            throw IllegalArgumentException("Chat title must be in $chatTitleLength range")
-        }
-    }
-
-    override fun method(): String = "setChatTitle"
-    override val resultDeserializer: DeserializationStrategy<Boolean>
-        get() = BooleanSerializer
-    override val requestSerializer: SerializationStrategy<*>
-        get() = serializer()
-}
-
-suspend fun RequestsExecutor.setChatTitle(
-    chatId: ChatIdentifier,
-    title: String
-) = execute(SetChatTitle(chatId, title))
-
-suspend fun RequestsExecutor.setChatTitle(
-    chat: PublicChat,
-    title: String
-) = setChatTitle(chat.id, title)

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

@@ -1,31 +0,0 @@
-package com.github.insanusmokrassar.TelegramBotAPI.requests.chat.modify
-
-import com.github.insanusmokrassar.TelegramBotAPI.CommonAbstracts.types.ChatRequest
-import com.github.insanusmokrassar.TelegramBotAPI.bot.RequestsExecutor
-import com.github.insanusmokrassar.TelegramBotAPI.requests.abstracts.SimpleRequest
-import com.github.insanusmokrassar.TelegramBotAPI.types.ChatIdentifier
-import com.github.insanusmokrassar.TelegramBotAPI.types.chat.abstracts.Chat
-import com.github.insanusmokrassar.TelegramBotAPI.types.chat.abstracts.PublicChat
-import com.github.insanusmokrassar.TelegramBotAPI.types.chatIdField
-import kotlinx.serialization.*
-import kotlinx.serialization.internal.BooleanSerializer
-
-@Serializable
-data class UnpinChatMessage(
-    @SerialName(chatIdField)
-    override val chatId: ChatIdentifier
-): ChatRequest, SimpleRequest<Boolean> {
-    override fun method(): String = "unpinChatMessage"
-    override val resultDeserializer: DeserializationStrategy<Boolean>
-        get() = BooleanSerializer
-    override val requestSerializer: SerializationStrategy<*>
-        get() = serializer()
-}
-
-suspend fun RequestsExecutor.unpinChatMessage(
-    chatId: ChatIdentifier
-) = execute(UnpinChatMessage(chatId))
-
-suspend fun RequestsExecutor.unpinChatMessage(
-    chat: PublicChat
-) = unpinChatMessage(chat.id)

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

@@ -1,31 +0,0 @@
-package com.github.insanusmokrassar.TelegramBotAPI.requests.chat.stickers
-
-import com.github.insanusmokrassar.TelegramBotAPI.CommonAbstracts.types.ChatRequest
-import com.github.insanusmokrassar.TelegramBotAPI.bot.RequestsExecutor
-import com.github.insanusmokrassar.TelegramBotAPI.requests.abstracts.SimpleRequest
-import com.github.insanusmokrassar.TelegramBotAPI.requests.chat.modify.DeleteChatPhoto
-import com.github.insanusmokrassar.TelegramBotAPI.types.ChatIdentifier
-import com.github.insanusmokrassar.TelegramBotAPI.types.chat.abstracts.*
-import com.github.insanusmokrassar.TelegramBotAPI.types.chatIdField
-import kotlinx.serialization.*
-import kotlinx.serialization.internal.BooleanSerializer
-
-@Serializable
-data class DeleteChatStickerSet(
-    @SerialName(chatIdField)
-    override val chatId: ChatIdentifier
-): ChatRequest, SimpleRequest<Boolean> {
-    override fun method(): String = "deleteChatStickerSet"
-    override val resultDeserializer: DeserializationStrategy<Boolean>
-        get() = BooleanSerializer
-    override val requestSerializer: SerializationStrategy<*>
-        get() = serializer()
-}
-
-suspend fun RequestsExecutor.deleteChatStickerSet(
-    chatId: ChatIdentifier
-) = execute(DeleteChatStickerSet(chatId))
-
-suspend fun RequestsExecutor.deleteChatStickerSet(
-    chat: SupergroupChat
-) = deleteChatStickerSet(chat.id)

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

@@ -1,33 +0,0 @@
-package com.github.insanusmokrassar.TelegramBotAPI.requests.chat.stickers
-
-import com.github.insanusmokrassar.TelegramBotAPI.CommonAbstracts.types.ChatRequest
-import com.github.insanusmokrassar.TelegramBotAPI.bot.RequestsExecutor
-import com.github.insanusmokrassar.TelegramBotAPI.requests.abstracts.SimpleRequest
-import com.github.insanusmokrassar.TelegramBotAPI.types.*
-import com.github.insanusmokrassar.TelegramBotAPI.types.chat.abstracts.*
-import kotlinx.serialization.*
-import kotlinx.serialization.internal.BooleanSerializer
-
-@Serializable
-data class SetChatStickerSet(
-    @SerialName(chatIdField)
-    override val chatId: ChatIdentifier,
-    @SerialName(stickerSetNameField)
-    val stickerSetName: StickerSetName
-): ChatRequest, SimpleRequest<Boolean> {
-    override fun method(): String = "setChatStickerSet"
-    override val resultDeserializer: DeserializationStrategy<Boolean>
-        get() = BooleanSerializer
-    override val requestSerializer: SerializationStrategy<*>
-        get() = serializer()
-}
-
-suspend fun RequestsExecutor.setChatStickerSet(
-    chatId: ChatIdentifier,
-    stickerSetName: StickerSetName
-) = execute(SetChatStickerSet(chatId, stickerSetName))
-
-suspend fun RequestsExecutor.setChatStickerSet(
-    chat: SupergroupChat,
-    stickerSetName: StickerSetName
-) = setChatStickerSet(chat.id, stickerSetName)

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

@@ -1,84 +0,0 @@
-package com.github.insanusmokrassar.TelegramBotAPI.requests.edit.LiveLocation
-
-import com.github.insanusmokrassar.TelegramBotAPI.bot.RequestsExecutor
-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.chat.abstracts.Chat
-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)
-    override val chatId: ChatIdentifier,
-    @SerialName(messageIdField)
-    override val messageId: MessageIdentifier,
-    @SerialName(latitudeField)
-    override val latitude: Double,
-    @SerialName(longitudeField)
-    override val longitude: Double,
-    @SerialName(replyMarkupField)
-    override val replyMarkup: InlineKeyboardMarkup? = null
-) : EditChatMessage<LocationContent>, EditReplyMessage, EditLocationMessage {
-    override fun method(): String = "editMessageLiveLocation"
-    override val resultDeserializer: DeserializationStrategy<ContentMessage<LocationContent>>
-        get() = commonResultDeserializer
-    override val requestSerializer: SerializationStrategy<*>
-        get() = serializer()
-}
-
-suspend fun RequestsExecutor.editLiveLocation(
-    chatId: ChatIdentifier,
-    messageId: MessageIdentifier,
-    latitude: Double,
-    longitude: Double,
-    replyMarkup: InlineKeyboardMarkup? = null
-) = execute(
-    EditChatMessageLiveLocation(
-        chatId, messageId, latitude, longitude, replyMarkup
-    )
-)
-
-suspend fun RequestsExecutor.editLiveLocation(
-    chat: Chat,
-    messageId: MessageIdentifier,
-    latitude: Double,
-    longitude: Double,
-    replyMarkup: InlineKeyboardMarkup? = null
-) = editLiveLocation(chat.id, messageId, latitude, longitude, replyMarkup)
-
-suspend fun RequestsExecutor.editLiveLocation(
-    message: ContentMessage<LocationContent>,
-    latitude: Double,
-    longitude: Double,
-    replyMarkup: InlineKeyboardMarkup? = null
-) = editLiveLocation(message.chat, message.messageId, latitude, longitude, replyMarkup)
-
-suspend fun RequestsExecutor.editLiveLocation(
-    chatId: ChatIdentifier,
-    messageId: MessageIdentifier,
-    location: Location,
-    replyMarkup: InlineKeyboardMarkup? = null
-) = execute(
-    EditChatMessageLiveLocation(
-        chatId, messageId, location.latitude, location.longitude, replyMarkup
-    )
-)
-
-suspend fun RequestsExecutor.editLiveLocation(
-    chat: Chat,
-    messageId: MessageIdentifier,
-    location: Location,
-    replyMarkup: InlineKeyboardMarkup? = null
-) = editLiveLocation(chat.id, messageId, location.latitude, location.longitude, replyMarkup)
-
-suspend fun RequestsExecutor.editLiveLocation(
-    message: ContentMessage<LocationContent>,
-    location: Location,
-    replyMarkup: InlineKeyboardMarkup? = null
-) = editLiveLocation(message.chat, message.messageId, location.latitude, location.longitude, replyMarkup)

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

@@ -1,39 +0,0 @@
-package com.github.insanusmokrassar.TelegramBotAPI.requests.edit.LiveLocation
-
-import com.github.insanusmokrassar.TelegramBotAPI.bot.RequestsExecutor
-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.*
-
-@Serializable
-data class EditInlineMessageLiveLocation(
-    @SerialName(inlineMessageIdField)
-    override val inlineMessageId: InlineMessageIdentifier,
-    @SerialName(latitudeField)
-    override val latitude: Double,
-    @SerialName(longitudeField)
-    override val longitude: Double,
-    @SerialName(replyMarkupField)
-    override val replyMarkup: InlineKeyboardMarkup? = null
-) : EditInlineMessage, EditReplyMessage, EditLocationMessage {
-    override fun method(): String = "editMessageLiveLocation"
-    override val requestSerializer: SerializationStrategy<*>
-        get() = serializer()
-}
-
-suspend fun RequestsExecutor.editLiveLocation(
-    inlineMessageId: InlineMessageIdentifier,
-    latitude: Double,
-    longitude: Double,
-    replyMarkup: InlineKeyboardMarkup? = null
-) = execute(
-    EditInlineMessageLiveLocation(
-        inlineMessageId, latitude, longitude, replyMarkup
-    )
-)
-suspend fun RequestsExecutor.editLiveLocation(
-    inlineMessageId: InlineMessageIdentifier,
-    location: Location,
-    replyMarkup: InlineKeyboardMarkup? = null
-) = editLiveLocation(inlineMessageId, location.latitude, location.longitude, replyMarkup)

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

@@ -1,52 +0,0 @@
-package com.github.insanusmokrassar.TelegramBotAPI.requests.edit.LiveLocation
-
-import com.github.insanusmokrassar.TelegramBotAPI.bot.RequestsExecutor
-import com.github.insanusmokrassar.TelegramBotAPI.requests.edit.abstracts.EditChatMessage
-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.chat.abstracts.Chat
-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)
-    override val chatId: ChatIdentifier,
-    @SerialName(messageIdField)
-    override val messageId: MessageIdentifier,
-    @SerialName(replyMarkupField)
-    override val replyMarkup: InlineKeyboardMarkup? = null
-) : EditChatMessage<LocationContent>, EditReplyMessage {
-    override fun method(): String = "stopMessageLiveLocation"
-    override val resultDeserializer: DeserializationStrategy<ContentMessage<LocationContent>>
-        get() = commonResultDeserializer
-    override val requestSerializer: SerializationStrategy<*>
-        get() = serializer()
-}
-
-
-suspend fun RequestsExecutor.stopLiveLocation(
-    chatId: ChatIdentifier,
-    messageId: MessageIdentifier,
-    replyMarkup: InlineKeyboardMarkup? = null
-) = execute(
-    StopChatMessageLiveLocation(
-        chatId, messageId, replyMarkup
-    )
-)
-
-suspend fun RequestsExecutor.stopLiveLocation(
-    chat: Chat,
-    messageId: MessageIdentifier,
-    replyMarkup: InlineKeyboardMarkup? = null
-) = stopLiveLocation(chat.id, messageId, replyMarkup)
-
-suspend fun RequestsExecutor.stopLiveLocation(
-    message: ContentMessage<LocationContent>,
-    replyMarkup: InlineKeyboardMarkup? = null
-) = stopLiveLocation(message.chat, message.messageId, replyMarkup)

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

@@ -1,29 +0,0 @@
-package com.github.insanusmokrassar.TelegramBotAPI.requests.edit.LiveLocation
-
-import com.github.insanusmokrassar.TelegramBotAPI.bot.RequestsExecutor
-import com.github.insanusmokrassar.TelegramBotAPI.requests.edit.abstracts.EditInlineMessage
-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.*
-
-@Serializable
-data class StopInlineMessageLiveLocation(
-    @SerialName(inlineMessageIdField)
-    override val inlineMessageId: InlineMessageIdentifier,
-    @SerialName(replyMarkupField)
-    override val replyMarkup: InlineKeyboardMarkup? = null
-) : EditInlineMessage, EditReplyMessage {
-    override fun method(): String = "stopMessageLiveLocation"
-    override val requestSerializer: SerializationStrategy<*>
-        get() = serializer()
-}
-
-suspend fun RequestsExecutor.stopLiveLocation(
-    inlineMessageId: InlineMessageIdentifier,
-    replyMarkup: InlineKeyboardMarkup? = null
-) = execute(
-    StopInlineMessageLiveLocation(
-        inlineMessageId, replyMarkup
-    )
-)

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

@@ -1,55 +0,0 @@
-package com.github.insanusmokrassar.TelegramBotAPI.requests.edit.ReplyMarkup
-
-import com.github.insanusmokrassar.TelegramBotAPI.bot.RequestsExecutor
-import com.github.insanusmokrassar.TelegramBotAPI.requests.edit.abstracts.EditChatMessage
-import com.github.insanusmokrassar.TelegramBotAPI.requests.edit.abstracts.EditReplyMessage
-import com.github.insanusmokrassar.TelegramBotAPI.requests.edit.media.EditChatMessageMedia
-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.chat.abstracts.Chat
-import com.github.insanusmokrassar.TelegramBotAPI.types.message.abstracts.*
-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)
-    override val chatId: ChatIdentifier,
-    @SerialName(messageIdField)
-    override val messageId: MessageIdentifier,
-    @SerialName(replyMarkupField)
-    override val replyMarkup: InlineKeyboardMarkup? = null
-) : EditChatMessage<MessageContent>, EditReplyMessage {
-
-    override fun method(): String = editMessageReplyMarkupMethod
-    override val resultDeserializer: DeserializationStrategy<ContentMessage<MessageContent>>
-        get() = commonResultDeserializer
-    override val requestSerializer: SerializationStrategy<*>
-        get() = serializer()
-}
-
-suspend fun RequestsExecutor.editMessageReplyMarkup(
-    chatId: ChatIdentifier,
-    messageId: MessageIdentifier,
-    replyMarkup: InlineKeyboardMarkup? = null
-) = execute(
-    EditChatMessageReplyMarkup(chatId, messageId, replyMarkup)
-)
-
-suspend fun RequestsExecutor.editMessageReplyMarkup(
-    chat: Chat,
-    messageId: MessageIdentifier,
-    replyMarkup: InlineKeyboardMarkup? = null
-) = editMessageReplyMarkup(chat.id, messageId, replyMarkup)
-
-suspend fun RequestsExecutor.editMessageReplyMarkup(
-    message: Message,
-    replyMarkup: InlineKeyboardMarkup? = null
-) = editMessageReplyMarkup(message.chat.id, message.messageId, replyMarkup)
-

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

@@ -1,27 +0,0 @@
-package com.github.insanusmokrassar.TelegramBotAPI.requests.edit.ReplyMarkup
-
-import com.github.insanusmokrassar.TelegramBotAPI.bot.RequestsExecutor
-import com.github.insanusmokrassar.TelegramBotAPI.requests.edit.abstracts.EditInlineMessage
-import com.github.insanusmokrassar.TelegramBotAPI.requests.edit.abstracts.EditReplyMessage
-import com.github.insanusmokrassar.TelegramBotAPI.requests.edit.media.EditInlineMessageMedia
-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.*
-
-@Serializable
-data class EditInlineMessageReplyMarkup(
-    @SerialName(inlineMessageIdField)
-    override val inlineMessageId: InlineMessageIdentifier,
-    @SerialName(replyMarkupField)
-    override val replyMarkup: InlineKeyboardMarkup? = null
-) : EditInlineMessage, EditReplyMessage {
-    override fun method(): String = editMessageReplyMarkupMethod
-    override val requestSerializer: SerializationStrategy<*>
-        get() = serializer()
-}
-
-suspend fun RequestsExecutor.editMessageReplyMarkup(
-    inlineMessageId: InlineMessageIdentifier,
-    replyMarkup: InlineKeyboardMarkup? = null
-) = execute(EditInlineMessageReplyMarkup(inlineMessageId, replyMarkup))

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

@@ -1,8 +0,0 @@
-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.abstracts.ContentMessage
-import com.github.insanusmokrassar.TelegramBotAPI.types.message.content.abstracts.MessageContent
-
-interface EditChatMessage<MT: MessageContent> : SimpleRequest<ContentMessage<MT>>, MessageAction

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

@@ -1,12 +0,0 @@
-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.DeserializationStrategy
-import kotlinx.serialization.internal.BooleanSerializer
-
-interface EditInlineMessage : SimpleRequest<Boolean> {
-    val inlineMessageId: InlineMessageIdentifier
-    override val resultDeserializer: DeserializationStrategy<Boolean>
-        get() = BooleanSerializer
-}

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

@@ -1,6 +0,0 @@
-package com.github.insanusmokrassar.TelegramBotAPI.requests.edit.abstracts
-
-interface EditLocationMessage {
-    val latitude: Double
-    val longitude: Double
-}

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

@@ -1,7 +0,0 @@
-package com.github.insanusmokrassar.TelegramBotAPI.requests.edit.abstracts
-
-import com.github.insanusmokrassar.TelegramBotAPI.types.InputMedia.InputMedia
-
-interface EditMediaMessage {
-    val media: InputMedia
-}

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

@@ -1,8 +0,0 @@
-package com.github.insanusmokrassar.TelegramBotAPI.requests.edit.abstracts
-
-import com.github.insanusmokrassar.TelegramBotAPI.CommonAbstracts.types.ReplyMarkup
-import com.github.insanusmokrassar.TelegramBotAPI.types.buttons.InlineKeyboardMarkup
-
-interface EditReplyMessage : ReplyMarkup {
-    override val replyMarkup: InlineKeyboardMarkup?
-}

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

@@ -1,8 +0,0 @@
-package com.github.insanusmokrassar.TelegramBotAPI.requests.edit.abstracts
-
-import com.github.insanusmokrassar.TelegramBotAPI.types.ParseMode.ParseMode
-
-interface EditTextChatMessage {
-    val text: String
-    val parseMode: ParseMode?
-}

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

@@ -1,69 +0,0 @@
-package com.github.insanusmokrassar.TelegramBotAPI.requests.edit.caption
-
-import com.github.insanusmokrassar.TelegramBotAPI.CommonAbstracts.CaptionedInput
-import com.github.insanusmokrassar.TelegramBotAPI.bot.RequestsExecutor
-import com.github.insanusmokrassar.TelegramBotAPI.requests.edit.abstracts.*
-import com.github.insanusmokrassar.TelegramBotAPI.requests.edit.media.MediaContentMessageResultDeserializer
-import com.github.insanusmokrassar.TelegramBotAPI.requests.edit.text.EditChatMessageText
-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.chat.abstracts.Chat
-import com.github.insanusmokrassar.TelegramBotAPI.types.message.CommonMessageImpl
-import com.github.insanusmokrassar.TelegramBotAPI.types.message.abstracts.ContentMessage
-import com.github.insanusmokrassar.TelegramBotAPI.types.message.abstracts.Message
-import com.github.insanusmokrassar.TelegramBotAPI.types.message.content.abstracts.MediaContent
-import com.github.insanusmokrassar.TelegramBotAPI.types.message.content.abstracts.MessageContent
-import com.github.insanusmokrassar.TelegramBotAPI.types.message.content.media.PhotoContent
-import kotlinx.serialization.*
-
-const val editMessageCaptionMethod = "editMessageCaption"
-
-@Serializable
-data class EditChatMessageCaption(
-    @SerialName(chatIdField)
-    override val chatId: ChatIdentifier,
-    @SerialName(messageIdField)
-    override val messageId: MessageIdentifier,
-    @SerialName(captionField)
-    override val text: String,
-    @SerialName(parseModeField)
-    override val parseMode: ParseMode? = null,
-    @SerialName(replyMarkupField)
-    override val replyMarkup: InlineKeyboardMarkup? = null
-) : EditChatMessage<MediaContent>, EditTextChatMessage, EditReplyMessage {
-
-    override fun method(): String = editMessageCaptionMethod
-    override val resultDeserializer: DeserializationStrategy<ContentMessage<MediaContent>>
-        get() = MediaContentMessageResultDeserializer
-    override val requestSerializer: SerializationStrategy<*>
-        get() = serializer()
-}
-
-suspend fun RequestsExecutor.editMessageCaption(
-    chatId: ChatIdentifier,
-    messageId: MessageIdentifier,
-    text: String,
-    parseMode: ParseMode? = null,
-    replyMarkup: InlineKeyboardMarkup? = null
-) = execute(
-    EditChatMessageCaption(chatId, messageId, text, parseMode, replyMarkup)
-)
-
-suspend fun RequestsExecutor.editMessageCaption(
-    chat: Chat,
-    messageId: MessageIdentifier,
-    text: String,
-    parseMode: ParseMode? = null,
-    replyMarkup: InlineKeyboardMarkup? = null
-) = editMessageCaption(chat.id, messageId, text, parseMode, replyMarkup)
-
-suspend fun <T> RequestsExecutor.editMessageCaption(
-    message: ContentMessage<T>,
-    text: String,
-    parseMode: ParseMode? = null,
-    replyMarkup: InlineKeyboardMarkup? = null
-): ContentMessage<MediaContent> where T : CaptionedInput, T : MediaContent {
-    return editMessageCaption(message.chat.id, message.messageId, text, parseMode, replyMarkup)
-}