Merge pull request #227 from llnulldisk/master

Update to API 5.7

3 files changed, 824 insertions, 209 deletions

diff --git a/src/Api.cpp b/src/Api.cpp
index c1c86d2..4107a4e 100644
--- a/src/Api.cpp
+++ b/src/Api.cpp
@@ -45,9 +45,10 @@ bool Api::setWebhook(const std::string& url,
                      std::int32_t maxConnection,
                      const StringArrayPtr& allowedUpdates,
                      const std::string& ipAddress,
-                     bool dropPendingUpdates) const {
+                     bool dropPendingUpdates,
+                     const std::string& secretToken) const {
     vector<HttpReqArg> args;
-    args.reserve(6);
+    args.reserve(7);
 
     args.emplace_back("url", url);
     if (certificate != nullptr) {
@@ -69,6 +70,9 @@ bool Api::setWebhook(const std::string& url,
     if (dropPendingUpdates) {
         args.emplace_back("drop_pending_updates", dropPendingUpdates);
     }
+    if (!secretToken.empty()) {
+        args.emplace_back("secret_token", secretToken);
+    }
 
     return sendRequest("setWebhook").get<bool>("", false);
 }
@@ -109,9 +113,10 @@ Message::Ptr Api::sendMessage(boost::variant<std::int64_t, const std::string&> c
                               const std::string& parseMode,
                               bool disableNotification,
                               const std::vector<MessageEntity::Ptr>& entities,
-                              bool allowSendingWithoutReply) const {
+                              bool allowSendingWithoutReply,
+                              bool protectContent) const {
     vector<HttpReqArg> args;
-    args.reserve(9);
+    args.reserve(10);
 
     args.emplace_back("chat_id", chatId);
     args.emplace_back("text", text);
@@ -127,6 +132,9 @@ Message::Ptr Api::sendMessage(boost::variant<std::int64_t, const std::string&> c
     if (disableNotification) {
         args.emplace_back("disable_notification", disableNotification);
     }
+    if (protectContent) {
+        args.emplace_back("protect_content", protectContent);
+    }
     if (replyToMessageId) {
         args.emplace_back("reply_to_message_id", replyToMessageId);
     }
@@ -140,24 +148,40 @@ Message::Ptr Api::sendMessage(boost::variant<std::int64_t, const std::string&> c
     return _tgTypeParser.parseJsonAndGetMessage(sendRequest("sendMessage", args));
 }
 
-Message::Ptr Api::forwardMessage(std::int64_t chatId, std::int64_t fromChatId, std::int32_t messageId, bool disableNotification) const {
+Message::Ptr Api::forwardMessage(boost::variant<std::int64_t, const std::string&> chatId,
+                                 boost::variant<std::int64_t, const std::string&> fromChatId,
+                                 std::int32_t messageId,
+                                 bool disableNotification,
+                                 bool protectContent) const {
     vector<HttpReqArg> args;
-    args.reserve(4);
+    args.reserve(5);
+
     args.emplace_back("chat_id", chatId);
     args.emplace_back("from_chat_id", fromChatId);
-    args.emplace_back("message_id", messageId);
     if (disableNotification) {
         args.emplace_back("disable_notification", disableNotification);
     }
+    if (protectContent) {
+        args.emplace_back("protect_content", protectContent);
+    }
+    args.emplace_back("message_id", messageId);
+
     return _tgTypeParser.parseJsonAndGetMessage(sendRequest("forwardMessage", args));
 }
 
-MessageId::Ptr Api::copyMessage(std::int64_t chatId, std::int64_t fromChatId, std::int32_t messageId,
-                                const std::string& caption, const std::string& parseMode, const std::vector<MessageEntity::Ptr>& captionEntities,
-                                bool disableNotification, std::int32_t replyToMessageId, bool allowSendingWithoutReply,
-                                GenericReply::Ptr replyMarkup) const {
+MessageId::Ptr Api::copyMessage(boost::variant<std::int64_t, const std::string&> chatId,
+                                boost::variant<std::int64_t, const std::string&> fromChatId,
+                                std::int32_t messageId,
+                                const std::string& caption,
+                                const std::string& parseMode,
+                                const std::vector<MessageEntity::Ptr>& captionEntities,
+                                bool disableNotification,
+                                std::int32_t replyToMessageId,
+                                bool allowSendingWithoutReply,
+                                GenericReply::Ptr replyMarkup,
+                                bool protectContent) const {
     vector<HttpReqArg> args;
-    args.reserve(10);
+    args.reserve(11);
 
     args.emplace_back("chat_id", chatId);
     args.emplace_back("from_chat_id", fromChatId);
@@ -174,6 +198,9 @@ MessageId::Ptr Api::copyMessage(std::int64_t chatId, std::int64_t fromChatId, st
     if (disableNotification) {
         args.emplace_back("disable_notification", disableNotification);
     }
+    if (protectContent) {
+        args.emplace_back("protect_content", protectContent);
+    }
     if (replyToMessageId) {
         args.emplace_back("reply_to_message_id", replyToMessageId);
     }
@@ -187,24 +214,25 @@ MessageId::Ptr Api::copyMessage(std::int64_t chatId, std::int64_t fromChatId, st
     return _tgTypeParser.parseJsonAndGetMessageId(sendRequest("copyMessage", args));
 }
 
-Message::Ptr Api::sendPhoto(std::int64_t chatId,
-                            boost::variant<InputFile::Ptr, std::string> photo,
+Message::Ptr Api::sendPhoto(boost::variant<std::int64_t, const std::string&> chatId,
+                            boost::variant<InputFile::Ptr, const std::string&> photo,
                             const std::string& caption,
                             std::int32_t replyToMessageId,
                             GenericReply::Ptr replyMarkup,
                             const std::string& parseMode,
                             bool disableNotification,
                             const std::vector<MessageEntity::Ptr>& captionEntities,
-                            bool allowSendingWithoutReply) const {
+                            bool allowSendingWithoutReply,
+                            bool protectContent) const {
     vector<HttpReqArg> args;
-    args.reserve(9);
+    args.reserve(10);
 
     args.emplace_back("chat_id", chatId);
-    if (photo.which() == 0 /* InputFile::Ptr */) {
+    if (photo.which() == 0) {  // InputFile::Ptr
         auto file = boost::get<InputFile::Ptr>(photo);
         args.emplace_back("photo", file->data, true, file->mimeType, file->fileName);
-    } else /* std::string */ {
-        args.emplace_back("photo", boost::get<std::string>(photo));
+    } else {  // const std::string&
+        args.emplace_back("photo", boost::get<const std::string&>(photo));
     }
     if (!caption.empty()) {
         args.emplace_back("caption", caption);
@@ -218,6 +246,9 @@ Message::Ptr Api::sendPhoto(std::int64_t chatId,
     if (disableNotification) {
         args.emplace_back("disable_notification", disableNotification);
     }
+    if (protectContent) {
+        args.emplace_back("protect_content", protectContent);
+    }
     if (replyToMessageId) {
         args.emplace_back("reply_to_message_id", replyToMessageId);
     }
@@ -231,28 +262,29 @@ Message::Ptr Api::sendPhoto(std::int64_t chatId,
     return _tgTypeParser.parseJsonAndGetMessage(sendRequest("sendPhoto", args));
 }
 
-Message::Ptr Api::sendAudio(std::int64_t chatId,
-                            boost::variant<InputFile::Ptr, std::string> audio,
+Message::Ptr Api::sendAudio(boost::variant<std::int64_t, const std::string&> chatId,
+                            boost::variant<InputFile::Ptr, const std::string&> audio,
                             const std::string& caption,
                             std::int32_t duration,
                             const std::string& performer,
                             const std::string& title,
-                            boost::variant<InputFile::Ptr, std::string> thumb,
+                            boost::variant<InputFile::Ptr, const std::string&> thumb,
                             std::int32_t replyToMessageId,
                             GenericReply::Ptr replyMarkup,
                             const std::string& parseMode,
                             bool disableNotification,
                             const std::vector<MessageEntity::Ptr>& captionEntities,
-                            bool allowSendingWithoutReply) const {
+                            bool allowSendingWithoutReply,
+                            bool protectContent) const {
     vector<HttpReqArg> args;
-    args.reserve(13);
+    args.reserve(14);
 
     args.emplace_back("chat_id", chatId);
-    if (audio.which() == 0 /* InputFile::Ptr */) {
+    if (audio.which() == 0) {   // InputFile::Ptr
         auto file = boost::get<InputFile::Ptr>(audio);
         args.emplace_back("audio", file->data, true, file->mimeType, file->fileName);
-    } else /* std::string */ {
-        args.emplace_back("audio", boost::get<std::string>(audio));
+    } else {    // const std::string&
+        args.emplace_back("audio", boost::get<const std::string&>(audio));
     }
     if (!caption.empty()) {
         args.emplace_back("caption", caption);
@@ -272,11 +304,11 @@ Message::Ptr Api::sendAudio(std::int64_t chatId,
     if (!title.empty()) {
         args.emplace_back("title", title);
     }
-    if (thumb.which() == 0 /* InputFile::Ptr */) {
+    if (thumb.which() == 0) {   // InputFile::Ptr
         auto file = boost::get<InputFile::Ptr>(thumb);
         args.emplace_back("thumb", file->data, true, file->mimeType, file->fileName);
-    } else /* std::string */ {
-        auto thumbStr = boost::get<std::string>(thumb);
+    } else {    // const std::string&
+        auto thumbStr = boost::get<const std::string&>(thumb);
         if (!thumbStr.empty()) {
             args.emplace_back("thumb", thumbStr);
         }
@@ -284,6 +316,9 @@ Message::Ptr Api::sendAudio(std::int64_t chatId,
     if (disableNotification) {
         args.emplace_back("disable_notification", disableNotification);
     }
+    if (protectContent) {
+        args.emplace_back("protect_content", protectContent);
+    }
     if (replyToMessageId) {
         args.emplace_back("reply_to_message_id", replyToMessageId);
     }
@@ -297,9 +332,9 @@ Message::Ptr Api::sendAudio(std::int64_t chatId,
     return _tgTypeParser.parseJsonAndGetMessage(sendRequest("sendAudio", args));
 }
 
-Message::Ptr Api::sendDocument(std::int64_t chatId,
-                               boost::variant<InputFile::Ptr, std::string> document,
-                               boost::variant<InputFile::Ptr, std::string> thumb,
+Message::Ptr Api::sendDocument(boost::variant<std::int64_t, const std::string&> chatId,
+                               boost::variant<InputFile::Ptr, const std::string&> document,
+                               boost::variant<InputFile::Ptr, const std::string&> thumb,
                                const std::string& caption,
                                std::int32_t replyToMessageId,
                                GenericReply::Ptr replyMarkup,
@@ -307,22 +342,23 @@ Message::Ptr Api::sendDocument(std::int64_t chatId,
                                bool disableNotification,
                                const std::vector<MessageEntity::Ptr>& captionEntities,
                                bool disableContentTypeDetection,
-                               bool allowSendingWithoutReply) const {
+                               bool allowSendingWithoutReply,
+                               bool protectContent) const {
     vector<HttpReqArg> args;
-    args.reserve(11);
+    args.reserve(12);
 
     args.emplace_back("chat_id", chatId);
-    if (document.which() == 0 /* InputFile::Ptr */) {
+    if (document.which() == 0) {    // InputFile::Ptr
         auto file = boost::get<InputFile::Ptr>(document);
         args.emplace_back("document", file->data, true, file->mimeType, file->fileName);
-    } else /* std::string */ {
-        args.emplace_back("document", boost::get<std::string>(document));
+    } else {    // const std::string&
+        args.emplace_back("document", boost::get<const std::string&>(document));
     }
-    if (thumb.which() == 0 /* InputFile::Ptr */) {
+    if (thumb.which() == 0) {   // InputFile::Ptr
         auto file = boost::get<InputFile::Ptr>(thumb);
         args.emplace_back("thumb", file->data, true, file->mimeType, file->fileName);
-    } else /* std::string */ {
-        auto thumbStr = boost::get<std::string>(thumb);
+    } else {    // const std::string&
+        auto thumbStr = boost::get<const std::string&>(thumb);
         if (!thumbStr.empty()) {
             args.emplace_back("thumb", thumbStr);
         }
@@ -342,6 +378,9 @@ Message::Ptr Api::sendDocument(std::int64_t chatId,
     if (disableNotification) {
         args.emplace_back("disable_notification", disableNotification);
     }
+    if (protectContent) {
+        args.emplace_back("protect_content", protectContent);
+    }
     if (replyToMessageId) {
         args.emplace_back("reply_to_message_id", replyToMessageId);
     }
@@ -355,29 +394,30 @@ Message::Ptr Api::sendDocument(std::int64_t chatId,
     return _tgTypeParser.parseJsonAndGetMessage(sendRequest("sendDocument", args));
 }
 
-Message::Ptr Api::sendVideo(std::int64_t chatId,
-                            boost::variant<InputFile::Ptr, std::string> video,
+Message::Ptr Api::sendVideo(boost::variant<std::int64_t, const std::string&> chatId,
+                            boost::variant<InputFile::Ptr, const std::string&> video,
                             bool supportsStreaming,
                             std::int32_t duration,
                             std::int32_t width,
                             std::int32_t height,
-                            boost::variant<InputFile::Ptr, std::string> thumb,
-                            const std::string& caption,
+                            boost::variant<InputFile::Ptr, const std::string&> thumb,
+                            const std::string& caption ,
                             std::int32_t replyToMessageId,
                             GenericReply::Ptr replyMarkup,
                             const std::string& parseMode,
                             bool disableNotification,
                             const std::vector<MessageEntity::Ptr>& captionEntities,
-                            bool allowSendingWithoutReply) const {
+                            bool allowSendingWithoutReply,
+                            bool protectContent) const {
     vector<HttpReqArg> args;
-    args.reserve(14);
+    args.reserve(15);
 
     args.emplace_back("chat_id", chatId);
-    if (video.which() == 0 /* InputFile::Ptr */) {
+    if (video.which() == 0) {   // InputFile::Ptr
         auto file = boost::get<InputFile::Ptr>(video);
         args.emplace_back("video", file->data, true, file->mimeType, file->fileName);
-    } else /* std::string */ {
-        args.emplace_back("video", boost::get<std::string>(video));
+    } else {    // const std::string&
+        args.emplace_back("video", boost::get<const std::string&>(video));
     }
     if (duration) {
         args.emplace_back("duration", duration);
@@ -388,11 +428,11 @@ Message::Ptr Api::sendVideo(std::int64_t chatId,
     if (height) {
         args.emplace_back("height", height);
     }
-    if (thumb.which() == 0 /* InputFile::Ptr */) {
+    if (thumb.which() == 0) {   // InputFile::Ptr
         auto file = boost::get<InputFile::Ptr>(thumb);
         args.emplace_back("thumb", file->data, true, file->mimeType, file->fileName);
-    } else /* std::string */ {
-        auto thumbStr = boost::get<std::string>(thumb);
+    } else {    // const std::string&
+        auto thumbStr = boost::get<const std::string&>(thumb);
         if (!thumbStr.empty()) {
             args.emplace_back("thumb", thumbStr);
         }
@@ -412,6 +452,9 @@ Message::Ptr Api::sendVideo(std::int64_t chatId,
     if (disableNotification) {
         args.emplace_back("disable_notification", disableNotification);
     }
+    if (protectContent) {
+        args.emplace_back("protect_content", protectContent);
+    }
     if (replyToMessageId) {
         args.emplace_back("reply_to_message_id", replyToMessageId);
     }
@@ -425,28 +468,29 @@ Message::Ptr Api::sendVideo(std::int64_t chatId,
     return _tgTypeParser.parseJsonAndGetMessage(sendRequest("sendVideo", args));
 }
 
-Message::Ptr Api::sendAnimation(std::int64_t chatId,
-                                boost::variant<InputFile::Ptr, std::string> animation,
+Message::Ptr Api::sendAnimation(boost::variant<std::int64_t, const std::string&> chatId,
+                                boost::variant<InputFile::Ptr, const std::string&> animation,
                                 std::int32_t duration,
                                 std::int32_t width,
                                 std::int32_t height,
-                                boost::variant<InputFile::Ptr, std::string> thumb,
+                                boost::variant<InputFile::Ptr, const std::string&> thumb,
                                 const std::string& caption,
                                 std::int32_t replyToMessageId,
                                 GenericReply::Ptr replyMarkup,
                                 const std::string& parseMode,
                                 bool disableNotification,
                                 const std::vector<MessageEntity::Ptr>& captionEntities,
-                                bool allowSendingWithoutReply) const {
+                                bool allowSendingWithoutReply,
+                                bool protectContent) const {
     vector<HttpReqArg> args;
-    args.reserve(13);
+    args.reserve(14);
 
     args.emplace_back("chat_id", chatId);
-    if (animation.which() == 0 /* InputFile::Ptr */) {
+    if (animation.which() == 0) {   // InputFile::Ptr
         auto file = boost::get<InputFile::Ptr>(animation);
         args.emplace_back("animation", file->data, true, file->mimeType, file->fileName);
-    } else /* std::string */ {
-        args.emplace_back("animation", boost::get<std::string>(animation));
+    } else {    // const std::string&
+        args.emplace_back("animation", boost::get<const std::string&>(animation));
     }
     if (duration) {
         args.emplace_back("duration", duration);
@@ -457,11 +501,11 @@ Message::Ptr Api::sendAnimation(std::int64_t chatId,
     if (height) {
         args.emplace_back("height", height);
     }
-    if (thumb.which() == 0 /* InputFile::Ptr */) {
+    if (thumb.which() == 0) {      // InputFile::Ptr
         auto file = boost::get<InputFile::Ptr>(thumb);
         args.emplace_back("thumb", file->data, true, file->mimeType, file->fileName);
-    } else /* std::string */ {
-        auto thumbStr = boost::get<std::string>(thumb);
+    } else {    // const std::string&
+        auto thumbStr = boost::get<const std::string&>(thumb);
         if (!thumbStr.empty()) {
             args.emplace_back("thumb", thumbStr);
         }
@@ -478,6 +522,9 @@ Message::Ptr Api::sendAnimation(std::int64_t chatId,
     if (disableNotification) {
         args.emplace_back("disable_notification", disableNotification);
     }
+    if (protectContent) {
+        args.emplace_back("protect_content", protectContent);
+    }
     if (replyToMessageId) {
         args.emplace_back("reply_to_message_id", replyToMessageId);
     }
@@ -491,8 +538,8 @@ Message::Ptr Api::sendAnimation(std::int64_t chatId,
     return _tgTypeParser.parseJsonAndGetMessage(sendRequest("sendAnimation", args));
 }
 
-Message::Ptr Api::sendVoice(std::int64_t chatId,
-                            boost::variant<InputFile::Ptr, std::string> voice,
+Message::Ptr Api::sendVoice(boost::variant<std::int64_t, const std::string&> chatId,
+                            boost::variant<InputFile::Ptr, const std::string&> voice,
                             const std::string& caption,
                             std::int32_t duration,
                             std::int32_t replyToMessageId,
@@ -500,16 +547,17 @@ Message::Ptr Api::sendVoice(std::int64_t chatId,
                             const std::string& parseMode,
                             bool disableNotification,
                             const std::vector<MessageEntity::Ptr>& captionEntities,
-                            bool allowSendingWithoutReply) const {
+                            bool allowSendingWithoutReply,
+                            bool protectContent) const {
     vector<HttpReqArg> args;
-    args.reserve(10);
+    args.reserve(11);
 
     args.emplace_back("chat_id", chatId);
-    if (voice.which() == 0 /* InputFile::Ptr */) {
+    if (voice.which() == 0) {   // InputFile::Ptr
         auto file = boost::get<InputFile::Ptr>(voice);
         args.emplace_back("voice", file->data, true, file->mimeType, file->fileName);
-    } else /* std::string */ {
-        args.emplace_back("voice", boost::get<std::string>(voice));
+    } else {    // const std::string&
+        args.emplace_back("voice", boost::get<const std::string&>(voice));
     }
     if (!caption.empty()) {
         args.emplace_back("caption", caption);
@@ -526,6 +574,9 @@ Message::Ptr Api::sendVoice(std::int64_t chatId,
     if (disableNotification) {
         args.emplace_back("disable_notification", disableNotification);
     }
+    if (protectContent) {
+        args.emplace_back("protect_content", protectContent);
+    }
     if (replyToMessageId) {
         args.emplace_back("reply_to_message_id", replyToMessageId);
     }
@@ -539,24 +590,25 @@ Message::Ptr Api::sendVoice(std::int64_t chatId,
     return _tgTypeParser.parseJsonAndGetMessage(sendRequest("sendVoice", args));
 }
 
-Message::Ptr Api::sendVideoNote(std::int64_t chatId,
-                                boost::variant<InputFile::Ptr, std::string> videoNote,
+Message::Ptr Api::sendVideoNote(boost::variant<std::int64_t, const std::string&> chatId,
+                                boost::variant<InputFile::Ptr, const std::string&> videoNote,
                                 std::int64_t replyToMessageId,
                                 bool disableNotification,
                                 std::int32_t duration,
                                 std::int32_t length,
-                                boost::variant<InputFile::Ptr, std::string> thumb,
+                                boost::variant<InputFile::Ptr, const std::string&> thumb,
                                 GenericReply::Ptr replyMarkup,
-                                bool allowSendingWithoutReply) const {
+                                bool allowSendingWithoutReply,
+                                bool protectContent) const {
     vector<HttpReqArg> args;
-    args.reserve(9);
+    args.reserve(10);
 
     args.emplace_back("chat_id", chatId);
-    if (videoNote.which() == 0 /* InputFile::Ptr */) {
+    if (videoNote.which() == 0) {   // InputFile::Ptr
         auto file = boost::get<InputFile::Ptr>(videoNote);
         args.emplace_back("video_note", file->data, true, file->mimeType, file->fileName);
-    } else /* std::string */ {
-        args.emplace_back("video_note", boost::get<std::string>(videoNote));
+    } else {    // const std::string&
+        args.emplace_back("video_note", boost::get<const std::string&>(videoNote));
     }
     if (duration) {
         args.emplace_back("duration", duration);
@@ -564,11 +616,11 @@ Message::Ptr Api::sendVideoNote(std::int64_t chatId,
     if (length) {
         args.emplace_back("length", length);
     }
-    if (thumb.which() == 0 /* InputFile::Ptr */) {
+    if (thumb.which() == 0) {   // InputFile::Ptr
         auto file = boost::get<InputFile::Ptr>(thumb);
         args.emplace_back("thumb", file->data, true, file->mimeType, file->fileName);
-    } else /* std::string */ {
-        auto thumbStr = boost::get<std::string>(thumb);
+    } else {    // const std::string&
+        auto thumbStr = boost::get<const std::string&>(thumb);
         if (!thumbStr.empty()) {
             args.emplace_back("thumb", thumbStr);
         }
@@ -576,6 +628,9 @@ Message::Ptr Api::sendVideoNote(std::int64_t chatId,
     if (disableNotification) {
         args.emplace_back("disable_notification", disableNotification);
     }
+    if (protectContent) {
+        args.emplace_back("protect_content", protectContent);
+    }
     if (replyToMessageId) {
         args.emplace_back("reply_to_message_id", replyToMessageId);
     }
@@ -589,16 +644,23 @@ Message::Ptr Api::sendVideoNote(std::int64_t chatId,
     return _tgTypeParser.parseJsonAndGetMessage(sendRequest("sendVideoNote", args));
 }
 
-vector<Message::Ptr> Api::sendMediaGroup(std::int64_t chatId, const std::vector<InputMedia::Ptr>& media, bool disableNotification,
-                                         std::int32_t replyToMessageId, bool allowSendingWithoutReply) const {
+vector<Message::Ptr> Api::sendMediaGroup(boost::variant<std::int64_t, const std::string&> chatId,
+                                         const std::vector<InputMedia::Ptr>& media,
+                                         bool disableNotification,
+                                         std::int32_t replyToMessageId,
+                                         bool allowSendingWithoutReply,
+                                         bool protectContent) const {
     vector<HttpReqArg> args;
-    args.reserve(5);
+    args.reserve(6);
 
     args.emplace_back("chat_id", chatId);
     args.emplace_back("media", _tgTypeParser.parseArray<InputMedia>(&TgTypeParser::parseInputMedia, media));
     if (disableNotification) {
         args.emplace_back("disable_notification", disableNotification);
     }
+    if (protectContent) {
+        args.emplace_back("protect_content", protectContent);
+    }
     if (replyToMessageId != 0) {
         args.emplace_back("reply_to_message_id", replyToMessageId);
     }
@@ -609,19 +671,20 @@ vector<Message::Ptr> Api::sendMediaGroup(std::int64_t chatId, const std::vector<
     return _tgTypeParser.parseJsonAndGetArray<Message>(&TgTypeParser::parseJsonAndGetMessage, sendRequest("sendMediaGroup", args));
 }
 
-Message::Ptr Api::sendLocation(std::int64_t chatId,
+Message::Ptr Api::sendLocation(boost::variant<std::int64_t, const std::string&> chatId,
                                float latitude,
                                float longitude,
-                               std::uint32_t livePeriod,
+                               std::int32_t livePeriod,
                                std::int32_t replyToMessageId,
                                GenericReply::Ptr replyMarkup,
                                bool disableNotification,
                                float horizontalAccuracy,
-                               std::uint32_t heading,
-                               std::uint32_t proximityAlertRadius,
-                               bool allowSendingWithoutReply) const {
+                               std::int32_t heading,
+                               std::int32_t proximityAlertRadius,
+                               bool allowSendingWithoutReply,
+                               bool protectContent) const {
     vector<HttpReqArg> args;
-    args.reserve(11);
+    args.reserve(12);
 
     args.emplace_back("chat_id", chatId);
     args.emplace_back("latitude", latitude);
@@ -641,6 +704,9 @@ Message::Ptr Api::sendLocation(std::int64_t chatId,
     if (disableNotification) {
         args.emplace_back("disable_notification", disableNotification);
     }
+    if (protectContent) {
+        args.emplace_back("protect_content", protectContent);
+    }
     if (replyToMessageId) {
         args.emplace_back("reply_to_message_id", replyToMessageId);
     }
@@ -711,7 +777,7 @@ Message::Ptr Api::stopMessageLiveLocation(std::int64_t chatId, std::int32_t mess
     return _tgTypeParser.parseJsonAndGetMessage(sendRequest("editMessageLiveLocation", args));
 }
 
-Message::Ptr Api::sendVenue(std::int64_t chatId,
+Message::Ptr Api::sendVenue(boost::variant<std::int64_t, const std::string&> chatId,
                             float latitude,
                             float longitude,
                             const std::string& title,
@@ -723,9 +789,10 @@ Message::Ptr Api::sendVenue(std::int64_t chatId,
                             GenericReply::Ptr replyMarkup,
                             const std::string& googlePlaceId,
                             const std::string& googlePlaceType,
-                            bool allowSendingWithoutReply) const {
+                            bool allowSendingWithoutReply,
+                            bool protectContent) const {
     vector<HttpReqArg> args;
-    args.reserve(13);
+    args.reserve(14);
 
     args.emplace_back("chat_id", chatId);
     args.emplace_back("latitude", latitude);
@@ -747,6 +814,9 @@ Message::Ptr Api::sendVenue(std::int64_t chatId,
     if (disableNotification) {
         args.emplace_back("disable_notification", disableNotification);
     }
+    if (protectContent) {
+        args.emplace_back("protect_content", protectContent);
+    }
     if (replyToMessageId) {
         args.emplace_back("reply_to_message_id", replyToMessageId);
     }
@@ -760,17 +830,18 @@ Message::Ptr Api::sendVenue(std::int64_t chatId,
     return _tgTypeParser.parseJsonAndGetMessage(sendRequest("sendVenue", args));
 }
 
-Message::Ptr Api::sendContact(std::int64_t chatId,
-                              const std::string& phoneNumber,
-                              const std::string& firstName,
-                              const std::string& lastName,
-                              const std::string& vcard,
-                              bool disableNotification,
-                              std::int32_t replyToMessageId,
-                              GenericReply::Ptr replyMarkup,
-                              bool allowSendingWithoutReply) const {
+Message::Ptr Api::sendContact(boost::variant<std::int64_t, const std::string&> chatId,
+                             const std::string& phoneNumber,
+                             const std::string& firstName,
+                             const std::string& lastName ,
+                             const std::string& vcard,
+                             bool disableNotification,
+                             std::int32_t replyToMessageId,
+                             GenericReply::Ptr replyMarkup,
+                             bool allowSendingWithoutReply,
+                             bool protectContent) const {
     vector<HttpReqArg> args;
-    args.reserve(9);
+    args.reserve(10);
 
     args.emplace_back("chat_id", chatId);
     args.emplace_back("phone_number", phoneNumber);
@@ -784,6 +855,9 @@ Message::Ptr Api::sendContact(std::int64_t chatId,
     if (disableNotification) {
         args.emplace_back("disable_notification", disableNotification);
     }
+    if (protectContent) {
+        args.emplace_back("protect_content", protectContent);
+    }
     if (replyToMessageId) {
         args.emplace_back("reply_to_message_id", replyToMessageId);
     }
@@ -797,7 +871,7 @@ Message::Ptr Api::sendContact(std::int64_t chatId,
     return _tgTypeParser.parseJsonAndGetMessage(sendRequest("sendContact", args));
 }
 
-Message::Ptr Api::sendPoll(std::int64_t chatId,
+Message::Ptr Api::sendPoll(boost::variant<std::int64_t, const std::string&> chatId,
                            const std::string& question,
                            const std::vector<std::string>& options,
                            bool disableNotification,
@@ -813,9 +887,10 @@ Message::Ptr Api::sendPoll(std::int64_t chatId,
                            std::int32_t openPeriod,
                            std::int32_t closeDate,
                            bool isClosed,
-                           bool allowSendingWithoutReply) const {
+                           bool allowSendingWithoutReply,
+                           bool protectContent) const {
     vector<HttpReqArg> args;
-    args.reserve(17);
+    args.reserve(18);
 
     args.emplace_back("chat_id", chatId);
     args.emplace_back("question", question);
@@ -855,6 +930,9 @@ Message::Ptr Api::sendPoll(std::int64_t chatId,
     if (disableNotification) {
         args.emplace_back("disable_notification", disableNotification);
     }
+    if (protectContent) {
+        args.emplace_back("protect_content", protectContent);
+    }
     if (replyToMessageId != 0) {
         args.emplace_back("reply_to_message_id", replyToMessageId);
     }
@@ -868,24 +946,32 @@ Message::Ptr Api::sendPoll(std::int64_t chatId,
     return _tgTypeParser.parseJsonAndGetMessage(sendRequest("sendPoll", args));
 }
 
-Message::Ptr Api::sendDice(std::int64_t chatId,
+Message::Ptr Api::sendDice(boost::variant<std::int64_t, const std::string&> chatId,
                            bool disableNotification,
                            std::int32_t replyToMessageId,
                            GenericReply::Ptr replyMarkup,
                            const std::string& emoji,
-                           bool allowSendingWithoutReply) const {
+                           bool allowSendingWithoutReply,
+                           bool protectContent) const {
     vector<HttpReqArg> args;
-    args.reserve(6);
+    args.reserve(7);
 
     args.emplace_back("chat_id", chatId);
     if (!emoji.empty()) {
         args.emplace_back("emoji", emoji);
     }
-    args.emplace_back("disable_notification", disableNotification);
+    if (disableNotification) {
+        args.emplace_back("disable_notification", disableNotification);
+    }
+    if (protectContent) {
+        args.emplace_back("protect_content", protectContent);
+    }
     if (replyToMessageId != 0) {
         args.emplace_back("reply_to_message_id", replyToMessageId);
     }
-    args.emplace_back("allow_sending_without_reply", allowSendingWithoutReply);
+    if (allowSendingWithoutReply) {
+        args.emplace_back("allow_sending_without_reply", allowSendingWithoutReply);
+    }
     if (replyMarkup) {
         args.emplace_back("reply_markup", _tgTypeParser.parseGenericReply(replyMarkup));
     }
@@ -975,7 +1061,7 @@ bool Api::restrictChatMember(std::int64_t chatId, std::int64_t userId, TgBot::Ch
     return sendRequest("restrictChatMember", args).get<bool>("", false);
 }
 
-bool Api::promoteChatMember(std::int64_t chatId,
+bool Api::promoteChatMember(boost::variant<std::int64_t, const std::string&> chatId,
                             std::int64_t userId,
                             bool canChangeInfo,
                             bool canPostMessages,
@@ -986,7 +1072,7 @@ bool Api::promoteChatMember(std::int64_t chatId,
                             bool canPromoteMembers,
                             bool isAnonymous,
                             bool canManageChat,
-                            bool canManageVoiceChats,
+                            bool canManageVideoChats,
                             bool canRestrictMembers) const {
     vector<HttpReqArg> args;
     args.reserve(13);
@@ -1008,8 +1094,8 @@ bool Api::promoteChatMember(std::int64_t chatId,
     if (canDeleteMessages) {
         args.emplace_back("can_delete_messages", canDeleteMessages);
     }
-    if (canManageVoiceChats) {
-        args.emplace_back("can_manage_voice_chats", canManageVoiceChats);
+    if (canManageVideoChats) {
+        args.emplace_back("can_manage_video_chats", canManageVideoChats);
     }
     if (canRestrictMembers) {
         args.emplace_back("can_restrict_members", canRestrictMembers);
@@ -1104,7 +1190,7 @@ ChatInviteLink::Ptr Api::createChatInviteLink(std::int64_t chatId,
 }
 
 ChatInviteLink::Ptr Api::editChatInviteLink(std::int64_t chatId,
-                                            std::string inviteLink,
+                                            const std::string& inviteLink,
                                             std::int32_t expireDate,
                                             std::int32_t memberLimit,
                                             const std::string& name,
@@ -1131,7 +1217,7 @@ ChatInviteLink::Ptr Api::editChatInviteLink(std::int64_t chatId,
 }
 
 ChatInviteLink::Ptr Api::revokeChatInviteLink(std::int64_t chatId,
-                                              std::string inviteLink) const {
+                                              const std::string& inviteLink) const {
     vector<HttpReqArg> args;
     args.reserve(2);
 
@@ -1345,6 +1431,58 @@ std::vector<BotCommand::Ptr> Api::getMyCommands(BotCommandScope::Ptr scope,
     return _tgTypeParser.parseJsonAndGetArray<BotCommand>(&TgTypeParser::parseJsonAndGetBotCommand, sendRequest("getMyCommands", args));
 }
 
+bool Api::setChatMenuButton(std::int64_t chatId,
+                            MenuButton::Ptr menuButton) const {
+    vector<HttpReqArg> args;
+    args.reserve(2);
+
+    if (chatId != 0) {
+        args.emplace_back("chat_id", chatId);
+    }
+    if (menuButton != nullptr) {
+        args.emplace_back("menu_button", _tgTypeParser.parseMenuButton(menuButton));
+    }
+
+    return sendRequest("setChatMenuButton", args).get<bool>("", false);
+}
+
+MenuButton::Ptr Api::getChatMenuButton(std::int64_t chatId) const {
+    vector<HttpReqArg> args;
+    args.reserve(1);
+
+    if (chatId != 0) {
+        args.emplace_back("chat_id", chatId);
+    }
+
+    return _tgTypeParser.parseJsonAndGetMenuButton(sendRequest("getChatMenuButton", args));
+}
+
+bool Api::setMyDefaultAdministratorRights(ChatAdministratorRights::Ptr rights,
+                                     bool forChannels) const {
+    vector<HttpReqArg> args;
+    args.reserve(2);
+
+    if (rights != nullptr) {
+        args.emplace_back("rights", _tgTypeParser.parseChatAdministratorRights(rights));
+    }
+    if (forChannels) {
+        args.emplace_back("for_channels", forChannels);
+    }
+
+    return sendRequest("setMyDefaultAdministratorRights", args).get<bool>("", false);
+}
+
+ChatAdministratorRights::Ptr Api::getMyDefaultAdministratorRights(bool forChannels) const {
+    vector<HttpReqArg> args;
+    args.reserve(1);
+
+    if (forChannels) {
+        args.emplace_back("for_channels", forChannels);
+    }
+
+    return _tgTypeParser.parseJsonAndGetChatAdministratorRights(sendRequest("getMyDefaultAdministratorRights", args));
+}
+
 Message::Ptr Api::editMessageText(const std::string& text,
                                   std::int64_t chatId,
                                   std::int32_t messageId,
@@ -1493,25 +1631,29 @@ void Api::deleteMessage(std::int64_t chatId, std::int32_t messageId) const {
     sendRequest("deleteMessage", { HttpReqArg("chat_id", chatId), HttpReqArg("message_id", messageId) });
 }
 
-Message::Ptr Api::sendSticker(std::int64_t chatId,
-                              boost::variant<InputFile::Ptr, std::string> sticker,
+Message::Ptr Api::sendSticker(boost::variant<std::int64_t, const std::string&> chatId,
+                              boost::variant<InputFile::Ptr, const std::string&> sticker,
                               std::int32_t replyToMessageId,
                               GenericReply::Ptr replyMarkup,
                               bool disableNotification,
-                              bool allowSendingWithoutReply) const {
+                              bool allowSendingWithoutReply,
+                              bool protectContent) const {
     vector<HttpReqArg> args;
-    args.reserve(6);
+    args.reserve(7);
 
     args.emplace_back("chat_id", chatId);
-    if (sticker.which() == 0 /* InputFile::Ptr */) {
+    if (sticker.which() == 0) { // InputFile::Ptr
         auto file = boost::get<InputFile::Ptr>(sticker);
         args.emplace_back("sticker", file->data, true, file->mimeType, file->fileName);
-    } else /* std::string */ {
-        args.emplace_back("sticker", boost::get<std::string>(sticker));
+    } else {    // const std::string&
+        args.emplace_back("sticker", boost::get<const std::string&>(sticker));
     }
     if (disableNotification) {
         args.emplace_back("disable_notification", disableNotification);
     }
+    if (protectContent) {
+        args.emplace_back("protect_content", protectContent);
+    }
     if (replyToMessageId) {
         args.emplace_back("reply_to_message_id", replyToMessageId);
     }
@@ -1534,6 +1676,17 @@ StickerSet::Ptr Api::getStickerSet(const string& name) const {
     return _tgTypeParser.parseJsonAndGetStickerSet(sendRequest("getStickerSet", args));
 }
 
+std::vector<Sticker::Ptr> Api::getCustomEmojiStickers(const std::vector<std::string>& customEmojiIds) const {
+    vector<HttpReqArg> args;
+    args.reserve(1);
+
+    args.emplace_back("custom_emoji_ids", _tgTypeParser.parseArray<std::string>([] (const std::string& customEmojiId) -> std::string {
+        return "\"" + StringTools::urlEncode(customEmojiId) + "\"";
+    }, customEmojiIds));
+
+    return _tgTypeParser.parseJsonAndGetArray<Sticker>(&TgTypeParser::parseJsonAndGetSticker, sendRequest("getCustomEmojiStickers", args));
+}
+
 File::Ptr Api::uploadStickerFile(std::int64_t userId, const InputFile::Ptr pngSticker) const {
     vector<HttpReqArg> args;
     args.reserve(2);
@@ -1546,32 +1699,33 @@ bool Api::createNewStickerSet(std::int64_t userId,
                               const std::string& name,
                               const std::string& title,
                               const std::string& emojis,
-                              bool containsMasks,
                               MaskPosition::Ptr maskPosition,
-                              boost::variant<InputFile::Ptr, std::string> pngSticker,
-                              boost::variant<InputFile::Ptr, std::string> tgsSticker) const {
+                              boost::variant<InputFile::Ptr, const std::string&> pngSticker,
+                              InputFile::Ptr tgsSticker,
+                              InputFile::Ptr webmSticker,
+                              const std::string& stickerType) const {
     vector<HttpReqArg> args;
-    args.reserve(8);
+    args.reserve(10);
 
     args.emplace_back("user_id", userId);
     args.emplace_back("name", name);
     args.emplace_back("title", title);
-    args.emplace_back("emojis", emojis);
-    if (pngSticker.which() == 0 /* InputFile::Ptr */) {
+    if (pngSticker.which() == 0) {  // InputFile::Ptr
         auto file = boost::get<InputFile::Ptr>(pngSticker);
         args.emplace_back("png_sticker", file->data, true, file->mimeType, file->fileName);
-    } else /* std::string */ {
-        args.emplace_back("png_sticker", boost::get<std::string>(pngSticker));
+    } else {    // const std::string&
+        args.emplace_back("png_sticker", boost::get<const std::string&>(pngSticker));
     }
-    if (tgsSticker.which() == 0 /* InputFile::Ptr */) {
-        auto file = boost::get<InputFile::Ptr>(tgsSticker);
-        args.emplace_back("tgs_sticker", file->data, true, file->mimeType, file->fileName);
-    } else /* std::string */ {
-        args.emplace_back("tgs_sticker", boost::get<std::string>(tgsSticker));
+    if (tgsSticker != nullptr) {
+        args.emplace_back("tgs_sticker", tgsSticker->data, true, tgsSticker->mimeType, tgsSticker->fileName);
     }
-    if (containsMasks) {
-        args.emplace_back("contains_mask", containsMasks);
+    if (webmSticker != nullptr) {
+        args.emplace_back("webm_sticker", webmSticker->data, true, webmSticker->mimeType, webmSticker->fileName);
     }
+    if (!stickerType.empty()) {
+        args.emplace_back("sticker_type", stickerType);
+    }
+    args.emplace_back("emojis", emojis);
     if (maskPosition != nullptr) {
         args.emplace_back("mask_position", _tgTypeParser.parseMaskPosition(maskPosition));
     }
@@ -1580,29 +1734,31 @@ bool Api::createNewStickerSet(std::int64_t userId,
 }
 
 bool Api::addStickerToSet(std::int64_t userId,
-                          const std::string& name,
-                          const std::string& emojis,
-                          MaskPosition::Ptr maskPosition,
-                          boost::variant<InputFile::Ptr, std::string> pngSticker,
-                          boost::variant<InputFile::Ptr, std::string> tgsSticker) const {
+                         const std::string& name,
+                         const std::string& emojis,
+                         MaskPosition::Ptr maskPosition,
+                         boost::variant<InputFile::Ptr, const std::string&> pngSticker,
+                         InputFile::Ptr tgsSticker,
+                         InputFile::Ptr webmSticker) const {
     vector<HttpReqArg> args;
-    args.reserve(6);
+    args.reserve(7);
 
     args.emplace_back("user_id", userId);
     args.emplace_back("name", name);
-    args.emplace_back("emojis", emojis);
-    if (pngSticker.which() == 0 /* InputFile::Ptr */) {
+    
+    if (pngSticker.which() == 0) {  // InputFile::Ptr
         auto file = boost::get<InputFile::Ptr>(pngSticker);
         args.emplace_back("png_sticker", file->data, true, file->mimeType, file->fileName);
-    } else /* std::string */ {
-        args.emplace_back("png_sticker", boost::get<std::string>(pngSticker));
+    } else {    // const std::string&
+        args.emplace_back("png_sticker", boost::get<const std::string&>(pngSticker));
     }
-    if (tgsSticker.which() == 0 /* InputFile::Ptr */) {
-        auto file = boost::get<InputFile::Ptr>(tgsSticker);
-        args.emplace_back("tgs_sticker", file->data, true, file->mimeType, file->fileName);
-    } else /* std::string */ {
-        args.emplace_back("tgs_sticker", boost::get<std::string>(tgsSticker));
+    if (tgsSticker != nullptr) {
+        args.emplace_back("tgs_sticker", tgsSticker->data, true, tgsSticker->mimeType, tgsSticker->fileName);
+    }
+    if (webmSticker != nullptr) {
+        args.emplace_back("webm_sticker", webmSticker->data, true, webmSticker->mimeType, webmSticker->fileName);
     }
+    args.emplace_back("emojis", emojis);
     if (maskPosition != nullptr) {
         args.emplace_back("mask_position", _tgTypeParser.parseMaskPosition(maskPosition));
     }
@@ -1666,7 +1822,18 @@ bool Api::answerInlineQuery(const string& inlineQueryId, const std::vector<Inlin
     return sendRequest("answerInlineQuery", args).get<bool>("", false);
 }
 
-Message::Ptr Api::sendInvoice(std::int64_t chatId,
+SentWebAppMessage::Ptr Api::answerWebAppQuery(const std::string& webAppQueryId,
+                                              InlineQueryResult::Ptr result) const {
+    vector<HttpReqArg> args;
+    args.reserve(2);
+
+    args.emplace_back("web_app_query_id", webAppQueryId);
+    args.emplace_back("result", _tgTypeParser.parseInlineQueryResult(result));
+
+    return _tgTypeParser.parseJsonAndGetSentWebAppMessage(sendRequest("answerWebAppQuery", args));
+}
+
+Message::Ptr Api::sendInvoice(boost::variant<std::int64_t, const std::string&> chatId,
                               const std::string& title,
                               const std::string& description,
                               const std::string& payload,
@@ -1691,9 +1858,10 @@ Message::Ptr Api::sendInvoice(std::int64_t chatId,
                               bool allowSendingWithoutReply,
                               std::int32_t maxTipAmount,
                               const std::vector<std::int32_t>& suggestedTipAmounts,
-                              const std::string& startParameter) const {
+                              const std::string& startParameter,
+                              bool protectContent) const {
     vector<HttpReqArg> args;
-    args.reserve(26);
+    args.reserve(27);
 
     args.emplace_back("chat_id", chatId);
     args.emplace_back("title", title);
@@ -1750,6 +1918,9 @@ Message::Ptr Api::sendInvoice(std::int64_t chatId,
     if (disableNotification) {
         args.emplace_back("disable_notification", disableNotification);
     }
+    if (protectContent) {
+        args.emplace_back("protect_content", protectContent);
+    }
     if (replyToMessageId) {
         args.emplace_back("reply_to_message_id", replyToMessageId);
     }
@@ -1763,6 +1934,81 @@ Message::Ptr Api::sendInvoice(std::int64_t chatId,
     return _tgTypeParser.parseJsonAndGetMessage(sendRequest("sendInvoice", args));
 }
 
+std::string Api::createInvoiceLink(const std::string& title,
+                                   const std::string& description,
+                                   const std::string& payload,
+                                   const std::string& providerToken,
+                                   const std::string& currency,
+                                   const std::vector<LabeledPrice::Ptr>& prices,
+                                   std::int32_t maxTipAmount,
+                                   const std::vector<std::int32_t>& suggestedTipAmounts,
+                                   const std::string& providerData,
+                                   const std::string& photoUrl,
+                                   std::int32_t photoSize,
+                                   std::int32_t photoWidth,
+                                   std::int32_t photoHeight,
+                                   bool needName,
+                                   bool needPhoneNumber,
+                                   bool needEmail,
+                                   bool needShippingAddress,
+                                   bool sendPhoneNumberToProvider,
+                                   bool sendEmailToProvider,
+                                   bool isFlexible) const {
+    vector<HttpReqArg> args;
+    args.reserve(20);
+
+    args.emplace_back("title", title);
+    args.emplace_back("description", description);
+    args.emplace_back("payload", payload);
+    args.emplace_back("provider_token", providerToken);
+    args.emplace_back("currency", currency);
+    args.emplace_back("prices", _tgTypeParser.parseArray<LabeledPrice>(&TgTypeParser::parseLabeledPrice, prices));
+    args.emplace_back("max_tip_amount", maxTipAmount);
+    if (!suggestedTipAmounts.empty()) {
+        args.emplace_back("suggested_tip_amounts", _tgTypeParser.parseArray<std::int32_t>([] (const std::int32_t& option) -> std::int32_t {
+            return option;
+        }, suggestedTipAmounts));
+    }
+    if (!providerData.empty()) {
+        args.emplace_back("provider_data", providerData);
+    }
+    if (!photoUrl.empty()) {
+        args.emplace_back("photo_url", photoUrl);
+    }
+    if (photoSize) {
+        args.emplace_back("photo_size", photoSize);
+    }
+    if (photoWidth) {
+        args.emplace_back("photo_width", photoWidth);
+    }
+    if (photoHeight) {
+        args.emplace_back("photo_height", photoHeight);
+    }
+    if (needName) {
+        args.emplace_back("need_name", needName);
+    }
+    if (needPhoneNumber) {
+        args.emplace_back("need_phone_number", needPhoneNumber);
+    }
+    if (needEmail) {
+        args.emplace_back("need_email", needEmail);
+    }
+    if (needShippingAddress) {
+        args.emplace_back("need_shipping_address", needShippingAddress);
+    }
+    if (sendPhoneNumberToProvider) {
+        args.emplace_back("send_phone_number_to_provider", sendPhoneNumberToProvider);
+    }
+    if (sendEmailToProvider) {
+        args.emplace_back("send_email_to_provider", sendEmailToProvider);
+    }
+    if (isFlexible) {
+        args.emplace_back("is_flexible", isFlexible);
+    }
+
+    return sendRequest("createInvoiceLink", args).get<std::string>("", "");
+}
+
 bool Api::answerShippingQuery(const std::string& shippingQueryId, bool ok, const std::vector<ShippingOption::Ptr>& shippingOptions, const std::string& errorMessage) const {
     vector<HttpReqArg> args;
     args.reserve(4);
@@ -1803,15 +2049,19 @@ Message::Ptr Api::sendGame(std::int64_t chatId,
                            std::int32_t replyToMessageId,
                            InlineKeyboardMarkup::Ptr replyMarkup,
                            bool disableNotification,
-                           bool allowSendingWithoutReply) const {
+                           bool allowSendingWithoutReply,
+                           bool protectContent) const {
     vector<HttpReqArg> args;
-    args.reserve(6);
+    args.reserve(7);
 
     args.emplace_back("chat_id", chatId);
     args.emplace_back("game_short_name", gameShortName);
     if (disableNotification) {
         args.emplace_back("disable_notification", disableNotification);
     }
+    if (protectContent) {
+        args.emplace_back("protect_content", protectContent);
+    }
     if (replyToMessageId) {
         args.emplace_back("reply_to_message_id", replyToMessageId);
     }
diff --git a/src/TgTypeParser.cpp b/src/TgTypeParser.cpp
index e8a81d7..d251da6 100644
--- a/src/TgTypeParser.cpp
+++ b/src/TgTypeParser.cpp
@@ -25,6 +25,9 @@ Chat::Ptr TgTypeParser::parseJsonAndGetChat(const boost::property_tree::ptree& d
     result->photo = tryParseJson<ChatPhoto>(&TgTypeParser::parseJsonAndGetChatPhoto, data, "photo");
     result->bio = data.get<std::string>("bio", "");
     result->hasPrivateForwards = data.get<bool>("has_private_forwards", false);
+    result->hasRestrictedVoiceAndVideoMessages = data.get<bool>("has_restricted_voice_and_video_messages", false);
+    result->joinToSendMessages = data.get<bool>("join_to_send_messages", false);
+    result->joinByRequest = data.get<bool>("join_by_request", false);
     result->description = data.get<std::string>("description", "");
     result->inviteLink = data.get<std::string>("invite_link", "");
     result->pinnedMessage = tryParseJson<Message>(&TgTypeParser::parseJsonAndGetMessage, data, "pinned_message");
@@ -62,6 +65,9 @@ std::string TgTypeParser::parseChat(const Chat::Ptr& object) const {
     appendToJson(result, "photo", parseChatPhoto(object->photo));
     appendToJson(result, "bio", object->bio);
     appendToJson(result, "has_private_forwards", object->hasPrivateForwards);
+    appendToJson(result, "has_restricted_voice_and_video_messages", object->hasRestrictedVoiceAndVideoMessages);
+    appendToJson(result, "join_to_send_messages", object->joinToSendMessages);
+    appendToJson(result, "join_by_request", object->joinByRequest);
     appendToJson(result, "description", object->description);
     appendToJson(result, "invite_link", object->inviteLink);
     appendToJson(result, "pinned_message", parseMessage(object->pinnedMessage));
@@ -86,6 +92,8 @@ User::Ptr TgTypeParser::parseJsonAndGetUser(const boost::property_tree::ptree& d
     result->lastName = data.get<std::string>("last_name", "");
     result->username = data.get<std::string>("username", "");
     result->languageCode = data.get<std::string>("language_code", "");
+    result->isPremium = data.get<bool>("is_premium", false);
+    result->addedToAttachmentMenu = data.get<bool>("added_to_attachment_menu", false);
     result->canJoinGroups = data.get<bool>("can_join_groups", false);
     result->canReadAllGroupMessages = data.get<bool>("can_read_all_group_messages", false);
     result->supportsInlineQueries = data.get<bool>("supports_inline_queries", false);
@@ -104,6 +112,8 @@ std::string TgTypeParser::parseUser(const User::Ptr& object) const {
     appendToJson(result, "last_name", object->lastName);
     appendToJson(result, "username", object->username);
     appendToJson(result, "language_code", object->languageCode);
+    appendToJson(result, "is_premium", object->isPremium);
+    appendToJson(result, "added_to_attachment_menu", object->addedToAttachmentMenu);
     appendToJson(result, "can_join_groups", object->canJoinGroups);
     appendToJson(result, "can_read_all_group_messages", object->canReadAllGroupMessages);
     appendToJson(result, "supports_inline_queries", object->supportsInlineQueries);
@@ -114,12 +124,48 @@ std::string TgTypeParser::parseUser(const User::Ptr& object) const {
 
 MessageEntity::Ptr TgTypeParser::parseJsonAndGetMessageEntity(const boost::property_tree::ptree& data) const{
     auto result(std::make_shared<MessageEntity>());
-    result->type = data.get<std::string>("type", "");
+    std::string type = data.get<std::string>("type", "");
+    if (type == "mention") {
+        result->type = MessageEntity::Type::Mention;
+    } else if (type == "hashtag") {
+        result->type = MessageEntity::Type::Hashtag;
+    } else if (type == "cashtag") {
+        result->type = MessageEntity::Type::Cashtag;
+    } else if (type == "bot_command") {
+        result->type = MessageEntity::Type::BotCommand;
+    } else if (type == "url") {
+        result->type = MessageEntity::Type::Url;
+    } else if (type == "email") {
+        result->type = MessageEntity::Type::Email;
+    } else if (type == "phone_number") {
+        result->type = MessageEntity::Type::PhoneNumber;
+    } else if (type == "bold") {
+        result->type = MessageEntity::Type::Bold;
+    } else if (type == "italic") {
+        result->type = MessageEntity::Type::Italic;
+    } else if (type == "underline") {
+        result->type = MessageEntity::Type::Underline;
+    } else if (type == "strikethrough") {
+        result->type = MessageEntity::Type::Strikethrough;
+    } else if (type == "spoiler") {
+        result->type = MessageEntity::Type::Spoiler;
+    } else if (type == "code") {
+        result->type = MessageEntity::Type::Code;
+    } else if (type == "pre") {
+        result->type = MessageEntity::Type::Pre;
+    } else if (type == "text_link") {
+        result->type = MessageEntity::Type::TextLink;
+    } else if (type == "text_mention") {
+        result->type = MessageEntity::Type::TextMention;
+    } else if (type == "custom_emoji") {
+        result->type = MessageEntity::Type::CustomEmoji;
+    }
     result->offset = data.get<std::int32_t>("offset", 0);
     result->length = data.get<std::int32_t>("length", 0);
     result->url = data.get<std::string>("url", "");
     result->user = tryParseJson<User>(&TgTypeParser::parseJsonAndGetUser, data, "user");
     result->language = data.get<std::string>("language", "");
+    result->customEmojiId = data.get<std::string>("custom_emoji_id", "");
     return result;
 }
 
@@ -129,12 +175,47 @@ std::string TgTypeParser::parseMessageEntity(const MessageEntity::Ptr& object) c
     }
     std::string result;
     result += '{';
-    appendToJson(result, "type", object->type);
+    if (object->type == MessageEntity::Type::Mention) {
+        appendToJson(result, "type", "mention");
+    } else if (object->type == MessageEntity::Type::Hashtag) {
+        appendToJson(result, "type", "hashtag");
+    } else if (object->type == MessageEntity::Type::Cashtag) {
+        appendToJson(result, "type", "cashtag");
+    } else if (object->type == MessageEntity::Type::BotCommand) {
+        appendToJson(result, "type", "bot_command");
+    } else if (object->type == MessageEntity::Type::Url) {
+        appendToJson(result, "type", "url");
+    } else if (object->type == MessageEntity::Type::Email) {
+        appendToJson(result, "type", "email");
+    } else if (object->type == MessageEntity::Type::PhoneNumber) {
+        appendToJson(result, "type", "phone_number");
+    } else if (object->type == MessageEntity::Type::Bold) {
+        appendToJson(result, "type", "bold");
+    } else if (object->type == MessageEntity::Type::Italic) {
+        appendToJson(result, "type", "italic");
+    } else if (object->type == MessageEntity::Type::Underline) {
+        appendToJson(result, "type", "underline");
+    } else if (object->type == MessageEntity::Type::Strikethrough) {
+        appendToJson(result, "type", "strikethrough");
+    } else if (object->type == MessageEntity::Type::Spoiler) {
+        appendToJson(result, "type", "spoiler");
+    } else if (object->type == MessageEntity::Type::Code) {
+        appendToJson(result, "type", "code");
+    } else if (object->type == MessageEntity::Type::Pre) {
+        appendToJson(result, "type", "pre");
+    } else if (object->type == MessageEntity::Type::TextLink) {
+        appendToJson(result, "type", "text_link");
+    } else if (object->type == MessageEntity::Type::TextMention) {
+        appendToJson(result, "type", "text_mention");
+    } else if (object->type == MessageEntity::Type::CustomEmoji) {
+        appendToJson(result, "type", "custom_emoji");
+    }
     appendToJson(result, "offset", object->offset);
     appendToJson(result, "length", object->length);
     appendToJson(result, "url", object->url);
     appendToJson(result, "user", parseUser(object->user));
-    appendToJson(result, "language", object->url);
+    appendToJson(result, "language", object->language);
+    appendToJson(result, "custom_emoji_id", object->customEmojiId);
     removeLastComma(result);
     result += '}';
     return result;
@@ -196,10 +277,11 @@ Message::Ptr TgTypeParser::parseJsonAndGetMessage(const boost::property_tree::pt
     result->passportData = tryParseJson<PassportData>(&TgTypeParser::parseJsonAndGetPassportData, data, "passport_data");
     result->passportData = tryParseJson<PassportData>(&TgTypeParser::parseJsonAndGetPassportData, data, "passport_data");
     result->proximityAlertTriggered = tryParseJson<ProximityAlertTriggered>(&TgTypeParser::parseJsonAndGetProximityAlertTriggered, data, "proximity_alert_triggered");
-    result->voiceChatScheduled = tryParseJson<VoiceChatScheduled>(&TgTypeParser::parseJsonAndGetVoiceChatScheduled, data, "voice_chat_scheduled");
-    result->voiceChatStarted = tryParseJson<VoiceChatStarted>(&TgTypeParser::parseJsonAndGetVoiceChatStarted, data, "voice_chat_started");
-    result->voiceChatEnded = tryParseJson<VoiceChatEnded>(&TgTypeParser::parseJsonAndGetVoiceChatEnded, data, "voice_chat_ended");
-    result->voiceChatParticipantsInvited = tryParseJson<VoiceChatParticipantsInvited>(&TgTypeParser::parseJsonAndGetVoiceChatParticipantsInvited, data, "voice_chat_participants_invited");
+    result->videoChatScheduled = tryParseJson<VideoChatScheduled>(&TgTypeParser::parseJsonAndGetVideoChatScheduled, data, "video_chat_scheduled");
+    result->videoChatStarted = tryParseJson<VideoChatStarted>(&TgTypeParser::parseJsonAndGetVideoChatStarted, data, "video_chat_started");
+    result->videoChatEnded = tryParseJson<VideoChatEnded>(&TgTypeParser::parseJsonAndGetVideoChatEnded, data, "video_chat_ended");
+    result->videoChatParticipantsInvited = tryParseJson<VideoChatParticipantsInvited>(&TgTypeParser::parseJsonAndGetVideoChatParticipantsInvited, data, "video_chat_participants_invited");
+    result->webAppData = tryParseJson<WebAppData>(&TgTypeParser::parseJsonAndGetWebAppData, data, "web_app_data");
     result->replyMarkup = tryParseJson<InlineKeyboardMarkup>(&TgTypeParser::parseJsonAndGetInlineKeyboardMarkup, data, "reply_markup");
     return result;
 }
@@ -263,10 +345,11 @@ std::string TgTypeParser::parseMessage(const Message::Ptr& object) const {
     appendToJson(result, "connected_website", object->connectedWebsite);
     appendToJson(result, "passport_data", parsePassportData(object->passportData));
     appendToJson(result, "proximity_alert_triggered", parseProximityAlertTriggered(object->proximityAlertTriggered));
-    appendToJson(result, "voice_chat_scheduled", parseVoiceChatScheduled(object->voiceChatScheduled));
-    appendToJson(result, "voice_chat_started", parseVoiceChatStarted(object->voiceChatStarted));
-    appendToJson(result, "voice_chat_ended", parseVoiceChatEnded(object->voiceChatEnded));
-    appendToJson(result, "voice_chat_participants_invited", parseVoiceChatParticipantsInvited(object->voiceChatParticipantsInvited));
+    appendToJson(result, "video_chat_scheduled", parseVideoChatScheduled(object->videoChatScheduled));
+    appendToJson(result, "video_chat_started", parseVideoChatStarted(object->videoChatStarted));
+    appendToJson(result, "video_chat_ended", parseVideoChatEnded(object->videoChatEnded));
+    appendToJson(result, "video_chat_participants_invited", parseVideoChatParticipantsInvited(object->videoChatParticipantsInvited));
+    appendToJson(result, "web_app_data", parseWebAppData(object->webAppData));
     appendToJson(result, "reply_markup", parseInlineKeyboardMarkup(object->replyMarkup));
     removeLastComma(result);
     result += '}';
@@ -326,7 +409,7 @@ Audio::Ptr TgTypeParser::parseJsonAndGetAudio(const boost::property_tree::ptree&
     result->title = data.get<std::string>("title", "");
     result->fileName = data.get<std::string>("file_name", "");
     result->mimeType = data.get<std::string>("mime_type", "");
-    result->fileSize = data.get<std::int32_t>("file_size", 0);
+    result->fileSize = data.get<std::int64_t>("file_size", 0);
     result->thumb = tryParseJson<PhotoSize>(&TgTypeParser::parseJsonAndGetPhotoSize, data, "thumb");
     return result;
 }
@@ -358,7 +441,7 @@ Document::Ptr TgTypeParser::parseJsonAndGetDocument(const boost::property_tree::
     result->thumb = tryParseJson<PhotoSize>(&TgTypeParser::parseJsonAndGetPhotoSize, data, "thumb");
     result->fileName = data.get<std::string>("file_name", "");
     result->mimeType = data.get<std::string>("mime_type", "");
-    result->fileSize = data.get<std::int32_t>("file_size", 0);
+    result->fileSize = data.get<std::int64_t>("file_size", 0);
     return result;
 }
 
@@ -383,13 +466,24 @@ Sticker::Ptr TgTypeParser::parseJsonAndGetSticker(const boost::property_tree::pt
     auto result(std::make_shared<Sticker>());
     result->fileId = data.get<std::string>("file_id", "");
     result->fileUniqueId = data.get<std::string>("file_unique_id", "");
+    std::string type = data.get<std::string>("type", "");
+    if (type == "regular") {
+        result->type = Sticker::Type::Regular;
+    } else if (type == "mask") {
+        result->type = Sticker::Type::Mask;
+    } else if (type == "custom_emoji") {
+        result->type = Sticker::Type::CustomEmoji;
+    }
     result->width = data.get<std::int32_t>("width", 0);
     result->height = data.get<std::int32_t>("height", 0);
     result->isAnimated = data.get<bool>("is_animated", false);
+    result->isVideo = data.get<bool>("is_video", false);
     result->thumb = tryParseJson<PhotoSize>(&TgTypeParser::parseJsonAndGetPhotoSize, data, "thumb");
     result->emoji = data.get<std::string>("emoji", "");
     result->setName = data.get<std::string>("set_name", "");
+    result->premiumAnimation = tryParseJson<File>(&TgTypeParser::parseJsonAndGetFile, data, "premium_animation");
     result->maskPosition = tryParseJson<MaskPosition>(&TgTypeParser::parseJsonAndGetMaskPosition, data, "mask_position");
+    result->customEmojiId = data.get<std::string>("custom_emoji_id", "");
     result->fileSize = data.get<std::int32_t>("file_size", 0);
     return result;
 }
@@ -402,13 +496,23 @@ std::string TgTypeParser::parseSticker(const Sticker::Ptr& object) const {
     result += '{';
     appendToJson(result, "file_id", object->fileId);
     appendToJson(result, "file_unique_id", object->fileUniqueId);
+    if (object->type == Sticker::Type::Regular) {
+        appendToJson(result, "type", "regular");
+    } else if (object->type == Sticker::Type::Mask) {
+        appendToJson(result, "type", "mask");
+    } else if (object->type == Sticker::Type::CustomEmoji) {
+        appendToJson(result, "type", "custom_emoji");
+    }
     appendToJson(result, "width", object->width);
     appendToJson(result, "height", object->height);
     appendToJson(result, "is_animated", object->isAnimated);
+    appendToJson(result, "is_video", object->isVideo);
     appendToJson(result, "thumb", parsePhotoSize(object->thumb));
     appendToJson(result, "emoji", object->emoji);
     appendToJson(result, "set_name", object->setName);
+    appendToJson(result, "premium_animation", parseFile(object->premiumAnimation));
     appendToJson(result, "mask_position", parseMaskPosition(object->maskPosition));
+    appendToJson(result, "custom_emoji_id", object->customEmojiId);
     appendToJson(result, "file_size", object->fileSize);
     removeLastComma(result);
     result += '}';
@@ -419,8 +523,16 @@ StickerSet::Ptr TgTypeParser::parseJsonAndGetStickerSet(const boost::property_tr
     auto result(std::make_shared<StickerSet>());
     result->name = data.get<std::string>("name", "");
     result->title = data.get<std::string>("title", "");
+    std::string type = data.get<std::string>("type", "");
+    if (type == "regular") {
+        result->type = StickerSet::Type::Regular;
+    } else if (type == "mask") {
+        result->type = StickerSet::Type::Mask;
+    } else if (type == "custom_emoji") {
+        result->type = StickerSet::Type::CustomEmoji;
+    }
     result->isAnimated = data.get<bool>("is_animated", false);
-    result->containsMasks = data.get<bool>("contains_masks", false);
+    result->isVideo = data.get<bool>("is_video", false);
     result->stickers = parseJsonAndGetArray<Sticker>(&TgTypeParser::parseJsonAndGetSticker, data, "stickers");
     result->thumb = tryParseJson<PhotoSize>(&TgTypeParser::parseJsonAndGetPhotoSize, data, "thumb");
     return result;
@@ -434,8 +546,15 @@ std::string TgTypeParser::parseStickerSet(const StickerSet::Ptr& object) const {
     result += '{';
     appendToJson(result, "name", object->name);
     appendToJson(result, "title", object->title);
+    if (object->type == StickerSet::Type::Regular) {
+        appendToJson(result, "type", "regular");
+    } else if (object->type == StickerSet::Type::Mask) {
+        appendToJson(result, "type", "mask");
+    } else if (object->type == StickerSet::Type::CustomEmoji) {
+        appendToJson(result, "type", "custom_emoji");
+    }
     appendToJson(result, "is_animated", object->isAnimated);
-    appendToJson(result, "contains_masks", object->containsMasks);
+    appendToJson(result, "is_video", object->isVideo);
     appendToJson(result, "stickers", parseArray(&TgTypeParser::parseSticker, object->stickers));
     appendToJson(result, "thumb", parsePhotoSize(object->thumb));
     removeLastComma(result);
@@ -637,7 +756,7 @@ Video::Ptr TgTypeParser::parseJsonAndGetVideo(const boost::property_tree::ptree&
     result->thumb = tryParseJson<PhotoSize>(&TgTypeParser::parseJsonAndGetPhotoSize, data, "thumb");
     result->fileName = data.get<std::string>("file_name", "");
     result->mimeType = data.get<std::string>("mime_type", "");
-    result->fileSize = data.get<std::int32_t>("file_size", 0);
+    result->fileSize = data.get<std::int64_t>("file_size", 0);
     return result;
 }
 
@@ -667,7 +786,7 @@ Voice::Ptr TgTypeParser::parseJsonAndGetVoice(const boost::property_tree::ptree&
     result->fileUniqueId = data.get<std::string>("file_unique_id", "");
     result->duration = data.get<std::int32_t>("duration", 0);
     result->mimeType = data.get<std::string>("mime_type", "");
-    result->fileSize = data.get<std::int32_t>("file_size", 0);
+    result->fileSize = data.get<std::int64_t>("file_size", 0);
     return result;
 }
 
@@ -743,6 +862,21 @@ std::string TgTypeParser::parseGame(const Game::Ptr& object) const {
     return result;
 }
 
+CallbackGame::Ptr TgTypeParser::parseJsonAndGetCallbackGame(const boost::property_tree::ptree& data) const {
+    auto result(std::make_shared<CallbackGame>());
+    return result;
+}
+
+std::string TgTypeParser::parseCallbackGame(const CallbackGame::Ptr& object) const {
+    if (!object) {
+        return "";
+    }
+    std::string result;
+    result += '{';
+    result += '}';
+    return result;
+}
+
 GameHighScore::Ptr TgTypeParser::parseJsonAndGetGameHighScore(const boost::property_tree::ptree& data) const {
     auto result(std::make_shared<GameHighScore>());
     result->position = data.get("position", "");
@@ -775,7 +909,7 @@ Animation::Ptr TgTypeParser::parseJsonAndGetAnimation(const boost::property_tree
     result->thumb = tryParseJson<PhotoSize>(&TgTypeParser::parseJsonAndGetPhotoSize, data, "thumb");
     result->fileName = data.get<std::string>("file_name", "");
     result->mimeType = data.get<std::string>("mime_type", "");
-    result->fileSize = data.get<std::int32_t>("file_size", 0);
+    result->fileSize = data.get<std::int64_t>("file_size", 0);
     return result;
 }
 
@@ -883,6 +1017,26 @@ std::string TgTypeParser::parseVenue(const Venue::Ptr& object) const {
     return result;
 }
 
+WebAppData::Ptr TgTypeParser::parseJsonAndGetWebAppData(const boost::property_tree::ptree& data) const {
+    auto result(std::make_shared<WebAppData>());
+    result->data = data.get<std::string>("data", "");
+    result->buttonText = data.get<std::string>("button_text", "");
+    return result;
+}
+
+std::string TgTypeParser::parseWebAppData(const WebAppData::Ptr& object) const {
+    if (!object) {
+        return "";
+    }
+    std::string result;
+    result += '{';
+    appendToJson(result, "data", object->data);
+    appendToJson(result, "button_text", object->buttonText);
+    removeLastComma(result);
+    result += '}';
+    return result;
+}
+
 ProximityAlertTriggered::Ptr TgTypeParser::parseJsonAndGetProximityAlertTriggered(const boost::property_tree::ptree& data) const {
     auto result(std::make_shared<ProximityAlertTriggered>());
     result->traveler = tryParseJson<User>(&TgTypeParser::parseJsonAndGetUser, data, "traveler");
@@ -923,13 +1077,13 @@ std::string TgTypeParser::parseMessageAutoDeleteTimerChanged(const MessageAutoDe
     return result;
 }
 
-VoiceChatScheduled::Ptr TgTypeParser::parseJsonAndGetVoiceChatScheduled(const boost::property_tree::ptree& data) const {
-    auto result(std::make_shared<VoiceChatScheduled>());
+VideoChatScheduled::Ptr TgTypeParser::parseJsonAndGetVideoChatScheduled(const boost::property_tree::ptree& data) const {
+    auto result(std::make_shared<VideoChatScheduled>());
     result->startDate = data.get<std::int32_t>("start_date", 0);
     return result;
 }
 
-std::string TgTypeParser::parseVoiceChatScheduled(const VoiceChatScheduled::Ptr& object) const {
+std::string TgTypeParser::parseVideoChatScheduled(const VideoChatScheduled::Ptr& object) const {
     if (!object) {
         return "";
     }
@@ -941,25 +1095,28 @@ std::string TgTypeParser::parseVoiceChatScheduled(const VoiceChatScheduled::Ptr&
     return result;
 }
 
-VoiceChatStarted::Ptr TgTypeParser::parseJsonAndGetVoiceChatStarted(const boost::property_tree::ptree& data) const {
-    auto result(std::make_shared<VoiceChatStarted>());
+VideoChatStarted::Ptr TgTypeParser::parseJsonAndGetVideoChatStarted(const boost::property_tree::ptree& data) const {
+    auto result(std::make_shared<VideoChatStarted>());
     return result;
 }
 
-std::string TgTypeParser::parseVoiceChatStarted(const VoiceChatStarted::Ptr& object) const {
+std::string TgTypeParser::parseVideoChatStarted(const VideoChatStarted::Ptr& object) const {
     if (!object) {
         return "";
     }
-    return "{}";
+    std::string result;
+    result += '{';
+    result += '}';
+    return result;
 }
 
-VoiceChatEnded::Ptr TgTypeParser::parseJsonAndGetVoiceChatEnded(const boost::property_tree::ptree& data) const {
-    auto result(std::make_shared<VoiceChatEnded>());
+VideoChatEnded::Ptr TgTypeParser::parseJsonAndGetVideoChatEnded(const boost::property_tree::ptree& data) const {
+    auto result(std::make_shared<VideoChatEnded>());
     result->duration = data.get<std::int32_t>("duration", 0);
     return result;
 }
 
-std::string TgTypeParser::parseVoiceChatEnded(const VoiceChatEnded::Ptr& object) const {
+std::string TgTypeParser::parseVideoChatEnded(const VideoChatEnded::Ptr& object) const {
     if (!object) {
         return "";
     }
@@ -971,13 +1128,13 @@ std::string TgTypeParser::parseVoiceChatEnded(const VoiceChatEnded::Ptr& object)
     return result;
 }
 
-VoiceChatParticipantsInvited::Ptr TgTypeParser::parseJsonAndGetVoiceChatParticipantsInvited(const boost::property_tree::ptree& data) const {
-    auto result(std::make_shared<VoiceChatParticipantsInvited>());
+VideoChatParticipantsInvited::Ptr TgTypeParser::parseJsonAndGetVideoChatParticipantsInvited(const boost::property_tree::ptree& data) const {
+    auto result(std::make_shared<VideoChatParticipantsInvited>());
     result->users = parseJsonAndGetArray<User>(&TgTypeParser::parseJsonAndGetUser, data, "users");
     return result;
 }
 
-std::string TgTypeParser::parseVoiceChatParticipantsInvited(const VoiceChatParticipantsInvited::Ptr& object) const {
+std::string TgTypeParser::parseVideoChatParticipantsInvited(const VideoChatParticipantsInvited::Ptr& object) const {
     if (!object) {
         return "";
     }
@@ -1230,7 +1387,7 @@ File::Ptr TgTypeParser::parseJsonAndGetFile(const boost::property_tree::ptree& d
     auto result(std::make_shared<File>());
     result->fileId = data.get<std::string>("file_id", "");
     result->fileUniqueId = data.get<std::string>("file_unique_id", "");
-    result->fileSize = data.get<std::int32_t>("file_size", 0);
+    result->fileSize = data.get<std::int64_t>("file_size", 0);
     result->filePath = data.get<std::string>("file_path", "");
     return result;
 }
@@ -1250,6 +1407,24 @@ std::string TgTypeParser::parseFile(const File::Ptr& object) const {
     return result;
 }
 
+WebAppInfo::Ptr TgTypeParser::parseJsonAndGetWebAppInfo(const boost::property_tree::ptree& data) const {
+    auto result(std::make_shared<WebAppInfo>());
+    result->url = data.get<std::string>("url", "");
+    return result;
+}
+
+std::string TgTypeParser::parseWebAppInfo(const WebAppInfo::Ptr& object) const {
+    if (!object) {
+        return "";
+    }
+    std::string result;
+    result += '{';
+    appendToJson(result, "url", object->url);
+    removeLastComma(result);
+    result += '}';
+    return result;
+}
+
 ReplyKeyboardMarkup::Ptr TgTypeParser::parseJsonAndGetReplyKeyboardMarkup(const boost::property_tree::ptree& data) const {
     auto result(std::make_shared<ReplyKeyboardMarkup>());
     for (const auto& item : data.find("keyboard")->second){
@@ -1296,6 +1471,7 @@ KeyboardButton::Ptr TgTypeParser::parseJsonAndGetKeyboardButton(const boost::pro
     result->requestContact = data.get<bool>("request_contact", false);
     result->requestLocation = data.get<bool>("request_location", false);
     result->requestPoll = tryParseJson<KeyboardButtonPollType>(&TgTypeParser::parseJsonAndGetKeyboardButtonPollType, data, "request_poll");
+    result->webApp = tryParseJson<WebAppInfo>(&TgTypeParser::parseJsonAndGetWebAppInfo, data, "web_app");
     return result;
 }
 
@@ -1309,6 +1485,7 @@ std::string TgTypeParser::parseKeyboardButton(const KeyboardButton::Ptr& object)
     appendToJson(result, "request_contact", object->requestContact);
     appendToJson(result, "request_location", object->requestLocation);
     appendToJson(result, "request_poll", parseKeyboardButtonPollType(object->requestPoll));
+    appendToJson(result, "web_app", parseWebAppInfo(object->webApp));
     removeLastComma(result);
     result += '}';
     return result;
@@ -1451,18 +1628,18 @@ ChatMemberAdministrator::Ptr TgTypeParser::parseJsonAndGetChatMemberAdministrato
     // NOTE: This function will be called by parseJsonAndGetChatMember().
     auto result(std::make_shared<ChatMemberAdministrator>());
     result->canBeEdited = data.get<bool>("can_be_edited", false);
-    result->customTitle = data.get<std::string>("custom_title", "");
     result->isAnonymous = data.get<bool>("is_anonymous", false);
     result->canManageChat = data.get<bool>("can_manage_chat", false);
-    result->canPostMessages = data.get<bool>("can_post_messages", false);
-    result->canEditMessages = data.get<bool>("can_edit_messages", false);
     result->canDeleteMessages = data.get<bool>("can_delete_messages", false);
-    result->canManageVoiceChats = data.get<bool>("can_manage_voice_chats", false);
+    result->canManageVideoChats = data.get<bool>("can_manage_video_chats", false);
     result->canRestrictMembers = data.get<bool>("can_restrict_members", false);
     result->canPromoteMembers = data.get<bool>("can_promote_members", false);
     result->canChangeInfo = data.get<bool>("can_change_info", false);
     result->canInviteUsers = data.get<bool>("can_invite_users", false);
+    result->canPostMessages = data.get<bool>("can_post_messages", false);
+    result->canEditMessages = data.get<bool>("can_edit_messages", false);
     result->canPinMessages = data.get<bool>("can_pin_messages", false);
+    result->customTitle = data.get<std::string>("custom_title", "");
     return result;
 }
 
@@ -1474,18 +1651,18 @@ std::string TgTypeParser::parseChatMemberAdministrator(const ChatMemberAdministr
     // curly brackets to the result std::string.
     std::string result;
     appendToJson(result, "can_be_edited", object->canBeEdited);
-    appendToJson(result, "custom_title", object->customTitle);
     appendToJson(result, "is_anonymous", object->isAnonymous);
     appendToJson(result, "can_manage_chat", object->canManageChat);
-    appendToJson(result, "can_post_messages", object->canPostMessages);
-    appendToJson(result, "can_edit_messages", object->canEditMessages);
     appendToJson(result, "can_delete_messages", object->canDeleteMessages);
-    appendToJson(result, "can_manage_voice_chats", object->canManageVoiceChats);
+    appendToJson(result, "can_manage_video_chats", object->canManageVideoChats);
     appendToJson(result, "can_restrict_members", object->canRestrictMembers);
     appendToJson(result, "can_promote_members", object->canPromoteMembers);
     appendToJson(result, "can_change_info", object->canChangeInfo);
     appendToJson(result, "can_invite_users", object->canInviteUsers);
+    appendToJson(result, "can_post_messages", object->canPostMessages);
+    appendToJson(result, "can_edit_messages", object->canEditMessages);
     appendToJson(result, "can_pin_messages", object->canPinMessages);
+    appendToJson(result, "custom_title", object->customTitle);
     // The last comma will be erased by parseChatMember().
     return result;
 }
@@ -1519,7 +1696,7 @@ ChatMemberRestricted::Ptr TgTypeParser::parseJsonAndGetChatMemberRestricted(cons
     result->canSendPolls = data.get<bool>("can_send_polls", false);
     result->canSendOtherMessages = data.get<bool>("can_send_other_messages", false);
     result->canAddWebPagePreviews = data.get<bool>("can_add_web_page_previews", false);
-    result->untilDate = data.get<uint32_t>("until_date", 0);
+    result->untilDate = data.get<std::uint32_t>("until_date", 0);
     return result;
 }
 
@@ -1666,9 +1843,9 @@ ChatInviteLink::Ptr TgTypeParser::parseJsonAndGetChatInviteLink(const boost::pro
     result->isPrimary = data.get<bool>("is_primary", false);
     result->isRevoked = data.get<bool>("is_revoked", false);
     result->name = data.get<std::string>("name", "");
-    result->expireDate = data.get<std::int32_t>("expire_date", 0);
-    result->memberLimit = data.get<std::int32_t>("member_limit", 0);
-    result->pendingJoinRequestCount = data.get<std::int32_t>("pending_join_request_count", 0);
+    result->expireDate = data.get<std::uint32_t>("expire_date", 0);
+    result->memberLimit = data.get<std::uint32_t>("member_limit", 0);
+    result->pendingJoinRequestCount = data.get<std::uint32_t>("pending_join_request_count", 0);
     return result;
 }
 
@@ -1692,6 +1869,44 @@ std::string TgTypeParser::parseChatInviteLink(const ChatInviteLink::Ptr& object)
     return result;
 }
 
+ChatAdministratorRights::Ptr TgTypeParser::parseJsonAndGetChatAdministratorRights(const boost::property_tree::ptree& data) const {
+    auto result(std::make_shared<ChatAdministratorRights>());
+    result->isAnonymous = data.get<bool>("is_anonymous", false);
+    result->canManageChat = data.get<bool>("can_manage_chat", false);
+    result->canDeleteMessages = data.get<bool>("can_delete_messages", false);
+    result->canManageVideoChats = data.get<bool>("can_manage_video_chats", false);
+    result->canRestrictMembers = data.get<bool>("can_restrict_members", false);
+    result->canPromoteMembers = data.get<bool>("can_promote_members", false);
+    result->canChangeInfo = data.get<bool>("can_change_info", false);
+    result->canInviteUsers = data.get<bool>("can_invite_users", false);
+    result->canPostMessages = data.get<bool>("can_post_messages", false);
+    result->canEditMessages = data.get<bool>("can_edit_messages", false);
+    result->canPinMessages = data.get<bool>("can_pin_messages", false);
+    return result;
+}
+
+std::string TgTypeParser::parseChatAdministratorRights(const ChatAdministratorRights::Ptr& object) const {
+    if (!object) {
+        return "";
+    }
+    std::string result;
+    result += '{';
+    appendToJson(result, "is_anonymous", object->isAnonymous);
+    appendToJson(result, "can_manage_chat", object->canManageChat);
+    appendToJson(result, "can_delete_messages", object->canDeleteMessages);
+    appendToJson(result, "can_manage_video_chats", object->canManageVideoChats);
+    appendToJson(result, "can_restrict_members", object->canRestrictMembers);
+    appendToJson(result, "can_promote_members", object->canPromoteMembers);
+    appendToJson(result, "can_change_info", object->canChangeInfo);
+    appendToJson(result, "can_invite_users", object->canInviteUsers);
+    appendToJson(result, "can_post_messages", object->canPostMessages);
+    appendToJson(result, "can_edit_messages", object->canEditMessages);
+    appendToJson(result, "can_pin_messages", object->canPinMessages);
+    removeLastComma(result);
+    result += '}';
+    return result;
+}
+
 ResponseParameters::Ptr TgTypeParser::parseJsonAndGetResponseParameters(const boost::property_tree::ptree& data) const {
     auto result(std::make_shared<ResponseParameters>());
     result->migrateToChatId = data.get<std::int64_t>("migrate_to_chat_id", 0);
@@ -2578,6 +2793,24 @@ std::string TgTypeParser::parseChosenInlineResult(const ChosenInlineResult::Ptr&
     return result;
 }
 
+SentWebAppMessage::Ptr TgTypeParser::parseJsonAndGetSentWebAppMessage(const boost::property_tree::ptree& data) const {
+    auto result(std::make_shared<SentWebAppMessage>());
+    result->inlineMessageId = data.get<std::string>("inline_message_id", "");
+    return result;
+}
+
+std::string TgTypeParser::parseSentWebAppMessage(const SentWebAppMessage::Ptr& object) const {
+    if (!object){
+        return "";
+    }
+    std::string result;
+    result += '{';
+    appendToJson(result, "inline_message_id", object->inlineMessageId);
+    removeLastComma(result);
+    result += '}';
+    return result;
+}
+
 CallbackQuery::Ptr TgTypeParser::parseJsonAndGetCallbackQuery(const boost::property_tree::ptree& data) const {
     auto result(std::make_shared<CallbackQuery>());
     result->id = data.get<std::string>("id");
@@ -2641,13 +2874,14 @@ std::string TgTypeParser::parseInlineKeyboardMarkup(const InlineKeyboardMarkup::
 
 InlineKeyboardButton::Ptr TgTypeParser::parseJsonAndGetInlineKeyboardButton(const boost::property_tree::ptree& data) const {
     auto result(std::make_shared<InlineKeyboardButton>());
-    result->text = data.get<std::string>("text");
+    result->text = data.get<std::string>("text", "");
     result->url = data.get<std::string>("url", "");
-    result->loginUrl = std::make_shared<LoginUrl>();
     result->callbackData = data.get<std::string>("callback_data", "");
+    result->webApp = tryParseJson<WebAppInfo>(&TgTypeParser::parseJsonAndGetWebAppInfo, data, "web_app");
+    result->loginUrl = tryParseJson<LoginUrl>(&TgTypeParser::parseJsonAndGetLoginUrl, data, "login_url");
     result->switchInlineQuery = data.get<std::string>("switch_inline_query", "");
     result->switchInlineQueryCurrentChat = data.get<std::string>("switch_inline_query_current_chat", "");
-    result->callbackGame = std::make_shared<CallbackGame>();
+    result->callbackGame = tryParseJson<CallbackGame>(&TgTypeParser::parseJsonAndGetCallbackGame, data, "callback_game");
     result->pay = data.get<bool>("pay", false);
     return result;
 }
@@ -2657,8 +2891,7 @@ std::string TgTypeParser::parseInlineKeyboardButton(const InlineKeyboardButton::
     }
     std::string result;
     result += '{';
-    if(object->pay)
-        appendToJson(result, "pay", object->pay);
+    appendToJson(result, "pay", object->pay);
     appendToJson(result, "text", object->text);
     appendToJson(result, "url", object->url);
     appendToJson(result, "callback_data", object->callbackData);
@@ -2669,6 +2902,30 @@ std::string TgTypeParser::parseInlineKeyboardButton(const InlineKeyboardButton::
     return result;
 }
 
+LoginUrl::Ptr TgTypeParser::parseJsonAndGetLoginUrl(const boost::property_tree::ptree& data) const {
+    auto result(std::make_shared<LoginUrl>());
+    result->url = data.get<std::string>("url", "");
+    result->forwardText = data.get<std::string>("forward_text", "");
+    result->botUsername = data.get<std::string>("bot_username", "");
+    result->requestWriteAccess = data.get<bool>("request_write_access", false);
+    return result;
+}
+
+std::string TgTypeParser::parseLoginUrl(const LoginUrl::Ptr& object) const {
+    if (!object){
+        return "";
+    }
+    std::string result;
+    result += '{';
+    appendToJson(result, "url", object->url);
+    appendToJson(result, "forward_text", object->forwardText);
+    appendToJson(result, "bot_username", object->botUsername);
+    appendToJson(result, "request_write_access", object->requestWriteAccess);
+    removeLastComma(result);
+    result += '}';
+    return result;
+}
+
 WebhookInfo::Ptr TgTypeParser::parseJsonAndGetWebhookInfo(const boost::property_tree::ptree& data) const {
     auto result(std::make_shared<WebhookInfo>());
     result->url = data.get<std::string>("url", "");
@@ -2677,6 +2934,7 @@ WebhookInfo::Ptr TgTypeParser::parseJsonAndGetWebhookInfo(const boost::property_
     result->ipAddress = data.get<std::string>("ip_address", "");
     result->lastErrorDate = data.get<std::int32_t>("last_error_date", 0);
     result->lastErrorMessage = data.get<std::string>("last_error_message", "");
+    result->lastSynchronizationErrorDate = data.get<std::int32_t>("last_synchronization_error_date", 0);
     result->maxConnections = data.get<std::int32_t>("max_connections", 0);
     result->allowedUpdates = parseJsonAndGetArray<std::string>(
         [](const boost::property_tree::ptree& innerData)->std::string {
@@ -2698,6 +2956,7 @@ std::string TgTypeParser::parseWebhookInfo(const WebhookInfo::Ptr& object) const
     appendToJson(result, "ip_address", object->ipAddress);
     appendToJson(result, "last_error_date", object->lastErrorDate);
     appendToJson(result, "last_error_message", object->lastErrorMessage);
+    appendToJson(result, "last_synchronization_error_date", object->lastSynchronizationErrorDate);
     appendToJson(result, "max_connections", object->maxConnections);
     appendToJson(result, "allowed_updates",
         parseArray<std::string>([](const std::string &s)->std::string {
@@ -3170,6 +3429,101 @@ std::string TgTypeParser::parseBotCommandScopeChatMember(const BotCommandScopeCh
     return result;
 }
 
+MenuButton::Ptr TgTypeParser::parseJsonAndGetMenuButton(const boost::property_tree::ptree& data) const {
+    std::string type = data.get<std::string>("type", "");
+    MenuButton::Ptr result;
+
+    if (type == MenuButtonCommands::TYPE) {
+        result = std::static_pointer_cast<MenuButton>(parseJsonAndGetMenuButtonCommands(data));
+    } else if (type == MenuButtonWebApp::TYPE) {
+        result = std::static_pointer_cast<MenuButton>(parseJsonAndGetMenuButtonWebApp(data));
+    } else if (type == MenuButtonDefault::TYPE) {
+        result = std::static_pointer_cast<MenuButton>(parseJsonAndGetMenuButtonDefault(data));
+    } else {
+        result = std::make_shared<MenuButton>();
+    }
+
+    result->type = type;
+
+    return result;
+}
+
+std::string TgTypeParser::parseMenuButton(const MenuButton::Ptr& object) const {
+    if (!object) {
+        return "";
+    }
+    std::string result;
+    result += '{';
+    appendToJson(result, "type", object->type);
+
+    if (object->type == MenuButtonCommands::TYPE) {
+        result += parseMenuButtonCommands(std::static_pointer_cast<MenuButtonCommands>(object));
+    } else if (object->type == MenuButtonWebApp::TYPE) {
+        result += parseMenuButtonWebApp(std::static_pointer_cast<MenuButtonWebApp>(object));
+    } else if (object->type == MenuButtonDefault::TYPE) {
+        result += parseMenuButtonDefault(std::static_pointer_cast<MenuButtonDefault>(object));
+    }
+
+    removeLastComma(result);
+    result += '}';
+    return result;
+}
+
+MenuButtonCommands::Ptr TgTypeParser::parseJsonAndGetMenuButtonCommands(const boost::property_tree::ptree& data) const {
+    // NOTE: This function will be called by parseJsonAndGetMenuButton().
+    auto result(std::make_shared<MenuButtonCommands>());
+    return result;
+}
+
+std::string TgTypeParser::parseMenuButtonCommands(const MenuButtonCommands::Ptr& object) const {
+    if (!object) {
+        return "";
+    }
+    // This function will be called by parseMenuButton(), so I don't add
+    // curly brackets to the result std::string.
+    std::string result;
+    // The last comma will be erased by parseMenuButton().
+    return result;
+}
+
+MenuButtonWebApp::Ptr TgTypeParser::parseJsonAndGetMenuButtonWebApp(const boost::property_tree::ptree& data) const {
+    // NOTE: This function will be called by parseJsonAndGetMenuButton().
+    auto result(std::make_shared<MenuButtonWebApp>());
+    result->text = data.get<std::string>("text", "");
+    result->webApp = tryParseJson<WebAppInfo>(&TgTypeParser::parseJsonAndGetWebAppInfo, data, "web_app");
+    return result;
+}
+
+std::string TgTypeParser::parseMenuButtonWebApp(const MenuButtonWebApp::Ptr& object) const {
+    if (!object) {
+        return "";
+    }
+    // This function will be called by parseMenuButton(), so I don't add
+    // curly brackets to the result std::string.
+    std::string result;
+    appendToJson(result, "text", object->text);
+    appendToJson(result, "web_app", parseWebAppInfo(object->webApp));
+    // The last comma will be erased by parseMenuButton().
+    return result;
+}
+
+MenuButtonDefault::Ptr TgTypeParser::parseJsonAndGetMenuButtonDefault(const boost::property_tree::ptree& data) const {
+    // NOTE: This function will be called by parseJsonAndGetMenuButton().
+    auto result(std::make_shared<MenuButtonDefault>());
+    return result;
+}
+
+std::string TgTypeParser::parseMenuButtonDefault(const MenuButtonDefault::Ptr& object) const {
+    if (!object) {
+        return "";
+    }
+    // This function will be called by parseMenuButton(), so I don't add
+    // curly brackets to the result std::string.
+    std::string result;
+    // The last comma will be erased by parseMenuButton().
+    return result;
+}
+
 OrderInfo::Ptr TgTypeParser::parseJsonAndGetOrderInfo(const boost::property_tree::ptree& data) const {
     auto result(std::make_shared<OrderInfo>());
     result->name = data.get<std::string>("name", "");
diff --git a/src/types/MenuButton.cpp b/src/types/MenuButton.cpp
new file mode 100644
index 0000000..54e3868
--- /dev/null
+++ b/src/types/MenuButton.cpp
@@ -0,0 +1,11 @@
+#include "tgbot/types/MenuButtonCommands.h"
+#include "tgbot/types/MenuButtonWebApp.h"
+#include "tgbot/types/MenuButtonDefault.h"
+
+#include <string>
+
+using namespace TgBot;
+
+const std::string MenuButtonCommands::TYPE = "commands";
+const std::string MenuButtonWebApp::TYPE = "web_app";
+const std::string MenuButtonDefault::TYPE = "default";