Merge pull request #221 from llnulldisk/master

Update to Bot API 4.9

2 files changed, 766 insertions, 738 deletions

diff --git a/src/Api.cpp b/src/Api.cpp
index 22115c2..9cb7f6e 100644
--- a/src/Api.cpp
+++ b/src/Api.cpp
@@ -19,42 +19,86 @@ Api::Api(string token, const HttpClient& httpClient, const std::string& url)
     : _token(std::move(token)), _httpClient(httpClient), _tgTypeParser(), _url(url) {
 }
 
-User::Ptr Api::getMe() const {
-    return _tgTypeParser.parseJsonAndGetUser(sendRequest("getMe"));
+vector<Update::Ptr> Api::getUpdates(std::int32_t offset, std::int32_t limit, std::int32_t timeout, const StringArrayPtr& allowedUpdates) const {
+    vector<HttpReqArg> args;
+    args.reserve(4);
+    if (offset) {
+        args.emplace_back("offset", offset);
+    }
+    limit = max(1, min(100, limit));
+    args.emplace_back("limit", limit);
+    if (timeout) {
+        args.emplace_back("timeout", timeout);
+    }
+    if (allowedUpdates != nullptr) {
+        string allowedUpdatesJson = _tgTypeParser.parseArray<string>(
+            [] (const string& s)->string {
+            return s;
+        }, *allowedUpdates);
+        args.emplace_back("allowed_updates", allowedUpdatesJson);
+    }
+    return _tgTypeParser.parseJsonAndGetArray<Update>(&TgTypeParser::parseJsonAndGetUpdate, sendRequest("getUpdates", args));
 }
 
-Message::Ptr Api::sendMessage(std::int64_t chatId, const string& text, bool disableWebPagePreview, std::int32_t replyToMessageId, const GenericReply::Ptr replyMarkup, const string& parseMode, bool disableNotification) const {
+void Api::setWebhook(const string& url, const InputFile::Ptr certificate, std::int32_t maxConnection, const StringArrayPtr& allowedUpdates) const {
     vector<HttpReqArg> args;
-    args.reserve(7);
-    args.emplace_back("chat_id", chatId);
-    args.emplace_back("text", text);
-    if (disableWebPagePreview) {
-        args.emplace_back("disable_web_page_preview", disableWebPagePreview);
+    args.reserve(4);
+    if (!url.empty()) {
+        args.emplace_back("url", url);
     }
-    if (disableNotification){
-        args.emplace_back("disable_notification", disableNotification);
+    if (certificate != nullptr) {
+        args.emplace_back("certificate", certificate->data, true, certificate->mimeType, certificate->fileName);
     }
-    if (replyToMessageId) {
-        args.emplace_back("reply_to_message_id", replyToMessageId);
+    if (maxConnection != 40) {
+        args.emplace_back("max_connections", maxConnection);
     }
-    if (replyMarkup) {
-        args.emplace_back("reply_markup", _tgTypeParser.parseGenericReply(replyMarkup));
+    if (allowedUpdates != nullptr) {
+        auto allowedUpdatesJson = _tgTypeParser.parseArray<string>(
+            [] (const string& s)->string {
+            return s;
+        }, *allowedUpdates);
+        args.emplace_back("allowed_updates", allowedUpdatesJson);
     }
-    if (!parseMode.empty()) {
-        args.emplace_back("parse_mode", parseMode);
+
+    sendRequest("setWebhook", args);
+}
+
+bool Api::deleteWebhook() const {
+    return sendRequest("deleteWebhook").get<bool>("", false);
+}
+
+WebhookInfo::Ptr Api::getWebhookInfo() const {
+    ptree p = sendRequest("getWebhookInfo");
+
+    if (!p.get_child_optional("url")) {
+        return nullptr;
     }
-    return _tgTypeParser.parseJsonAndGetMessage(sendRequest("sendMessage", args));
+    if (p.get<string>("url", "") != string("")) {
+        return _tgTypeParser.parseJsonAndGetWebhookInfo(p);
+    } else {
+        return nullptr;
+    }
+}
+
+User::Ptr Api::getMe() const {
+    return _tgTypeParser.parseJsonAndGetUser(sendRequest("getMe"));
 }
 
-Message::Ptr Api::sendMessage(const std::string &chatId, const string& text, bool disableWebPagePreview, std::int32_t replyToMessageId, const GenericReply::Ptr replyMarkup, const string& parseMode, bool disableNotification) const {
+Message::Ptr Api::sendMessage(boost::variant<std::int64_t, const std::string&> chatId, const std::string& text, bool disableWebPagePreview,
+                              std::int32_t replyToMessageId, GenericReply::Ptr replyMarkup, const std::string& parseMode,
+                              bool disableNotification) const {
     vector<HttpReqArg> args;
     args.reserve(7);
+
     args.emplace_back("chat_id", chatId);
     args.emplace_back("text", text);
+    if (!parseMode.empty()) {
+        args.emplace_back("parse_mode", parseMode);
+    }
     if (disableWebPagePreview) {
         args.emplace_back("disable_web_page_preview", disableWebPagePreview);
     }
-    if (disableNotification){
+    if (disableNotification) {
         args.emplace_back("disable_notification", disableNotification);
     }
     if (replyToMessageId) {
@@ -63,9 +107,7 @@ Message::Ptr Api::sendMessage(const std::string &chatId, const string& text, boo
     if (replyMarkup) {
         args.emplace_back("reply_markup", _tgTypeParser.parseGenericReply(replyMarkup));
     }
-    if (!parseMode.empty()) {
-        args.emplace_back("parse_mode", parseMode);
-    }
+
     return _tgTypeParser.parseJsonAndGetMessage(sendRequest("sendMessage", args));
 }
 
@@ -75,7 +117,7 @@ Message::Ptr Api::forwardMessage(std::int64_t chatId, std::int64_t fromChatId, s
     args.emplace_back("chat_id", chatId);
     args.emplace_back("from_chat_id", fromChatId);
     args.emplace_back("message_id", messageId);
-    if (disableNotification){
+    if (disableNotification) {
         args.emplace_back("disable_notification", disableNotification);
     }
     return _tgTypeParser.parseJsonAndGetMessage(sendRequest("forwardMessage", args));
@@ -103,13 +145,13 @@ Message::Ptr Api::sendPhoto(std::int64_t chatId, boost::variant<InputFile::Ptr,
     if (!parseMode.empty()) {
         args.emplace_back("parse_mode", parseMode);
     }
-    if (disableNotification){
+    if (disableNotification) {
         args.emplace_back("disable_notification", disableNotification);
     }
     return _tgTypeParser.parseJsonAndGetMessage(sendRequest("sendPhoto", args));
 }
 
-Message::Ptr Api::sendAudio(std::int64_t chatId, boost::variant<InputFile::Ptr, std::string> audio, const string &caption, std::int32_t duration, const string& performer, const string& title, boost::variant<InputFile::Ptr, std::string> thumb, std::int32_t replyToMessageId, const GenericReply::Ptr replyMarkup, const string& parseMode, bool disableNotification) const {
+Message::Ptr Api::sendAudio(std::int64_t chatId, boost::variant<InputFile::Ptr, std::string> audio, const string& caption, std::int32_t duration, const string& performer, const string& title, boost::variant<InputFile::Ptr, std::string> thumb, std::int32_t replyToMessageId, const GenericReply::Ptr replyMarkup, const string& parseMode, bool disableNotification) const {
     vector<HttpReqArg> args;
     args.reserve(11);
     args.emplace_back("chat_id", chatId);
@@ -125,10 +167,10 @@ Message::Ptr Api::sendAudio(std::int64_t chatId, boost::variant<InputFile::Ptr,
     if (duration) {
         args.emplace_back("duration", duration);
     }
-    if (!performer.empty()){
+    if (!performer.empty()) {
         args.emplace_back("performer", performer);
     }
-    if (!title.empty()){
+    if (!title.empty()) {
         args.emplace_back("title", title);
     }
     if (thumb.which() == 0 /* InputFile::Ptr */) {
@@ -149,13 +191,13 @@ Message::Ptr Api::sendAudio(std::int64_t chatId, boost::variant<InputFile::Ptr,
     if (!parseMode.empty()) {
         args.emplace_back("parse_mode", parseMode);
     }
-    if (disableNotification){
+    if (disableNotification) {
         args.emplace_back("disable_notification", disableNotification);
     }
     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, const string &caption, std::int32_t replyToMessageId, const GenericReply::Ptr replyMarkup, const string& parseMode, bool disableNotification) const {
+Message::Ptr Api::sendDocument(std::int64_t chatId, boost::variant<InputFile::Ptr, std::string> document, boost::variant<InputFile::Ptr, std::string> thumb, const string& caption, std::int32_t replyToMessageId, const GenericReply::Ptr replyMarkup, const string& parseMode, bool disableNotification) const {
     vector<HttpReqArg> args;
     args.reserve(8);
     args.emplace_back("chat_id", chatId);
@@ -186,228 +228,13 @@ Message::Ptr Api::sendDocument(std::int64_t chatId, boost::variant<InputFile::Pt
     if (!parseMode.empty()) {
         args.emplace_back("parse_mode", parseMode);
     }
-    if (disableNotification){
+    if (disableNotification) {
         args.emplace_back("disable_notification", disableNotification);
     }
     return _tgTypeParser.parseJsonAndGetMessage(sendRequest("sendDocument", args));
 }
 
-Message::Ptr Api::sendInvoice(std::int64_t chatId, const std::string& title, const std::string& description, const std::string& payload,
-                             const std::string& providerToken, const std::string& startParameter, const std::string& currency, const std::vector<LabeledPrice::Ptr>& prices,
-                             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,
-                             std::int32_t replyToMessageId, const GenericReply::Ptr replyMarkup, bool disableNotification) const {
-    vector<HttpReqArg> args;
-    args.reserve(23);
-    args.emplace_back("chat_id", chatId);
-    args.emplace_back("title", title);
-    args.emplace_back("description", description);
-    args.emplace_back("payload", payload);
-    args.emplace_back("provider_token", providerToken);
-    args.emplace_back("start_parameter", startParameter);
-    args.emplace_back("currency", currency);
-    args.emplace_back("prices", _tgTypeParser.parseArray<LabeledPrice>(&TgTypeParser::parseLabeledPrice, prices));
-    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);
-    }
-    if (replyToMessageId) {
-        args.emplace_back("reply_to_message_id", replyToMessageId);
-    }
-    if (replyMarkup) {
-        args.emplace_back("reply_markup", _tgTypeParser.parseGenericReply(replyMarkup));
-    }
-    if (disableNotification){
-        args.emplace_back("disable_notification", disableNotification);
-    }
-    return _tgTypeParser.parseJsonAndGetMessage(sendRequest("sendInvoice", args));
-}
-
-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);
-    args.emplace_back("shipping_query_id", shippingQueryId);
-    args.emplace_back("ok", ok);
-    if (!shippingOptions.empty()) {
-        args.emplace_back("shipping_options", _tgTypeParser.parseArray<ShippingOption>(&TgTypeParser::parseShippingOption, shippingOptions));
-    }
-    if (!errorMessage.empty()) {
-        args.emplace_back("error_message", errorMessage);
-    }
-    return sendRequest("answerShippingQuery", args).get<bool>("", false);
-}
-
-bool Api::answerPreCheckoutQuery(const std::string& preCheckoutQueryId, bool ok, const std::string& errorMessage) const {
-    vector<HttpReqArg> args;
-    args.reserve(3);
-    args.emplace_back("pre_checkout_query_id", preCheckoutQueryId);
-    args.emplace_back("ok", ok);
-    if (!errorMessage.empty()) {
-        args.emplace_back("error_message", errorMessage);
-    }
-    return sendRequest("answerPreCheckoutQuery", args).get<bool>("", false);
-}
-
-
-Message::Ptr Api::sendSticker(std::int64_t chatId, boost::variant<InputFile::Ptr, std::string> sticker, std::int32_t replyToMessageId, const GenericReply::Ptr replyMarkup, bool disableNotification) const {
-    vector<HttpReqArg> args;
-    args.reserve(5);
-    args.emplace_back("chat_id", chatId);
-    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));
-    }
-    if (replyToMessageId) {
-        args.emplace_back("reply_to_message_id", replyToMessageId);
-    }
-    if (replyMarkup) {
-        args.emplace_back("reply_markup", _tgTypeParser.parseGenericReply(replyMarkup));
-    }
-    if (disableNotification){
-        args.emplace_back("disable_notification", disableNotification);
-    }
-    return _tgTypeParser.parseJsonAndGetMessage(sendRequest("sendSticker", args));
-}
-
-StickerSet::Ptr Api::getStickerSet(const string& name) const {
-    vector<HttpReqArg> args;
-    args.reserve(1);
-    args.emplace_back("name", name);
-    return _tgTypeParser.parseJsonAndGetStickerSet(sendRequest("getStickerSet", args));
-}
-
-File::Ptr Api::uploadStickerFile(std::int64_t userId, const InputFile::Ptr pngSticker) const {
-    vector<HttpReqArg> args;
-    args.reserve(2);
-    args.emplace_back("user_id", userId);
-    args.emplace_back("png_sticker", pngSticker->data, true, pngSticker->mimeType, pngSticker->fileName);
-    return _tgTypeParser.parseJsonAndGetFile(sendRequest("uploadStickerFile", args));
-}
-
-bool Api::createNewStickerSet(std::int64_t userId, const std::string& name, const std::string& title, const std::string& emojis,
-                              boost::variant<InputFile::Ptr, std::string> pngSticker, boost::variant<InputFile::Ptr, std::string> tgsSticker,
-                              bool containsMasks, MaskPosition::Ptr maskPosition) const {
-    vector<HttpReqArg> args;
-    args.reserve(8);
-    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 */) {
-        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));
-    }
-    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 (containsMasks) {
-        args.emplace_back("contains_mask", containsMasks);
-    }
-    if (maskPosition != nullptr) {
-        args.emplace_back("mask_position", _tgTypeParser.parseMaskPosition(maskPosition));
-    }
-    return sendRequest("createNewStickerSet", args).get<bool>("", false);
-}
-
-bool Api::addStickerToSet(std::int64_t userId, const std::string& name, const std::string& emojis,
-                          boost::variant<InputFile::Ptr, std::string> pngSticker, boost::variant<InputFile::Ptr, std::string> tgsSticker,
-                          MaskPosition::Ptr maskPosition) const {
-    vector<HttpReqArg> args;
-    args.reserve(6);
-    args.emplace_back("user_id", userId);
-    args.emplace_back("name", name);
-    args.emplace_back("emojis", emojis);
-
-    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));
-    }
-    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 (maskPosition != nullptr) {
-        args.emplace_back("mask_position", _tgTypeParser.parseMaskPosition(maskPosition));
-    }
-    return sendRequest("addStickerToSet", args).get<bool>("", false);
-}
-
-bool Api::setStickerPositionInSet(const string& sticker, std::uint32_t position) const {
-    vector<HttpReqArg> args;
-    args.reserve(2);
-    args.emplace_back("sticker", sticker);
-    args.emplace_back("position", position);
-    return sendRequest("setStickerPositionInSet", args).get<bool>("", false);
-}
-
-bool Api::deleteStickerFromSet(const string& sticker) const {
-    vector<HttpReqArg> args;
-    args.reserve(1);
-    args.emplace_back("sticker", sticker);
-    return sendRequest("deleteStickerFromSet", args).get<bool>("", false);
-}
-
-bool Api::setStickerSetThumb(const std::string& name, std::int64_t userId, boost::variant<InputFile::Ptr, std::string> thumb) const {
-    vector<HttpReqArg> args;
-    args.reserve(3);
-    args.emplace_back("name", name);
-    args.emplace_back("user_id", userId);
-    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 */ {
-        args.emplace_back("thumb", boost::get<std::string>(thumb));
-    }
-    return sendRequest("setStickerSetThumb", args).get<bool>("", false);
-}
-
-Message::Ptr Api::sendVideo(std::int64_t chatId, boost::variant<InputFile::Ptr, 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 string &caption, std::int32_t replyToMessageId, const GenericReply::Ptr replyMarkup, const string& parseMode, bool disableNotification) const {
+Message::Ptr Api::sendVideo(std::int64_t chatId, boost::variant<InputFile::Ptr, 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 string& caption, std::int32_t replyToMessageId, const GenericReply::Ptr replyMarkup, const string& parseMode, bool disableNotification) const {
     vector<HttpReqArg> args;
     args.reserve(12);
     args.emplace_back("chat_id", chatId);
@@ -450,7 +277,7 @@ Message::Ptr Api::sendVideo(std::int64_t chatId, boost::variant<InputFile::Ptr,
     if (!parseMode.empty()) {
         args.emplace_back("parse_mode", parseMode);
     }
-    if (disableNotification){
+    if (disableNotification) {
         args.emplace_back("disable_notification", disableNotification);
     }
     return _tgTypeParser.parseJsonAndGetMessage(sendRequest("sendVideo", args));
@@ -496,12 +323,43 @@ Message::Ptr Api::sendAnimation(std::int64_t chatId, boost::variant<InputFile::P
     if (!parseMode.empty()) {
         args.emplace_back("parse_mode", parseMode);
     }
-    if (disableNotification){
+    if (disableNotification) {
         args.emplace_back("disable_notification", disableNotification);
     }
     return _tgTypeParser.parseJsonAndGetMessage(sendRequest("sendAnimation", args));
 }
 
+Message::Ptr Api::sendVoice(std::int64_t chatId, boost::variant<InputFile::Ptr, std::string> voice, const string& caption, int duration, std::int32_t replyToMessageId, const GenericReply::Ptr replyMarkup, const string& parseMode, bool disableNotification) const {
+    vector<HttpReqArg> args;
+    args.reserve(8);
+    args.emplace_back("chat_id", chatId);
+    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));
+    }
+    if (!caption.empty()) {
+        args.emplace_back("caption", caption);
+    }
+    if (duration) {
+        args.emplace_back("duration", duration);
+    }
+    if (replyToMessageId) {
+        args.emplace_back("reply_to_message_id", replyToMessageId);
+    }
+    if (replyMarkup) {
+        args.emplace_back("reply_markup", _tgTypeParser.parseGenericReply(replyMarkup));
+    }
+    if (!parseMode.empty()) {
+        args.emplace_back("parse_mode", parseMode);
+    }
+    if (disableNotification) {
+        args.emplace_back("disable_notification", disableNotification);
+    }
+    return _tgTypeParser.parseJsonAndGetMessage(sendRequest("sendVoice", args));
+}
+
 Message::Ptr Api::sendVideoNote(std::int64_t chatId, boost::variant<InputFile::Ptr, std::string> videoNote, std::int64_t replyToMessageId, bool disableNotification, std::int32_t duration, std::int32_t length, boost::variant<InputFile::Ptr, std::string> thumb, const GenericReply::Ptr replyMarkup) const {
     vector<HttpReqArg> args;
     args.reserve(8);
@@ -550,54 +408,6 @@ vector<Message::Ptr> Api::sendMediaGroup(std::int64_t chatId, const vector<Input
     return _tgTypeParser.parseJsonAndGetArray<Message>(&TgTypeParser::parseJsonAndGetMessage, sendRequest("sendMediaGroup", args));
 }
 
-Message::Ptr Api::sendVoice(std::int64_t chatId, boost::variant<InputFile::Ptr, std::string> voice, const string &caption, int duration, std::int32_t replyToMessageId, const GenericReply::Ptr replyMarkup, const string& parseMode, bool disableNotification) const {
-    vector<HttpReqArg> args;
-    args.reserve(8);
-    args.emplace_back("chat_id", chatId);
-    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));
-    }
-    if (!caption.empty()) {
-        args.emplace_back("caption", caption);
-    }
-    if (duration){
-        args.emplace_back("duration", duration);
-    }
-    if (replyToMessageId) {
-        args.emplace_back("reply_to_message_id", replyToMessageId);
-    }
-    if (replyMarkup) {
-        args.emplace_back("reply_markup", _tgTypeParser.parseGenericReply(replyMarkup));
-    }
-    if (!parseMode.empty()) {
-        args.emplace_back("parse_mode", parseMode);
-    }
-    if (disableNotification){
-        args.emplace_back("disable_notification", disableNotification);
-    }
-    return _tgTypeParser.parseJsonAndGetMessage(sendRequest("sendVoice", args));
-}
-
-Message::Ptr Api::sendGame(std::int64_t chatId, const std::string& gameShortName, std::int32_t replyToMessageId, const InlineKeyboardMarkup::Ptr replyMarkup, bool disableNotification) const {
-    vector<HttpReqArg> args;
-    args.reserve(5);
-    args.emplace_back("chat_id", chatId);
-    args.emplace_back("game_short_name", gameShortName);
-    if (replyToMessageId) {
-        args.emplace_back("reply_to_message_id", replyToMessageId);
-    }
-    if (replyMarkup) {
-        args.emplace_back("reply_markup", _tgTypeParser.parseGenericReply(replyMarkup));
-    }
-    if (disableNotification){
-        args.emplace_back("disable_notification", disableNotification);
-    }
-    return _tgTypeParser.parseJsonAndGetMessage(sendRequest("sendGame", args));
-}
-
 Message::Ptr Api::sendLocation(std::int64_t chatId, float latitude, float longitude, std::uint32_t livePeriod, std::int32_t replyToMessageId, const GenericReply::Ptr replyMarkup, bool disableNotification) const {
     vector<HttpReqArg> args;
     args.reserve(7);
@@ -613,7 +423,7 @@ Message::Ptr Api::sendLocation(std::int64_t chatId, float latitude, float longit
     if (replyMarkup) {
         args.emplace_back("reply_markup", _tgTypeParser.parseGenericReply(replyMarkup));
     }
-    if (disableNotification){
+    if (disableNotification) {
         args.emplace_back("disable_notification", disableNotification);
     }
     return _tgTypeParser.parseJsonAndGetMessage(sendRequest("sendLocation", args));
@@ -657,21 +467,6 @@ Message::Ptr Api::stopMessageLiveLocation(std::int64_t chatId, std::int32_t mess
     return _tgTypeParser.parseJsonAndGetMessage(sendRequest("editMessageLiveLocation", args));
 }
 
-bool Api::setChatStickerSet(std::int64_t chatId, const string& stickerSetName) const {
-    vector<HttpReqArg> args;
-    args.reserve(2);
-    args.emplace_back("chat_id", chatId);
-    args.emplace_back("sticker_set_name	", stickerSetName);
-    return sendRequest("setChatStickerSet", args).get<bool>("", false);
-}
-
-bool Api::deleteChatStickerSet(std::int64_t chatId) const {
-    vector<HttpReqArg> args;
-    args.reserve(1);
-    args.emplace_back("chat_id", chatId);
-    return sendRequest("deleteChatStickerSet", args).get<bool>("", false);
-}
-
 Message::Ptr Api::sendVenue(std::int64_t chatId, float latitude, float longitude, const string& title, const string& address, const string& foursquareId, const string& foursquareType, bool disableNotification, std::int32_t replyToMessageId, const GenericReply::Ptr replyMarkup) const {
     vector<HttpReqArg> args;
     args.reserve(10);
@@ -692,7 +487,7 @@ Message::Ptr Api::sendVenue(std::int64_t chatId, float latitude, float longitude
     if (replyMarkup) {
         args.emplace_back("reply_markup", _tgTypeParser.parseGenericReply(replyMarkup));
     }
-    if (disableNotification){
+    if (disableNotification) {
         args.emplace_back("disable_notification", disableNotification);
     }
     return _tgTypeParser.parseJsonAndGetMessage(sendRequest("sendVenue", args));
@@ -716,12 +511,93 @@ Message::Ptr Api::sendContact(std::int64_t chatId, const string& phoneNumber, co
     if (replyMarkup) {
         args.emplace_back("reply_markup", _tgTypeParser.parseGenericReply(replyMarkup));
     }
-    if (disableNotification){
+    if (disableNotification) {
         args.emplace_back("disable_notification", disableNotification);
     }
     return _tgTypeParser.parseJsonAndGetMessage(sendRequest("sendContact", args));
 }
 
+Message::Ptr Api::sendPoll(std::int64_t chatId, const std::string& question, const std::vector<std::string>& options,
+                           bool isAnonymous, const std::string& type, bool allowsMultipleAnswers,
+                           std::int32_t correctOptionId, const std::string& explanation, const std::string& explanationParseMode,
+                           std::int32_t openPeriod, std::int64_t closeDate, bool isClosed,
+                           bool disableNotification, std::int32_t replyToMessageId, GenericReply::Ptr replyMarkup) const {
+    vector<HttpReqArg> args;
+    args.reserve(15);
+
+    args.emplace_back("chat_id", chatId);
+    args.emplace_back("question", question);
+    args.emplace_back("options", _tgTypeParser.parseArray<std::string>([] (const std::string& option) -> std::string {
+        return StringTools::urlEncode(option);
+    }, options));
+    if (!isAnonymous) {
+        args.emplace_back("is_anonymous", isAnonymous);
+    }
+    if (!type.empty()) {
+        args.emplace_back("type", type);
+    }
+    if (allowsMultipleAnswers) {
+        args.emplace_back("allows_multiple_answers", allowsMultipleAnswers);
+    }
+    if (correctOptionId != 0) {
+        args.emplace_back("correct_option_id", correctOptionId);
+    }
+    if (!explanation.empty()) {
+        args.emplace_back("explanation", explanation);
+    }
+    if (!explanationParseMode.empty()) {
+        args.emplace_back("explanation_parse_mode", explanationParseMode);
+    }
+    if (openPeriod != 0) {
+        args.emplace_back("open_period", openPeriod);
+    }
+    if (closeDate != 0) {
+        args.emplace_back("close_date", closeDate);
+    }
+    if (isClosed) {
+        args.emplace_back("is_closed", isClosed);
+    }
+    if (disableNotification) {
+        args.emplace_back("disable_notification", disableNotification);
+    }
+    if (replyToMessageId != 0) {
+        args.emplace_back("reply_to_message_id", replyToMessageId);
+    }
+    if (replyMarkup) {
+        args.emplace_back("reply_markup", _tgTypeParser.parseGenericReply(replyMarkup));
+    }
+
+    return _tgTypeParser.parseJsonAndGetMessage(sendRequest("sendPoll", args));
+}
+
+Message::Ptr Api::sendPoll(std::int64_t chatId, const std::string& question, const std::vector<std::string>& options,
+                           bool disableNotification, std::int32_t replyToMessageId, GenericReply::Ptr replyMarkup) const {
+
+    return sendPoll(chatId, question, options, true, "", false, 0, "", "", 0, 0, false, false, 0);
+}
+
+Message::Ptr Api::sendDice(std::int64_t chatId, const std::string& emoji, bool disableNotification,
+                           std::int32_t replyToMessageId, GenericReply::Ptr replyMarkup) const {
+    vector<HttpReqArg> args;
+    args.reserve(5);
+
+    args.emplace_back("chat_id", chatId);
+    if (disableNotification) {
+        args.emplace_back("disable_notification", disableNotification);
+    }
+    if (!emoji.empty()) {
+        args.emplace_back("emoji", emoji);
+    }
+    if (replyToMessageId != 0) {
+        args.emplace_back("reply_to_message_id", replyToMessageId);
+    }
+    if (replyMarkup) {
+        args.emplace_back("reply_markup", _tgTypeParser.parseGenericReply(replyMarkup));
+    }
+
+    return _tgTypeParser.parseJsonAndGetMessage(sendRequest("sendDice", args));
+}
+
 void Api::sendChatAction(std::int64_t chatId, const string& action) const {
     vector<HttpReqArg> args;
     args.reserve(2);
@@ -742,13 +618,163 @@ UserProfilePhotos::Ptr Api::getUserProfilePhotos(std::int64_t userId, std::int32
     return _tgTypeParser.parseJsonAndGetUserProfilePhotos(sendRequest("getUserProfilePhotos", args));
 }
 
-File::Ptr Api::getFile(const string &fileId) const {
+File::Ptr Api::getFile(const string& fileId) const {
     vector<HttpReqArg> args;
     args.reserve(1);
     args.emplace_back("file_id", fileId);
     return _tgTypeParser.parseJsonAndGetFile(sendRequest("getFile", args));
 }
 
+string Api::downloadFile(const string& filePath, const std::vector<HttpReqArg>& args) const {
+    string url(_url);
+    url += "/file/bot";
+    url += _token;
+    url += "/";
+    url += filePath;
+
+    string serverResponse = _httpClient.makeRequest(url, args);
+
+    return serverResponse;
+}
+
+bool Api::kickChatMember(std::int64_t chatId, std::int64_t userId, std::uint64_t untilDate) const {
+    vector<HttpReqArg> args;
+    args.reserve(3);
+    args.emplace_back("chat_id", chatId);
+    args.emplace_back("user_id", userId);
+    if (untilDate) {
+        args.emplace_back("until_date", untilDate);
+    }
+    return sendRequest("kickChatMember", args).get<bool>("", false);
+}
+
+bool Api::unbanChatMember(std::int64_t chatId, std::int64_t userId) const {
+    vector<HttpReqArg> args;
+    args.reserve(2);
+    args.emplace_back("chat_id", chatId);
+    args.emplace_back("user_id", userId);
+    return sendRequest("unbanChatMember", args).get<bool>("", false);
+}
+
+bool Api::restrictChatMember(std::int64_t chatId, std::int64_t userId, TgBot::ChatPermissions::Ptr permissions,
+                             std::uint64_t untilDate) const {
+    vector<HttpReqArg> args;
+    args.reserve(4);
+    args.emplace_back("chat_id", chatId);
+    args.emplace_back("user_id", userId);
+    args.emplace_back("permissions", _tgTypeParser.parseChatPermissions(permissions));
+    if (untilDate) {
+        args.emplace_back("until_date", untilDate);
+    }
+
+    return sendRequest("restrictChatMember", args).get<bool>("", false);
+}
+
+bool Api::promoteChatMember(std::int64_t chatId, std::int64_t userId, bool canChangeInfo, bool canPostMessages,
+                            bool canEditMessages, bool canDeleteMessages, bool canInviteUsers, bool canPinMessages, bool canPromoteMembers) const {
+    vector<HttpReqArg> args;
+    args.reserve(9);
+    args.emplace_back("chat_id", chatId);
+    args.emplace_back("user_id", userId);
+    if (canChangeInfo) {
+        args.emplace_back("can_change_info", canChangeInfo);
+    }
+    if (canPostMessages) {
+        args.emplace_back("can_post_messages", canPostMessages);
+    }
+    if (canEditMessages) {
+        args.emplace_back("can_edit_messages", canEditMessages);
+    }
+    if (canDeleteMessages) {
+        args.emplace_back("can_delete_messages", canDeleteMessages);
+    }
+    if (canInviteUsers) {
+        args.emplace_back("can_invite_users", canInviteUsers);
+    }
+    if (canPinMessages) {
+        args.emplace_back("can_pin_messages", canPinMessages);
+    }
+    if (canPromoteMembers) {
+        args.emplace_back("can_promote_members", canPromoteMembers);
+    }
+    return sendRequest("promoteChatMember", args).get<bool>("", false);
+}
+
+bool Api::setChatAdministratorCustomTitle(std::int64_t chatId, std::int64_t userId, const std::string& customTitle) const {
+    vector<HttpReqArg> args;
+    args.reserve(3);
+
+    args.emplace_back("chat_id", chatId);
+    args.emplace_back("user_id", userId);
+    args.emplace_back("custom_title", customTitle);
+
+    return sendRequest("setChatAdministratorCustomTitle", args).get<bool>("", false);
+}
+
+bool Api::setChatPermissions(std::int64_t chatId, ChatPermissions::Ptr permissions) const {
+    vector<HttpReqArg> args;
+    args.reserve(2);
+    args.emplace_back("chat_id", chatId);
+    args.emplace_back("permissions", _tgTypeParser.parseChatPermissions(permissions));
+    return sendRequest("setChatPermissions", args).get<bool>("", false);
+}
+
+string Api::exportChatInviteLink(std::int64_t chatId) const {
+    vector<HttpReqArg> args;
+    args.reserve(1);
+    args.emplace_back("chat_id", chatId);
+    return sendRequest("exportChatInviteLink", args).get("", "");
+}
+
+bool Api::setChatPhoto(std::int64_t chatId, const InputFile::Ptr photo) const {
+    vector<HttpReqArg> args;
+    args.reserve(2);
+    args.emplace_back("chat_id", chatId);
+    args.emplace_back("photo", photo->data, true, photo->mimeType, photo->fileName);
+    return sendRequest("setChatPhoto", args).get<bool>("", false);
+}
+
+bool Api::deleteChatPhoto(std::int64_t chatId) const {
+    vector<HttpReqArg> args;
+    args.reserve(1);
+    args.emplace_back("chat_id", chatId);
+    return sendRequest("deleteChatPhoto", args).get<bool>("", false);
+}
+
+bool Api::setChatTitle(std::int64_t chatId, const string& title) const {
+    vector<HttpReqArg> args;
+    args.reserve(2);
+    args.emplace_back("chat_id", chatId);
+    args.emplace_back("title", title);
+    return sendRequest("setChatTitle", args).get<bool>("", false);
+}
+
+bool Api::setChatDescription(std::int64_t chatId, const string& description) const {
+    vector<HttpReqArg> args;
+    args.reserve(2);
+    args.emplace_back("chat_id", chatId);
+    args.emplace_back("description", description);
+    return sendRequest("setChatDescription", args).get<bool>("", false);
+}
+
+bool Api::pinChatMessage(std::int64_t chatId, std::int32_t messageId, bool disableNotification) const {
+    vector<HttpReqArg> args;
+    args.reserve(3);
+    args.emplace_back("chat_id", chatId);
+    args.emplace_back("message_id", messageId);
+    if (disableNotification) {
+        args.emplace_back("disable_notification", disableNotification);
+    }
+    return sendRequest("pinChatMessage", args).get<bool>("", false);
+}
+
+bool Api::unpinChatMessage(std::int64_t chatId) const {
+    vector<HttpReqArg> args;
+    args.reserve(1);
+    args.emplace_back("chat_id", chatId);
+    return sendRequest("unpinChatMessage", args).get<bool>("", false);
+}
+
 bool Api::leaveChat(std::int64_t chatId) const {
     vector<HttpReqArg> args;
     args.reserve(1);
@@ -777,7 +803,30 @@ int32_t Api::getChatMembersCount(std::int64_t chatId) const {
     return sendRequest("getChatMembersCount", args).get<int32_t>("", 0);
 }
 
-bool Api::answerCallbackQuery(const string & callbackQueryId, const string & text, bool showAlert, const string &url, std::int32_t cacheTime) const {
+ChatMember::Ptr Api::getChatMember(std::int64_t chatId, std::int64_t userId) const {
+    vector<HttpReqArg> args;
+    args.reserve(2);
+    args.emplace_back("chat_id", chatId);
+    args.emplace_back("user_id", userId);
+    return _tgTypeParser.parseJsonAndGetChatMember(sendRequest("getChatMember", args));
+}
+
+bool Api::setChatStickerSet(std::int64_t chatId, const string& stickerSetName) const {
+    vector<HttpReqArg> args;
+    args.reserve(2);
+    args.emplace_back("chat_id", chatId);
+    args.emplace_back("sticker_set_name	", stickerSetName);
+    return sendRequest("setChatStickerSet", args).get<bool>("", false);
+}
+
+bool Api::deleteChatStickerSet(std::int64_t chatId) const {
+    vector<HttpReqArg> args;
+    args.reserve(1);
+    args.emplace_back("chat_id", chatId);
+    return sendRequest("deleteChatStickerSet", args).get<bool>("", false);
+}
+
+bool Api::answerCallbackQuery(const string& callbackQueryId, const string& text, bool showAlert, const string& url, std::int32_t cacheTime) const {
     vector<HttpReqArg> args;
     args.reserve(5);
     args.emplace_back("callback_query_id", callbackQueryId);
@@ -796,8 +845,22 @@ bool Api::answerCallbackQuery(const string & callbackQueryId, const string & tex
     return sendRequest("answerCallbackQuery", args).get<bool>("", false);
 }
 
+bool Api::setMyCommands(const std::vector<BotCommand::Ptr>& commands) const {
+    vector<HttpReqArg> args;
+    args.reserve(5);
+
+    string commandsJson = _tgTypeParser.parseArray<BotCommand>(&TgTypeParser::parseBotCommand, commands);
+    args.emplace_back("commands", commandsJson);
+
+    return sendRequest("setMyCommands", args).get<bool>("", false);
+}
+
+std::vector<BotCommand::Ptr> Api::getMyCommands() const {
+    return _tgTypeParser.parseJsonAndGetArray<BotCommand>(&TgTypeParser::parseJsonAndGetBotCommand, sendRequest("getMyCommands"));
+}
+
 Message::Ptr Api::editMessageText(const string& text, std::int64_t chatId, std::int32_t messageId, const string& inlineMessageId,
-    const string& parseMode, bool disableWebPagePreview, const GenericReply::Ptr replyMarkup) const {
+                                  const string& parseMode, bool disableWebPagePreview, const GenericReply::Ptr replyMarkup) const {
 
     vector<HttpReqArg> args;
     args.reserve(7);
@@ -830,7 +893,6 @@ Message::Ptr Api::editMessageText(const string& text, std::int64_t chatId, std::
 
 Message::Ptr Api::editMessageCaption(std::int64_t chatId, std::int32_t messageId, const string& caption,
                                      const string& inlineMessageId, const GenericReply::Ptr replyMarkup) const {
-
     vector<HttpReqArg> args;
     args.reserve(5);
     if (chatId) {
@@ -856,11 +918,12 @@ Message::Ptr Api::editMessageCaption(std::int64_t chatId, std::int32_t messageId
     }
 }
 
-Message::Ptr Api::editMessageReplyMarkup(std::int64_t chatId, std::int32_t messageId, const string& inlineMessageId,
-                                         const GenericReply::Ptr replyMarkup) const {
+Message::Ptr Api::editMessageMedia(InputMedia::Ptr media, std::int64_t chatId, std::int32_t messageId, const std::string& inlineMessageId,
+                                   GenericReply::Ptr replyMarkup) const {
 
     vector<HttpReqArg> args;
-    args.reserve(4);
+    args.reserve(5);
+    args.emplace_back("media", _tgTypeParser.parseInputMedia(media));
     if (chatId) {
         args.emplace_back("chat_id", chatId);
     }
@@ -873,7 +936,7 @@ Message::Ptr Api::editMessageReplyMarkup(std::int64_t chatId, std::int32_t messa
     if (replyMarkup) {
         args.emplace_back("reply_markup", _tgTypeParser.parseGenericReply(replyMarkup));
     }
-    ptree p = sendRequest("editMessageReplyMarkup", args);
+    ptree p = sendRequest("editMessageMedia", args);
     if (p.get_child_optional("message_id")) {
         return _tgTypeParser.parseJsonAndGetMessage(p);
     } else {
@@ -881,12 +944,11 @@ Message::Ptr Api::editMessageReplyMarkup(std::int64_t chatId, std::int32_t messa
     }
 }
 
-Message::Ptr Api::editMessageMedia(InputMedia::Ptr media, std::int64_t chatId, std::int32_t messageId, const std::string& inlineMessageId,
-                                  GenericReply::Ptr replyMarkup) const {
+Message::Ptr Api::editMessageReplyMarkup(std::int64_t chatId, std::int32_t messageId, const string& inlineMessageId,
+                                         const GenericReply::Ptr replyMarkup) const {
 
     vector<HttpReqArg> args;
-    args.reserve(5);
-    args.emplace_back("media", _tgTypeParser.parseInputMedia(media));
+    args.reserve(4);
     if (chatId) {
         args.emplace_back("chat_id", chatId);
     }
@@ -899,7 +961,7 @@ Message::Ptr Api::editMessageMedia(InputMedia::Ptr media, std::int64_t chatId, s
     if (replyMarkup) {
         args.emplace_back("reply_markup", _tgTypeParser.parseGenericReply(replyMarkup));
     }
-    ptree p = sendRequest("editMessageMedia", args);
+    ptree p = sendRequest("editMessageReplyMarkup", args);
     if (p.get_child_optional("message_id")) {
         return _tgTypeParser.parseJsonAndGetMessage(p);
     } else {
@@ -907,74 +969,159 @@ Message::Ptr Api::editMessageMedia(InputMedia::Ptr media, std::int64_t chatId, s
     }
 }
 
-ChatMember::Ptr Api::getChatMember(std::int64_t chatId, std::int64_t userId) const {
+Poll::Ptr Api::stopPoll(std::int64_t chatId, std::int64_t messageId, const InlineKeyboardMarkup::Ptr replyMarkup) const {
     vector<HttpReqArg> args;
-    args.reserve(2);
+    args.reserve(3);
     args.emplace_back("chat_id", chatId);
-    args.emplace_back("user_id", userId);
-    return _tgTypeParser.parseJsonAndGetChatMember(sendRequest("getChatMember", args));
+    args.emplace_back("message_id", messageId);
+    if (replyMarkup) {
+        args.emplace_back("reply_markup", _tgTypeParser.parseGenericReply(replyMarkup));
+    }
+    return _tgTypeParser.parseJsonAndGetPoll(sendRequest("stopPoll", args));
 }
 
-vector<Update::Ptr> Api::getUpdates(std::int32_t offset, std::int32_t limit, std::int32_t timeout, const StringArrayPtr &allowedUpdates) const {
+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, std::int32_t replyToMessageId, const GenericReply::Ptr replyMarkup, bool disableNotification) const {
     vector<HttpReqArg> args;
-    args.reserve(4);
-    if (offset) {
-        args.emplace_back("offset", offset);
+    args.reserve(5);
+    args.emplace_back("chat_id", chatId);
+    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));
     }
-    limit = max(1, min(100, limit));
-    args.emplace_back("limit", limit);
-    if (timeout) {
-        args.emplace_back("timeout", timeout);
+    if (replyToMessageId) {
+        args.emplace_back("reply_to_message_id", replyToMessageId);
     }
-    if (allowedUpdates != nullptr) {
-        string allowedUpdatesJson = _tgTypeParser.parseArray<string>(
-            [](const string &s)->string {
-            return s;
-        }, *allowedUpdates);
-        args.emplace_back("allowed_updates", allowedUpdatesJson);
+    if (replyMarkup) {
+        args.emplace_back("reply_markup", _tgTypeParser.parseGenericReply(replyMarkup));
     }
-    return _tgTypeParser.parseJsonAndGetArray<Update>(&TgTypeParser::parseJsonAndGetUpdate, sendRequest("getUpdates", args));
+    if (disableNotification) {
+        args.emplace_back("disable_notification", disableNotification);
+    }
+    return _tgTypeParser.parseJsonAndGetMessage(sendRequest("sendSticker", args));
 }
 
-void Api::setWebhook(const string& url, const InputFile::Ptr certificate, std::int32_t maxConnection, const StringArrayPtr &allowedUpdates) const {
+StickerSet::Ptr Api::getStickerSet(const string& name) const {
     vector<HttpReqArg> args;
-    args.reserve(4);
-    if (!url.empty()) {
-        args.emplace_back("url", url);
+    args.reserve(1);
+    args.emplace_back("name", name);
+    return _tgTypeParser.parseJsonAndGetStickerSet(sendRequest("getStickerSet", args));
+}
+
+File::Ptr Api::uploadStickerFile(std::int64_t userId, const InputFile::Ptr pngSticker) const {
+    vector<HttpReqArg> args;
+    args.reserve(2);
+    args.emplace_back("user_id", userId);
+    args.emplace_back("png_sticker", pngSticker->data, true, pngSticker->mimeType, pngSticker->fileName);
+    return _tgTypeParser.parseJsonAndGetFile(sendRequest("uploadStickerFile", args));
+}
+
+bool Api::createNewStickerSet(std::int64_t userId, const std::string& name, const std::string& title,
+                              const std::string& emojis, boost::variant<InputFile::Ptr, std::string> pngSticker, boost::variant<InputFile::Ptr, std::string> tgsSticker,
+                              bool containsMasks, MaskPosition::Ptr maskPosition) const {
+    vector<HttpReqArg> args;
+    args.reserve(8);
+
+    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 */) {
+        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));
     }
-    if (certificate != nullptr) {
-        args.emplace_back("certificate", certificate->data, true, certificate->mimeType, certificate->fileName);
+    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 (maxConnection != 40) {
-        args.emplace_back("max_connections", maxConnection);
+    if (containsMasks) {
+        args.emplace_back("contains_mask", containsMasks);
     }
-    if (allowedUpdates != nullptr) {
-        auto allowedUpdatesJson = _tgTypeParser.parseArray<string>(
-            [](const string &s)->string {
-                return s;
-            }, *allowedUpdates);
-        args.emplace_back("allowed_updates", allowedUpdatesJson);
+    if (maskPosition != nullptr) {
+        args.emplace_back("mask_position", _tgTypeParser.parseMaskPosition(maskPosition));
     }
 
-    sendRequest("setWebhook", args);
+    return sendRequest("createNewStickerSet", args).get<bool>("", false);
 }
 
-bool Api::deleteWebhook() const {
-    return sendRequest("deleteWebhook").get<bool>("", false);
+bool Api::createNewStickerSet(std::int64_t userId, const std::string& name, const std::string& title,
+                              boost::variant<InputFile::Ptr, std::string> pngSticker, const std::string& emojis, bool containsMasks,
+                              MaskPosition::Ptr maskPosition) const {
+
+    return createNewStickerSet(userId, name, title, emojis, pngSticker, "", containsMasks, maskPosition);
 }
 
-WebhookInfo::Ptr Api::getWebhookInfo() const {
-    ptree p = sendRequest("getWebhookInfo");
+bool Api::addStickerToSet(std::int64_t userId, const std::string& name, const std::string& emojis,
+                          boost::variant<InputFile::Ptr, std::string> pngSticker, boost::variant<InputFile::Ptr, std::string> tgsSticker, MaskPosition::Ptr maskPosition) const {
+    vector<HttpReqArg> args;
+    args.reserve(6);
 
-    if (!p.get_child_optional("url")) {
-        return nullptr;
+    args.emplace_back("user_id", userId);
+    args.emplace_back("name", name);
+    args.emplace_back("emojis", emojis);
+    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));
     }
-    if (p.get<string>("url","") != string("")) {
-        return _tgTypeParser.parseJsonAndGetWebhookInfo(p);
+    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));
     }
-    else {
-        return nullptr;
+    if (maskPosition != nullptr) {
+        args.emplace_back("mask_position", _tgTypeParser.parseMaskPosition(maskPosition));
     }
+
+    return sendRequest("addStickerToSet", args).get<bool>("", false);
+}
+
+bool Api::addStickerToSet(std::int64_t userId, const std::string& name, boost::variant<InputFile::Ptr, std::string> pngSticker,
+                          const std::string& emojis, MaskPosition::Ptr maskPosition) const {
+
+    return addStickerToSet(userId, name, emojis, pngSticker, "", maskPosition);
+}
+
+bool Api::setStickerPositionInSet(const string& sticker, std::uint32_t position) const {
+    vector<HttpReqArg> args;
+    args.reserve(2);
+    args.emplace_back("sticker", sticker);
+    args.emplace_back("position", position);
+    return sendRequest("setStickerPositionInSet", args).get<bool>("", false);
+}
+
+bool Api::deleteStickerFromSet(const string& sticker) const {
+    vector<HttpReqArg> args;
+    args.reserve(1);
+    args.emplace_back("sticker", sticker);
+    return sendRequest("deleteStickerFromSet", args).get<bool>("", false);
+}
+
+bool Api::setStickerSetThumb(const std::string& name, std::int64_t userId, boost::variant<InputFile::Ptr, std::string> thumb) const {
+    vector<HttpReqArg> args;
+    args.reserve(3);
+
+    args.emplace_back("name", name);
+    args.emplace_back("user_id", userId);
+    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 */ {
+        args.emplace_back("thumb", boost::get<std::string>(thumb));
+    }
+
+    return sendRequest("setStickerSetThumb", args).get<bool>("", false);
 }
 
 bool Api::answerInlineQuery(const string& inlineQueryId, const std::vector<InlineQueryResult::Ptr>& results,
@@ -1002,139 +1149,111 @@ bool Api::answerInlineQuery(const string& inlineQueryId, const std::vector<Inlin
     return sendRequest("answerInlineQuery", args).get<bool>("", false);
 }
 
-bool Api::kickChatMember(std::int64_t chatId, std::int64_t userId, std::uint64_t untilDate) const {
+Message::Ptr Api::sendInvoice(std::int64_t chatId, const std::string& title, const std::string& description, const std::string& payload,
+                              const std::string& providerToken, const std::string& startParameter, const std::string& currency, const std::vector<LabeledPrice::Ptr>& prices,
+                              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,
+                              std::int32_t replyToMessageId, const GenericReply::Ptr replyMarkup, bool disableNotification) const {
     vector<HttpReqArg> args;
-    args.reserve(3);
+    args.reserve(23);
     args.emplace_back("chat_id", chatId);
-    args.emplace_back("user_id", userId);
-    if (untilDate) {
-        args.emplace_back("until_date", untilDate);
+    args.emplace_back("title", title);
+    args.emplace_back("description", description);
+    args.emplace_back("payload", payload);
+    args.emplace_back("provider_token", providerToken);
+    args.emplace_back("start_parameter", startParameter);
+    args.emplace_back("currency", currency);
+    args.emplace_back("prices", _tgTypeParser.parseArray<LabeledPrice>(&TgTypeParser::parseLabeledPrice, prices));
+    if (!providerData.empty()) {
+        args.emplace_back("provider_data", providerData);
     }
-    return sendRequest("kickChatMember", args).get<bool>("", false);
-}
-
-bool Api::unbanChatMember(std::int64_t chatId, std::int64_t userId) const {
-    vector<HttpReqArg> args;
-    args.reserve(2);
-    args.emplace_back("chat_id", chatId);
-    args.emplace_back("user_id", userId);
-    return sendRequest("unbanChatMember", args).get<bool>("", false);
-}
-bool Api::restrictChatMember(std::int64_t chatId, std::int64_t userId, TgBot::ChatPermissions::Ptr permissions,
-                             std::uint64_t untilDate) const {
-    vector<HttpReqArg> args;
-    args.reserve(4);
-    args.emplace_back("chat_id", chatId);
-    args.emplace_back("user_id", userId);
-    args.emplace_back("permissions", _tgTypeParser.parseChatPermissions(permissions));
-    if (untilDate) {
-        args.emplace_back("until_date", untilDate);
+    if (!photoUrl.empty()) {
+        args.emplace_back("photo_url", photoUrl);
     }
-
-    return sendRequest("restrictChatMember", args).get<bool>("", false);
-}
-
-bool Api::promoteChatMember(std::int64_t chatId, std::int64_t userId, bool canChangeInfo, bool canPostMessages,
-                            bool canEditMessages, bool canDeleteMessages, bool canInviteUsers, bool canPinMessages, bool canPromoteMembers) const {
-    vector<HttpReqArg> args;
-    args.reserve(9);
-    args.emplace_back("chat_id", chatId);
-    args.emplace_back("user_id", userId);
-    if (canChangeInfo) {
-        args.emplace_back("can_change_info", canChangeInfo);
+    if (photoSize) {
+        args.emplace_back("photo_size", photoSize);
     }
-    if (canPostMessages) {
-        args.emplace_back("can_post_messages", canPostMessages);
+    if (photoWidth) {
+        args.emplace_back("photo_width", photoWidth);
     }
-    if (canEditMessages) {
-        args.emplace_back("can_edit_messages", canEditMessages);
+    if (photoHeight) {
+        args.emplace_back("photo_height", photoHeight);
     }
-    if (canDeleteMessages) {
-        args.emplace_back("can_delete_messages", canDeleteMessages);
+    if (needName) {
+        args.emplace_back("need_name", needName);
     }
-    if (canInviteUsers) {
-        args.emplace_back("can_invite_users", canInviteUsers);
+    if (needPhoneNumber) {
+        args.emplace_back("need_phone_number", needPhoneNumber);
     }
-    if (canPinMessages) {
-        args.emplace_back("can_pin_messages", canPinMessages);
+    if (needEmail) {
+        args.emplace_back("need_email", needEmail);
     }
-    if (canPromoteMembers) {
-        args.emplace_back("can_promote_members", canPromoteMembers);
+    if (needShippingAddress) {
+        args.emplace_back("need_shipping_address", needShippingAddress);
     }
-    return sendRequest("promoteChatMember", args).get<bool>("", false);
-}
-
-bool Api::setChatAdministratorCustomTitle(std::int64_t chatId, std::int64_t userId, const std::string& customTitle) const {
-    vector<HttpReqArg> args;
-    args.reserve(3);
-    args.emplace_back("chat_id", chatId);
-    args.emplace_back("user_id", userId);
-    args.emplace_back("custom_title", customTitle);
-    return sendRequest("setChatAdministratorCustomTitle", args).get<bool>("", false);
-}
-
-bool Api::setChatPermissions(std::int64_t chatId, ChatPermissions::Ptr permissions) const{
-    vector<HttpReqArg> args;
-    args.reserve(2);
-    args.emplace_back("chat_id", chatId);
-    args.emplace_back("permissions", _tgTypeParser.parseChatPermissions(permissions));
-    return sendRequest("setChatPermissions", args).get<bool>("", false);
-}
-
-string Api::exportChatInviteLink(std::int64_t chatId) const {
-    vector<HttpReqArg> args;
-    args.reserve(1);
-    args.emplace_back("chat_id", chatId);
-    return sendRequest("exportChatInviteLink", args).get("", "");
-}
-
-bool Api::setChatPhoto(std::int64_t chatId, const InputFile::Ptr photo) const {
-    vector<HttpReqArg> args;
-    args.reserve(2);
-    args.emplace_back("chat_id", chatId);
-    args.emplace_back("photo", photo->data, true, photo->mimeType, photo->fileName);
-    return sendRequest("setChatPhoto", args).get<bool>("", false);
-}
-
-bool Api::deleteChatPhoto(std::int64_t chatId) const {
-    vector<HttpReqArg> args;
-    args.reserve(1);
-    args.emplace_back("chat_id", chatId);
-    return sendRequest("deleteChatPhoto", args).get<bool>("", false);
+    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);
+    }
+    if (replyToMessageId) {
+        args.emplace_back("reply_to_message_id", replyToMessageId);
+    }
+    if (replyMarkup) {
+        args.emplace_back("reply_markup", _tgTypeParser.parseGenericReply(replyMarkup));
+    }
+    if (disableNotification) {
+        args.emplace_back("disable_notification", disableNotification);
+    }
+    return _tgTypeParser.parseJsonAndGetMessage(sendRequest("sendInvoice", args));
 }
 
-bool Api::setChatTitle(std::int64_t chatId, const string& title) const {
+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(2);
-    args.emplace_back("chat_id", chatId);
-    args.emplace_back("title", title);
-    return sendRequest("setChatTitle", args).get<bool>("", false);
+    args.reserve(4);
+    args.emplace_back("shipping_query_id", shippingQueryId);
+    args.emplace_back("ok", ok);
+    if (!shippingOptions.empty()) {
+        args.emplace_back("shipping_options", _tgTypeParser.parseArray<ShippingOption>(&TgTypeParser::parseShippingOption, shippingOptions));
+    }
+    if (!errorMessage.empty()) {
+        args.emplace_back("error_message", errorMessage);
+    }
+    return sendRequest("answerShippingQuery", args).get<bool>("", false);
 }
 
-bool Api::setChatDescription(std::int64_t chatId, const string& description) const {
+bool Api::answerPreCheckoutQuery(const std::string& preCheckoutQueryId, bool ok, const std::string& errorMessage) const {
     vector<HttpReqArg> args;
-    args.reserve(2);
-    args.emplace_back("chat_id", chatId);
-    args.emplace_back("description", description);
-    return sendRequest("setChatDescription", args).get<bool>("", false);
+    args.reserve(3);
+    args.emplace_back("pre_checkout_query_id", preCheckoutQueryId);
+    args.emplace_back("ok", ok);
+    if (!errorMessage.empty()) {
+        args.emplace_back("error_message", errorMessage);
+    }
+    return sendRequest("answerPreCheckoutQuery", args).get<bool>("", false);
 }
 
-bool Api::pinChatMessage(std::int64_t chatId, std::int32_t messageId, bool disableNotification) const {
+Message::Ptr Api::sendGame(std::int64_t chatId, const std::string& gameShortName, std::int32_t replyToMessageId, const InlineKeyboardMarkup::Ptr replyMarkup, bool disableNotification) const {
     vector<HttpReqArg> args;
-    args.reserve(3);
+    args.reserve(5);
     args.emplace_back("chat_id", chatId);
-    args.emplace_back("message_id", messageId);
+    args.emplace_back("game_short_name", gameShortName);
+    if (replyToMessageId) {
+        args.emplace_back("reply_to_message_id", replyToMessageId);
+    }
+    if (replyMarkup) {
+        args.emplace_back("reply_markup", _tgTypeParser.parseGenericReply(replyMarkup));
+    }
     if (disableNotification) {
         args.emplace_back("disable_notification", disableNotification);
     }
-    return sendRequest("pinChatMessage", args).get<bool>("", false);
-}
-
-bool Api::unpinChatMessage(std::int64_t chatId) const {
-    vector<HttpReqArg> args;
-    args.reserve(1);
-    args.emplace_back("chat_id", chatId);
-    return sendRequest("unpinChatMessage", args).get<bool>("", false);
+    return _tgTypeParser.parseJsonAndGetMessage(sendRequest("sendGame", args));
 }
 
 Message::Ptr Api::setGameScore(std::int64_t userId, std::int32_t score, bool force, bool disableEditMessage, std::int64_t chatId, std::int32_t messageId, const std::string& inlineMessageId) const {
@@ -1148,13 +1267,13 @@ Message::Ptr Api::setGameScore(std::int64_t userId, std::int32_t score, bool for
     if (disableEditMessage) {
         args.emplace_back("disable_edit_message", disableEditMessage);
     }
-    if (chatId){
+    if (chatId) {
         args.emplace_back("chat_id", chatId);
     }
-    if (messageId){
+    if (messageId) {
         args.emplace_back("message_id", messageId);
     }
-    if (!inlineMessageId.empty()){
+    if (!inlineMessageId.empty()) {
         args.emplace_back("inline_message_id", inlineMessageId);
     }
     return _tgTypeParser.parseJsonAndGetMessage(sendRequest("setGameScore", args));
@@ -1177,98 +1296,12 @@ vector<GameHighScore::Ptr> Api::getGameHighScores(std::int64_t userId, std::int3
     if (messageId) {
         args.emplace_back("message_id", messageId);
     }
-    if (!inlineMessageId.empty()){
+    if (!inlineMessageId.empty()) {
         args.emplace_back("inline_message_id", inlineMessageId);
     }
     return _tgTypeParser.parseJsonAndGetArray<GameHighScore>(&TgTypeParser::parseJsonAndGetGameHighScore, sendRequest("getGameHighScores", args));
 }
 
-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::sendPoll(std::int64_t chatId, const std::string& question, const std::vector<std::string>& options, bool disableNotification, std::int32_t replyToMessageId, 
-                           const GenericReply::Ptr replyMarkup, bool isAnonymous, const std::string& type, bool allowsMultipleAnswers,
-                           std::int32_t correctOptionId, bool isClosed) const {
-    vector<HttpReqArg> args;
-    args.reserve(11);
-    args.emplace_back("chat_id", chatId);
-    args.emplace_back("question", question);
-    args.emplace_back("options", _tgTypeParser.parseArray<std::string>([] (const std::string& option) -> std::string {
-        return StringTools::urlEncode(option);
-    }, options));
-
-    if (!isAnonymous) {
-        args.emplace_back("is_anonymous", isAnonymous);
-    }
-    if (!type.empty()) {
-        args.emplace_back("type", type);
-    }
-    if (allowsMultipleAnswers) {
-        args.emplace_back("allows_multiple_answers", allowsMultipleAnswers);
-    }
-    if (correctOptionId != 0) {
-        args.emplace_back("correct_option_id", correctOptionId);
-    }
-    if (isClosed) {
-        args.emplace_back("is_closed", isClosed);
-    }
-    if (disableNotification) {
-        args.emplace_back("disable_notification", disableNotification);
-    }
-    if (replyToMessageId != 0) {
-        args.emplace_back("reply_to_message_id", replyToMessageId);
-    }
-    if (replyMarkup) {
-        args.emplace_back("reply_markup", _tgTypeParser.parseGenericReply(replyMarkup));
-    }
-
-    return _tgTypeParser.parseJsonAndGetMessage(sendRequest("sendPoll", args));
-}
-
-Message::Ptr Api::sendDice(std::int64_t chatId, bool disableNotification, std::int32_t replyToMessageId, GenericReply::Ptr replyMarkup) const {
-    vector<HttpReqArg> args;
-    args.reserve(4);
-    args.emplace_back("chat_id", chatId);
-
-    if (disableNotification) {
-        args.emplace_back("disable_notification", disableNotification);
-    }
-    if (replyToMessageId != 0) {
-        args.emplace_back("reply_to_message_id", replyToMessageId);
-    }
-    if (replyMarkup) {
-        args.emplace_back("reply_markup", _tgTypeParser.parseGenericReply(replyMarkup));
-    }
-
-    return _tgTypeParser.parseJsonAndGetMessage(sendRequest("sendDice", args));
-}
-
-Poll::Ptr Api::stopPoll(std::int64_t chatId, std::int64_t messageId, const InlineKeyboardMarkup::Ptr replyMarkup) const {
-    vector<HttpReqArg> args;
-    args.reserve(3);
-    args.emplace_back("chat_id", chatId);
-    args.emplace_back("message_id", messageId);
-    if (replyMarkup){
-        args.emplace_back("reply_markup", _tgTypeParser.parseGenericReply(replyMarkup));
-    }
-    return _tgTypeParser.parseJsonAndGetPoll(sendRequest("stopPoll", args));
-}
-
-bool Api::setMyCommands(const std::vector<BotCommand::Ptr>& commands) const {
-    vector<HttpReqArg> args;
-    args.reserve(5);
-
-    string commandsJson = _tgTypeParser.parseArray<BotCommand>(&TgTypeParser::parseBotCommand, commands);
-    args.emplace_back("commands", commandsJson);
-
-    return sendRequest("setMyCommands",args).get<bool>("",false);
-}
-
-std::vector<BotCommand::Ptr> Api::getMyCommands() const {
-    return _tgTypeParser.parseJsonAndGetArray<BotCommand>(&TgTypeParser::parseJsonAndGetBotCommand, sendRequest("getMyCommands"));
-}
-
 ptree Api::sendRequest(const string& method, const vector<HttpReqArg>& args) const {
     string url(_url);
     url += "/bot";
@@ -1292,19 +1325,4 @@ ptree Api::sendRequest(const string& method, const vector<HttpReqArg>& args) con
         throw TgException("tgbot-cpp library can't parse json response. " + string(e.what()));
     }
 }
-
-string Api::downloadFile(const string& filePath, const std::vector<HttpReqArg>& args) const {
-    string url(_url);
-    url += "/file/bot";
-    url += _token;
-    url += "/";
-    url += filePath;
-
-    string serverResponse = _httpClient.makeRequest(url, args);
-
-    return serverResponse;
-}
-
-
-
 }
diff --git a/src/TgTypeParser.cpp b/src/TgTypeParser.cpp
index 37dafb6..daa6184 100644
--- a/src/TgTypeParser.cpp
+++ b/src/TgTypeParser.cpp
@@ -10,8 +10,8 @@ namespace TgBot {
 
 Chat::Ptr TgTypeParser::parseJsonAndGetChat(const ptree& data) const {
     auto result(make_shared<Chat>());
-    result->id = data.get<int64_t>("id");
-    string type = data.get<string>("type");
+    result->id = data.get<int64_t>("id", 0);
+    string type = data.get<string>("type", "");
     if (type == "private") {
         result->type = Chat::Type::Private;
     } else if (type == "group") {
@@ -21,20 +21,18 @@ Chat::Ptr TgTypeParser::parseJsonAndGetChat(const ptree& data) const {
     } else if (type == "channel") {
         result->type = Chat::Type::Channel;
     }
-    result->title = data.get("title", "");
-    result->username = data.get("username", "");
-    result->firstName = data.get("first_name", "");
-    result->lastName = data.get("last_name", "");
-    result->allMembersAreAdministrators = data.get<bool>("all_members_are_administrators", false);
+    result->title = data.get<string>("title", "");
+    result->username = data.get<string>("username", "");
+    result->firstName = data.get<string>("first_name", "");
+    result->lastName = data.get<string>("last_name", "");
     result->photo = tryParseJson<ChatPhoto>(&TgTypeParser::parseJsonAndGetChatPhoto, data, "photo");
-    result->description = data.get("description", "");
-    result->inviteLink = data.get("invite_link", "");
+    result->description = data.get<string>("description", "");
+    result->inviteLink = data.get<string>("invite_link", "");
     result->pinnedMessage = tryParseJson<Message>(&TgTypeParser::parseJsonAndGetMessage, data, "pinned_message");
     result->permissions = tryParseJson<ChatPermissions>(&TgTypeParser::parseJsonAndGetChatPermissions, data, "permissions");
-    result->slowModeDelay = data.get<int32_t>("slow_mode_delay");
-    result->stickerSetName = data.get("sticker_set_name", "");
+    result->slowModeDelay = data.get<int32_t>("slow_mode_delay", 0);
+    result->stickerSetName = data.get<string>("sticker_set_name", "");
     result->canSetStickerSet = data.get<bool>("can_set_sticker_set", false);
-
     return result;
 }
 
@@ -58,7 +56,6 @@ string TgTypeParser::parseChat(const Chat::Ptr& object) const {
     appendToJson(result, "username", object->username);
     appendToJson(result, "first_name", object->firstName);
     appendToJson(result, "last_name", object->lastName);
-    appendToJson(result, "all_members_are_administrators", object->allMembersAreAdministrators);
     appendToJson(result, "photo", parseChatPhoto(object->photo));
     appendToJson(result, "description", object->description);
     appendToJson(result, "invite_link", object->inviteLink);
@@ -74,12 +71,12 @@ string TgTypeParser::parseChat(const Chat::Ptr& object) const {
 
 User::Ptr TgTypeParser::parseJsonAndGetUser(const ptree& data) const {
     auto result(make_shared<User>());
-    result->id = data.get<int64_t>("id");
+    result->id = data.get<int64_t>("id", 0);
     result->isBot = data.get<bool>("is_bot", false);
-    result->firstName = data.get<string>("first_name");
-    result->lastName = data.get("last_name", "");
-    result->username = data.get("username", "");
-    result->languageCode = data.get("language_code", "");
+    result->firstName = data.get<string>("first_name", "");
+    result->lastName = data.get<string>("last_name", "");
+    result->username = data.get<string>("username", "");
+    result->languageCode = data.get<string>("language_code", "");
     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);
@@ -108,9 +105,9 @@ string TgTypeParser::parseUser(const User::Ptr& object) const {
 
 MessageEntity::Ptr TgTypeParser::parseJsonAndGetMessageEntity(const ptree& data) const{
     auto result(make_shared<MessageEntity>());
-    result->type = data.get<string>("type");
-    result->offset = data.get<int32_t>("offset");
-    result->length = data.get<int32_t>("length");
+    result->type = data.get<string>("type", "");
+    result->offset = data.get<int32_t>("offset", 0);
+    result->length = data.get<int32_t>("length", 0);
     result->url = data.get<string>("url", "");
     result->user = tryParseJson<User>(&TgTypeParser::parseJsonAndGetUser, data, "user");
     result->language = data.get<string>("language", "");
@@ -136,21 +133,22 @@ string TgTypeParser::parseMessageEntity(const MessageEntity::Ptr& object) const
 
 Message::Ptr TgTypeParser::parseJsonAndGetMessage(const ptree& data) const {
     auto result(make_shared<Message>());
-    result->messageId = data.get<int32_t>("message_id");
+    result->messageId = data.get<int32_t>("message_id", 0);
     result->from = tryParseJson<User>(&TgTypeParser::parseJsonAndGetUser, data, "from");
-    result->date = data.get<int32_t>("date");
+    result->date = data.get<int32_t>("date", 0);
     result->chat = parseJsonAndGetChat(data.find("chat")->second);
     result->forwardFrom = tryParseJson<User>(&TgTypeParser::parseJsonAndGetUser, data, "forward_from");
     result->forwardFromChat = tryParseJson<Chat>(&TgTypeParser::parseJsonAndGetChat, data, "forward_from_chat");
     result->forwardFromMessageId = data.get<int32_t>("forward_from_message_id", 0);
-    result->forwardSignature = data.get("forward_signature", "");
-    result->forwardSenderName = data.get("forward_sender_name", "");
-    result->forwardDate = data.get("forward_date", 0);
+    result->forwardSignature = data.get<string>("forward_signature", "");
+    result->forwardSenderName = data.get<string>("forward_sender_name", "");
+    result->forwardDate = data.get<int32_t>("forward_date", 0);
     result->replyToMessage = tryParseJson<Message>(&TgTypeParser::parseJsonAndGetMessage, data, "reply_to_message");
+    result->viaBot = tryParseJson<User>(&TgTypeParser::parseJsonAndGetUser, data, "via_bot");
     result->editDate = data.get<int32_t>("edit_date", 0);
-    result->mediaGroupId = data.get("media_group_id", "");
-    result->authorSignature = data.get("author_signature", "");
-    result->text = data.get("text", "");
+    result->mediaGroupId = data.get<string>("media_group_id", "");
+    result->authorSignature = data.get<string>("author_signature", "");
+    result->text = data.get<string>("text", "");
     result->entities = parseJsonAndGetArray<MessageEntity>(&TgTypeParser::parseJsonAndGetMessageEntity, data, "entities");
     result->captionEntities = parseJsonAndGetArray<MessageEntity>(&TgTypeParser::parseJsonAndGetMessageEntity, data, "caption_entities");
     result->audio = tryParseJson<Audio>(&TgTypeParser::parseJsonAndGetAudio, data, "audio");
@@ -162,31 +160,29 @@ Message::Ptr TgTypeParser::parseJsonAndGetMessage(const ptree& data) const {
     result->video = tryParseJson<Video>(&TgTypeParser::parseJsonAndGetVideo, data, "video");
     result->voice = tryParseJson<Voice>(&TgTypeParser::parseJsonAndGetVoice, data, "voice");
     result->videoNote = tryParseJson<VideoNote>(&TgTypeParser::parseJsonAndGetVideoNote, data, "video_note");
-    result->caption = data.get("caption", "");
+    result->caption = data.get<string>("caption", "");
     result->contact = tryParseJson<Contact>(&TgTypeParser::parseJsonAndGetContact, data, "contact");
     result->location = tryParseJson<Location>(&TgTypeParser::parseJsonAndGetLocation, data, "location");
     result->venue = tryParseJson<Venue>(&TgTypeParser::parseJsonAndGetVenue, data, "venue");
     result->poll = tryParseJson<Poll>(&TgTypeParser::parseJsonAndGetPoll, data, "poll");
     result->dice = tryParseJson<Dice>(&TgTypeParser::parseJsonAndGetDice, data, "dice");
-    result->newChatMember = tryParseJson<User>(&TgTypeParser::parseJsonAndGetUser, data, "new_chat_member");
     result->newChatMembers = parseJsonAndGetArray<User>(&TgTypeParser::parseJsonAndGetUser, data, "new_chat_members");
     result->leftChatMember = tryParseJson<User>(&TgTypeParser::parseJsonAndGetUser, data, "left_chat_member");
-    result->newChatTitle = data.get("new_chat_title", "");
+    result->newChatTitle = data.get<string>("new_chat_title", "");
     result->newChatPhoto = parseJsonAndGetArray<PhotoSize>(&TgTypeParser::parseJsonAndGetPhotoSize, data, "new_chat_photo");
-    result->deleteChatPhoto = data.get("delete_chat_photo", false);
-    result->groupChatCreated = data.get("group_chat_created", false);
-    result->supergroupChatCreated = data.get("supergroup_chat_created", false);
-    result->channelChatCreated = data.get("channel_chat_created", false);
+    result->deleteChatPhoto = data.get<bool>("delete_chat_photo", false);
+    result->groupChatCreated = data.get<bool>("group_chat_created", false);
+    result->supergroupChatCreated = data.get<bool>("supergroup_chat_created", false);
+    result->channelChatCreated = data.get<bool>("channel_chat_created", false);
     result->migrateToChatId = data.get<int64_t>("migrate_to_chat_id", 0);
     result->migrateFromChatId = data.get<int64_t>("migrate_from_chat_id", 0);
     result->pinnedMessage = tryParseJson<Message>(&TgTypeParser::parseJsonAndGetMessage, data, "pinned_message");
     result->invoice = tryParseJson<Invoice>(&TgTypeParser::parseJsonAndGetInvoice, data, "invoice");
     result->successfulPayment = tryParseJson<SuccessfulPayment>(&TgTypeParser::parseJsonAndGetSuccessfulPayment, data, "successful_payment");
-    result->connectedWebsite = data.get("connected_website", "");
+    result->connectedWebsite = data.get<string>("connected_website", "");
     // result->passportData = tryParseJson<PassportData>(&TgTypeParser::parseJsonAndGetPassportData, data, "passport_data");
     result->replyMarkup = tryParseJson<InlineKeyboardMarkup>(&TgTypeParser::parseJsonAndGetInlineKeyboardMarkup, data, "reply_markup");
-    result->automaticForward = data.get("is_automatic_forward", false);
-    
+    result->automaticForward = data.get<bool>("is_automatic_forward", false);
     return result;
 }
 
@@ -207,6 +203,7 @@ string TgTypeParser::parseMessage(const Message::Ptr& object) const {
     appendToJson(result, "forward_sender_name", object->forwardSenderName);
     appendToJson(result, "forward_date", object->forwardDate);
     appendToJson(result, "reply_to_message", parseMessage(object->replyToMessage));
+    appendToJson(result, "via_bot", parseUser(object->viaBot));
     appendToJson(result, "edit_date", object->editDate);
     appendToJson(result, "media_group_id", object->mediaGroupId);
     appendToJson(result, "author_signature", object->authorSignature);
@@ -228,7 +225,6 @@ string TgTypeParser::parseMessage(const Message::Ptr& object) const {
     appendToJson(result, "venue", parseVenue(object->venue));
     appendToJson(result, "poll", parsePoll(object->poll));
     appendToJson(result, "dice", parseDice(object->dice));
-    appendToJson(result, "new_chat_member", parseUser(object->newChatMember));
     appendToJson(result, "new_chat_members", parseArray(&TgTypeParser::parseUser, object->newChatMembers));
     appendToJson(result, "left_chat_member", parseUser(object->leftChatMember));
     appendToJson(result, "new_chat_title", object->newChatTitle);
@@ -245,6 +241,7 @@ string TgTypeParser::parseMessage(const Message::Ptr& object) const {
     appendToJson(result, "connected_website", object->connectedWebsite);
     // appendToJson(result, "passport_data", parsePassportData(object->passportData));
     appendToJson(result, "reply_markup", parseInlineKeyboardMarkup(object->replyMarkup));
+    appendToJson(result, "is_automatic_forward", object->automaticForward);
     removeLastComma(result);
     result += '}';
     return result;
@@ -252,11 +249,11 @@ string TgTypeParser::parseMessage(const Message::Ptr& object) const {
 
 PhotoSize::Ptr TgTypeParser::parseJsonAndGetPhotoSize(const ptree& data) const {
     auto result(make_shared<PhotoSize>());
-    result->fileId = data.get<string>("file_id");
-    result->fileUniqueId = data.get<string>("file_unique_id");
-    result->width = data.get<int32_t>("width");
-    result->height = data.get<int32_t>("height");
-    result->fileSize = data.get("file_size", 0);
+    result->fileId = data.get<string>("file_id", "");
+    result->fileUniqueId = data.get<string>("file_unique_id", "");
+    result->width = data.get<int32_t>("width", 0);
+    result->height = data.get<int32_t>("height", 0);
+    result->fileSize = data.get<int32_t>("file_size", 0);
     return result;
 }
 
@@ -278,13 +275,13 @@ string TgTypeParser::parsePhotoSize(const PhotoSize::Ptr& object) const {
 
 Audio::Ptr TgTypeParser::parseJsonAndGetAudio(const ptree& data) const {
     auto result(make_shared<Audio>());
-    result->fileId = data.get<string>("file_id");
-    result->fileUniqueId = data.get<string>("file_unique_id");
-    result->duration = data.get<int32_t>("duration");
+    result->fileId = data.get<string>("file_id", "");
+    result->fileUniqueId = data.get<string>("file_unique_id", "");
+    result->duration = data.get<int32_t>("duration", 0);
     result->performer = data.get<string>("performer", "");
     result->title = data.get<string>("title", "");
-    result->mimeType = data.get("mime_type", "");
-    result->fileSize = data.get("file_size", 0);
+    result->mimeType = data.get<string>("mime_type", "");
+    result->fileSize = data.get<int32_t>("file_size", 0);
     result->thumb = tryParseJson<PhotoSize>(&TgTypeParser::parseJsonAndGetPhotoSize, data, "thumb");
     return result;
 }
@@ -310,12 +307,12 @@ string TgTypeParser::parseAudio(const Audio::Ptr& object) const {
 
 Document::Ptr TgTypeParser::parseJsonAndGetDocument(const ptree& data) const {
     auto result(make_shared<Document>());
-    result->fileId = data.get<string>("file_id");
-    result->fileUniqueId = data.get<string>("file_unique_id");
+    result->fileId = data.get<string>("file_id", "");
+    result->fileUniqueId = data.get<string>("file_unique_id", "");
     result->thumb = tryParseJson<PhotoSize>(&TgTypeParser::parseJsonAndGetPhotoSize, data, "thumb");
-    result->fileName = data.get("file_name", "");
-    result->mimeType = data.get("mime_type", "");
-    result->fileSize = data.get("file_size", 0);
+    result->fileName = data.get<string>("file_name", "");
+    result->mimeType = data.get<string>("mime_type", "");
+    result->fileSize = data.get<int32_t>("file_size", 0);
     return result;
 }
 
@@ -338,16 +335,16 @@ string TgTypeParser::parseDocument(const Document::Ptr& object) const {
 
 Sticker::Ptr TgTypeParser::parseJsonAndGetSticker(const ptree& data) const {
     auto result(make_shared<Sticker>());
-    result->fileId = data.get<string>("file_id");
-    result->fileUniqueId = data.get<string>("file_unique_id");
-    result->width = data.get<int32_t>("width");
-    result->height = data.get<int32_t>("height");
+    result->fileId = data.get<string>("file_id", "");
+    result->fileUniqueId = data.get<string>("file_unique_id", "");
+    result->width = data.get<int32_t>("width", 0);
+    result->height = data.get<int32_t>("height", 0);
     result->isAnimated = data.get<bool>("is_animated", false);
     result->thumb = tryParseJson<PhotoSize>(&TgTypeParser::parseJsonAndGetPhotoSize, data, "thumb");
-    result->emoji = data.get("emoji", "");
-    result->setName = data.get("set_name", "");
+    result->emoji = data.get<string>("emoji", "");
+    result->setName = data.get<string>("set_name", "");
     result->maskPosition = tryParseJson<MaskPosition>(&TgTypeParser::parseJsonAndGetMaskPosition, data, "mask_position");
-    result->fileSize = data.get("file_size", 0);
+    result->fileSize = data.get<int32_t>("file_size", 0);
     return result;
 }
 
@@ -374,8 +371,8 @@ string TgTypeParser::parseSticker(const Sticker::Ptr& object) const {
 
 StickerSet::Ptr TgTypeParser::parseJsonAndGetStickerSet(const ptree& data) const {
     auto result(make_shared<StickerSet>());
-    result->name = data.get("name", "");
-    result->title = data.get("title", "");
+    result->name = data.get<string>("name", "");
+    result->title = data.get<string>("title", "");
     result->isAnimated = data.get<bool>("is_animated", false);
     result->containsMasks = data.get<bool>("contains_masks", false);
     result->stickers = parseJsonAndGetArray<Sticker>(&TgTypeParser::parseJsonAndGetSticker, data, "stickers");
@@ -426,15 +423,19 @@ string TgTypeParser::parseMaskPosition(const MaskPosition::Ptr& object) const {
 
 Poll::Ptr TgTypeParser::parseJsonAndGetPoll(const ptree& data) const {
     auto result(make_shared<Poll>());
-    result->id = data.get("id", 0);
-    result->question = data.get("question", "");
+    result->id = data.get<string>("id", "");
+    result->question = data.get<string>("question", "");
     result->options = parseJsonAndGetArray<PollOption>(&TgTypeParser::parseJsonAndGetPollOption, data, "options");
-    result->totalVoterCount = data.get("total_voter_count", 0);
-    result->isClosed = data.get<bool>("is_closed");
-    result->isAnonymous = data.get<bool>("is_anonymous");
-    result->type = data.get("type", "");
-    result->allowsMultipleAnswers = data.get<bool>("allows_multiple_answers");
-    result->correctOptionId = data.get("correct_option_id", 0);
+    result->totalVoterCount = data.get<int32_t>("total_voter_count", 0);
+    result->isClosed = data.get<bool>("is_closed", false);
+    result->isAnonymous = data.get<bool>("is_anonymous", true);
+    result->type = data.get<string>("type", "");
+    result->allowsMultipleAnswers = data.get<bool>("allows_multiple_answers", false);
+    result->correctOptionId = data.get<int32_t>("correct_option_id", 0);
+    result->explanation = data.get<string>("explanation", "");
+    result->explanationEntities = parseJsonAndGetArray<MessageEntity>(&TgTypeParser::parseJsonAndGetMessageEntity, data, "explanation_entities");
+    result->openPeriod = data.get<int32_t>("open_period", 0);
+    result->closeDate = data.get<int64_t>("close_date", 0);
     return result;
 }
 
@@ -453,6 +454,10 @@ string TgTypeParser::parsePoll(const Poll::Ptr& object) const {
     appendToJson(result, "type", object->type);
     appendToJson(result, "allows_multiple_answers", object->allowsMultipleAnswers);
     appendToJson(result, "correct_option_id", object->correctOptionId);
+    appendToJson(result, "explanation", object->correctOptionId);
+    appendToJson(result, "explanation_entities", parseArray(&TgTypeParser::parseMessageEntity, object->explanationEntities));
+    appendToJson(result, "open_period", object->openPeriod);
+    appendToJson(result, "close_date", object->closeDate);
     removeLastComma(result);
     result += '}';
     return result;
@@ -460,7 +465,8 @@ string TgTypeParser::parsePoll(const Poll::Ptr& object) const {
 
 Dice::Ptr TgTypeParser::parseJsonAndGetDice(const ptree& data) const {
     auto result(make_shared<Dice>());
-    result->value = data.get("value", 0);
+    result->emoji = data.get<string>("emoji", "");
+    result->value = data.get<int8_t>("value", 0);
     return result;
 }
 
@@ -470,6 +476,7 @@ string TgTypeParser::parseDice(const Dice::Ptr& object) const {
     }
     string result;
     result += '{';
+    appendToJson(result, "emoji", object->emoji);
     appendToJson(result, "value", object->value);
     removeLastComma(result);
     result += '}';
@@ -478,12 +485,11 @@ string TgTypeParser::parseDice(const Dice::Ptr& object) const {
 
 PollAnswer::Ptr TgTypeParser::parseJsonAndGetPollAnswer(const ptree& data) const {
     auto result(make_shared<PollAnswer>());
-    result->pollId = data.get("poll_id", "");
+    result->pollId = data.get<string>("poll_id", "");
     result->user = tryParseJson<User>(&TgTypeParser::parseJsonAndGetUser, data, "user");
     result->optionIds = parseJsonAndGetArray<std::int32_t>([] (const ptree& innerData)->std::int32_t {
         return innerData.get<std::int32_t>(0);
     }, data, "option_ids");
-
     return result;
 }
 
@@ -557,14 +563,14 @@ string TgTypeParser::parseChatPermissions(const ChatPermissions::Ptr& object) co
 
 Video::Ptr TgTypeParser::parseJsonAndGetVideo(const ptree& data) const {
     auto result(make_shared<Video>());
-    result->fileId = data.get<string>("file_id");
-    result->fileUniqueId = data.get<string>("file_unique_id");
-    result->width = data.get<int32_t>("width");
-    result->height = data.get<int32_t>("height");
-    result->duration = data.get<int32_t>("duration");
+    result->fileId = data.get<string>("file_id", "");
+    result->fileUniqueId = data.get<string>("file_unique_id", "");
+    result->width = data.get<int32_t>("width", 0);
+    result->height = data.get<int32_t>("height", 0);
+    result->duration = data.get<int32_t>("duration", 0);
     result->thumb = tryParseJson<PhotoSize>(&TgTypeParser::parseJsonAndGetPhotoSize, data, "thumb");
-    result->mimeType = data.get("mime_type", "");
-    result->fileSize = data.get("file_size", 0);
+    result->mimeType = data.get<string>("mime_type", "");
+    result->fileSize = data.get<int32_t>("file_size", 0);
     return result;
 }
 
@@ -589,11 +595,11 @@ string TgTypeParser::parseVideo(const Video::Ptr& object) const {
 
 Voice::Ptr TgTypeParser::parseJsonAndGetVoice(const ptree& data) const {
     auto result(make_shared<Voice>());
-    result->fileId = data.get<string>("file_id");
-    result->fileUniqueId = data.get<string>("file_unique_id");
-    result->duration = data.get<int32_t>("duration");
-    result->mimeType = data.get("mime_type", "");
-    result->fileSize = data.get("file_size", 0);
+    result->fileId = data.get<string>("file_id", "");
+    result->fileUniqueId = data.get<string>("file_unique_id", "");
+    result->duration = data.get<int32_t>("duration", 0);
+    result->mimeType = data.get<string>("mime_type", "");
+    result->fileSize = data.get<int32_t>("file_size", 0);
     return result;
 }
 
@@ -615,10 +621,10 @@ string TgTypeParser::parseVoice(const Voice::Ptr& object) const {
 
 VideoNote::Ptr TgTypeParser::parseJsonAndGetVideoNote(const ptree& data) const {
     auto result(make_shared<VideoNote>());
-    result->fileId = data.get<string>("file_id");
-    result->fileUniqueId = data.get<string>("file_unique_id");
-    result->length = data.get<int32_t>("length");
-    result->duration = data.get<int32_t>("duration");
+    result->fileId = data.get<string>("file_id", "");
+    result->fileUniqueId = data.get<string>("file_unique_id", "");
+    result->length = data.get<int32_t>("length", 0);
+    result->duration = data.get<int32_t>("duration", 0);
     result->thumb = tryParseJson<PhotoSize>(&TgTypeParser::parseJsonAndGetPhotoSize, data, "thumb");
     result->fileSize = data.get("file_size", 0);
     return result;
@@ -636,8 +642,8 @@ string TgTypeParser::parseVideoNote(const VideoNote::Ptr& object) const {
     appendToJson(result, "duration", object->duration);
     appendToJson(result, "thumb", parsePhotoSize(object->thumb));
     appendToJson(result, "file_size", object->fileSize);
+    removeLastComma(result);
     result += '}';
-    result.erase();
     return result;
 }
 
@@ -693,14 +699,14 @@ string TgTypeParser::parseGameHighScore(const GameHighScore::Ptr& object) const
 
 Animation::Ptr TgTypeParser::parseJsonAndGetAnimation(const ptree& data) const {
     auto result(make_shared<Animation>());
-    result->fileId = data.get("file_id", "");
-    result->fileUniqueId = data.get("file_unique_id", "");
+    result->fileId = data.get<string>("file_id", "");
+    result->fileUniqueId = data.get<string>("file_unique_id", "");
     result->width = data.get<int32_t>("width", 0);
     result->height = data.get<int32_t>("height", 0);
     result->duration = data.get<int32_t>("duration", 0);
     result->thumb = tryParseJson<PhotoSize>(&TgTypeParser::parseJsonAndGetPhotoSize, data, "thumb");
-    result->fileName = data.get("file_name", "");
-    result->mimeType = data.get("mime_type", "");
+    result->fileName = data.get<string>("file_name", "");
+    result->mimeType = data.get<string>("mime_type", "");
     result->fileSize = data.get<int32_t>("file_size", 0);
     return result;
 }
@@ -778,7 +784,6 @@ Venue::Ptr TgTypeParser::parseJsonAndGetVenue(const ptree& data) const {
     result->address = data.get<string>("address", "");
     result->foursquareId = data.get<string>("foursquare_id", "");
     result->foursquareType = data.get<string>("foursquare_type", "");
-
     return result;
 }
 
@@ -800,7 +805,7 @@ string TgTypeParser::parseVenue(const Venue::Ptr& object) const {
 
 Update::Ptr TgTypeParser::parseJsonAndGetUpdate(const ptree& data) const {
     auto result(make_shared<Update>());
-    result->updateId = data.get<int32_t>("update_id");
+    result->updateId = data.get<int32_t>("update_id", 0);
     result->message = tryParseJson<Message>(&TgTypeParser::parseJsonAndGetMessage, data, "message");
     result->editedMessage = tryParseJson<Message>(&TgTypeParser::parseJsonAndGetMessage, data, "edited_message");
     result->channelPost = tryParseJson<Message>(&TgTypeParser::parseJsonAndGetMessage, data, "channel_post");
@@ -961,10 +966,10 @@ string TgTypeParser::parseInputMedia(const InputMedia::Ptr& object) const {
     return result;
 }
 
-File::Ptr TgTypeParser::parseJsonAndGetFile(const boost::property_tree::ptree& data) const {
+File::Ptr TgTypeParser::parseJsonAndGetFile(const ptree& data) const {
     auto result(make_shared<File>());
-    result->fileId = data.get<string>("file_id");
-    result->fileUniqueId = data.get<string>("file_unique_id");
+    result->fileId = data.get<string>("file_id", "");
+    result->fileUniqueId = data.get<string>("file_unique_id", "");
     result->fileSize = data.get<int32_t>("file_size", 0);
     result->filePath = data.get<string>("file_path", "");
     return result;
@@ -1023,17 +1028,16 @@ std::string TgTypeParser::parseReplyKeyboardMarkup(const ReplyKeyboardMarkup::Pt
     return result;
 }
 
-KeyboardButton::Ptr TgTypeParser::parseJsonAndGetKeyboardButton(const boost::property_tree::ptree& data) const {
+KeyboardButton::Ptr TgTypeParser::parseJsonAndGetKeyboardButton(const ptree& data) const {
     auto result(make_shared<KeyboardButton>());
-    result->text = data.get<string>("text");
+    result->text = data.get<string>("text", "");
     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");
-
     return result;
 }
 
-std::string TgTypeParser::parseKeyboardButton(const KeyboardButton::Ptr& object) const {
+string TgTypeParser::parseKeyboardButton(const KeyboardButton::Ptr& object) const {
     if (!object) {
         return "";
     }
@@ -1050,7 +1054,7 @@ std::string TgTypeParser::parseKeyboardButton(const KeyboardButton::Ptr& object)
 
 KeyboardButtonPollType::Ptr TgTypeParser::parseJsonAndGetKeyboardButtonPollType(const ptree& data) const {
     auto result(make_shared<KeyboardButtonPollType>());
-    result->type = data.get<string>("type");
+    result->type = data.get<string>("type", "");
     return result;
 }
 
@@ -1104,11 +1108,11 @@ std::string TgTypeParser::parseForceReply(const ForceReply::Ptr& object) const {
     return result;
 }
 
-ChatMember::Ptr TgTypeParser::parseJsonAndGetChatMember(const boost::property_tree::ptree& data) const {
+ChatMember::Ptr TgTypeParser::parseJsonAndGetChatMember(const ptree& data) const {
     auto result(make_shared<ChatMember>());
     result->user = tryParseJson<User>(&TgTypeParser::parseJsonAndGetUser, data, "user");
-    result->status = data.get("status", "");
-    result->customTitle = data.get("custom_title", "");
+    result->status = data.get<string>("status", "");
+    result->customTitle = data.get<string>("custom_title", "");
     result->untilDate = data.get<uint64_t>("until_date", 0);
     result->canBeEdited = data.get<bool>("can_be_edited", false);
     result->canPostMessages = data.get<bool>("can_post_messages", false);
@@ -1128,7 +1132,7 @@ ChatMember::Ptr TgTypeParser::parseJsonAndGetChatMember(const boost::property_tr
     return result;
 }
 
-std::string TgTypeParser::parseChatMember(const ChatMember::Ptr& object) const {
+string TgTypeParser::parseChatMember(const ChatMember::Ptr& object) const {
     if (!object) {
         return "";
     }
@@ -1158,16 +1162,16 @@ std::string TgTypeParser::parseChatMember(const ChatMember::Ptr& object) const {
     return result;
 }
 
-ChatPhoto::Ptr TgTypeParser::parseJsonAndGetChatPhoto(const boost::property_tree::ptree& data) const {
+ChatPhoto::Ptr TgTypeParser::parseJsonAndGetChatPhoto(const ptree& data) const {
     auto result(make_shared<ChatPhoto>());
-    result->smallFileId = data.get("small_file_id", "");
-    result->smallFileUniqueId = data.get("small_file_unique_id", "");
-    result->bigFileId = data.get("big_file_id", "");
-    result->bigFileUniqueId = data.get("big_file_unique_id", "");
+    result->smallFileId = data.get<string>("small_file_id", "");
+    result->smallFileUniqueId = data.get<string>("small_file_unique_id", "");
+    result->bigFileId = data.get<string>("big_file_id", "");
+    result->bigFileUniqueId = data.get<string>("big_file_unique_id", "");
     return result;
 }
 
-std::string TgTypeParser::parseChatPhoto(const ChatPhoto::Ptr& object) const {
+string TgTypeParser::parseChatPhoto(const ChatPhoto::Ptr& object) const {
     if (!object) {
         return "";
     }
@@ -1258,8 +1262,8 @@ std::string TgTypeParser::parseInlineQuery(const InlineQuery::Ptr& object) const
     return result;
 }
 
-InlineQueryResult::Ptr TgTypeParser::parseJsonAndGetInlineQueryResult(const boost::property_tree::ptree& data) const {
-    string type = data.get<string>("type");
+InlineQueryResult::Ptr TgTypeParser::parseJsonAndGetInlineQueryResult(const ptree& data) const {
+    string type = data.get<string>("type", "");
     InlineQueryResult::Ptr result;
 
     if (type == InlineQueryResultCachedAudio::TYPE) {
@@ -1306,26 +1310,27 @@ InlineQueryResult::Ptr TgTypeParser::parseJsonAndGetInlineQueryResult(const boos
         result = make_shared<InlineQueryResult>();
     }
 
-    result->id = data.get<string>("id");
+    result->id = data.get<string>("id", "");
     result->title = data.get<string>("title", "");
     result->caption = data.get<string>("caption", "");
+    result->parseMode = data.get<string>("parse_mode", "");
     result->replyMarkup = tryParseJson<InlineKeyboardMarkup>(&TgTypeParser::parseJsonAndGetInlineKeyboardMarkup, data, "reply_markup");
     result->inputMessageContent = tryParseJson<InputMessageContent>(&TgTypeParser::parseJsonAndGetInputMessageContent, data, "input_message_content");
 
     return result;
 }
 
-std::string TgTypeParser::parseInlineQueryResult(const InlineQueryResult::Ptr& object) const {
+string TgTypeParser::parseInlineQueryResult(const InlineQueryResult::Ptr& object) const {
     if (!object){
         return "";
     }
-
     string result;
     result += '{';
     appendToJson(result, "id", object->id);
     appendToJson(result, "type", object->type);
     appendToJson(result, "title", object->title);
     appendToJson(result, "caption", object->caption);
+    appendToJson(result, "parse_mode", object->parseMode);
     appendToJson(result, "reply_markup", parseInlineKeyboardMarkup(object->replyMarkup));
     appendToJson(result, "input_message_content", parseInputMessageContent(object->inputMessageContent));
 
@@ -1396,7 +1401,7 @@ std::string TgTypeParser::parseInlineQueryResult(const InlineQueryResult::Ptr& o
 }
 
 InlineQueryResultCachedAudio::Ptr TgTypeParser::parseJsonAndGetInlineQueryResultCachedAudio(const boost::property_tree::ptree& data) const {
-    // NOTE: This function will be called by parseJsonAndGgetInlineQueryResult().
+    // NOTE: This function will be called by parseJsonAndGetInlineQueryResult().
     auto result(make_shared<InlineQueryResultCachedAudio>());
     result->audioFileId = data.get<string>("audio_file_id");
     return result;
@@ -1415,7 +1420,7 @@ std::string TgTypeParser::parseInlineQueryResultCachedAudio(const InlineQueryRes
 }
 
 InlineQueryResultCachedDocument::Ptr TgTypeParser::parseJsonAndGetInlineQueryResultCachedDocument(const boost::property_tree::ptree& data) const {
-    // NOTE: This function will be called by parseJsonAndGgetInlineQueryResult().
+    // NOTE: This function will be called by parseJsonAndGetInlineQueryResult().
     auto result(make_shared<InlineQueryResultCachedDocument>());
     result->documentFileId = data.get<string>("document_file_id");
     result->description = data.get<string>("description", "");
@@ -1437,7 +1442,7 @@ std::string TgTypeParser::parseInlineQueryResultCachedDocument(const InlineQuery
 
 
 InlineQueryResultCachedGif::Ptr TgTypeParser::parseJsonAndGetInlineQueryResultCachedGif(const boost::property_tree::ptree& data) const {
-    // NOTE: This function will be called by parseJsonAndGgetInlineQueryResult().
+    // NOTE: This function will be called by parseJsonAndGetInlineQueryResult().
     auto result(make_shared<InlineQueryResultCachedGif>());
     result->gifFileId = data.get<string>("gif_file_id");
     return result;
@@ -1457,7 +1462,7 @@ std::string TgTypeParser::parseInlineQueryResultCachedGif(const InlineQueryResul
 
 
 InlineQueryResultCachedMpeg4Gif::Ptr TgTypeParser::parseJsonAndGetInlineQueryResultCachedMpeg4Gif(const boost::property_tree::ptree& data) const {
-    // NOTE: This function will be called by parseJsonAndGgetInlineQueryResult().
+    // NOTE: This function will be called by parseJsonAndGetInlineQueryResult().
     auto result(make_shared<InlineQueryResultCachedMpeg4Gif>());
     result->mpeg4FileId = data.get<string>("mpeg4_file_id");
     return result;
@@ -1477,7 +1482,7 @@ std::string TgTypeParser::parseInlineQueryResultCachedMpeg4Gif(const InlineQuery
 
 
 InlineQueryResultCachedPhoto::Ptr TgTypeParser::parseJsonAndGetInlineQueryResultCachedPhoto(const boost::property_tree::ptree& data) const {
-    // NOTE: This function will be called by parseJsonAndGgetInlineQueryResult().
+    // NOTE: This function will be called by parseJsonAndGetInlineQueryResult().
     auto result(make_shared<InlineQueryResultCachedPhoto>());
     result->photoFileId = data.get<string>("photo_file_id");
     result->description = data.get<string>("description", "");
@@ -1499,7 +1504,7 @@ std::string TgTypeParser::parseInlineQueryResultCachedPhoto(const InlineQueryRes
 
 
 InlineQueryResultCachedSticker::Ptr TgTypeParser::parseJsonAndGetInlineQueryResultCachedSticker(const boost::property_tree::ptree& data) const {
-    // NOTE: This function will be called by parseJsonAndGgetInlineQueryResult().
+    // NOTE: This function will be called by parseJsonAndGetInlineQueryResult().
     auto result(make_shared<InlineQueryResultCachedSticker>());
     result->stickerFileId = data.get<string>("sticker_file_id");
     return result;
@@ -1518,7 +1523,7 @@ std::string TgTypeParser::parseInlineQueryResultCachedSticker(const InlineQueryR
 }
 
 InlineQueryResultCachedVideo::Ptr TgTypeParser::parseJsonAndGetInlineQueryResultCachedVideo(const boost::property_tree::ptree& data) const {
-    // NOTE: This function will be called by parseJsonAndGgetInlineQueryResult().
+    // NOTE: This function will be called by parseJsonAndGetInlineQueryResult().
     auto result(make_shared<InlineQueryResultCachedVideo>());
     result->videoFileId = data.get<string>("video_file_id");
     result->description = data.get<string>("description", "");
@@ -1540,7 +1545,7 @@ std::string TgTypeParser::parseInlineQueryResultCachedVideo(const InlineQueryRes
 
 
 InlineQueryResultCachedVoice::Ptr TgTypeParser::parseJsonAndGetInlineQueryResultCachedVoice(const boost::property_tree::ptree& data) const {
-    // NOTE: This function will be called by parseJsonAndGgetInlineQueryResult().
+    // NOTE: This function will be called by parseJsonAndGetInlineQueryResult().
     auto result(make_shared<InlineQueryResultCachedVoice>());
     result->voiceFileId = data.get<string>("voice_file_id");
     return result;
@@ -1559,7 +1564,7 @@ std::string TgTypeParser::parseInlineQueryResultCachedVoice(const InlineQueryRes
 }
 
 InlineQueryResultArticle::Ptr TgTypeParser::parseJsonAndGetInlineQueryResultArticle(const boost::property_tree::ptree& data) const {
-    // NOTE: This function will be called by parseJsonAndGgetInlineQueryResult().
+    // NOTE: This function will be called by parseJsonAndGetInlineQueryResult().
     auto result(make_shared<InlineQueryResultArticle>());
     result->url = data.get<string>("url", "");
     result->hideUrl = data.get("hide_url", false);
@@ -1588,7 +1593,7 @@ std::string TgTypeParser::parseInlineQueryResultArticle(const InlineQueryResultA
 }
 
 InlineQueryResultAudio::Ptr TgTypeParser::parseJsonAndGetInlineQueryResultAudio(const boost::property_tree::ptree& data) const {
-    // NOTE: This function will be called by parseJsonAndGgetInlineQueryResult().
+    // NOTE: This function will be called by parseJsonAndGetInlineQueryResult().
     auto result(make_shared<InlineQueryResultAudio>());
     result->audioUrl = data.get<string>("audio_url");
     result->performer = data.get<string>("performer", "");
@@ -1612,7 +1617,7 @@ std::string TgTypeParser::parseInlineQueryResultAudio(const InlineQueryResultAud
 
 
 InlineQueryResultContact::Ptr TgTypeParser::parseJsonAndGetInlineQueryResultContact(const boost::property_tree::ptree& data) const {
-    // NOTE: This function will be called by parseJsonAndGgetInlineQueryResult().
+    // NOTE: This function will be called by parseJsonAndGetInlineQueryResult().
     auto result(make_shared<InlineQueryResultContact>());
     result->phoneNumber = data.get<string>("phone_number");
     result->firstName = data.get<string>("first_name");
@@ -1644,7 +1649,7 @@ std::string TgTypeParser::parseInlineQueryResultContact(const InlineQueryResultC
 
 
 InlineQueryResultGame::Ptr TgTypeParser::parseJsonAndGetInlineQueryResultGame(const boost::property_tree::ptree& data) const {
-    // NOTE: This function will be called by parseJsonAndGgetInlineQueryResult().
+    // NOTE: This function will be called by parseJsonAndGetInlineQueryResult().
     auto result(make_shared<InlineQueryResultGame>());
     result->gameShortName = data.get<string>("game_short_name");
     return result;
@@ -1663,7 +1668,7 @@ std::string TgTypeParser::parseInlineQueryResultGame(const InlineQueryResultGame
 }
 
 InlineQueryResultDocument::Ptr TgTypeParser::parseJsonAndGetInlineQueryResultDocument(const boost::property_tree::ptree& data) const {
-    // NOTE: This function will be called by parseJsonAndGgetInlineQueryResult().
+    // NOTE: This function will be called by parseJsonAndGetInlineQueryResult().
     auto result(make_shared<InlineQueryResultDocument>());
     result->documentUrl = data.get<string>("document_url");
     result->mimeType = data.get<string>("mime_type");
@@ -1692,7 +1697,7 @@ std::string TgTypeParser::parseInlineQueryResultDocument(const InlineQueryResult
 }
 
 InlineQueryResultLocation::Ptr TgTypeParser::parseJsonAndGetInlineQueryResultLocation(const boost::property_tree::ptree& data) const {
-    // NOTE: This function will be called by parseJsonAndGgetInlineQueryResult().
+    // NOTE: This function will be called by parseJsonAndGetInlineQueryResult().
     auto result(make_shared<InlineQueryResultLocation>());
     result->latitude = data.get<float>("latitude");
     result->longitude = data.get<float>("longitude");
@@ -1720,7 +1725,7 @@ std::string TgTypeParser::parseInlineQueryResultLocation(const InlineQueryResult
 
 
 InlineQueryResultVenue::Ptr TgTypeParser::parseJsonAndGetInlineQueryResultVenue(const boost::property_tree::ptree& data) const {
-    // NOTE: This function will be called by parseJsonAndGgetInlineQueryResult().
+    // NOTE: This function will be called by parseJsonAndGetInlineQueryResult().
     auto result(make_shared<InlineQueryResultVenue>());
     result->latitude = data.get<float>("latitude");
     result->longitude = data.get<float>("longitude");
@@ -1753,7 +1758,7 @@ std::string TgTypeParser::parseInlineQueryResultVenue(const InlineQueryResultVen
 }
 
 InlineQueryResultVoice::Ptr TgTypeParser::parseJsonAndGetInlineQueryResultVoice(const boost::property_tree::ptree& data) const {
-    // NOTE: This function will be called by parseJsonAndGgetInlineQueryResult().
+    // NOTE: This function will be called by parseJsonAndGetInlineQueryResult().
     auto result(make_shared<InlineQueryResultVoice>());
     result->voiceUrl = data.get<string>("voice_url");
     result->voiceDuration = data.get<int32_t>("voice_duration", 0);
@@ -1774,7 +1779,7 @@ std::string TgTypeParser::parseInlineQueryResultVoice(const InlineQueryResultVoi
 }
 
 InlineQueryResultPhoto::Ptr TgTypeParser::parseJsonAndGetInlineQueryResultPhoto(const boost::property_tree::ptree& data) const {
-    // NOTE: This function will be called by parseJsonAndGgetInlineQueryResult().
+    // NOTE: This function will be called by parseJsonAndGetInlineQueryResult().
     auto result(make_shared<InlineQueryResultPhoto>());
     result->photoUrl = data.get<string>("photo_url", "");
     result->thumbUrl = data.get<string>("thumb_url");
@@ -1800,17 +1805,19 @@ std::string TgTypeParser::parseInlineQueryResultPhoto(const InlineQueryResultPho
     return result;
 }
 
-InlineQueryResultGif::Ptr TgTypeParser::parseJsonAndGetInlineQueryResultGif(const boost::property_tree::ptree& data) const {
-    // NOTE: This function will be called by parseJsonAndGgetInlineQueryResult().
+InlineQueryResultGif::Ptr TgTypeParser::parseJsonAndGetInlineQueryResultGif(const ptree& data) const {
+    // NOTE: This function will be called by parseJsonAndGetInlineQueryResult().
     auto result(make_shared<InlineQueryResultGif>());
     result->gifUrl = data.get<string>("gif_url", "");
-    result->gifWidth = data.get("gif_width", 0);
-    result->gifHeight = data.get("gif_height", 0);
-    result->gifDuration = data.get("gif_duration", 0);
-    result->thumbUrl = data.get<string>("thumb_url");
+    result->gifWidth = data.get<int32_t>("gif_width", 0);
+    result->gifHeight = data.get<int32_t>("gif_height", 0);
+    result->gifDuration = data.get<int32_t>("gif_duration", 0);
+    result->thumbUrl = data.get<string>("thumb_url", "");
+    result->thumbMimeType = data.get<string>("thumb_mime_type", "");
     return result;
 }
-std::string TgTypeParser::parseInlineQueryResultGif(const InlineQueryResultGif::Ptr& object) const {
+
+string TgTypeParser::parseInlineQueryResultGif(const InlineQueryResultGif::Ptr& object) const {
     if (!object){
         return "";
     }
@@ -1822,18 +1829,20 @@ std::string TgTypeParser::parseInlineQueryResultGif(const InlineQueryResultGif::
     appendToJson(result, "gif_height", object->gifHeight);
     appendToJson(result, "gif_duration", object->gifDuration);
     appendToJson(result, "thumb_url", object->thumbUrl);
+    appendToJson(result, "thumb_mime_type", object->thumbMimeType);
     // The last comma will be erased by parseInlineQueryResult().
     return result;
 }
 
-InlineQueryResultMpeg4Gif::Ptr TgTypeParser::parseJsonAndGetInlineQueryResultMpeg4Gif(const boost::property_tree::ptree& data) const {
-    // NOTE: This function will be called by parseJsonAndGgetInlineQueryResult().
+InlineQueryResultMpeg4Gif::Ptr TgTypeParser::parseJsonAndGetInlineQueryResultMpeg4Gif(const ptree& data) const {
+    // NOTE: This function will be called by parseJsonAndGetInlineQueryResult().
     auto result(make_shared<InlineQueryResultMpeg4Gif>());
-    result->mpeg4Url = data.get<string>("mpeg4_url");
-    result->mpeg4Width = data.get("mpeg4_width", 0);
-    result->mpeg4Height = data.get("mpeg4_height", 0);
-    result->mpeg4Duration = data.get("mpeg4_duration", 0);
-    result->thumbUrl = data.get<string>("thumb_url");
+    result->mpeg4Url = data.get<string>("mpeg4_url", "");
+    result->mpeg4Width = data.get<int32_t>("mpeg4_width", 0);
+    result->mpeg4Height = data.get<int32_t>("mpeg4_height", 0);
+    result->mpeg4Duration = data.get<int32_t>("mpeg4_duration", 0);
+    result->thumbUrl = data.get<string>("thumb_url", "");
+    result->thumbMimeType = data.get<string>("thumb_mime_type", "");
     return result;
 }
 
@@ -1849,12 +1858,13 @@ std::string TgTypeParser::parseInlineQueryResultMpeg4Gif(const InlineQueryResult
     appendToJson(result, "mpeg4_height", object->mpeg4Height);
     appendToJson(result, "mpeg4_duration", object->mpeg4Duration);
     appendToJson(result, "thumb_url", object->thumbUrl);
+    appendToJson(result, "thumb_mime_type", object->thumbMimeType);
     // The last comma will be erased by parseInlineQueryResult().
     return result;
 }
 
 InlineQueryResultVideo::Ptr TgTypeParser::parseJsonAndGetInlineQueryResultVideo(const boost::property_tree::ptree& data) const {
-    // NOTE: This function will be called by parseJsonAndGgetInlineQueryResult().
+    // NOTE: This function will be called by parseJsonAndGetInlineQueryResult().
     auto result(make_shared<InlineQueryResultVideo>());
     result->videoUrl = data.get<string>("video_url");
     result->mimeType = data.get<string>("mime_type");