Merge pull request #938 from rubenlagus/dev

Dev

README.md

@@ -27,18 +27,18 @@ Just import add the library to your project with one of these options:
     <dependency>
         <groupId>org.telegram</groupId>
         <artifactId>telegrambots</artifactId>
-        <version>5.2.0</version>
+        <version>5.3.0</version>
     </dependency>
 ```
 
   2. Using Gradle: 
 
 ```gradle
-    implementation 'org.telegram:telegrambots:5.2.0'
+    implementation 'org.telegram:telegrambots:5.3.0'
 ```
 
-  3. Using Jitpack from [here](https://jitpack.io/#rubenlagus/TelegramBots/5.2.0)
+  3. Using Jitpack from [here](https://jitpack.io/#rubenlagus/TelegramBots/5.3.0)
-  4. Download the jar(including all dependencies) from [here](https://mvnrepository.com/artifact/org.telegram/telegrambots/5.2.0)
+  4. Download the jar(including all dependencies) from [here](https://mvnrepository.com/artifact/org.telegram/telegrambots/5.3.0)
 
 In order to use Long Polling mode, just create your own bot extending `org.telegram.telegrambots.bots.TelegramLongPollingBot`.
 

TelegramBots.wiki/Changelog.md

@@ -1,5 +1,12 @@
+### <a id="5.3.0"></a>5.3.0 ###
+1. Update Api version [5.3](https://core.telegram.org/bots/api-changelog#june-25-2021)
+2. `KeyboardRow` now support creation from a collection of buttons.
+3. Bug fixing: #920, #931 and #937
+
+**[[How to update to version 5.3.0|How-To-Update#5.3.0]]**
+
 ### <a id="5.2.0"></a>5.2.0 ###
-1. Update Api version [5.2](https://core.telegram.org/bots/api#april-26-2021)
+1. Update Api version [5.2](https://core.telegram.org/bots/api-changelog#april-26-2021)
 2. Allow custom BackOff implementations
 3. Spring version 2.4.5 in spring module
 4. Bug fixing: #869, #888 and #892

TelegramBots.wiki/FAQ.md

@@ -225,6 +225,46 @@ Custom keyboards can be appended to messages using the `setReplyMarkup`. In this
     }
 ```
 
+[InlineKeyboardMarkup](https://core.telegram.org/bots/api#inlinekeyboardmarkup) use list to capture the buttons instead of KeyboardRow.
+
+```java
+   public void sendInlineKeyboard(String chatId) {
+        SendMessage message = new SendMessage();
+        message.setChatId(chatId);
+        message.setText("Inline model below.");
+
+        // Create InlineKeyboardMarkup object
+        InlineKeyboardMarkup inlineKeyboardMarkup = new InlineKeyboardMarkup();
+        // Create the keyboard (list of InlineKeyboardButton list)
+        List<List<InlineKeyboardButton>> keyboard = new ArrayList<>();
+        // Create a list for buttons
+        List<InlineKeyboardButton> Buttons = new ArrayList<InlineKeyboardButton>();
+        // Initialize each button, the text must be written
+        InlineKeyboardButton youtube= new InlineKeyboardButton("youtube");
+        // Also must use exactly one of the optional fields,it can edit  by set method
+        youtube.setUrl("https://www.youtube.com");
+        // Add button to the list
+        Buttons.add(youtube);
+        // Initialize each button, the text must be written
+        InlineKeyboardButton github= new InlineKeyboardButton("github");
+        // Also must use exactly one of the optional fields,it can edit  by set method
+        github.setUrl("https://github.com");
+        // Add button to the list
+        Buttons.add(github);
+        keyboard.add(Buttons);
+        inlineKeyboardMarkup.setKeyboard(keyboard);
+        // Add it to the message
+        message.setReplyMarkup(inlineKeyboardMarkup);
+
+        try {
+        // Send the message
+        execute(message);
+        } catch (TelegramApiException e) {
+        e.printStackTrace();
+        }
+        }
+```
+
 ## <a id="how_to_host"></a>How can I run my bot? ##
 
 You don't need to spend a lot of money into hosting your own telegram bot. Basically, there are two options around how to host:

TelegramBots.wiki/Getting-Started.md

@@ -11,13 +11,13 @@ First you need ot get the library and add it to your project. There are few poss
            <dependency>
               <groupId>org.telegram</groupId>
               <artifactId>telegrambots</artifactId>
-              <version>5.2.0</version>
+              <version>5.3.0</version>
            </dependency>
         ```
     * With **Gradle**:
     
         ```gradle
-          implementation 'org.telegram:telegrambots:5.2.0'
+          implementation 'org.telegram:telegrambots:5.3.0'
         ```
  
 2. Don't like **Maven Central Repository**? It can also be taken from [Jitpack](https://jitpack.io/#rubenlagus/TelegramBots).

TelegramBots.wiki/How-To-Update.md

@@ -1,3 +1,18 @@
+### <a id="5.3.0"></a>To version 5.3.0 ###
+1. As per API guidelines, ChatMember method has been divided in different classed. 
+   Where used in your code, replace old import with new one 
+   (GetChatAdministrators.java, GetChatMember.java, ChatMemberUpdated.java):
+   
+   `import org.telegram.telegrambots.meta.api.objects.ChatMember;`
+   
+   to
+   
+   `import org.telegram.telegrambots.meta.api.objects.chatmember.ChatMember;`
+2. ChatMember is an interface now, you'll need to cast it to the corresponding implementation when using it.
+3. `GetChatMembersCount` renamed to `GetChatMemberCount`, old version will still work until next major version.
+4. `KickChatMember` renamed to `BanChatMember`, old version will still work until next major version.
+   
+
 ### <a id="5.1.0"></a>To version 5.1.0 ###
 1. All users IDs fields are now Long type as per API guidelines.
 

TelegramBots.wiki/abilities/Simple-Example.md

@@ -9,12 +9,12 @@ As with any Java project, you will need to set your dependencies.
    <dependency>
       <groupId>org.telegram</groupId>
       <artifactId>telegrambots-abilities</artifactId>
-      <version>5.2.0</version>
+      <version>5.3.0</version>
    </dependency>
 ```
 * **Gradle**
 ```gradle
-  implementation 'org.telegram:telegrambots-abilities:5.2.0'
+  implementation 'org.telegram:telegrambots-abilities:5.3.0'
 ```
 * [JitPack](https://jitpack.io/#rubenlagus/TelegramBots)
     

pom.xml

@@ -7,7 +7,7 @@
     <groupId>org.telegram</groupId>
     <artifactId>Bots</artifactId>
     <packaging>pom</packaging>
-    <version>5.2.0</version>
+    <version>5.3.0</version>
 
     <modules>
         <module>telegrambots</module>

telegrambots-abilities/README.md

@@ -18,14 +18,14 @@ Usage
     <dependency>
         <groupId>org.telegram</groupId>
         <artifactId>telegrambots-abilities</artifactId>
-        <version>5.2.0</version>
+        <version>5.3.0</version>
     </dependency>
 ```
 
 **Gradle**
 
 ```gradle
-    implementation 'org.telegram:telegrambots-abilities:5.2.0'
+    implementation 'org.telegram:telegrambots-abilities:5.3.0'
 ```
 
 **JitPack** - [JitPack](https://jitpack.io/#rubenlagus/TelegramBots/v5.0.1)

telegrambots-abilities/pom.xml

@@ -7,7 +7,7 @@
     <parent>
         <groupId>org.telegram</groupId>
         <artifactId>Bots</artifactId>
-        <version>5.2.0</version>
+        <version>5.3.0</version>
     </parent>
 
     <artifactId>telegrambots-abilities</artifactId>
@@ -84,7 +84,7 @@
         <dependency>
             <groupId>org.telegram</groupId>
             <artifactId>telegrambots</artifactId>
-            <version>5.2.0</version>
+            <version>5.3.0</version>
         </dependency>
         <dependency>
             <groupId>org.apache.commons</groupId>

telegrambots-abilities/src/main/java/org/telegram/abilitybots/api/bot/BaseAbilityBot.java

@@ -21,6 +21,8 @@ import org.telegram.telegrambots.meta.api.methods.groupadministration.GetChatAdm
 import org.telegram.telegrambots.meta.api.objects.Message;
 import org.telegram.telegrambots.meta.api.objects.Update;
 import org.telegram.telegrambots.meta.api.objects.User;
+import org.telegram.telegrambots.meta.api.objects.chatmember.ChatMemberAdministrator;
+import org.telegram.telegrambots.meta.api.objects.chatmember.ChatMemberOwner;
 
 import java.lang.reflect.InvocationTargetException;
 import java.lang.reflect.Method;
@@ -260,8 +262,17 @@ public abstract class BaseAbilityBot extends DefaultAbsSender implements Ability
     public boolean isGroupAdmin(long chatId, long id) {
         GetChatAdministrators admins = GetChatAdministrators.builder().chatId(Long.toString(chatId)).build();
         return silent.execute(admins)
-            .orElse(new ArrayList<>()).stream()
+                .orElse(new ArrayList<>())
-            .anyMatch(member -> member.getUser().getId() == id);
+                .stream()
+                .map(member -> {
+                    if (member instanceof ChatMemberAdministrator) {
+                        return ((ChatMemberAdministrator) member).getUser().getId();
+                    } else if (member instanceof ChatMemberOwner) {
+                        return ((ChatMemberOwner) member).getUser().getId();
+                    }
+                    return 0L;
+                })
+                .anyMatch(member -> member == id);
     }
 
     public boolean isCreator(long id) {

telegrambots-abilities/src/main/java/org/telegram/abilitybots/api/sender/SilentSender.java

@@ -39,7 +39,10 @@ public class SilentSender {
     SendMessage msg = new SendMessage();
     msg.setText(message);
     msg.setChatId(Long.toString(id));
-    msg.setReplyMarkup(new ForceReplyKeyboard());
+    ForceReplyKeyboard kb = new ForceReplyKeyboard();
+    kb.setForceReply(true);
+    kb.setSelective(true);
+    msg.setReplyMarkup(kb);
 
     return execute(msg);
   }

telegrambots-abilities/src/test/java/org/telegram/abilitybots/api/bot/AbilityBotTest.java

@@ -10,14 +10,23 @@ import org.junit.jupiter.api.Test;
 import org.mockito.ArgumentMatchers;
 import org.mockito.Mockito;
 import org.telegram.abilitybots.api.db.DBContext;
-import org.telegram.abilitybots.api.objects.*;
+import org.telegram.abilitybots.api.objects.Ability;
+import org.telegram.abilitybots.api.objects.Flag;
+import org.telegram.abilitybots.api.objects.Locality;
+import org.telegram.abilitybots.api.objects.MessageContext;
+import org.telegram.abilitybots.api.objects.Privacy;
 import org.telegram.abilitybots.api.sender.MessageSender;
 import org.telegram.abilitybots.api.sender.SilentSender;
 import org.telegram.abilitybots.api.util.AbilityUtils;
 import org.telegram.abilitybots.api.util.Pair;
 import org.telegram.abilitybots.api.util.Trio;
 import org.telegram.telegrambots.meta.api.methods.groupadministration.GetChatAdministrators;
-import org.telegram.telegrambots.meta.api.objects.*;
+import org.telegram.telegrambots.meta.api.objects.Document;
+import org.telegram.telegrambots.meta.api.objects.File;
+import org.telegram.telegrambots.meta.api.objects.Message;
+import org.telegram.telegrambots.meta.api.objects.Update;
+import org.telegram.telegrambots.meta.api.objects.User;
+import org.telegram.telegrambots.meta.api.objects.chatmember.ChatMemberAdministrator;
 import org.telegram.telegrambots.meta.exceptions.TelegramApiException;
 
 import java.io.BufferedWriter;
@@ -37,19 +46,32 @@ import static java.util.Optional.empty;
 import static org.apache.commons.io.FileUtils.deleteQuietly;
 import static org.apache.commons.lang3.ArrayUtils.addAll;
 import static org.apache.commons.lang3.StringUtils.EMPTY;
-import static org.junit.jupiter.api.Assertions.*;
+import static org.junit.jupiter.api.Assertions.assertEquals;
-import static org.mockito.Mockito.*;
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+import static org.mockito.Mockito.any;
+import static org.mockito.Mockito.anyLong;
+import static org.mockito.Mockito.anyString;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
 import static org.mockito.internal.verification.VerificationModeFactory.times;
-import static org.telegram.abilitybots.api.bot.DefaultBot.*;
+import static org.telegram.abilitybots.api.bot.DefaultBot.FIRST_REPLY_KEY_MESSAGE;
+import static org.telegram.abilitybots.api.bot.DefaultBot.SECOND_REPLY_KEY_MESSAGE;
+import static org.telegram.abilitybots.api.bot.DefaultBot.getDefaultBuilder;
 import static org.telegram.abilitybots.api.bot.TestUtils.CREATOR;
-import static org.telegram.abilitybots.api.bot.TestUtils.*;
+import static org.telegram.abilitybots.api.bot.TestUtils.USER;
+import static org.telegram.abilitybots.api.bot.TestUtils.mockContext;
+import static org.telegram.abilitybots.api.bot.TestUtils.mockFullUpdate;
 import static org.telegram.abilitybots.api.db.MapDBContext.offlineInstance;
 import static org.telegram.abilitybots.api.objects.Flag.DOCUMENT;
 import static org.telegram.abilitybots.api.objects.Flag.MESSAGE;
 import static org.telegram.abilitybots.api.objects.Locality.ALL;
 import static org.telegram.abilitybots.api.objects.Locality.GROUP;
 import static org.telegram.abilitybots.api.objects.MessageContext.newContext;
-import static org.telegram.abilitybots.api.objects.Privacy.*;
+import static org.telegram.abilitybots.api.objects.Privacy.ADMIN;
+import static org.telegram.abilitybots.api.objects.Privacy.GROUP_ADMIN;
+import static org.telegram.abilitybots.api.objects.Privacy.PUBLIC;
 
 public class AbilityBotTest {
   // Messages
@@ -431,7 +453,7 @@ public class AbilityBotTest {
     mockUser(update, message, user);
     when(message.isGroupMessage()).thenReturn(true);
 
-    ChatMember member = mock(ChatMember.class);
+    ChatMemberAdministrator member = mock(ChatMemberAdministrator.class);
     when(member.getUser()).thenReturn(user);
     when(member.getUser()).thenReturn(user);
 

telegrambots-chat-session-bot/README.md

@@ -15,14 +15,14 @@ Usage
     <dependency>
         <groupId>org.telegram</groupId>
         <artifactId>telegrambots-chat-session-bot</artifactId>
-        <version>5.2.0</version>
+        <version>5.3.0</version>
     </dependency>
 ```
 
 **Gradle**
 
 ```gradle
-    implementation 'org.telegram:telegrambots-chat-session-bot:5.2.0'
+    implementation 'org.telegram:telegrambots-chat-session-bot:5.3.0'
 ```
 
 Motivation

telegrambots-chat-session-bot/pom.xml

@@ -7,7 +7,7 @@
     <parent>
         <groupId>org.telegram</groupId>
         <artifactId>Bots</artifactId>
-        <version>5.2.0</version>
+        <version>5.3.0</version>
     </parent>
 
     <artifactId>telegrambots-chat-session-bot</artifactId>
@@ -84,7 +84,7 @@
         <dependency>
             <groupId>org.telegram</groupId>
             <artifactId>telegrambots</artifactId>
-            <version>5.2.0</version>
+            <version>5.3.0</version>
         </dependency>
 
         <!-- https://mvnrepository.com/artifact/org.apache.shiro/shiro-core -->

telegrambots-extensions/README.md

@@ -16,12 +16,12 @@ Just import add the library to your project with one of these options:
     <dependency>
         <groupId>org.telegram</groupId>
         <artifactId>telegrambotsextensions</artifactId>
-        <version>5.2.0</version>
+        <version>5.3.0</version>
     </dependency>
 ```
 
    2. Using Gradle:
 
 ```gradle
-    implementation 'org.telegram:telegrambotsextensions:5.2.0'
+    implementation 'org.telegram:telegrambotsextensions:5.3.0'
 ```

telegrambots-extensions/pom.xml

@@ -7,7 +7,7 @@
     <parent>
         <groupId>org.telegram</groupId>
         <artifactId>Bots</artifactId>
-        <version>5.2.0</version>
+        <version>5.3.0</version>
     </parent>
 
     <artifactId>telegrambotsextensions</artifactId>
@@ -75,7 +75,7 @@
         <dependency>
             <groupId>org.telegram</groupId>
             <artifactId>telegrambots</artifactId>
-            <version>5.2.0</version>
+            <version>5.3.0</version>
         </dependency>
     </dependencies>
 

telegrambots-meta/pom.xml

@@ -7,7 +7,7 @@
     <parent>
         <groupId>org.telegram</groupId>
         <artifactId>Bots</artifactId>
-        <version>5.2.0</version>
+        <version>5.3.0</version>
     </parent>
 
     <artifactId>telegrambots-meta</artifactId>

telegrambots-meta/src/main/java/org/telegram/telegrambots/meta/api/methods/commands/DeleteMyCommands.java

@@ -0,0 +1,85 @@
+package org.telegram.telegrambots.meta.api.methods.commands;
+
+import com.fasterxml.jackson.annotation.JsonProperty;
+import com.fasterxml.jackson.core.type.TypeReference;
+import lombok.AllArgsConstructor;
+import lombok.Builder;
+import lombok.EqualsAndHashCode;
+import lombok.Getter;
+import lombok.NoArgsConstructor;
+import lombok.Setter;
+import lombok.ToString;
+import org.telegram.telegrambots.meta.api.methods.BotApiMethod;
+import org.telegram.telegrambots.meta.api.objects.ApiResponse;
+import org.telegram.telegrambots.meta.api.objects.commands.scope.BotCommandScope;
+import org.telegram.telegrambots.meta.exceptions.TelegramApiRequestException;
+import org.telegram.telegrambots.meta.exceptions.TelegramApiValidationException;
+
+import java.io.IOException;
+
+/**
+ * @author Ruben Bermudez
+ * @version 5.3
+ *
+ * Use this method to delete the list of the bot's commands for the given scope and user language.
+ * After deletion, higher level commands will be shown to affected users.
+ * Returns True on success.
+ */
+@EqualsAndHashCode(callSuper = false)
+@Getter
+@Setter
+@ToString
+@NoArgsConstructor
+@AllArgsConstructor
+@Builder
+public class DeleteMyCommands extends BotApiMethod<Boolean> {
+    public static final String PATH = "deleteMyCommands";
+
+    private static final String SCOPE_FIELD = "scope";
+    private static final String LANGUAGECODE_FIELD = "language_code";
+
+    /**
+     * Optional
+     * A JSON-serialized object, describing scope of users for which the commands are relevant.
+     * Defaults to BotCommandScopeDefault.
+     */
+    @JsonProperty(SCOPE_FIELD)
+    private BotCommandScope scope;
+    /**
+     * Optional
+     * A two-letter ISO 639-1 language code.
+     * If empty, commands will be applied to all users from the given scope, for whose language there are no dedicated commands
+     */
+    @JsonProperty(LANGUAGECODE_FIELD)
+    private String languageCode;
+
+    @Override
+    public String getMethod() {
+        return PATH;
+    }
+
+    @Override
+    public Boolean deserializeResponse(String answer) throws TelegramApiRequestException {
+        try {
+            ApiResponse<Boolean> result = OBJECT_MAPPER.readValue(answer,
+                    new TypeReference<ApiResponse<Boolean>>(){});
+            if (result.getOk()) {
+                return result.getResult();
+            } else {
+                throw new TelegramApiRequestException("Error sending commands", result);
+            }
+        } catch (IOException e) {
+            throw new TelegramApiRequestException("Unable to deserialize response", e);
+        }
+    }
+
+    @Override
+    public void validate() throws TelegramApiValidationException {
+        if (scope != null) {
+            scope.validate();
+        }
+        if (languageCode != null && languageCode.isEmpty()) {
+            throw new TelegramApiValidationException("LanguageCode parameter can't be empty string", this);
+        }
+    }
+}

telegrambots-meta/src/main/java/org/telegram/telegrambots/meta/api/methods/commands/GetMyCommands.java

@@ -1,15 +1,18 @@
 package org.telegram.telegrambots.meta.api.methods.commands;
 
+import com.fasterxml.jackson.annotation.JsonProperty;
 import com.fasterxml.jackson.core.type.TypeReference;
 import lombok.AllArgsConstructor;
 import lombok.Builder;
 import lombok.EqualsAndHashCode;
 import lombok.Getter;
+import lombok.NoArgsConstructor;
 import lombok.Setter;
 import lombok.ToString;
 import org.telegram.telegrambots.meta.api.methods.BotApiMethod;
 import org.telegram.telegrambots.meta.api.objects.ApiResponse;
 import org.telegram.telegrambots.meta.api.objects.commands.BotCommand;
+import org.telegram.telegrambots.meta.api.objects.commands.scope.BotCommandScope;
 import org.telegram.telegrambots.meta.exceptions.TelegramApiRequestException;
 import org.telegram.telegrambots.meta.exceptions.TelegramApiValidationException;
 
@@ -19,19 +22,38 @@ import java.util.ArrayList;
 /**
  * @author Ruben Bermudez
  * @version 4.7
- * Use this method to get the current list of the bot's commands.
+ * Use this method to get the current list of the bot's commands for the given scope and user language.
- * Requires no parameters.
  * Returns Array of BotCommand on success.
+ * If commands aren't set, an empty list is returned.
  */
 @EqualsAndHashCode(callSuper = false)
 @Getter
 @Setter
 @ToString
+@NoArgsConstructor
 @AllArgsConstructor
 @Builder
 public class GetMyCommands extends BotApiMethod<ArrayList<BotCommand>> {
     public static final String PATH = "getMyCommands";
 
+    private static final String SCOPE_FIELD = "scope";
+    private static final String LANGUAGECODE_FIELD = "language_code";
+
+    /**
+     * Optional
+     * A JSON-serialized object, describing scope of users for which the commands are relevant.
+     * Defaults to BotCommandScopeDefault.
+     */
+    @JsonProperty(SCOPE_FIELD)
+    private BotCommandScope scope;
+    /**
+     * Optional
+     * A two-letter ISO 639-1 language code.
+     * If empty, commands will be applied to all users from the given scope, for whose language there are no dedicated commands
+     */
+    @JsonProperty(LANGUAGECODE_FIELD)
+    private String languageCode;
+
     @Override
     public String getMethod() {
         return PATH;
@@ -54,5 +76,11 @@ public class GetMyCommands extends BotApiMethod<ArrayList<BotCommand>> {
 
     @Override
     public void validate() throws TelegramApiValidationException {
+        if (scope != null) {
+            scope.validate();
+        }
+        if (languageCode != null && languageCode.isEmpty()) {
+            throw new TelegramApiValidationException("LanguageCode parameter can't be empty string", this);
+        }
     }
 }

telegrambots-meta/src/main/java/org/telegram/telegrambots/meta/api/methods/commands/SetMyCommands.java

@@ -14,6 +14,7 @@ import lombok.ToString;
 import org.telegram.telegrambots.meta.api.methods.BotApiMethod;
 import org.telegram.telegrambots.meta.api.objects.ApiResponse;
 import org.telegram.telegrambots.meta.api.objects.commands.BotCommand;
+import org.telegram.telegrambots.meta.api.objects.commands.scope.BotCommandScope;
 import org.telegram.telegrambots.meta.exceptions.TelegramApiRequestException;
 import org.telegram.telegrambots.meta.exceptions.TelegramApiValidationException;
 
@@ -23,7 +24,9 @@ import java.util.List;
 /**
  * @author Ruben Bermudez
  * @version 4.7
- * Use this method to change the list of the bot's commands. Returns True on success.
+ * Use this method to change the list of the bot's commands.
+ * See https://core.telegram.org/bots#commands for more details about bot commands.
+ * Returns True on success.
  */
 @EqualsAndHashCode(callSuper = false)
 @Getter
@@ -36,6 +39,8 @@ public class SetMyCommands extends BotApiMethod<Boolean> {
     public static final String PATH = "setMyCommands";
 
     private static final String COMMANDS_FIELD = "commands";
+    private static final String SCOPE_FIELD = "scope";
+    private static final String LANGUAGECODE_FIELD = "language_code";
 
     /**
      * A JSON-serialized list of bot commands to be set as the list of the bot's commands.
@@ -45,6 +50,20 @@ public class SetMyCommands extends BotApiMethod<Boolean> {
     @Singular
     @NonNull
     private List<BotCommand> commands;
+    /**
+     * Optional
+     * A JSON-serialized object, describing scope of users for which the commands are relevant.
+     * Defaults to BotCommandScopeDefault.
+     */
+    @JsonProperty(SCOPE_FIELD)
+    private BotCommandScope scope;
+    /**
+     * Optional
+     * A two-letter ISO 639-1 language code.
+     * If empty, commands will be applied to all users from the given scope, for whose language there are no dedicated commands
+     */
+    @JsonProperty(LANGUAGECODE_FIELD)
+    private String languageCode;
 
     @Override
     public String getMethod() {
@@ -68,7 +87,10 @@ public class SetMyCommands extends BotApiMethod<Boolean> {
 
     @Override
     public void validate() throws TelegramApiValidationException {
-        if (commands == null) {
+        if (languageCode != null && languageCode.isEmpty()) {
+            throw new TelegramApiValidationException("LanguageCode parameter can't be empty string", this);
+        }
+        if (commands == null || commands.isEmpty()) {
             throw new TelegramApiValidationException("Commands parameter can't be empty", this);
         }
         if (commands.size() > 100) {
@@ -77,5 +99,8 @@ public class SetMyCommands extends BotApiMethod<Boolean> {
         for (BotCommand command : commands) {
             command.validate();
         }
+        if (scope != null) {
+            scope.validate();
+        }
     }
 }

telegrambots-meta/src/main/java/org/telegram/telegrambots/meta/api/methods/groupadministration/BanChatMember.java

@@ -0,0 +1,117 @@
+package org.telegram.telegrambots.meta.api.methods.groupadministration;
+
+import com.fasterxml.jackson.annotation.JsonIgnore;
+import com.fasterxml.jackson.annotation.JsonProperty;
+import com.fasterxml.jackson.core.type.TypeReference;
+import lombok.AllArgsConstructor;
+import lombok.Builder;
+import lombok.EqualsAndHashCode;
+import lombok.Getter;
+import lombok.NoArgsConstructor;
+import lombok.NonNull;
+import lombok.RequiredArgsConstructor;
+import lombok.Setter;
+import lombok.ToString;
+import org.telegram.telegrambots.meta.api.methods.BotApiMethod;
+import org.telegram.telegrambots.meta.api.objects.ApiResponse;
+import org.telegram.telegrambots.meta.exceptions.TelegramApiRequestException;
+import org.telegram.telegrambots.meta.exceptions.TelegramApiValidationException;
+
+import java.io.IOException;
+import java.time.Duration;
+import java.time.Instant;
+import java.time.ZonedDateTime;
+
+/**
+ * @author Ruben Bermudez
+ * @version 5.3
+ * Use this method to kick a user from a group, a supergroup or a channel. In the case of supergroups,
+ * the user will not be able to return to the group on their own using invite links, etc., unless
+ * unbanned first. The bot must be an administrator in the group for this to work. Returns True on
+ * success.
+ * @apiNote  This will method only work if the ‘All Members Are Admins’ setting is off in the target
+ * group. Otherwise members may only be removed by the group's creator or by the member that added
+ * them.
+ */
+@EqualsAndHashCode(callSuper = false)
+@Getter
+@Setter
+@ToString
+@NoArgsConstructor
+@RequiredArgsConstructor
+@AllArgsConstructor
+@Builder
+public class BanChatMember extends BotApiMethod<Boolean> {
+    public static final String PATH = "banChatMember";
+
+    private static final String CHATID_FIELD = "chat_id";
+    private static final String USER_ID_FIELD = "user_id";
+    private static final String UNTILDATE_FIELD = "until_date";
+    private static final String REVOKEMESSAGES_FIELD = "revoke_messages";
+
+    @JsonProperty(CHATID_FIELD)
+    @NonNull
+    private String chatId; ///< Required. Unique identifier for the chat to send the message to (Or username for channels)
+    @JsonProperty(USER_ID_FIELD)
+    @NonNull
+    private Long userId; ///< Required. Unique identifier of the target user
+    @JsonProperty(UNTILDATE_FIELD)
+    private Integer untilDate; ///< Optional. Date when the user will be unbanned, unix time. If user is banned for more than 366 days or less than 30 seconds from the current time they are considered to be banned forever
+    /**
+     * Optional
+     *
+     * Pass True to delete all messages from the chat for the user that is being removed.
+     *
+     * If False, the user will be able to see messages in the group that were sent before the user was removed.
+     *
+     * Always True for supergroups and channels.
+     */
+    @JsonProperty(REVOKEMESSAGES_FIELD)
+    private Boolean revokeMessages;
+
+
+    @JsonIgnore
+    public void setUntilDateInstant(Instant instant) {
+        setUntilDate((int) instant.getEpochSecond());
+    }
+
+    @JsonIgnore
+    public void setUntilDateDateTime(ZonedDateTime date) {
+        setUntilDateInstant(date.toInstant());
+    }
+
+    @JsonIgnore
+    public void forTimePeriodDuration(Duration duration) {
+        setUntilDateInstant(Instant.now().plusMillis(duration.toMillis()));
+    }
+
+    @Override
+    public String getMethod() {
+        return PATH;
+    }
+
+    @Override
+    public Boolean deserializeResponse(String answer) throws TelegramApiRequestException {
+        try {
+            ApiResponse<Boolean> result = OBJECT_MAPPER.readValue(answer,
+                    new TypeReference<ApiResponse<Boolean>>(){});
+            if (result.getOk()) {
+                return result.getResult();
+            } else {
+                throw new TelegramApiRequestException("Error kicking chat member", result);
+            }
+        } catch (IOException e) {
+            throw new TelegramApiRequestException("Unable to deserialize response", e);
+        }
+    }
+
+    @Override
+    public void validate() throws TelegramApiValidationException {
+        if (chatId == null || chatId.isEmpty()) {
+            throw new TelegramApiValidationException("ChatId can't be empty", this);
+        }
+        if (userId == null || userId == 0) {
+            throw new TelegramApiValidationException("UserId can't be null or 0", this);
+        }
+    }
+}

telegrambots-meta/src/main/java/org/telegram/telegrambots/meta/api/methods/groupadministration/GetChatAdministrators.java

@@ -12,7 +12,7 @@ import lombok.Setter;
 import lombok.ToString;
 import org.telegram.telegrambots.meta.api.methods.BotApiMethod;
 import org.telegram.telegrambots.meta.api.objects.ApiResponse;
-import org.telegram.telegrambots.meta.api.objects.ChatMember;
+import org.telegram.telegrambots.meta.api.objects.chatmember.ChatMember;
 import org.telegram.telegrambots.meta.exceptions.TelegramApiRequestException;
 import org.telegram.telegrambots.meta.exceptions.TelegramApiValidationException;
 

telegrambots-meta/src/main/java/org/telegram/telegrambots/meta/api/methods/groupadministration/GetChatMember.java

@@ -12,7 +12,7 @@ import lombok.Setter;
 import lombok.ToString;
 import org.telegram.telegrambots.meta.api.methods.BotApiMethod;
 import org.telegram.telegrambots.meta.api.objects.ApiResponse;
-import org.telegram.telegrambots.meta.api.objects.ChatMember;
+import org.telegram.telegrambots.meta.api.objects.chatmember.ChatMember;
 import org.telegram.telegrambots.meta.exceptions.TelegramApiRequestException;
 import org.telegram.telegrambots.meta.exceptions.TelegramApiValidationException;
 

telegrambots-meta/src/main/java/org/telegram/telegrambots/meta/api/methods/groupadministration/GetChatMemberCount.java

@@ -0,0 +1,67 @@
+package org.telegram.telegrambots.meta.api.methods.groupadministration;
+
+import com.fasterxml.jackson.annotation.JsonProperty;
+import com.fasterxml.jackson.core.type.TypeReference;
+import lombok.AllArgsConstructor;
+import lombok.Builder;
+import lombok.EqualsAndHashCode;
+import lombok.Getter;
+import lombok.NoArgsConstructor;
+import lombok.NonNull;
+import lombok.Setter;
+import lombok.ToString;
+import org.telegram.telegrambots.meta.api.methods.BotApiMethod;
+import org.telegram.telegrambots.meta.api.objects.ApiResponse;
+import org.telegram.telegrambots.meta.exceptions.TelegramApiRequestException;
+import org.telegram.telegrambots.meta.exceptions.TelegramApiValidationException;
+
+import java.io.IOException;
+
+/**
+ * @author Ruben Bermudez
+ * @version 5.3
+ * Use this method to get the number of members in a chat. Returns Int on success.
+ */
+@EqualsAndHashCode(callSuper = false)
+@Getter
+@Setter
+@ToString
+@NoArgsConstructor
+@AllArgsConstructor
+@Builder
+public class GetChatMemberCount extends BotApiMethod<Integer> {
+    public static final String PATH = "getChatMemberCount";
+
+    private static final String CHATID_FIELD = "chat_id";
+
+    @JsonProperty(CHATID_FIELD)
+    @NonNull
+    private String chatId; ///< Unique identifier for the chat to send the message to (Or username for channels)
+
+    @Override
+    public String getMethod() {
+        return PATH;
+    }
+
+    @Override
+    public Integer deserializeResponse(String answer) throws TelegramApiRequestException {
+        try {
+            ApiResponse<Integer> result = OBJECT_MAPPER.readValue(answer,
+                    new TypeReference<ApiResponse<Integer>>(){});
+            if (result.getOk()) {
+                return result.getResult();
+            } else {
+                throw new TelegramApiRequestException("Error getting chat members count", result);
+            }
+        } catch (IOException e) {
+            throw new TelegramApiRequestException("Unable to deserialize response", e);
+        }
+    }
+
+    @Override
+    public void validate() throws TelegramApiValidationException {
+        if (chatId == null || chatId.isEmpty()) {
+            throw new TelegramApiValidationException("ChatId can't be empty", this);
+        }
+    }
+}

telegrambots-meta/src/main/java/org/telegram/telegrambots/meta/api/methods/groupadministration/GetChatMembersCount.java

@@ -21,6 +21,8 @@ import java.io.IOException;
  * @author Ruben Bermudez
  * @version 1.0
  * Use this method to get the number of members in a chat. Returns Int on success.
+ *
+ * @deprecated Use {{@link GetChatMemberCount#GetChatMemberCount()}
  */
 @EqualsAndHashCode(callSuper = false)
 @Getter
@@ -29,6 +31,7 @@ import java.io.IOException;
 @NoArgsConstructor
 @AllArgsConstructor
 @Builder
+@Deprecated
 public class GetChatMembersCount extends BotApiMethod<Integer> {
     public static final String PATH = "getChatMembersCount";
 

telegrambots-meta/src/main/java/org/telegram/telegrambots/meta/api/methods/groupadministration/KickChatMember.java

@@ -32,6 +32,8 @@ import java.time.ZonedDateTime;
  * @apiNote  This will method only work if the ‘All Members Are Admins’ setting is off in the target
  * group. Otherwise members may only be removed by the group's creator or by the member that added
  * them.
+ *
+ * @deprecated Use {@link BanChatMember#BanChatMember()} instead
  */
 @EqualsAndHashCode(callSuper = false)
 @Getter
@@ -41,6 +43,7 @@ import java.time.ZonedDateTime;
 @RequiredArgsConstructor
 @AllArgsConstructor
 @Builder
+@Deprecated
 public class KickChatMember extends BotApiMethod<Boolean> {
     public static final String PATH = "kickchatmember";
 

telegrambots-meta/src/main/java/org/telegram/telegrambots/meta/api/methods/send/SendInvoice.java

@@ -199,9 +199,6 @@ public class SendInvoice extends BotApiMethod<Message> {
         if (Strings.isNullOrEmpty(providerToken)) {
             throw new TelegramApiValidationException("ProviderToken parameter can't be empty", this);
         }
-        if (Strings.isNullOrEmpty(startParameter)) {
-            throw new TelegramApiValidationException("StartParameter parameter can't be empty", this);
-        }
         if (Strings.isNullOrEmpty(currency)) {
             throw new TelegramApiValidationException("Currency parameter can't be empty", this);
         }

telegrambots-meta/src/main/java/org/telegram/telegrambots/meta/api/methods/stickers/SetStickerSetThumb.java

@@ -31,7 +31,7 @@ import java.io.IOException;
 @AllArgsConstructor
 @Builder
 public class SetStickerSetThumb extends BotApiMethod<Boolean> {
-    private static final String PATH = "setStickerSetThumb";
+    public static final String PATH = "setStickerSetThumb";
 
     public static final String NAME_FIELD = "name";
     public static final String USERID_FIELD = "user_id";

telegrambots-meta/src/main/java/org/telegram/telegrambots/meta/api/objects/ChatMember.java

@@ -1,117 +0,0 @@
-package org.telegram.telegrambots.meta.api.objects;
-
-import com.fasterxml.jackson.annotation.JsonProperty;
-import lombok.AllArgsConstructor;
-import lombok.EqualsAndHashCode;
-import lombok.Getter;
-import lombok.NoArgsConstructor;
-import lombok.Setter;
-import lombok.ToString;
-import org.telegram.telegrambots.meta.api.interfaces.BotApiObject;
-
-import java.time.Instant;
-
-/**
- * @author Ruben Bermudez
- * @version 1.0
- * This object contains information about one member of the chat.
- */
-@EqualsAndHashCode(callSuper = false)
-@Getter
-@Setter
-@ToString
-@NoArgsConstructor
-@AllArgsConstructor
-public class ChatMember implements BotApiObject {
-    private static final String USER_FIELD = "user";
-    private static final String STATUS_FIELD = "status";
-    private static final String UNTILDATE_FIELD = "until_date";
-    private static final String CANBEEDITED_FIELD = "can_be_edited";
-    private static final String CANCHANGEINFO_FIELD = "can_change_info";
-    private static final String CANPOSTMESSAGES_FIELD = "can_post_messages";
-    private static final String CANEDITMESSAGES_FIELD = "can_edit_messages";
-    private static final String CANDELETEMESSAGES_FIELD = "can_delete_messages";
-    private static final String CANINVITEUSERS_FIELD = "can_invite_users";
-    private static final String CANRESTRICTMEMBERS_FIELD = "can_restrict_members";
-    private static final String CANPINMESSAGES_FIELD = "can_pin_messages";
-    private static final String CANPROMOTEMEMBERS_FIELD = "can_promote_members";
-    private static final String CANSENDMESSAGES_FIELD = "can_send_messages";
-    private static final String CANSENDMEDIAMESSAGES_FIELD = "can_send_media_messages";
-    private static final String CANSENDOTHERMESSAGES_FIELD = "can_send_other_messages";
-    private static final String CANADDWEBPAGEPREVIEWS_FIELD = "can_add_web_page_previews";
-    private static final String CAN_SEND_POLLS_FIELD = "can_send_polls";
-    private static final String ISMEMBER_FIELD = "is_member";
-    private static final String CUSTOMTITLE_FIELD = "custom_title";
-    private static final String ISANONYMOUS_FIELD = "is_anonymous";
-    private static final String CANMANAGECHAT_FIELD = "can_manage_chat";
-    private static final String CANMANAGEVOICECHATS_FIELD = "can_manage_voice_chats";
-
-    @JsonProperty(USER_FIELD)
-    private User user; ///< Information about the user
-    @JsonProperty(STATUS_FIELD)
-    private String status; ///< The member's status in the chat. Can be “creator”, “administrator”, “member”, “restricted”, “left” or “kicked”
-    @JsonProperty(UNTILDATE_FIELD)
-    private Integer untilDate; ///< Optional. Restricted and kicked only. Date when restrictions will be lifted for this user, unix time
-    @JsonProperty(CANBEEDITED_FIELD)
-    private Boolean canBeEdited; ///< Optional. Administrators only. True, if the bot is allowed to edit administrator privileges of that user
-    @JsonProperty(CANCHANGEINFO_FIELD)
-    private Boolean canChangeInfo; ///< Optional. Administrators and restricted only. True, if the administrator can change the chat title, photo and other settings
-    @JsonProperty(CANPOSTMESSAGES_FIELD)
-    private Boolean canPostMessages; ///< Optional. Administrators only. True, if the administrator can post in the channel, channels only
-    @JsonProperty(CANEDITMESSAGES_FIELD)
-    private Boolean canEditMessages; ///< Optional. Administrators only. True, if the administrator can edit messages of other users and can pin messages, channels only
-    @JsonProperty(CANDELETEMESSAGES_FIELD)
-    private Boolean canDeleteMessages; ///< Optional. Administrators only. True, if the administrator can delete messages of other users
-    @JsonProperty(CANINVITEUSERS_FIELD)
-    private Boolean canInviteUsers; ///< Optional. Administrators and restricted only. True, if the administrator can invite new users to the chat
-    @JsonProperty(CANRESTRICTMEMBERS_FIELD)
-    private Boolean canRestrictMembers; ///< Optional. Administrators only. True, if the administrator can restrict, ban or unban chat members
-    @JsonProperty(CANPINMESSAGES_FIELD)
-    private Boolean canPinMessages; ///< Optional. Administrators and restricted only. True, if the administrator can pin messages, groups and supergroups only
-    @JsonProperty(CANPROMOTEMEMBERS_FIELD)
-    private Boolean canPromoteMembers; ///< Optional. Administrators only. True, if the administrator can add new administrators with a subset of his own privileges or demote administrators that it has promoted, directly or indirectly (promoted by administrators that were appointed by the bot)
-    @JsonProperty(CANSENDMESSAGES_FIELD)
-    private Boolean canSendMessages; ///< Optional. Restricted only. True, if the user is allowed to send text messages, contacts, locations and venues
-    @JsonProperty(CANSENDMEDIAMESSAGES_FIELD)
-    private Boolean canSendMediaMessages; ///< Optional. Restricted only. True, if the user is allowed to send audios, documents, photos, videos, video notes and voice notes, implies can_send_messages
-    @JsonProperty(CANSENDOTHERMESSAGES_FIELD)
-    private Boolean canSendOtherMessages; ///< Optional. Restricted only. True, if the user is allowed to send animations, games, stickers and use inline bots, implies can_send_media_messages
-    @JsonProperty(CANADDWEBPAGEPREVIEWS_FIELD)
-    private Boolean canAddWebPagePreviews; ///< Optional. Restricted only. True, if the user is allowed to add web page previews to his messages
-    @JsonProperty(CAN_SEND_POLLS_FIELD)
-    private Boolean canSendPolls; ///< Optional. Restricted only. True, if the user is allowed to send polls.
-    @JsonProperty(ISMEMBER_FIELD)
-    private Boolean isMember; ///< True, if the user is a member of the chat at the moment of the request. For example, it can be false for the chat creator or for a restricted user.
-    @JsonProperty(CUSTOMTITLE_FIELD)
-    private String customTitle; ///< Optional. Owner and administrators only. Custom title for this user
-    @JsonProperty(ISANONYMOUS_FIELD)
-    private Boolean isAnonymous; ///< Optional. Owner and administrators only. True, if the user's presence in the chat is hidden
-    /**
-     * Optional.
-     *
-     * Administrators only.
-     *
-     * True, if the administrator can access the chat event log, chat statistics, message statistics in channels,
-     * see channel members, see anonymous administrators in supergoups and ignore slow mode.
-     *
-     * Implied by any other administrator privilege
-     */
-    @JsonProperty(CANMANAGECHAT_FIELD)
-    private Boolean canManageChat;
-    /**
-     * Optional.
-     *
-     * Administrators only.
-     *
-     * True, if the administrator can manage voice chats; groups and supergroups only
-     */
-    @JsonProperty(CANMANAGEVOICECHATS_FIELD)
-    private Boolean canManageVoiceChats;
-
-    public Instant getUntilDateAsInstant() {
-        if (untilDate == null) {
-            return null;
-        }
-        return Instant.ofEpochSecond(untilDate);
-    }
-}

telegrambots-meta/src/main/java/org/telegram/telegrambots/meta/api/objects/ChatMemberUpdated.java

@@ -8,6 +8,7 @@ import lombok.NoArgsConstructor;
 import lombok.Setter;
 import lombok.ToString;
 import org.telegram.telegrambots.meta.api.interfaces.BotApiObject;
+import org.telegram.telegrambots.meta.api.objects.chatmember.ChatMember;
 
 /**
  * @author Ruben Bermudez

telegrambots-meta/src/main/java/org/telegram/telegrambots/meta/api/objects/chatmember/ChatMember.java

@@ -0,0 +1,17 @@
+package org.telegram.telegrambots.meta.api.objects.chatmember;
+
+import com.fasterxml.jackson.databind.annotation.JsonDeserialize;
+import org.telegram.telegrambots.meta.api.interfaces.BotApiObject;
+import org.telegram.telegrambots.meta.api.objects.chatmember.serialization.ChatMemberDeserializer;
+
+/**
+ * @author Ruben Bermudez
+ * @version 5.3
+ *
+ * This object contains information about one member of a chat. Currently, the following 6
+ * types of chat members are supported:
+ */
+@JsonDeserialize(using = ChatMemberDeserializer.class)
+public interface ChatMember extends BotApiObject {
+    String getStatus();
+}

telegrambots-meta/src/main/java/org/telegram/telegrambots/meta/api/objects/chatmember/ChatMemberAdministrator.java

@@ -0,0 +1,125 @@
+package org.telegram.telegrambots.meta.api.objects.chatmember;
+
+import com.fasterxml.jackson.annotation.JsonProperty;
+import com.fasterxml.jackson.databind.annotation.JsonDeserialize;
+import lombok.AllArgsConstructor;
+import lombok.Builder;
+import lombok.EqualsAndHashCode;
+import lombok.Getter;
+import lombok.NoArgsConstructor;
+import lombok.Setter;
+import lombok.ToString;
+import org.telegram.telegrambots.meta.api.objects.User;
+
+/**
+ * @author Ruben Bermudez
+ * @version 5.3
+ *
+ * Represents a chat member that has some additional privileges.
+ */
+@JsonDeserialize
+@EqualsAndHashCode(callSuper = false)
+@Getter
+@Setter
+@ToString
+@NoArgsConstructor
+@AllArgsConstructor
+@Builder
+public class ChatMemberAdministrator implements ChatMember {
+    private static final String STATUS_FIELD = "status";
+    private static final String USER_FIELD = "user";
+    private static final String CANBEEDITED_FIELD = "can_be_edited";
+    private static final String CUSTOMTITLE_FIELD = "custom_title";
+    private static final String ISANONYMOUS_FIELD = "is_anonymous";
+    private static final String CANMANAGECHAT_FIELD = "can_manage_chat";
+    private static final String CANPOSTMESSAGES_FIELD = "can_post_messages";
+    private static final String CANEDITMESSAGES_FIELD = "can_edit_messages";
+    private static final String CANDELETEMESSAGES_FIELD = "can_delete_messages";
+    private static final String CANMANAGEVOICECHATS_FIELD = "can_manage_voice_chats";
+    private static final String CANRESTRICTMEMBERS_FIELD = "can_restrict_members";
+    private static final String CANPROMOTEMEMBERS_FIELD = "can_promote_members";
+    private static final String CANCHANGEINFO_FIELD = "can_change_info";
+    private static final String CANINVITEUSERS_FIELD = "can_invite_users";
+    private static final String CANPINMESSAGES_FIELD = "can_pin_messages";
+
+    /**
+     * The member's status in the chat, always “administrator”
+     */
+    @JsonProperty(STATUS_FIELD)
+    private final String status = "administrator";
+    /**
+     * Information about the user
+     */
+    @JsonProperty(USER_FIELD)
+    private User user;
+    /**
+     * True, if the bot is allowed to edit administrator privileges of that user
+     */
+    @JsonProperty(CANBEEDITED_FIELD)
+    private Boolean canBeEdited;
+    /**
+     * Custom title for this user
+     */
+    @JsonProperty(CUSTOMTITLE_FIELD)
+    private String customTitle;
+    /**
+     * True, if the user's presence in the chat is hidden
+     */
+    @JsonProperty(ISANONYMOUS_FIELD)
+    private Boolean isAnonymous;
+    /**
+     * True, if the administrator can access the chat event log, chat statistics,
+     * message statistics in channels, see channel members,
+     * see anonymous administrators in supergroups and ignore slow mode.
+     * Implied by any other administrator privilege
+     */
+    @JsonProperty(CANMANAGECHAT_FIELD)
+    private Boolean canManageChat;
+    /**
+     * True, if the administrator can post in the channel; channels only
+     */
+    @JsonProperty(CANPOSTMESSAGES_FIELD)
+    private Boolean canPostMessages;
+    /**
+     * True, if the administrator can edit messages of other users and can pin messages; channels only
+     */
+    @JsonProperty(CANEDITMESSAGES_FIELD)
+    private Boolean canEditMessages;
+    /**
+     * True, if the administrator can delete messages of other users
+     */
+    @JsonProperty(CANDELETEMESSAGES_FIELD)
+    private Boolean canDeleteMessages;
+    /**
+     * True, if the administrator can manage voice chats
+     */
+    @JsonProperty(CANMANAGEVOICECHATS_FIELD)
+    private Boolean canManageVoiceChats;
+    /**
+     * True, if the administrator can restrict, ban or unban chat members
+     */
+    @JsonProperty(CANRESTRICTMEMBERS_FIELD)
+    private Boolean canRestrictMembers;
+    /**
+     * True, if the administrator can add new administrators with a subset of their own privileges or
+     * demote administrators that he has promoted, directly or indirectly
+     * (promoted by administrators that were appointed by the user)
+     */
+    @JsonProperty(CANPROMOTEMEMBERS_FIELD)
+    private Boolean canPromoteMembers;
+    /**
+     * True, if the user is allowed to change the chat title, photo and other settings
+     */
+    @JsonProperty(CANCHANGEINFO_FIELD)
+    private Boolean canChangeInfo;
+    /**
+     * True, if the user is allowed to invite new users to the chat
+     */
+    @JsonProperty(CANINVITEUSERS_FIELD)
+    private Boolean canInviteUsers;
+    /**
+     * True, if the user is allowed to pin messages; groups and supergroups only
+     */
+    @JsonProperty(CANPINMESSAGES_FIELD)
+    private Boolean canPinMessages;
+}

telegrambots-meta/src/main/java/org/telegram/telegrambots/meta/api/objects/chatmember/ChatMemberBanned.java

@@ -0,0 +1,48 @@
+package org.telegram.telegrambots.meta.api.objects.chatmember;
+
+import com.fasterxml.jackson.annotation.JsonProperty;
+import com.fasterxml.jackson.databind.annotation.JsonDeserialize;
+import lombok.AllArgsConstructor;
+import lombok.Builder;
+import lombok.EqualsAndHashCode;
+import lombok.Getter;
+import lombok.NoArgsConstructor;
+import lombok.Setter;
+import lombok.ToString;
+import org.telegram.telegrambots.meta.api.objects.User;
+
+/**
+ * @author Ruben Bermudez
+ * @version 5.3
+ *
+ * Represents a chat member that was banned in the chat and can't return to the chat or view chat messages.
+ */
+@JsonDeserialize
+@EqualsAndHashCode(callSuper = false)
+@Getter
+@Setter
+@ToString
+@NoArgsConstructor
+@AllArgsConstructor
+@Builder
+public class ChatMemberBanned implements ChatMember {
+    private static final String STATUS_FIELD = "status";
+    private static final String USER_FIELD = "user";
+    private static final String UNTILDATE_FIELD = "until_date";
+
+    /**
+     * The member's status in the chat, always “kicked”
+     */
+    @JsonProperty(STATUS_FIELD)
+    private final String status = "kicked";
+    /**
+     * Information about the user
+     */
+    @JsonProperty(USER_FIELD)
+    private User user;
+    /**
+     * Date when restrictions will be lifted for this user; unix time
+     */
+    @JsonProperty(UNTILDATE_FIELD)
+    private Integer untilDate;
+}

telegrambots-meta/src/main/java/org/telegram/telegrambots/meta/api/objects/chatmember/ChatMemberLeft.java

@@ -0,0 +1,42 @@
+package org.telegram.telegrambots.meta.api.objects.chatmember;
+
+import com.fasterxml.jackson.annotation.JsonProperty;
+import com.fasterxml.jackson.databind.annotation.JsonDeserialize;
+import lombok.AllArgsConstructor;
+import lombok.Builder;
+import lombok.EqualsAndHashCode;
+import lombok.Getter;
+import lombok.NoArgsConstructor;
+import lombok.Setter;
+import lombok.ToString;
+import org.telegram.telegrambots.meta.api.objects.User;
+
+/**
+ * @author Ruben Bermudez
+ * @version 5.3
+ *
+ * Represents a chat member that isn't currently a member of the chat, but may join it themselves.
+ */
+@JsonDeserialize
+@EqualsAndHashCode(callSuper = false)
+@Getter
+@Setter
+@ToString
+@NoArgsConstructor
+@AllArgsConstructor
+@Builder
+public class ChatMemberLeft implements ChatMember {
+    private static final String STATUS_FIELD = "status";
+    private static final String USER_FIELD = "user";
+
+    /**
+     * The member's status in the chat, always “left”
+     */
+    @JsonProperty(STATUS_FIELD)
+    private final String status = "left";
+    /**
+     * Information about the user
+     */
+    @JsonProperty(USER_FIELD)
+    private User user;
+}

telegrambots-meta/src/main/java/org/telegram/telegrambots/meta/api/objects/chatmember/ChatMemberMember.java

@@ -0,0 +1,42 @@
+package org.telegram.telegrambots.meta.api.objects.chatmember;
+
+import com.fasterxml.jackson.annotation.JsonProperty;
+import com.fasterxml.jackson.databind.annotation.JsonDeserialize;
+import lombok.AllArgsConstructor;
+import lombok.Builder;
+import lombok.EqualsAndHashCode;
+import lombok.Getter;
+import lombok.NoArgsConstructor;
+import lombok.Setter;
+import lombok.ToString;
+import org.telegram.telegrambots.meta.api.objects.User;
+
+/**
+ * @author Ruben Bermudez
+ * @version 5.3
+ *
+ * Represents a chat member that has no additional privileges or restrictions.
+ */
+@JsonDeserialize
+@EqualsAndHashCode(callSuper = false)
+@Getter
+@Setter
+@ToString
+@NoArgsConstructor
+@AllArgsConstructor
+@Builder
+public class ChatMemberMember implements ChatMember {
+    private static final String STATUS_FIELD = "status";
+    private static final String USER_FIELD = "user";
+
+    /**
+     * The member's status in the chat, always “member”
+     */
+    @JsonProperty(STATUS_FIELD)
+    private final String status = "member";
+    /**
+     * Information about the user
+     */
+    @JsonProperty(USER_FIELD)
+    private User user;
+}

telegrambots-meta/src/main/java/org/telegram/telegrambots/meta/api/objects/chatmember/ChatMemberOwner.java

@@ -0,0 +1,54 @@
+package org.telegram.telegrambots.meta.api.objects.chatmember;
+
+import com.fasterxml.jackson.annotation.JsonProperty;
+import com.fasterxml.jackson.databind.annotation.JsonDeserialize;
+import lombok.AllArgsConstructor;
+import lombok.Builder;
+import lombok.EqualsAndHashCode;
+import lombok.Getter;
+import lombok.NoArgsConstructor;
+import lombok.Setter;
+import lombok.ToString;
+import org.telegram.telegrambots.meta.api.objects.User;
+
+/**
+ * @author Ruben Bermudez
+ * @version 5.3
+ *
+ * Represents a chat member that owns the chat and has all administrator privileges.
+ */
+@JsonDeserialize
+@EqualsAndHashCode(callSuper = false)
+@Getter
+@Setter
+@ToString
+@NoArgsConstructor
+@AllArgsConstructor
+@Builder
+public class ChatMemberOwner implements ChatMember {
+    private static final String STATUS_FIELD = "status";
+    private static final String USER_FIELD = "user";
+    private static final String CUSTOMTITLE_FIELD = "custom_title";
+    private static final String ISANONYMOUS_FIELD = "is_anonymous";
+
+    /**
+     * The member's status in the chat, always “creator”
+     */
+    @JsonProperty(STATUS_FIELD)
+    private final String status = "creator";
+    /**
+     * Information about the user
+     */
+    @JsonProperty(USER_FIELD)
+    private User user;
+    /**
+     * Custom title for this user
+     */
+    @JsonProperty(CUSTOMTITLE_FIELD)
+    private String customTitle;
+    /**
+     * True, if the user's presence in the chat is hidden
+     */
+    @JsonProperty(ISANONYMOUS_FIELD)
+    private Boolean isAnonymous;
+}

telegrambots-meta/src/main/java/org/telegram/telegrambots/meta/api/objects/chatmember/ChatMemberRestricted.java

@@ -0,0 +1,102 @@
+package org.telegram.telegrambots.meta.api.objects.chatmember;
+
+import com.fasterxml.jackson.annotation.JsonProperty;
+import com.fasterxml.jackson.databind.annotation.JsonDeserialize;
+import lombok.AllArgsConstructor;
+import lombok.Builder;
+import lombok.EqualsAndHashCode;
+import lombok.Getter;
+import lombok.NoArgsConstructor;
+import lombok.Setter;
+import lombok.ToString;
+import org.telegram.telegrambots.meta.api.objects.User;
+
+/**
+ * @author Ruben Bermudez
+ * @version 5.3
+ *
+ * Represents a chat member that is under certain restrictions in the chat. Supergroups only.
+ */
+@JsonDeserialize
+@EqualsAndHashCode(callSuper = false)
+@Getter
+@Setter
+@ToString
+@NoArgsConstructor
+@AllArgsConstructor
+@Builder
+public class ChatMemberRestricted implements ChatMember {
+    private static final String STATUS_FIELD = "status";
+    private static final String USER_FIELD = "user";
+    private static final String ISMEMBER_FIELD = "is_member";
+    private static final String CANCHANGEINFO_FIELD = "can_change_info";
+    private static final String CANINVITEUSERS_FIELD = "can_invite_users";
+    private static final String CANPINMESSAGES_FIELD = "can_pin_messages";
+    private static final String CANSENDMESSAGES_FIELD = "can_send_messages";
+    private static final String CANSENDMEDIAMESSAGES_FIELD = "can_send_media_messages";
+    private static final String CANSENDPOLLS_FIELD = "can_send_polls";
+    private static final String CANSENDOTHERMESSAGES_FIELD = "can_send_other_messages";
+    private static final String CANADDWEBPAGEPREVIEWS_FIELD = "can_add_web_page_previews";
+    private static final String UNTILDATE_FIELD = "until_date";
+
+    /**
+     * The member's status in the chat, always “restricted”
+     */
+    @JsonProperty(STATUS_FIELD)
+    private final String status = "restricted";
+    /**
+     * Information about the user
+     */
+    @JsonProperty(USER_FIELD)
+    private User user;
+    /**
+     * True, if the user is a member of the chat at the moment of the request
+     */
+    @JsonProperty(ISMEMBER_FIELD)
+    private Boolean isMember;
+    /**
+     * True, if the user is allowed to change the chat title, photo and other settings
+     */
+    @JsonProperty(CANCHANGEINFO_FIELD)
+    private Boolean canChangeInfo;
+    /**
+     * True, if the user is allowed to invite new users to the chat
+     */
+    @JsonProperty(CANINVITEUSERS_FIELD)
+    private Boolean canInviteUsers;
+    /**
+     * True, if the user is allowed to pin messages; groups and supergroups only
+     */
+    @JsonProperty(CANPINMESSAGES_FIELD)
+    private Boolean canPinMessages;
+    /**
+     * True, if the user is allowed to send text messages, contacts, locations and venues
+     */
+    @JsonProperty(CANSENDMESSAGES_FIELD)
+    private Boolean canSendMessages;
+    /**
+     * True, if the user is allowed to send audios, documents, photos, videos, video notes and voice notes
+     */
+    @JsonProperty(CANSENDMEDIAMESSAGES_FIELD)
+    private Boolean canSendMediaMessages;
+    /**
+     * True, if the user is allowed to send polls
+     */
+    @JsonProperty(CANSENDPOLLS_FIELD)
+    private Boolean canSendPolls;
+    /**
+     * True, if the user is allowed to send animations, games, stickers and use inline bots
+     */
+    @JsonProperty(CANSENDOTHERMESSAGES_FIELD)
+    private Boolean canSendOtherMessages;
+    /**
+     * True, if the user is allowed to add web page previews to their messages
+     */
+    @JsonProperty(CANADDWEBPAGEPREVIEWS_FIELD)
+    private Boolean canAddWebpagePreviews;
+    /**
+     * Date when restrictions will be lifted for this user; unix time
+     */
+    @JsonProperty(UNTILDATE_FIELD)
+    private Integer untilDate;
+}

telegrambots-meta/src/main/java/org/telegram/telegrambots/meta/api/objects/chatmember/serialization/ChatMemberDeserializer.java

@@ -0,0 +1,64 @@
+package org.telegram.telegrambots.meta.api.objects.chatmember.serialization;
+
+import com.fasterxml.jackson.core.JsonParser;
+import com.fasterxml.jackson.core.type.TypeReference;
+import com.fasterxml.jackson.databind.DeserializationContext;
+import com.fasterxml.jackson.databind.JsonNode;
+import com.fasterxml.jackson.databind.ObjectMapper;
+import com.fasterxml.jackson.databind.deser.std.StdDeserializer;
+import org.telegram.telegrambots.meta.api.objects.chatmember.ChatMember;
+import org.telegram.telegrambots.meta.api.objects.chatmember.ChatMemberAdministrator;
+import org.telegram.telegrambots.meta.api.objects.chatmember.ChatMemberBanned;
+import org.telegram.telegrambots.meta.api.objects.chatmember.ChatMemberLeft;
+import org.telegram.telegrambots.meta.api.objects.chatmember.ChatMemberMember;
+import org.telegram.telegrambots.meta.api.objects.chatmember.ChatMemberOwner;
+import org.telegram.telegrambots.meta.api.objects.chatmember.ChatMemberRestricted;
+
+import java.io.IOException;
+
+/**
+ * @author Ruben Bermudez
+ * @version 5.3
+ */
+public class ChatMemberDeserializer extends StdDeserializer<ChatMember> {
+    private final ObjectMapper objectMapper;
+
+    public ChatMemberDeserializer() {
+        this(null);
+    }
+
+    private ChatMemberDeserializer(Class<?> vc) {
+        super(vc);
+        this.objectMapper = new ObjectMapper();
+    }
+
+    @Override
+    public ChatMember deserialize(JsonParser jsonParser, DeserializationContext deserializationContext)
+            throws IOException {
+        JsonNode node = jsonParser.getCodec().readTree(jsonParser);
+
+        String type = node.has("status") ? node.get("status").asText() : "";
+        switch (type) {
+            case "administrator":
+                return objectMapper.readValue(node.toString(),
+                        new TypeReference<ChatMemberAdministrator>(){});
+            case "kicked":
+                return objectMapper.readValue(node.toString(),
+                        new TypeReference<ChatMemberBanned>(){});
+            case "left":
+                return objectMapper.readValue(node.toString(),
+                        new TypeReference<ChatMemberLeft>(){});
+            case "member":
+                return objectMapper.readValue(node.toString(),
+                        new TypeReference<ChatMemberMember>(){});
+            case "creator":
+                return objectMapper.readValue(node.toString(),
+                        new TypeReference<ChatMemberOwner>(){});
+            case "restricted":
+                return objectMapper.readValue(node.toString(),
+                        new TypeReference<ChatMemberRestricted>(){});
+            default:
+                return null;
+        }
+    }
+}

telegrambots-meta/src/main/java/org/telegram/telegrambots/meta/api/objects/commands/scope/BotCommandScope.java

@@ -0,0 +1,50 @@
+package org.telegram.telegrambots.meta.api.objects.commands.scope;
+
+import com.fasterxml.jackson.databind.annotation.JsonDeserialize;
+import org.telegram.telegrambots.meta.api.interfaces.BotApiObject;
+import org.telegram.telegrambots.meta.api.interfaces.Validable;
+import org.telegram.telegrambots.meta.api.objects.commands.scope.serialization.BotCommandScopeDeserializer;
+
+/**
+ * @author Ruben Bermudez
+ * @version 5.3
+ *
+ * This object represents the scope to which bot commands are applied. Currently, the following 7 scopes are supported:
+ *
+ * BotCommandScopeDefault
+ * BotCommandScopeAllPrivateChats
+ * BotCommandScopeAllGroupChats
+ * BotCommandScopeAllChatAdministrators
+ * BotCommandScopeChat
+ * BotCommandScopeChatAdministrators
+ * BotCommandScopeChatMember
+ *
+ * The following algorithm is used to determine the list of commands for a particular user viewing the bot menu. The first list of commands which is set is returned:
+ *
+ * Commands in the chat with the bot
+ *
+ * botCommandScopeChat + language_code
+ * botCommandScopeChat
+ * botCommandScopeAllPrivateChats + language_code
+ * botCommandScopeAllPrivateChats
+ * botCommandScopeDefault + language_code
+ * botCommandScopeDefault
+ * Commands in group and supergroup chats
+ *
+ * botCommandScopeChatMember + language_code
+ * botCommandScopeChatMember
+ * botCommandScopeChatAdministrators + language_code (admins only)
+ * botCommandScopeChatAdministrators (admins only)
+ * botCommandScopeChat + language_code
+ * botCommandScopeChat
+ * botCommandScopeAllChatAdministrators + language_code (admins only)
+ * botCommandScopeAllChatAdministrators (admins only)
+ * botCommandScopeAllGroupChats + language_code
+ * botCommandScopeAllGroupChats
+ * botCommandScopeDefault + language_code
+ * botCommandScopeDefault
+ */
+@JsonDeserialize(using = BotCommandScopeDeserializer.class)
+public interface BotCommandScope extends BotApiObject, Validable {
+    String getType();
+}

telegrambots-meta/src/main/java/org/telegram/telegrambots/meta/api/objects/commands/scope/BotCommandScopeAllChatAdministrators.java

@@ -0,0 +1,39 @@
+package org.telegram.telegrambots.meta.api.objects.commands.scope;
+
+import com.fasterxml.jackson.annotation.JsonProperty;
+import com.fasterxml.jackson.databind.annotation.JsonDeserialize;
+import lombok.Builder;
+import lombok.EqualsAndHashCode;
+import lombok.Getter;
+import lombok.NoArgsConstructor;
+import lombok.Setter;
+import lombok.ToString;
+import org.telegram.telegrambots.meta.exceptions.TelegramApiValidationException;
+
+/**
+ * @author Ruben Bermudez
+ * @version 5.3
+ *
+ * Represents the scope of bot commands, covering all group and supergroup chat administrators.
+ */
+@JsonDeserialize
+@EqualsAndHashCode(callSuper = false)
+@Getter
+@Setter
+@ToString
+@NoArgsConstructor
+@Builder
+public class BotCommandScopeAllChatAdministrators implements BotCommandScope {
+    private static final String TYPE_FIELD = "type";
+
+    /**
+     * Scope type, must be chat
+     */
+    @JsonProperty(TYPE_FIELD)
+    private final String type = "all_chat_administrators";
+
+    @Override
+    public void validate() throws TelegramApiValidationException {
+
+    }
+}

telegrambots-meta/src/main/java/org/telegram/telegrambots/meta/api/objects/commands/scope/BotCommandScopeAllGroupChats.java

@@ -0,0 +1,39 @@
+package org.telegram.telegrambots.meta.api.objects.commands.scope;
+
+import com.fasterxml.jackson.annotation.JsonProperty;
+import com.fasterxml.jackson.databind.annotation.JsonDeserialize;
+import lombok.Builder;
+import lombok.EqualsAndHashCode;
+import lombok.Getter;
+import lombok.NoArgsConstructor;
+import lombok.Setter;
+import lombok.ToString;
+import org.telegram.telegrambots.meta.exceptions.TelegramApiValidationException;
+
+/**
+ * @author Ruben Bermudez
+ * @version 5.3
+ *
+ * Represents the scope of bot commands, covering all group and supergroup chats.
+ */
+@JsonDeserialize
+@EqualsAndHashCode(callSuper = false)
+@Getter
+@Setter
+@ToString
+@NoArgsConstructor
+@Builder
+public class BotCommandScopeAllGroupChats implements BotCommandScope {
+    private static final String TYPE_FIELD = "type";
+
+    /**
+     * Scope type, must be chat
+     */
+    @JsonProperty(TYPE_FIELD)
+    private final String type = "all_group_chats";
+
+    @Override
+    public void validate() throws TelegramApiValidationException {
+
+    }
+}

telegrambots-meta/src/main/java/org/telegram/telegrambots/meta/api/objects/commands/scope/BotCommandScopeAllPrivateChats.java

@@ -0,0 +1,39 @@
+package org.telegram.telegrambots.meta.api.objects.commands.scope;
+
+import com.fasterxml.jackson.annotation.JsonProperty;
+import com.fasterxml.jackson.databind.annotation.JsonDeserialize;
+import lombok.Builder;
+import lombok.EqualsAndHashCode;
+import lombok.Getter;
+import lombok.NoArgsConstructor;
+import lombok.Setter;
+import lombok.ToString;
+import org.telegram.telegrambots.meta.exceptions.TelegramApiValidationException;
+
+/**
+ * @author Ruben Bermudez
+ * @version 5.3
+ *
+ * Represents the scope of bot commands, covering all private chats.
+ */
+@JsonDeserialize
+@EqualsAndHashCode(callSuper = false)
+@Getter
+@Setter
+@ToString
+@NoArgsConstructor
+@Builder
+public class BotCommandScopeAllPrivateChats implements BotCommandScope {
+    private static final String TYPE_FIELD = "type";
+
+    /**
+     * Scope type, must be chat
+     */
+    @JsonProperty(TYPE_FIELD)
+    private final String type = "all_private_chats";
+
+    @Override
+    public void validate() throws TelegramApiValidationException {
+
+    }
+}

telegrambots-meta/src/main/java/org/telegram/telegrambots/meta/api/objects/commands/scope/BotCommandScopeChat.java

@@ -0,0 +1,51 @@
+package org.telegram.telegrambots.meta.api.objects.commands.scope;
+
+import com.fasterxml.jackson.annotation.JsonProperty;
+import com.fasterxml.jackson.databind.annotation.JsonDeserialize;
+import lombok.AllArgsConstructor;
+import lombok.Builder;
+import lombok.EqualsAndHashCode;
+import lombok.Getter;
+import lombok.NoArgsConstructor;
+import lombok.NonNull;
+import lombok.Setter;
+import lombok.ToString;
+import org.telegram.telegrambots.meta.exceptions.TelegramApiValidationException;
+
+/**
+ * @author Ruben Bermudez
+ * @version 5.3
+ *
+ * Represents the scope of bot commands, covering a specific chat.
+ */
+@JsonDeserialize
+@EqualsAndHashCode(callSuper = false)
+@Getter
+@Setter
+@ToString
+@NoArgsConstructor
+@AllArgsConstructor
+@Builder
+public class BotCommandScopeChat implements BotCommandScope {
+    private static final String TYPE_FIELD = "type";
+    private static final String CHATID_FIELD = "chat_id";
+
+    /**
+     * Scope type, must be chat
+     */
+    @JsonProperty(TYPE_FIELD)
+    private final String type = "chat";
+    /**
+     * Unique identifier for the target chat or username of the target supergroup (in the format @supergroupusername)
+     */
+    @JsonProperty(CHATID_FIELD)
+    @NonNull
+    private String chatId;
+
+    @Override
+    public void validate() throws TelegramApiValidationException {
+        if (chatId == null || chatId.isEmpty()) {
+            throw new TelegramApiValidationException("ChatId parameter can't be empty", this);
+        }
+    }
+}

telegrambots-meta/src/main/java/org/telegram/telegrambots/meta/api/objects/commands/scope/BotCommandScopeChatAdministrators.java

@@ -0,0 +1,51 @@
+package org.telegram.telegrambots.meta.api.objects.commands.scope;
+
+import com.fasterxml.jackson.annotation.JsonProperty;
+import com.fasterxml.jackson.databind.annotation.JsonDeserialize;
+import lombok.AllArgsConstructor;
+import lombok.Builder;
+import lombok.EqualsAndHashCode;
+import lombok.Getter;
+import lombok.NoArgsConstructor;
+import lombok.NonNull;
+import lombok.Setter;
+import lombok.ToString;
+import org.telegram.telegrambots.meta.exceptions.TelegramApiValidationException;
+
+/**
+ * @author Ruben Bermudez
+ * @version 5.3
+ *
+ * Represents the scope of bot commands, covering all administrators of a specific group or supergroup chat.
+ */
+@JsonDeserialize
+@EqualsAndHashCode(callSuper = false)
+@Getter
+@Setter
+@ToString
+@NoArgsConstructor
+@AllArgsConstructor
+@Builder
+public class BotCommandScopeChatAdministrators implements BotCommandScope {
+    private static final String TYPE_FIELD = "type";
+    private static final String CHATID_FIELD = "chat_id";
+
+    /**
+     * Scope type, must be chat
+     */
+    @JsonProperty(TYPE_FIELD)
+    private final String type = "chat_administrators";
+    /**
+     * Unique identifier for the target chat or username of the target supergroup (in the format @supergroupusername)
+     */
+    @JsonProperty(CHATID_FIELD)
+    @NonNull
+    private String chatId;
+
+    @Override
+    public void validate() throws TelegramApiValidationException {
+        if (chatId == null || chatId.isEmpty()) {
+            throw new TelegramApiValidationException("ChatId parameter can't be empty", this);
+        }
+    }
+}

telegrambots-meta/src/main/java/org/telegram/telegrambots/meta/api/objects/commands/scope/BotCommandScopeChatMember.java

@@ -0,0 +1,61 @@
+package org.telegram.telegrambots.meta.api.objects.commands.scope;
+
+import com.fasterxml.jackson.annotation.JsonProperty;
+import com.fasterxml.jackson.databind.annotation.JsonDeserialize;
+import lombok.AllArgsConstructor;
+import lombok.Builder;
+import lombok.EqualsAndHashCode;
+import lombok.Getter;
+import lombok.NoArgsConstructor;
+import lombok.NonNull;
+import lombok.Setter;
+import lombok.ToString;
+import org.telegram.telegrambots.meta.exceptions.TelegramApiValidationException;
+
+/**
+ * @author Ruben Bermudez
+ * @version 5.3
+ *
+ * Represents the scope of bot commands, covering a specific member of a group or supergroup chat.
+ */
+@JsonDeserialize
+@EqualsAndHashCode(callSuper = false)
+@Getter
+@Setter
+@ToString
+@NoArgsConstructor
+@AllArgsConstructor
+@Builder
+public class BotCommandScopeChatMember implements BotCommandScope {
+    private static final String TYPE_FIELD = "type";
+    private static final String CHATID_FIELD = "chat_id";
+    private static final String USERID_FIELD = "user_id";
+
+    /**
+     * Scope type, must be chat
+     */
+    @JsonProperty(TYPE_FIELD)
+    private final String type = "chat_member";
+    /**
+     * Unique identifier for the target chat or username of the target supergroup (in the format @supergroupusername)
+     */
+    @JsonProperty(CHATID_FIELD)
+    @NonNull
+    private String chatId;
+    /**
+     * Unique identifier of the target user
+     */
+    @JsonProperty(USERID_FIELD)
+    @NonNull
+    private Long userId;
+
+    @Override
+    public void validate() throws TelegramApiValidationException {
+        if (chatId == null || chatId.isEmpty()) {
+            throw new TelegramApiValidationException("ChatId parameter can't be empty", this);
+        }
+        if (userId == null || userId == 0L) {
+            throw new TelegramApiValidationException("UserId parameter can't be empty", this);
+        }
+    }
+}

telegrambots-meta/src/main/java/org/telegram/telegrambots/meta/api/objects/commands/scope/BotCommandScopeDefault.java

@@ -0,0 +1,40 @@
+package org.telegram.telegrambots.meta.api.objects.commands.scope;
+
+import com.fasterxml.jackson.annotation.JsonProperty;
+import com.fasterxml.jackson.databind.annotation.JsonDeserialize;
+import lombok.Builder;
+import lombok.EqualsAndHashCode;
+import lombok.Getter;
+import lombok.NoArgsConstructor;
+import lombok.Setter;
+import lombok.ToString;
+import org.telegram.telegrambots.meta.exceptions.TelegramApiValidationException;
+
+/**
+ * @author Ruben Bermudez
+ * @version 5.3
+ *
+ * Represents the default scope of bot commands.
+ * Default commands are used if no commands with a narrower scope are specified for the user.
+ */
+@JsonDeserialize
+@EqualsAndHashCode(callSuper = false)
+@Getter
+@Setter
+@ToString
+@NoArgsConstructor
+@Builder
+public class BotCommandScopeDefault implements BotCommandScope {
+    private static final String TYPE_FIELD = "type";
+
+    /**
+     * Scope type, must be chat
+     */
+    @JsonProperty(TYPE_FIELD)
+    private final String type = "default";
+
+    @Override
+    public void validate() throws TelegramApiValidationException {
+
+    }
+}

telegrambots-meta/src/main/java/org/telegram/telegrambots/meta/api/objects/commands/scope/serialization/BotCommandScopeDeserializer.java

@@ -0,0 +1,68 @@
+package org.telegram.telegrambots.meta.api.objects.commands.scope.serialization;
+
+import com.fasterxml.jackson.core.JsonParser;
+import com.fasterxml.jackson.core.type.TypeReference;
+import com.fasterxml.jackson.databind.DeserializationContext;
+import com.fasterxml.jackson.databind.JsonNode;
+import com.fasterxml.jackson.databind.ObjectMapper;
+import com.fasterxml.jackson.databind.deser.std.StdDeserializer;
+import org.telegram.telegrambots.meta.api.objects.commands.scope.BotCommandScope;
+import org.telegram.telegrambots.meta.api.objects.commands.scope.BotCommandScopeAllChatAdministrators;
+import org.telegram.telegrambots.meta.api.objects.commands.scope.BotCommandScopeAllGroupChats;
+import org.telegram.telegrambots.meta.api.objects.commands.scope.BotCommandScopeAllPrivateChats;
+import org.telegram.telegrambots.meta.api.objects.commands.scope.BotCommandScopeChat;
+import org.telegram.telegrambots.meta.api.objects.commands.scope.BotCommandScopeChatAdministrators;
+import org.telegram.telegrambots.meta.api.objects.commands.scope.BotCommandScopeChatMember;
+import org.telegram.telegrambots.meta.api.objects.commands.scope.BotCommandScopeDefault;
+
+import java.io.IOException;
+
+/**
+ * @author Ruben Bermudez
+ * @version 5.3
+ */
+public class BotCommandScopeDeserializer extends StdDeserializer<BotCommandScope> {
+    private final ObjectMapper objectMapper;
+
+    public BotCommandScopeDeserializer() {
+        this(null);
+    }
+
+    private BotCommandScopeDeserializer(Class<?> vc) {
+        super(vc);
+        this.objectMapper = new ObjectMapper();
+    }
+
+    @Override
+    public BotCommandScope deserialize(JsonParser jsonParser, DeserializationContext deserializationContext)
+            throws IOException {
+        JsonNode node = jsonParser.getCodec().readTree(jsonParser);
+
+        String type = node.has("Type") ? node.get("type").asText() : "";
+        switch (type) {
+            case "default":
+                return objectMapper.readValue(node.toString(),
+                        new TypeReference<BotCommandScopeDefault>(){});
+            case "all_private_chats":
+                return objectMapper.readValue(node.toString(),
+                        new TypeReference<BotCommandScopeAllPrivateChats>(){});
+            case "all_group_chats":
+                return objectMapper.readValue(node.toString(),
+                        new TypeReference<BotCommandScopeAllGroupChats>(){});
+            case "all_chat_administrators":
+                return objectMapper.readValue(node.toString(),
+                        new TypeReference<BotCommandScopeAllChatAdministrators>(){});
+            case "chat":
+                return objectMapper.readValue(node.toString(),
+                        new TypeReference<BotCommandScopeChat>(){});
+            case "chat_administrators":
+                return objectMapper.readValue(node.toString(),
+                        new TypeReference<BotCommandScopeChatAdministrators>(){});
+            case "chat_member":
+                return objectMapper.readValue(node.toString(),
+                        new TypeReference<BotCommandScopeChatMember>(){});
+            default:
+                return null;
+        }
+    }
+}

telegrambots-meta/src/main/java/org/telegram/telegrambots/meta/api/objects/replykeyboard/ForceReplyKeyboard.java

@@ -33,6 +33,7 @@ import org.telegram.telegrambots.meta.exceptions.TelegramApiValidationException;
 public class ForceReplyKeyboard implements ReplyKeyboard {
     private static final String FORCEREPLY_FIELD = "force_reply";
     private static final String SELECTIVE_FIELD = "selective";
+    private static final String INPUTFIELDPLACEHOLDER_FIELD = "input_field_placeholder";
 
     /**
      * Shows reply interface to the user, as if they manually selected the bot‘s message and tapped
@@ -40,7 +41,8 @@ public class ForceReplyKeyboard implements ReplyKeyboard {
      */
     @JsonProperty(FORCEREPLY_FIELD)
     @NonNull
-    private Boolean forceReply;
+    @Builder.Default
+    private Boolean forceReply = true;
     /**
      * Optional.
      *
@@ -50,11 +52,20 @@ public class ForceReplyKeyboard implements ReplyKeyboard {
      */
     @JsonProperty(SELECTIVE_FIELD)
     private Boolean selective;
+    /**
+     * Optional.
+     * The placeholder to be shown in the input field when the keyboard is active; 1-64 characters
+     */
+    @JsonProperty(INPUTFIELDPLACEHOLDER_FIELD)
+    private String inputFieldPlaceholder;
 
     @Override
     public void validate() throws TelegramApiValidationException {
         if (forceReply == null) {
             throw new TelegramApiValidationException("ForceReply parameter can't not be null", this);
         }
+        if (inputFieldPlaceholder != null && (inputFieldPlaceholder.length() < 1 || inputFieldPlaceholder.length() > 64)) {
+            throw new TelegramApiValidationException("InputFieldPlaceholder must be between 1 and 64 characters", this);
+        }
     }
 }

telegrambots-meta/src/main/java/org/telegram/telegrambots/meta/api/objects/replykeyboard/ReplyKeyboardMarkup.java

@@ -37,6 +37,7 @@ public class ReplyKeyboardMarkup implements ReplyKeyboard {
     private static final String RESIZEKEYBOARD_FIELD = "resize_keyboard";
     private static final String ONETIMEKEYBOARD_FIELD = "one_time_keyboard";
     private static final String SELECTIVE_FIELD = "selective";
+    private static final String INPUTFIELDPLACEHOLDER_FIELD = "input_field_placeholder";
 
     @JsonProperty(KEYBOARD_FIELD)
     @NonNull
@@ -55,12 +56,21 @@ public class ReplyKeyboardMarkup implements ReplyKeyboard {
      */
     @JsonProperty(SELECTIVE_FIELD)
     private Boolean selective;
+    /**
+     * Optional.
+     * The placeholder to be shown in the input field when the keyboard is active; 1-64 characters
+     */
+    @JsonProperty(INPUTFIELDPLACEHOLDER_FIELD)
+    private String inputFieldPlaceholder;
 
     @Override
     public void validate() throws TelegramApiValidationException {
         if (keyboard == null) {
             throw new TelegramApiValidationException("Keyboard parameter can't be null", this);
         }
+        if (inputFieldPlaceholder != null && (inputFieldPlaceholder.length() < 1 || inputFieldPlaceholder.length() > 64)) {
+            throw new TelegramApiValidationException("InputFieldPlaceholder must be between 1 and 64 characters", this);
+        }
         for (KeyboardRow keyboardButtons : keyboard) {
             keyboardButtons.validate();
         }

telegrambots-meta/src/main/java/org/telegram/telegrambots/meta/api/objects/replykeyboard/buttons/KeyboardRow.java

@@ -4,6 +4,7 @@ import org.telegram.telegrambots.meta.api.interfaces.Validable;
 import org.telegram.telegrambots.meta.exceptions.TelegramApiValidationException;
 
 import java.util.ArrayList;
+import java.util.Collection;
 import java.util.List;
 
 /**
@@ -12,6 +13,17 @@ import java.util.List;
  * Row for ReplyKeyBoardMarkup
  */
 public class KeyboardRow extends ArrayList<KeyboardButton> implements Validable {
+    public KeyboardRow(int initialCapacity) {
+        super(initialCapacity);
+    }
+
+    public KeyboardRow() {
+    }
+
+    public KeyboardRow(Collection<? extends KeyboardButton> c) {
+        super(c);
+    }
+
     public boolean add(String text) {
         return super.add(new KeyboardButton(text));
     }

telegrambots-meta/src/test/java/org/telegram/telegrambots/meta/api/methods/commands/DeleteMyCommandsTest.java

@@ -0,0 +1,41 @@
+package org.telegram.telegrambots.meta.api.methods.commands;
+
+import org.junit.jupiter.api.Test;
+import org.telegram.telegrambots.meta.api.objects.commands.scope.BotCommandScopeDefault;
+import org.telegram.telegrambots.meta.exceptions.TelegramApiValidationException;
+
+import static org.junit.jupiter.api.Assertions.assertDoesNotThrow;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertThrows;
+
+/**
+ * @author Ruben Bermudez
+ * @version 5.3
+ */
+public class DeleteMyCommandsTest {
+    @Test
+    public void testDeleteMyCommandsWithEmptyScope() {
+        DeleteMyCommands deleteMyCommands = DeleteMyCommands.builder().build();
+        assertEquals("deleteMyCommands", deleteMyCommands.getMethod());
+        assertDoesNotThrow(deleteMyCommands::validate);
+    }
+
+    @Test
+    public void testDeleteMyCommandsWithEmptyStringLanguageCode() {
+        DeleteMyCommands deleteMyCommands = DeleteMyCommands.builder().languageCode("").build();
+        assertEquals("deleteMyCommands", deleteMyCommands.getMethod());
+        Throwable thrown = assertThrows(TelegramApiValidationException.class, deleteMyCommands::validate);
+        assertEquals("LanguageCode parameter can't be empty string", thrown.getMessage());
+    }
+
+    @Test
+    public void testDeleteMyCommandsWithScope() {
+        DeleteMyCommands deleteMyCommands = DeleteMyCommands
+                .builder()
+                .scope(BotCommandScopeDefault.builder().build())
+                .build();
+        assertEquals("deleteMyCommands", deleteMyCommands.getMethod());
+        assertEquals("default", deleteMyCommands.getScope().getType());
+        assertDoesNotThrow(deleteMyCommands::validate);
+    }
+}

telegrambots-meta/src/test/java/org/telegram/telegrambots/meta/api/methods/commands/GetMyCommandsTest.java

@@ -0,0 +1,48 @@
+package org.telegram.telegrambots.meta.api.methods.commands;
+
+import org.junit.jupiter.api.Test;
+import org.telegram.telegrambots.meta.api.objects.commands.scope.BotCommandScopeDefault;
+import org.telegram.telegrambots.meta.exceptions.TelegramApiValidationException;
+
+import static org.junit.jupiter.api.Assertions.assertDoesNotThrow;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertThrows;
+
+/**
+ * @author Ruben Bermudez
+ * @version 5.3
+ */
+public class GetMyCommandsTest {
+    @Test
+    public void testGetMyCommandsWithAllSet() {
+        GetMyCommands getMyCommands = GetMyCommands
+                .builder()
+                .languageCode("en")
+                .scope(BotCommandScopeDefault.builder().build())
+                .build();
+        assertEquals("getMyCommands", getMyCommands.getMethod());
+        assertDoesNotThrow(getMyCommands::validate);
+    }
+
+    @Test
+    public void testGetMyCommandsWithEmptyScope() {
+        GetMyCommands getMyCommands = GetMyCommands
+                .builder()
+                .languageCode("en")
+                .build();
+        assertEquals("getMyCommands", getMyCommands.getMethod());
+        assertDoesNotThrow(getMyCommands::validate);
+    }
+
+    @Test
+    public void testSetMyCommandsWithEmptyStringLanguageCode() {
+        GetMyCommands getMyCommands = GetMyCommands
+                .builder()
+                .languageCode("")
+                .scope(BotCommandScopeDefault.builder().build())
+                .build();
+        assertEquals("getMyCommands", getMyCommands.getMethod());
+        Throwable thrown = assertThrows(TelegramApiValidationException.class, getMyCommands::validate);
+        assertEquals("LanguageCode parameter can't be empty string", thrown.getMessage());
+    }
+}

telegrambots-meta/src/test/java/org/telegram/telegrambots/meta/api/methods/commands/SetMyCommandsTest.java

@@ -0,0 +1,84 @@
+package org.telegram.telegrambots.meta.api.methods.commands;
+
+import org.junit.jupiter.api.Test;
+import org.telegram.telegrambots.meta.api.objects.commands.BotCommand;
+import org.telegram.telegrambots.meta.api.objects.commands.scope.BotCommandScopeDefault;
+import org.telegram.telegrambots.meta.exceptions.TelegramApiValidationException;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import static org.junit.jupiter.api.Assertions.assertDoesNotThrow;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertThrows;
+
+/**
+ * @author Ruben Bermudez
+ * @version 5.3
+ */
+public class SetMyCommandsTest {
+    @Test
+    public void testSetMyCommandsWithAllSet() {
+        SetMyCommands setMyCommands = SetMyCommands
+                .builder()
+                .command(BotCommand.builder().command("test").description("Test description").build())
+                .languageCode("en")
+                .scope(BotCommandScopeDefault.builder().build())
+                .build();
+        assertEquals("setMyCommands", setMyCommands.getMethod());
+        assertDoesNotThrow(setMyCommands::validate);
+    }
+
+    @Test
+    public void testSetMyCommandsWithEmptyScope() {
+        SetMyCommands setMyCommands = SetMyCommands
+                .builder()
+                .command(BotCommand.builder().command("test").description("Test description").build())
+                .languageCode("en")
+                .build();
+        assertEquals("setMyCommands", setMyCommands.getMethod());
+        assertDoesNotThrow(setMyCommands::validate);
+    }
+
+    @Test
+    public void testSetMyCommandsWithEmptyStringLanguageCode() {
+        SetMyCommands setMyCommands = SetMyCommands
+                .builder()
+                .command(BotCommand.builder().command("test").description("Test description").build())
+                .languageCode("")
+                .scope(BotCommandScopeDefault.builder().build())
+                .build();
+        assertEquals("setMyCommands", setMyCommands.getMethod());
+        Throwable thrown = assertThrows(TelegramApiValidationException.class, setMyCommands::validate);
+        assertEquals("LanguageCode parameter can't be empty string", thrown.getMessage());
+    }
+
+    @Test
+    public void testSetMyCommandsWithEmptyCommands() {
+        SetMyCommands setMyCommands = SetMyCommands
+                .builder()
+                .languageCode("en")
+                .scope(BotCommandScopeDefault.builder().build())
+                .build();
+        assertEquals("setMyCommands", setMyCommands.getMethod());
+        Throwable thrown = assertThrows(TelegramApiValidationException.class, setMyCommands::validate);
+        assertEquals("Commands parameter can't be empty", thrown.getMessage());
+    }
+
+    @Test
+    public void testSetMyCommandsWithMoreThan100Commands() {
+        SetMyCommands setMyCommands = SetMyCommands
+                .builder()
+                .languageCode("en")
+                .scope(BotCommandScopeDefault.builder().build())
+                .build();
+        List<BotCommand> commands = new ArrayList<>();
+        for(int i = 0; i < 102; i++) {
+            commands.add(BotCommand.builder().command("test").description("Test Description").build());
+        }
+        setMyCommands.setCommands(commands);
+        assertEquals("setMyCommands", setMyCommands.getMethod());
+        Throwable thrown = assertThrows(TelegramApiValidationException.class, setMyCommands::validate);
+        assertEquals("No more than 100 commands are allowed", thrown.getMessage());
+    }
+}

telegrambots-meta/src/test/java/org/telegram/telegrambots/meta/api/methods/groupadministration/BanChatMemberTest.java

@@ -0,0 +1,55 @@
+package org.telegram.telegrambots.meta.api.methods.groupadministration;
+
+import org.junit.jupiter.api.Test;
+import org.telegram.telegrambots.meta.exceptions.TelegramApiValidationException;
+
+import static org.junit.jupiter.api.Assertions.assertDoesNotThrow;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertThrows;
+
+/**
+ * @author Ruben Bermudez
+ * @version 5.3
+ */
+public class BanChatMemberTest {
+    @Test
+    public void testBanChatMemberWithAllSet() {
+        BanChatMember banChatMember = BanChatMember
+                .builder()
+                .chatId("12345")
+                .userId(12345L)
+                .untilDate(1000)
+                .revokeMessages(true)
+                .build();
+        assertEquals("banChatMember", banChatMember.getMethod());
+        assertDoesNotThrow(banChatMember::validate);
+    }
+
+    @Test
+    public void testBanChatMemberWithEmptyChatId() {
+        BanChatMember banChatMember = BanChatMember
+                .builder()
+                .chatId("")
+                .userId(12345L)
+                .untilDate(1000)
+                .revokeMessages(true)
+                .build();
+        assertEquals("banChatMember", banChatMember.getMethod());
+        Throwable thrown = assertThrows(TelegramApiValidationException.class, banChatMember::validate);
+        assertEquals("ChatId can't be empty", thrown.getMessage());
+    }
+
+    @Test
+    public void testBanChatMemberWithEmptyUserId() {
+        BanChatMember banChatMember = BanChatMember
+                .builder()
+                .chatId("12345")
+                .userId(0L)
+                .untilDate(1000)
+                .revokeMessages(true)
+                .build();
+        assertEquals("banChatMember", banChatMember.getMethod());
+        Throwable thrown = assertThrows(TelegramApiValidationException.class, banChatMember::validate);
+        assertEquals("UserId can't be null or 0", thrown.getMessage());
+    }
+}

telegrambots-meta/src/test/java/org/telegram/telegrambots/meta/api/methods/groupadministration/GetChatMemberCountTest.java

@@ -0,0 +1,35 @@
+package org.telegram.telegrambots.meta.api.methods.groupadministration;
+
+import org.junit.jupiter.api.Test;
+import org.telegram.telegrambots.meta.exceptions.TelegramApiValidationException;
+
+import static org.junit.jupiter.api.Assertions.assertDoesNotThrow;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertThrows;
+
+/**
+ * @author Ruben Bermudez
+ * @version 5.3
+ */
+public class GetChatMemberCountTest {
+    @Test
+    public void testGetChatMemberCountWithAllSet() {
+        GetChatMemberCount getChatMemberCount = GetChatMemberCount
+                .builder()
+                .chatId("12345")
+                .build();
+        assertEquals("getChatMemberCount", getChatMemberCount.getMethod());
+        assertDoesNotThrow(getChatMemberCount::validate);
+    }
+
+    @Test
+    public void testGetChatMemberCountWithEmptyChatId() {
+        GetChatMemberCount getChatMemberCount = GetChatMemberCount
+                .builder()
+                .chatId("")
+                .build();
+        assertEquals("getChatMemberCount", getChatMemberCount.getMethod());
+        Throwable thrown = assertThrows(TelegramApiValidationException.class, getChatMemberCount::validate);
+        assertEquals("ChatId can't be empty", thrown.getMessage());
+    }
+}

telegrambots-meta/src/test/java/org/telegram/telegrambots/meta/api/methods/send/SendInvoiceTest.java

@@ -67,14 +67,6 @@ public class SendInvoiceTest {
         assertEquals("ProviderToken parameter can't be empty", thrown.getMessage());
     }
 
-    @Test
-    public void startParameterCantBeEmpty() {
-        SendInvoice sendInvoice = createSendInvoiceObject();
-        sendInvoice.setStartParameter("");
-        Throwable thrown = assertThrows(TelegramApiValidationException.class, sendInvoice::validate);
-        assertEquals("StartParameter parameter can't be empty", thrown.getMessage());
-    }
-
     @Test
     public void currencyCantBeEmpty() {
         SendInvoice sendInvoice = createSendInvoiceObject();

telegrambots-meta/src/test/java/org/telegram/telegrambots/meta/api/objects/chatmember/ChatMemberTest.java

@@ -0,0 +1,203 @@
+package org.telegram.telegrambots.meta.api.objects.chatmember;
+
+import org.junit.jupiter.api.Test;
+import org.telegram.telegrambots.meta.api.methods.groupadministration.GetChatMember;
+import org.telegram.telegrambots.meta.api.objects.User;
+import org.telegram.telegrambots.meta.exceptions.TelegramApiRequestException;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+/**
+ * @author Ruben Bermudez
+ * @version 5.3
+ */
+public class ChatMemberTest {
+    @Test
+    public void testDeserializationChatMember() throws TelegramApiRequestException {
+        String text = "{\n" +
+                "    \"ok\": true,\n" +
+                "    \"result\": {\n" +
+                "        \"status\": \"member\",\n" +
+                "        \"user\": {\n" +
+                "            \"id\": 123456,\n" +
+                "            \"first_name\": \"FirstName\",\n" +
+                "            \"last_name\": \"LastName\",\n" +
+                "            \"username\": \"UserName\",\n" +
+                "            \"language_code\": \"en\"\n" +
+                "        }\n" +
+                "    }\n" +
+                "}";
+        ChatMember chatMember = new GetChatMember().deserializeResponse(text);
+        assertEquals("member", chatMember.getStatus());
+        ChatMemberMember chatMemberMember = (ChatMemberMember) chatMember;
+        assertEquals(getUser(), chatMemberMember.getUser());
+    }
+
+    @Test
+    public void testDeserializationChatMemberLeft() throws TelegramApiRequestException {
+        String text = "{\n" +
+                "    \"ok\": true,\n" +
+                "    \"result\": {\n" +
+                "        \"status\": \"left\",\n" +
+                "        \"user\": {\n" +
+                "            \"id\": 123456,\n" +
+                "            \"first_name\": \"FirstName\",\n" +
+                "            \"last_name\": \"LastName\",\n" +
+                "            \"username\": \"UserName\",\n" +
+                "            \"language_code\": \"en\"\n" +
+                "        }\n" +
+                "    }\n" +
+                "}";
+        ChatMember chatMember = new GetChatMember().deserializeResponse(text);
+        assertEquals("left", chatMember.getStatus());
+        ChatMemberLeft chatMemberLeft = (ChatMemberLeft) chatMember;
+        assertEquals(getUser(), chatMemberLeft.getUser());
+    }
+
+    @Test
+    public void testDeserializationChatMemberBanned() throws TelegramApiRequestException {
+        String text = "{\n" +
+                "    \"ok\": true,\n" +
+                "    \"result\": {\n" +
+                "        \"status\": \"kicked\",\n" +
+                "        \"user\": {\n" +
+                "            \"id\": 123456,\n" +
+                "            \"first_name\": \"FirstName\",\n" +
+                "            \"last_name\": \"LastName\",\n" +
+                "            \"username\": \"UserName\",\n" +
+                "            \"language_code\": \"en\"\n" +
+                "        },\n" +
+                "        \"until_date\": 10\n" +
+                "    }\n" +
+                "}";
+        ChatMember chatMember = new GetChatMember().deserializeResponse(text);
+        assertEquals("kicked", chatMember.getStatus());
+        ChatMemberBanned chatMemberBanned = (ChatMemberBanned) chatMember;
+        assertEquals(getUser(), chatMemberBanned.getUser());
+        assertEquals(10, chatMemberBanned.getUntilDate());
+    }
+
+    @Test
+    public void testDeserializationChatMemberOwner() throws TelegramApiRequestException {
+        String text = "{\n" +
+                "    \"ok\": true,\n" +
+                "    \"result\": {\n" +
+                "        \"status\": \"creator\",\n" +
+                "        \"user\": {\n" +
+                "            \"id\": 123456,\n" +
+                "            \"first_name\": \"FirstName\",\n" +
+                "            \"last_name\": \"LastName\",\n" +
+                "            \"username\": \"UserName\",\n" +
+                "            \"language_code\": \"en\"\n" +
+                "        },\n" +
+                "        \"custom_title\": \"CustomTitle\",\n" +
+                "        \"is_anonymous\": true\n" +
+                "    }\n" +
+                "}";
+        ChatMember chatMember = new GetChatMember().deserializeResponse(text);
+        assertEquals("creator", chatMember.getStatus());
+        ChatMemberOwner chatMemberOwner = (ChatMemberOwner) chatMember;
+        assertEquals(getUser(), chatMemberOwner.getUser());
+        assertEquals("CustomTitle", chatMemberOwner.getCustomTitle());
+        assertEquals(true, chatMemberOwner.getIsAnonymous());
+    }
+
+    @Test
+    public void testDeserializationChatMemberAdministrator() throws TelegramApiRequestException {
+        String text = "{\n" +
+                "    \"ok\": true,\n" +
+                "    \"result\": {\n" +
+                "        \"status\": \"administrator\",\n" +
+                "        \"user\": {\n" +
+                "            \"id\": 123456,\n" +
+                "            \"first_name\": \"FirstName\",\n" +
+                "            \"last_name\": \"LastName\",\n" +
+                "            \"username\": \"UserName\",\n" +
+                "            \"language_code\": \"en\"\n" +
+                "        },\n" +
+                "        \"can_be_edited\": true,\n" +
+                "        \"custom_title\": \"CustomTitle\",\n" +
+                "        \"is_anonymous\": true,\n" +
+                "        \"can_manage_chat\": true,\n" +
+                "        \"can_post_messages\": true,\n" +
+                "        \"can_edit_messages\": true,\n" +
+                "        \"can_delete_messages\": true,\n" +
+                "        \"can_manage_voice_chats\": true,\n" +
+                "        \"can_restrict_members\": true,\n" +
+                "        \"can_promote_members\": true,\n" +
+                "        \"can_change_info\": true,\n" +
+                "        \"can_invite_users\": true,\n" +
+                "        \"can_pin_messages\": true\n" +
+                "    }\n" +
+                "}";
+        ChatMember chatMember = new GetChatMember().deserializeResponse(text);
+        assertEquals("administrator", chatMember.getStatus());
+        ChatMemberAdministrator chatMemberAdministrator = (ChatMemberAdministrator) chatMember;
+        assertEquals(getUser(), chatMemberAdministrator.getUser());
+        assertEquals("CustomTitle", chatMemberAdministrator.getCustomTitle());
+        assertEquals(true, chatMemberAdministrator.getIsAnonymous());
+        assertEquals(true, chatMemberAdministrator.getCanBeEdited());
+        assertEquals(true, chatMemberAdministrator.getCanManageChat());
+        assertEquals(true, chatMemberAdministrator.getCanPostMessages());
+        assertEquals(true, chatMemberAdministrator.getCanEditMessages());
+        assertEquals(true, chatMemberAdministrator.getCanDeleteMessages());
+        assertEquals(true, chatMemberAdministrator.getCanManageVoiceChats());
+        assertEquals(true, chatMemberAdministrator.getCanRestrictMembers());
+        assertEquals(true, chatMemberAdministrator.getCanPromoteMembers());
+        assertEquals(true, chatMemberAdministrator.getCanChangeInfo());
+        assertEquals(true, chatMemberAdministrator.getCanInviteUsers());
+        assertEquals(true, chatMemberAdministrator.getCanPinMessages());
+    }
+
+    @Test
+    public void testDeserializationChatMemberRestricted() throws TelegramApiRequestException {
+        String text = "{\n" +
+                "    \"ok\": true,\n" +
+                "    \"result\": {\n" +
+                "        \"status\": \"restricted\",\n" +
+                "        \"user\": {\n" +
+                "            \"id\": 123456,\n" +
+                "            \"first_name\": \"FirstName\",\n" +
+                "            \"last_name\": \"LastName\",\n" +
+                "            \"username\": \"UserName\",\n" +
+                "            \"language_code\": \"en\"\n" +
+                "        },\n" +
+                "        \"is_anonymous\": true,\n" +
+                "        \"can_change_info\": true,\n" +
+                "        \"can_invite_users\": true,\n" +
+                "        \"can_pin_messages\": true,\n" +
+                "        \"is_member\": true,\n" +
+                "        \"can_send_messages\": true,\n" +
+                "        \"can_send_media_messages\": true,\n" +
+                "        \"can_send_polls\": true,\n" +
+                "        \"can_send_other_messages\": true,\n" +
+                "        \"can_add_web_page_previews\": true,\n" +
+                "        \"until_date\": 100\n" +
+                "    }\n" +
+                "}";
+        ChatMember chatMember = new GetChatMember().deserializeResponse(text);
+        assertEquals("restricted", chatMember.getStatus());
+        ChatMemberRestricted chatMemberRestricted = (ChatMemberRestricted) chatMember;
+        assertEquals(getUser(), chatMemberRestricted.getUser());
+        assertEquals(true, chatMemberRestricted.getCanChangeInfo());
+        assertEquals(true, chatMemberRestricted.getCanInviteUsers());
+        assertEquals(true, chatMemberRestricted.getCanPinMessages());
+        assertEquals(true, chatMemberRestricted.getCanSendMessages());
+        assertEquals(true, chatMemberRestricted.getCanSendMediaMessages());
+        assertEquals(true, chatMemberRestricted.getCanSendPolls());
+        assertEquals(true, chatMemberRestricted.getCanSendOtherMessages());
+        assertEquals(true, chatMemberRestricted.getCanAddWebpagePreviews());
+        assertEquals(100, chatMemberRestricted.getUntilDate());
+    }
+
+
+    private User getUser() {
+        User user = new User();
+        user.setId(123456L);
+        user.setFirstName("FirstName");
+        user.setLastName("LastName");
+        user.setUserName("UserName");
+        user.setLanguageCode("en");
+        return user;
+    }
+}

telegrambots-meta/src/test/java/org/telegram/telegrambots/meta/api/objects/commands/scope/BotCommandScopeTest.java

@@ -0,0 +1,120 @@
+package org.telegram.telegrambots.meta.api.objects.commands.scope;
+
+import org.junit.jupiter.api.Test;
+import org.telegram.telegrambots.meta.exceptions.TelegramApiValidationException;
+
+import static org.junit.jupiter.api.Assertions.assertDoesNotThrow;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertThrows;
+
+/**
+ * @author Ruben Bermudez
+ * @version 1.0
+ */
+public class BotCommandScopeTest {
+    @Test
+    public void testBotCommandScopeDefault() {
+        BotCommandScopeDefault botCommandScope = BotCommandScopeDefault.builder().build();
+        assertEquals("default", botCommandScope.getType());
+        assertDoesNotThrow(botCommandScope::validate);
+    }
+
+    @Test
+    public void testBotCommandScopeAllChatAdministrators() {
+        BotCommandScopeAllChatAdministrators botCommandScope = BotCommandScopeAllChatAdministrators.builder().build();
+        assertEquals("all_chat_administrators", botCommandScope.getType());
+        assertDoesNotThrow(botCommandScope::validate);
+    }
+
+    @Test
+    public void testBotCommandScopeAllGroupChats() {
+        BotCommandScopeAllGroupChats botCommandScope = BotCommandScopeAllGroupChats.builder().build();
+        assertEquals("all_group_chats", botCommandScope.getType());
+        assertDoesNotThrow(botCommandScope::validate);
+    }
+
+    @Test
+    public void testBotCommandScopeAllPrivateChats() {
+        BotCommandScopeAllPrivateChats botCommandScope = BotCommandScopeAllPrivateChats.builder().build();
+        assertEquals("all_private_chats", botCommandScope.getType());
+        assertDoesNotThrow(botCommandScope::validate);
+    }
+
+    @Test
+    public void testBotCommandScopeChatWithValidChatIId() {
+        BotCommandScopeChat botCommandScope = BotCommandScopeChat
+                .builder()
+                .chatId("12345")
+                .build();
+        assertEquals("chat", botCommandScope.getType());
+        assertDoesNotThrow(botCommandScope::validate);
+    }
+
+    @Test
+    public void testBotCommandScopeChatWithEmptyChatId() {
+        BotCommandScopeChat botCommandScope = BotCommandScopeChat
+                .builder()
+                .chatId("")
+                .build();
+        assertEquals("chat", botCommandScope.getType());
+        Throwable thrown = assertThrows(TelegramApiValidationException.class, botCommandScope::validate);
+        assertEquals("ChatId parameter can't be empty", thrown.getMessage());
+    }
+
+
+    @Test
+    public void testBotCommandScopeChatAdministratorsWithValidChatIId() {
+        BotCommandScopeChatAdministrators botCommandScope = BotCommandScopeChatAdministrators
+                .builder()
+                .chatId("12345")
+                .build();
+        assertEquals("chat_administrators", botCommandScope.getType());
+        assertDoesNotThrow(botCommandScope::validate);
+    }
+
+    @Test
+    public void testBotCommandScopeChatAdministratorsWithEmptyChatId() {
+        BotCommandScopeChatAdministrators botCommandScope = BotCommandScopeChatAdministrators
+                .builder()
+                .chatId("")
+                .build();
+        assertEquals("chat_administrators", botCommandScope.getType());
+        Throwable thrown = assertThrows(TelegramApiValidationException.class, botCommandScope::validate);
+        assertEquals("ChatId parameter can't be empty", thrown.getMessage());
+    }
+
+    @Test
+    public void testBotCommandScopeChatMemberWithValidSetUp() {
+        BotCommandScopeChatMember botCommandScope = BotCommandScopeChatMember
+                .builder()
+                .chatId("12345")
+                .userId(12345L)
+                .build();
+        assertEquals("chat_member", botCommandScope.getType());
+        assertDoesNotThrow(botCommandScope::validate);
+    }
+
+    @Test
+    public void testBotCommandScopeChatMemberWithEmptyChatId() {
+        BotCommandScopeChatMember botCommandScope = BotCommandScopeChatMember
+                .builder()
+                .chatId("")
+                .userId(12345L)
+                .build();
+        assertEquals("chat_member", botCommandScope.getType());
+        Throwable thrown = assertThrows(TelegramApiValidationException.class, botCommandScope::validate);
+        assertEquals("ChatId parameter can't be empty", thrown.getMessage());
+    }
+
+    @Test
+    public void testBotCommandScopeChatMemberWith0UserId() {
+        BotCommandScopeChatMember botCommandScope = BotCommandScopeChatMember
+                .builder()
+                .chatId("12345")
+                .userId(0L)
+                .build();
+        assertEquals("chat_member", botCommandScope.getType());
+        Throwable thrown = assertThrows(TelegramApiValidationException.class, botCommandScope::validate);
+        assertEquals("UserId parameter can't be empty", thrown.getMessage());
+    }
+}

telegrambots-meta/src/test/java/org/telegram/telegrambots/meta/api/objects/replykeyboard/ForceReplyKeyboardTest.java

@@ -0,0 +1,60 @@
+package org.telegram.telegrambots.meta.api.objects.replykeyboard;
+
+import org.junit.jupiter.api.Test;
+import org.telegram.telegrambots.meta.exceptions.TelegramApiValidationException;
+
+import static org.junit.jupiter.api.Assertions.assertDoesNotThrow;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertThrows;
+
+/**
+ * @author Ruben Bermudez
+ * @version 1.0
+ */
+public class ForceReplyKeyboardTest {
+    @Test
+    public void testForceReplyDefaultFields() {
+        ForceReplyKeyboard forceReplyKeyboard = ForceReplyKeyboard
+                .builder()
+                .build();
+        assertDoesNotThrow(forceReplyKeyboard::validate);
+        forceReplyKeyboard = new ForceReplyKeyboard();
+        assertDoesNotThrow(forceReplyKeyboard::validate);
+    }
+
+    @Test
+    public void testForceReplyAllFieldSet() {
+        ForceReplyKeyboard forceReplyKeyboard = ForceReplyKeyboard
+                .builder()
+                .forceReply(true)
+                .selective(true)
+                .inputFieldPlaceholder("Placeholder")
+                .build();
+        assertDoesNotThrow(forceReplyKeyboard::validate);
+    }
+
+    @Test
+    public void testForceReplyEmptyInputPlaceholder() {
+        ForceReplyKeyboard forceReplyKeyboard = ForceReplyKeyboard
+                .builder()
+                .forceReply(true)
+                .selective(true)
+                .inputFieldPlaceholder("")
+                .build();
+        Throwable thrown = assertThrows(TelegramApiValidationException.class, forceReplyKeyboard::validate);
+        assertEquals("InputFieldPlaceholder must be between 1 and 64 characters", thrown.getMessage());
+    }
+
+
+    @Test
+    public void testForceReplyOver64InputPlaceholder() {
+        ForceReplyKeyboard forceReplyKeyboard = ForceReplyKeyboard
+                .builder()
+                .forceReply(true)
+                .selective(true)
+                .inputFieldPlaceholder("D%YNdVJe/6xUGR_)W]rVLx_,g/9:ZX7+XiiM-*nPm{(g5gEtv![te6H[;tWAT&Z4K")
+                .build();
+        Throwable thrown = assertThrows(TelegramApiValidationException.class, forceReplyKeyboard::validate);
+        assertEquals("InputFieldPlaceholder must be between 1 and 64 characters", thrown.getMessage());
+    }
+}

telegrambots-meta/src/test/java/org/telegram/telegrambots/meta/api/objects/replykeyboard/ReplyKeyboardMarkupTest.java

@@ -0,0 +1,76 @@
+package org.telegram.telegrambots.meta.api.objects.replykeyboard;
+
+import org.junit.jupiter.api.Test;
+import org.telegram.telegrambots.meta.api.objects.replykeyboard.buttons.KeyboardButton;
+import org.telegram.telegrambots.meta.api.objects.replykeyboard.buttons.KeyboardRow;
+import org.telegram.telegrambots.meta.exceptions.TelegramApiValidationException;
+
+import java.util.Collections;
+
+import static org.junit.jupiter.api.Assertions.assertDoesNotThrow;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertThrows;
+
+/**
+ * @author Ruben Bermudez
+ * @version 1.0
+ */
+public class ReplyKeyboardMarkupTest {
+    @Test
+    public void testReplyKeyboardMarkupAllDefaults() {
+        ReplyKeyboardMarkup replyKeyboardMarkup = ReplyKeyboardMarkup
+                .builder()
+                .build();
+        assertDoesNotThrow(replyKeyboardMarkup::validate);
+    }
+
+    @Test
+    public void testReplyKeyboardMarkupAllFieldSet() {
+        ReplyKeyboardMarkup replyKeyboardMarkup = ReplyKeyboardMarkup
+                .builder()
+                .keyboard(Collections.singletonList(new KeyboardRow(Collections.singletonList(KeyboardButton
+                        .builder()
+                        .text("ButtonText")
+                        .build()))))
+                .resizeKeyboard(true)
+                .oneTimeKeyboard(true)
+                .selective(true)
+                .inputFieldPlaceholder("Placeholder")
+                .build();
+        assertDoesNotThrow(replyKeyboardMarkup::validate);
+    }
+
+    @Test
+    public void testReplyKeyboardMarkupEmptyInputPlaceholder() {
+        ReplyKeyboardMarkup replyKeyboardMarkup = ReplyKeyboardMarkup
+                .builder()
+                .keyboard(Collections.singletonList(new KeyboardRow(Collections.singletonList(KeyboardButton
+                        .builder()
+                        .text("ButtonText")
+                        .build()))))
+                .resizeKeyboard(true)
+                .oneTimeKeyboard(true)
+                .selective(true)
+                .inputFieldPlaceholder("")
+                .build();
+        Throwable thrown = assertThrows(TelegramApiValidationException.class, replyKeyboardMarkup::validate);
+        assertEquals("InputFieldPlaceholder must be between 1 and 64 characters", thrown.getMessage());
+    }
+
+    @Test
+    public void testReplyKeyboardMarkupOver64InputPlaceholder() {
+        ReplyKeyboardMarkup replyKeyboardMarkup = ReplyKeyboardMarkup
+                .builder()
+                .keyboard(Collections.singletonList(new KeyboardRow(Collections.singletonList(KeyboardButton
+                        .builder()
+                        .text("ButtonText")
+                        .build()))))
+                .resizeKeyboard(true)
+                .oneTimeKeyboard(true)
+                .selective(true)
+                .inputFieldPlaceholder("D%YNdVJe/6xUGR_)W]rVLx_,g/9:ZX7+XiiM-*nPm{(g5gEtv![te6H[;tWAT&Z4K")
+                .build();
+        Throwable thrown = assertThrows(TelegramApiValidationException.class, replyKeyboardMarkup::validate);
+        assertEquals("InputFieldPlaceholder must be between 1 and 64 characters", thrown.getMessage());
+    }
+}

telegrambots-meta/src/test/java/org/telegram/telegrambots/meta/test/TestDeserialization.java

@@ -15,7 +15,6 @@ import org.telegram.telegrambots.meta.api.objects.ApiResponse;
 import org.telegram.telegrambots.meta.api.objects.Audio;
 import org.telegram.telegrambots.meta.api.objects.CallbackQuery;
 import org.telegram.telegrambots.meta.api.objects.Chat;
-import org.telegram.telegrambots.meta.api.objects.ChatMember;
 import org.telegram.telegrambots.meta.api.objects.Document;
 import org.telegram.telegrambots.meta.api.objects.EntityType;
 import org.telegram.telegrambots.meta.api.objects.Message;
@@ -23,6 +22,8 @@ import org.telegram.telegrambots.meta.api.objects.MessageEntity;
 import org.telegram.telegrambots.meta.api.objects.Update;
 import org.telegram.telegrambots.meta.api.objects.User;
 import org.telegram.telegrambots.meta.api.objects.Voice;
+import org.telegram.telegrambots.meta.api.objects.chatmember.ChatMember;
+import org.telegram.telegrambots.meta.api.objects.chatmember.ChatMemberRestricted;
 import org.telegram.telegrambots.meta.api.objects.commands.BotCommand;
 import org.telegram.telegrambots.meta.api.objects.inlinequery.ChosenInlineQuery;
 import org.telegram.telegrambots.meta.api.objects.inlinequery.InlineQuery;
@@ -322,25 +323,27 @@ class TestDeserialization {
                 "    }\n" +
                 "}";
 
-        ChatMember response = new GetChatMember().deserializeResponse(updateText);
+        ChatMember chatMember = new GetChatMember().deserializeResponse(updateText);
 
-        assertNotNull(response);
+        assertNotNull(chatMember);
-        assertNotNull(response.getUser());
+        assertTrue(chatMember instanceof ChatMemberRestricted);
-        assertEquals(1111111, response.getUser().getId());
+        ChatMemberRestricted chatMemberRestricted = (ChatMemberRestricted) chatMember;
-        assertTrue(response.getUser().getIsBot());
+        assertNotNull(chatMemberRestricted.getUser());
-        assertEquals("MyTesting", response.getUser().getFirstName());
+        assertEquals(1111111, chatMemberRestricted.getUser().getId());
-        assertEquals("MyTestingUsername", response.getUser().getUserName());
+        assertTrue(chatMemberRestricted.getUser().getIsBot());
-        assertEquals("restricted", response.getStatus());
+        assertEquals("MyTesting", chatMemberRestricted.getUser().getFirstName());
-        assertEquals(0, response.getUntilDate());
+        assertEquals("MyTestingUsername", chatMemberRestricted.getUser().getUserName());
-        assertFalse(response.getCanSendMessages());
+        assertEquals("restricted", chatMemberRestricted.getStatus());
-        assertFalse(response.getCanSendMediaMessages());
+        assertEquals(0, chatMemberRestricted.getUntilDate());
-        assertFalse(response.getCanSendPolls());
+        assertFalse(chatMemberRestricted.getCanSendMessages());
-        assertFalse(response.getCanSendOtherMessages());
+        assertFalse(chatMemberRestricted.getCanSendMediaMessages());
-        assertFalse(response.getCanAddWebPagePreviews());
+        assertFalse(chatMemberRestricted.getCanSendPolls());
-        assertFalse(response.getCanChangeInfo());
+        assertFalse(chatMemberRestricted.getCanSendOtherMessages());
-        assertFalse(response.getCanInviteUsers());
+        assertFalse(chatMemberRestricted.getCanAddWebpagePreviews());
-        assertFalse(response.getCanPinMessages());
+        assertFalse(chatMemberRestricted.getCanChangeInfo());
-        assertTrue(response.getIsMember());
+        assertFalse(chatMemberRestricted.getCanInviteUsers());
+        assertFalse(chatMemberRestricted.getCanPinMessages());
+        assertTrue(chatMemberRestricted.getIsMember());
     }
 
     @Test

telegrambots-spring-boot-starter/README.md

@@ -18,14 +18,14 @@ Usage
     <dependency>
         <groupId>org.telegram</groupId>
         <artifactId>telegrambots-spring-boot-starter</artifactId>
-        <version>5.2.0</version>
+        <version>5.3.0</version>
     </dependency>
 ```
 
 **Gradle**
 
 ```gradle
-    implementation 'org.telegram:telegrambots-spring-boot-starter:5.2.0'
+    implementation 'org.telegram:telegrambots-spring-boot-starter:5.3.0'
 ```
 
 Motivation

telegrambots-spring-boot-starter/pom.xml

@@ -7,7 +7,7 @@
     <parent>
         <groupId>org.telegram</groupId>
         <artifactId>Bots</artifactId>
-        <version>5.2.0</version>
+        <version>5.3.0</version>
     </parent>
 
     <artifactId>telegrambots-spring-boot-starter</artifactId>
@@ -70,7 +70,7 @@
         <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
         <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
 
-        <telegrambots.version>5.2.0</telegrambots.version>
+        <telegrambots.version>5.3.0</telegrambots.version>
         <spring-boot.version>2.4.5</spring-boot.version>
 
         <maven-gpg-plugin.version>1.6</maven-gpg-plugin.version>

telegrambots/pom.xml

@@ -7,7 +7,7 @@
     <parent>
         <groupId>org.telegram</groupId>
         <artifactId>Bots</artifactId>
-        <version>5.2.0</version>
+        <version>5.3.0</version>
     </parent>
 
     <artifactId>telegrambots</artifactId>
@@ -92,7 +92,7 @@
         <dependency>
             <groupId>org.telegram</groupId>
             <artifactId>telegrambots-meta</artifactId>
-            <version>5.2.0</version>
+            <version>5.3.0</version>
         </dependency>
         <dependency>
             <groupId>org.projectlombok</groupId>

telegrambots/src/main/java/org/telegram/telegrambots/bots/DefaultAbsSender.java

@@ -610,7 +610,7 @@ public abstract class DefaultAbsSender extends AbsSender {
         assertParamNotNull(setStickerSetThumb, "setStickerSetThumb");
         setStickerSetThumb.validate();
         try {
-            String url = getBaseUrl() + AddStickerToSet.PATH;
+            String url = getBaseUrl() + SetStickerSetThumb.PATH;
             HttpPost httppost = configuredHttpPost(url);
             MultipartEntityBuilder builder = MultipartEntityBuilder.create();
             builder.setLaxMode();
@@ -623,7 +623,7 @@ public abstract class DefaultAbsSender extends AbsSender {
 
             return setStickerSetThumb.deserializeResponse(sendHttpPostRequest(httppost));
         } catch (IOException e) {
-            throw new TelegramApiException("Unable to add sticker to set", e);
+            throw new TelegramApiException("Unable to set sticker set thumb", e);
         }
     }
 

telegrambots/src/test/java/org/telegram/telegrambots/test/BotApiMethodHelperFactory.java

@@ -11,11 +11,11 @@ import org.telegram.telegrambots.meta.api.methods.GetUserProfilePhotos;
 import org.telegram.telegrambots.meta.api.methods.ParseMode;
 import org.telegram.telegrambots.meta.api.methods.games.GetGameHighScores;
 import org.telegram.telegrambots.meta.api.methods.games.SetGameScore;
+import org.telegram.telegrambots.meta.api.methods.groupadministration.BanChatMember;
 import org.telegram.telegrambots.meta.api.methods.groupadministration.GetChat;
 import org.telegram.telegrambots.meta.api.methods.groupadministration.GetChatAdministrators;
 import org.telegram.telegrambots.meta.api.methods.groupadministration.GetChatMember;
-import org.telegram.telegrambots.meta.api.methods.groupadministration.GetChatMembersCount;
+import org.telegram.telegrambots.meta.api.methods.groupadministration.GetChatMemberCount;
-import org.telegram.telegrambots.meta.api.methods.groupadministration.KickChatMember;
 import org.telegram.telegrambots.meta.api.methods.groupadministration.LeaveChat;
 import org.telegram.telegrambots.meta.api.methods.groupadministration.UnbanChatMember;
 import org.telegram.telegrambots.meta.api.methods.send.SendChatAction;
@@ -30,12 +30,12 @@ import org.telegram.telegrambots.meta.api.methods.updatingmessages.EditMessageCa
 import org.telegram.telegrambots.meta.api.methods.updatingmessages.EditMessageReplyMarkup;
 import org.telegram.telegrambots.meta.api.methods.updatingmessages.EditMessageText;
 import org.telegram.telegrambots.meta.api.objects.Chat;
-import org.telegram.telegrambots.meta.api.objects.ChatMember;
 import org.telegram.telegrambots.meta.api.objects.File;
 import org.telegram.telegrambots.meta.api.objects.Message;
 import org.telegram.telegrambots.meta.api.objects.User;
 import org.telegram.telegrambots.meta.api.objects.UserProfilePhotos;
 import org.telegram.telegrambots.meta.api.objects.WebhookInfo;
+import org.telegram.telegrambots.meta.api.objects.chatmember.ChatMember;
 import org.telegram.telegrambots.meta.api.objects.games.GameHighScore;
 import org.telegram.telegrambots.meta.api.objects.inlinequery.inputmessagecontent.InputMessageContent;
 import org.telegram.telegrambots.meta.api.objects.inlinequery.inputmessagecontent.InputTextMessageContent;
@@ -159,8 +159,8 @@ public final class BotApiMethodHelperFactory {
                 .build();
     }
 
-    public static BotApiMethod<Integer> getChatMembersCount() {
+    public static BotApiMethod<Integer> getChatMemberCount() {
-        return GetChatMembersCount
+        return GetChatMemberCount
                 .builder()
                 .chatId("12345")
                 .build();
@@ -199,8 +199,8 @@ public final class BotApiMethodHelperFactory {
         return new GetWebhookInfo();
     }
 
-    public static BotApiMethod<Boolean> getKickChatMember() {
+    public static BotApiMethod<Boolean> getBanChatMember() {
-        return KickChatMember
+        return BanChatMember
                 .builder()
                 .chatId("12345")
                 .userId(98765L)

telegrambots/src/test/java/org/telegram/telegrambots/test/TestRestApi.java

@@ -16,11 +16,11 @@ import org.telegram.telegrambots.meta.api.methods.GetMe;
 import org.telegram.telegrambots.meta.api.methods.GetUserProfilePhotos;
 import org.telegram.telegrambots.meta.api.methods.games.GetGameHighScores;
 import org.telegram.telegrambots.meta.api.methods.games.SetGameScore;
+import org.telegram.telegrambots.meta.api.methods.groupadministration.BanChatMember;
 import org.telegram.telegrambots.meta.api.methods.groupadministration.GetChat;
 import org.telegram.telegrambots.meta.api.methods.groupadministration.GetChatAdministrators;
 import org.telegram.telegrambots.meta.api.methods.groupadministration.GetChatMember;
-import org.telegram.telegrambots.meta.api.methods.groupadministration.GetChatMembersCount;
+import org.telegram.telegrambots.meta.api.methods.groupadministration.GetChatMemberCount;
-import org.telegram.telegrambots.meta.api.methods.groupadministration.KickChatMember;
 import org.telegram.telegrambots.meta.api.methods.groupadministration.LeaveChat;
 import org.telegram.telegrambots.meta.api.methods.groupadministration.UnbanChatMember;
 import org.telegram.telegrambots.meta.api.methods.send.SendChatAction;
@@ -35,13 +35,13 @@ import org.telegram.telegrambots.meta.api.methods.updatingmessages.EditMessageCa
 import org.telegram.telegrambots.meta.api.methods.updatingmessages.EditMessageReplyMarkup;
 import org.telegram.telegrambots.meta.api.methods.updatingmessages.EditMessageText;
 import org.telegram.telegrambots.meta.api.objects.Chat;
-import org.telegram.telegrambots.meta.api.objects.ChatMember;
 import org.telegram.telegrambots.meta.api.objects.File;
 import org.telegram.telegrambots.meta.api.objects.Message;
 import org.telegram.telegrambots.meta.api.objects.Update;
 import org.telegram.telegrambots.meta.api.objects.User;
 import org.telegram.telegrambots.meta.api.objects.UserProfilePhotos;
 import org.telegram.telegrambots.meta.api.objects.WebhookInfo;
+import org.telegram.telegrambots.meta.api.objects.chatmember.ChatMember;
 import org.telegram.telegrambots.meta.api.objects.games.GameHighScore;
 import org.telegram.telegrambots.test.Fakes.FakeWebhook;
 import org.telegram.telegrambots.updatesreceivers.RestApi;
@@ -219,13 +219,13 @@ public class TestRestApi extends JerseyTest {
 
     @Test
     public void TestGetChatMembersCount() {
-        webhookBot.setReturnValue(BotApiMethodHelperFactory.getChatMembersCount());
+        webhookBot.setReturnValue(BotApiMethodHelperFactory.getChatMemberCount());
 
         Entity<Update> entity = Entity.json(getUpdate());
         BotApiMethod<Integer> result =
                 target("callback/testbot")
                         .request(MediaType.APPLICATION_JSON)
-                        .post(entity, GetChatMembersCount.class);
+                        .post(entity, GetChatMemberCount.class);
 
         assertEquals("{\"chat_id\":\"12345\",\"method\":\"getChatMembersCount\"}", map(result));
     }
@@ -297,13 +297,13 @@ public class TestRestApi extends JerseyTest {
 
     @Test
     public void TestKickChatMember() {
-        webhookBot.setReturnValue(BotApiMethodHelperFactory.getKickChatMember());
+        webhookBot.setReturnValue(BotApiMethodHelperFactory.getBanChatMember());
 
         Entity<Update> entity = Entity.json(getUpdate());
         BotApiMethod<Boolean> result =
                 target("callback/testbot")
                         .request(MediaType.APPLICATION_JSON)
-                        .post(entity, KickChatMember.class);
+                        .post(entity, BanChatMember.class);
 
         assertEquals("{\"chat_id\":\"12345\",\"user_id\":98765,\"method\":\"kickchatmember\"}", map(result));
     }