neogram 9.3.0

package/src/Bot.js

@@ -0,0 +1,4419 @@
+import axios from 'axios';
+import FormData from 'form-data';
+import { User } from './types/User.js';
+
+const API_ROOT = 'https://api.telegram.org';
+
+function serialize(obj) {
+  if (obj === null || obj === undefined) {
+    return undefined;
+  }
+  if (typeof obj === 'string' || typeof obj === 'number' || typeof obj === 'boolean') {
+    return obj;
+  }
+  if (Array.isArray(obj)) {
+    const serialized = obj.map(item => {
+      if (item && typeof item === 'object' && typeof item.toJSON === 'function') {
+        return item.toJSON();
+      }
+      return item;
+    });
+    return JSON.stringify(serialized);
+  }
+  if (typeof obj === 'object' && typeof obj.toJSON === 'function') {
+    try {
+      return JSON.stringify(obj.toJSON());
+    } catch (_e) {
+      // Fallback to regular serialization if toJSON fails
+      return JSON.stringify(obj);
+    }
+  }
+  if (typeof obj === 'object') {
+    return JSON.stringify(obj);
+  }
+  return obj;
+}
+
+export class Bot {
+  constructor(token, options = {}) {
+    if (!token || typeof token !== 'string') {
+      throw new Error('Bot token is required and must be a string');
+    }
+
+    const { timeout = 60_000 } = options;
+
+    this.token = token;
+    this.timeout = timeout;
+    this.http = axios.create({
+      baseURL: `${API_ROOT}/bot${token}/`,
+      timeout,
+    });
+  }
+
+  async _request(method, params = {}, files = null) {
+    let res;
+    if (files && Object.keys(files).length > 0) {
+      const form = new FormData();
+      for (const [k, v] of Object.entries(params)) {
+        if (v !== null && v !== undefined) {
+          // Better handling of different value types
+          if (typeof v === 'object') {
+            form.append(k, JSON.stringify(v));
+          } else {
+            form.append(k, String(v));
+          }
+        }
+      }
+      for (const [k, v] of Object.entries(files)) {
+        form.append(k, v);
+      }
+      res = await this.http.post(method, form, { headers: form.getHeaders() });
+    } else {
+      res = await this.http.post(method, params);
+    }
+    const data = res.data;
+    if (!data.ok) {
+      const err = new Error(`Error ${data.error_code || 'Unknown'}: ${data.description || 'No description'}`);
+      err.error_code = data.error_code;
+      err.description = data.description;
+      throw err;
+    }
+    return data.result;
+  }
+
+  // === Core API (порт основных методов Bot из Python-версии) ===
+
+  async getUpdates({ offset, limit, timeout, allowed_updates } = {}) {
+    const params = {
+      offset,
+      limit,
+      timeout,
+      allowed_updates: allowed_updates ? JSON.stringify(allowed_updates) : undefined,
+    };
+    const clean = Object.fromEntries(Object.entries(params).filter(([_, v]) => v !== undefined && v !== null));
+    const result = await this._request('getUpdates', clean);
+    return Array.isArray(result) ? result : [];
+  }
+
+  async setWebhook({ url, certificate, ip_address, max_connections, allowed_updates, drop_pending_updates, secret_token } = {}) {
+    if (!url) {
+      throw new Error('url required');
+    }
+    const params = {
+      url,
+      ip_address,
+      max_connections,
+      allowed_updates: serialize(allowed_updates),
+      drop_pending_updates,
+      secret_token,
+    };
+    const clean = Object.fromEntries(Object.entries(params).filter(([_, v]) => v !== undefined && v !== null));
+    const files = {};
+    if (certificate) {
+      files.certificate = certificate;
+    }
+    const result = await this._request('setWebhook', clean, files);
+    return !!result;
+  }
+
+  async deleteWebhook({ drop_pending_updates } = {}) {
+    const params = { drop_pending_updates };
+    const clean = Object.fromEntries(Object.entries(params).filter(([_, v]) => v !== undefined && v !== null));
+    const result = await this._request('deleteWebhook', clean);
+    return !!result;
+  }
+
+  async getWebhookInfo() {
+    const result = await this._request('getWebhookInfo', {});
+    return result; // можно обернуть в WebhookInfo.fromJSON позже
+  }
+
+  async getMe() {
+    const result = await this._request('getMe', {});
+    return User.fromJSON(result);
+  }
+
+  async sendMessage(options = {}) {
+    const {
+      chat_id,
+      text,
+      business_connection_id,
+      message_thread_id,
+      direct_messages_topic_id,
+      parse_mode,
+      entities,
+      link_preview_options,
+      disable_notification,
+      protect_content,
+      allow_paid_broadcast,
+      message_effect_id,
+      suggested_post_parameters,
+      reply_parameters,
+      reply_markup,
+    } = options;
+    if (chat_id === undefined || chat_id === null) {
+      throw new Error('chat_id required');
+    }
+    if (text === undefined || text === null) {
+      throw new Error('text required');
+    }
+    const params = {
+      chat_id: serialize(chat_id),
+      text,
+      business_connection_id,
+      message_thread_id,
+      direct_messages_topic_id,
+      parse_mode,
+      entities: serialize(entities),
+      link_preview_options: serialize(link_preview_options),
+      disable_notification,
+      protect_content,
+      allow_paid_broadcast,
+      message_effect_id,
+      suggested_post_parameters: serialize(suggested_post_parameters),
+      reply_parameters: serialize(reply_parameters),
+      reply_markup: serialize(reply_markup),
+    };
+    const clean = Object.fromEntries(Object.entries(params).filter(([_, v]) => v !== undefined && v !== null));
+    const result = await this._request('sendMessage', clean);
+    return result; // Message.fromJSON можно добавить позже
+  }
+
+  async deleteMessage({ chat_id, message_id } = {}) {
+    if (chat_id === undefined || chat_id === null) {
+      throw new Error('chat_id required');
+    }
+    if (message_id === undefined || message_id === null) {
+      throw new Error('message_id required');
+    }
+    const params = { chat_id: serialize(chat_id), message_id };
+    const result = await this._request('deleteMessage', params);
+    return !!result;
+  }
+
+  // Пример ещё одного метода — sendPhoto (остальные можно перенести по той же схеме)
+  async sendPhoto(options = {}) {
+    const {
+      chat_id,
+      photo,
+      business_connection_id,
+      message_thread_id,
+      direct_messages_topic_id,
+      caption,
+      parse_mode,
+      caption_entities,
+      show_caption_above_media,
+      has_spoiler,
+      disable_notification,
+      protect_content,
+      allow_paid_broadcast,
+      message_effect_id,
+      suggested_post_parameters,
+      reply_parameters,
+      reply_markup,
+    } = options;
+    if (chat_id === undefined || chat_id === null) {
+      throw new Error('chat_id required');
+    }
+    if (!photo) {
+      throw new Error('photo required');
+    }
+    const params = {
+      chat_id: serialize(chat_id),
+      business_connection_id,
+      message_thread_id,
+      direct_messages_topic_id,
+      caption,
+      parse_mode,
+      caption_entities: serialize(caption_entities),
+      show_caption_above_media,
+      has_spoiler,
+      disable_notification,
+      protect_content,
+      allow_paid_broadcast,
+      message_effect_id,
+      suggested_post_parameters: serialize(suggested_post_parameters),
+      reply_parameters: serialize(reply_parameters),
+      reply_markup: serialize(reply_markup),
+    };
+    const clean = Object.fromEntries(Object.entries(params).filter(([_, v]) => v !== undefined && v !== null));
+    const files = {};
+    if (photo instanceof Buffer || (photo && typeof photo.pipe === 'function')) {
+      files.photo = photo;
+    } else {
+      clean.photo = photo;
+    }
+    const result = await this._request('sendPhoto', clean, files);
+    return result;
+  }
+
+  async logOut() {
+    const result = await this._request('logOut', {});
+    return !!result;
+  }
+
+  async close() {
+    const result = await this._request('close', {});
+    return !!result;
+  }
+
+  async forwardMessage(options = {}) {
+    const {
+      chat_id,
+      from_chat_id,
+      message_id,
+      message_thread_id,
+      direct_messages_topic_id,
+      video_start_timestamp,
+      disable_notification,
+      protect_content,
+      message_effect_id,
+      suggested_post_parameters,
+    } = options;
+    if (chat_id === undefined || chat_id === null) {
+      throw new Error('chat_id required');
+    }
+    if (from_chat_id === undefined || from_chat_id === null) {
+      throw new Error('from_chat_id required');
+    }
+    if (message_id === undefined || message_id === null) {
+      throw new Error('message_id required');
+    }
+    const params = {
+      chat_id: serialize(chat_id),
+      from_chat_id: serialize(from_chat_id),
+      message_id,
+      message_thread_id,
+      direct_messages_topic_id,
+      video_start_timestamp,
+      disable_notification,
+      protect_content,
+      message_effect_id,
+      suggested_post_parameters: serialize(suggested_post_parameters),
+    };
+    const clean = Object.fromEntries(Object.entries(params).filter(([_, v]) => v !== undefined && v !== null));
+    const result = await this._request('forwardMessage', clean);
+    return result;
+  }
+
+  async forwardMessages(options = {}) {
+    const {
+      chat_id,
+      from_chat_id,
+      message_ids,
+      message_thread_id,
+      direct_messages_topic_id,
+      disable_notification,
+      protect_content,
+    } = options;
+    if (chat_id === undefined || chat_id === null) {
+      throw new Error('chat_id required');
+    }
+    if (from_chat_id === undefined || from_chat_id === null) {
+      throw new Error('from_chat_id required');
+    }
+    if (!message_ids) {
+      throw new Error('message_ids required');
+    }
+    const params = {
+      chat_id: serialize(chat_id),
+      from_chat_id: serialize(from_chat_id),
+      message_ids: serialize(message_ids),
+      message_thread_id,
+      direct_messages_topic_id,
+      disable_notification,
+      protect_content,
+    };
+    const clean = Object.fromEntries(Object.entries(params).filter(([_, v]) => v !== undefined && v !== null));
+    const result = await this._request('forwardMessages', clean);
+    return result;
+  }
+
+  async copyMessage(options = {}) {
+    const {
+      chat_id,
+      from_chat_id,
+      message_id,
+      message_thread_id,
+      direct_messages_topic_id,
+      video_start_timestamp,
+      caption,
+      parse_mode,
+      caption_entities,
+      show_caption_above_media,
+      disable_notification,
+      protect_content,
+      allow_paid_broadcast,
+      message_effect_id,
+      suggested_post_parameters,
+      reply_parameters,
+      reply_markup,
+    } = options;
+    if (chat_id === undefined || chat_id === null) {
+      throw new Error('chat_id required');
+    }
+    if (from_chat_id === undefined || from_chat_id === null) {
+      throw new Error('from_chat_id required');
+    }
+    if (message_id === undefined || message_id === null) {
+      throw new Error('message_id required');
+    }
+    const params = {
+      chat_id: serialize(chat_id),
+      from_chat_id: serialize(from_chat_id),
+      message_id,
+      message_thread_id,
+      direct_messages_topic_id,
+      video_start_timestamp,
+      caption,
+      parse_mode,
+      caption_entities: serialize(caption_entities),
+      show_caption_above_media,
+      disable_notification,
+      protect_content,
+      allow_paid_broadcast,
+      message_effect_id,
+      suggested_post_parameters: serialize(suggested_post_parameters),
+      reply_parameters: serialize(reply_parameters),
+      reply_markup: serialize(reply_markup),
+    };
+    const clean = Object.fromEntries(Object.entries(params).filter(([_, v]) => v !== undefined && v !== null));
+    const result = await this._request('copyMessage', clean);
+    return result;
+  }
+
+  async copyMessages(options = {}) {
+    const {
+      chat_id,
+      from_chat_id,
+      message_ids,
+      message_thread_id,
+      direct_messages_topic_id,
+      disable_notification,
+      protect_content,
+      remove_caption,
+    } = options;
+    if (chat_id === undefined || chat_id === null) {
+      throw new Error('chat_id required');
+    }
+    if (from_chat_id === undefined || from_chat_id === null) {
+      throw new Error('from_chat_id required');
+    }
+    if (!message_ids) {
+      throw new Error('message_ids required');
+    }
+    const params = {
+      chat_id: serialize(chat_id),
+      from_chat_id: serialize(from_chat_id),
+      message_ids: serialize(message_ids),
+      message_thread_id,
+      direct_messages_topic_id,
+      disable_notification,
+      protect_content,
+      remove_caption,
+    };
+    const clean = Object.fromEntries(Object.entries(params).filter(([_, v]) => v !== undefined && v !== null));
+    const result = await this._request('copyMessages', clean);
+    return result;
+  }
+
+  async sendAudio(options = {}) {
+    const {
+      chat_id,
+      audio,
+      business_connection_id,
+      message_thread_id,
+      direct_messages_topic_id,
+      caption,
+      parse_mode,
+      caption_entities,
+      duration,
+      performer,
+      title,
+      thumbnail,
+      disable_notification,
+      protect_content,
+      allow_paid_broadcast,
+      message_effect_id,
+      suggested_post_parameters,
+      reply_parameters,
+      reply_markup,
+    } = options;
+    if (chat_id === undefined || chat_id === null) {
+      throw new Error('chat_id required');
+    }
+    if (!audio) {
+      throw new Error('audio required');
+    }
+    const params = {
+      chat_id: serialize(chat_id),
+      business_connection_id,
+      message_thread_id,
+      direct_messages_topic_id,
+      caption,
+      parse_mode,
+      caption_entities: serialize(caption_entities),
+      duration,
+      performer,
+      title,
+      disable_notification,
+      protect_content,
+      allow_paid_broadcast,
+      message_effect_id,
+      suggested_post_parameters: serialize(suggested_post_parameters),
+      reply_parameters: serialize(reply_parameters),
+      reply_markup: serialize(reply_markup),
+    };
+    const clean = Object.fromEntries(Object.entries(params).filter(([_, v]) => v !== undefined && v !== null));
+    const files = {};
+    if (audio instanceof Buffer || (audio && typeof audio.pipe === 'function')) {
+      files.audio = audio;
+    } else {
+      clean.audio = audio;
+    }
+    if (thumbnail) {
+      if (thumbnail instanceof Buffer || (thumbnail && typeof thumbnail.pipe === 'function')) {
+        files.thumbnail = thumbnail;
+      } else {
+        clean.thumbnail = thumbnail;
+      }
+    }
+    const result = await this._request('sendAudio', clean, files);
+    return result;
+  }
+
+  async sendDocument(options = {}) {
+    const {
+      chat_id,
+      document,
+      business_connection_id,
+      message_thread_id,
+      direct_messages_topic_id,
+      thumbnail,
+      caption,
+      parse_mode,
+      caption_entities,
+      disable_content_type_detection,
+      disable_notification,
+      protect_content,
+      allow_paid_broadcast,
+      message_effect_id,
+      suggested_post_parameters,
+      reply_parameters,
+      reply_markup,
+    } = options;
+    if (chat_id === undefined || chat_id === null) {
+      throw new Error('chat_id required');
+    }
+    if (!document) {
+      throw new Error('document required');
+    }
+    const params = {
+      chat_id: serialize(chat_id),
+      business_connection_id,
+      message_thread_id,
+      direct_messages_topic_id,
+      caption,
+      parse_mode,
+      caption_entities: serialize(caption_entities),
+      disable_content_type_detection,
+      disable_notification,
+      protect_content,
+      allow_paid_broadcast,
+      message_effect_id,
+      suggested_post_parameters: serialize(suggested_post_parameters),
+      reply_parameters: serialize(reply_parameters),
+      reply_markup: serialize(reply_markup),
+    };
+    const clean = Object.fromEntries(Object.entries(params).filter(([_, v]) => v !== undefined && v !== null));
+    const files = {};
+    if (document instanceof Buffer || (document && typeof document.pipe === 'function')) {
+      files.document = document;
+    } else {
+      clean.document = document;
+    }
+    if (thumbnail) {
+      if (thumbnail instanceof Buffer || (thumbnail && typeof thumbnail.pipe === 'function')) {
+        files.thumbnail = thumbnail;
+      } else {
+        clean.thumbnail = thumbnail;
+      }
+    }
+    const result = await this._request('sendDocument', clean, files);
+    return result;
+  }
+
+  async sendVideo(options = {}) {
+    const {
+      chat_id,
+      video,
+      business_connection_id,
+      message_thread_id,
+      direct_messages_topic_id,
+      duration,
+      width,
+      height,
+      thumbnail,
+      cover,
+      start_timestamp,
+      caption,
+      parse_mode,
+      caption_entities,
+      show_caption_above_media,
+      has_spoiler,
+      supports_streaming,
+      disable_notification,
+      protect_content,
+      allow_paid_broadcast,
+      message_effect_id,
+      suggested_post_parameters,
+      reply_parameters,
+      reply_markup,
+    } = options;
+    if (chat_id === undefined || chat_id === null) {
+      throw new Error('chat_id required');
+    }
+    if (!video) {
+      throw new Error('video required');
+    }
+    const params = {
+      chat_id: serialize(chat_id),
+      business_connection_id,
+      message_thread_id,
+      direct_messages_topic_id,
+      duration,
+      width,
+      height,
+      start_timestamp,
+      caption,
+      parse_mode,
+      caption_entities: serialize(caption_entities),
+      show_caption_above_media,
+      has_spoiler,
+      supports_streaming,
+      disable_notification,
+      protect_content,
+      allow_paid_broadcast,
+      message_effect_id,
+      suggested_post_parameters: serialize(suggested_post_parameters),
+      reply_parameters: serialize(reply_parameters),
+      reply_markup: serialize(reply_markup),
+    };
+    const clean = Object.fromEntries(Object.entries(params).filter(([_, v]) => v !== undefined && v !== null));
+    const files = {};
+    if (video instanceof Buffer || (video && typeof video.pipe === 'function')) {
+      files.video = video;
+    } else {
+      clean.video = video;
+    }
+    if (thumbnail) {
+      if (thumbnail instanceof Buffer || (thumbnail && typeof thumbnail.pipe === 'function')) {
+        files.thumbnail = thumbnail;
+      } else {
+        clean.thumbnail = thumbnail;
+      }
+    }
+    if (cover) {
+      if (cover instanceof Buffer || (cover && typeof cover.pipe === 'function')) {
+        files.cover = cover;
+      } else {
+        clean.cover = cover;
+      }
+    }
+    const result = await this._request('sendVideo', clean, files);
+    return result;
+  }
+
+  async sendAnimation(options = {}) {
+    const {
+      chat_id,
+      animation,
+      business_connection_id,
+      message_thread_id,
+      direct_messages_topic_id,
+      duration,
+      width,
+      height,
+      thumbnail,
+      caption,
+      parse_mode,
+      caption_entities,
+      show_caption_above_media,
+      has_spoiler,
+      disable_notification,
+      protect_content,
+      allow_paid_broadcast,
+      message_effect_id,
+      suggested_post_parameters,
+      reply_parameters,
+      reply_markup,
+    } = options;
+    if (chat_id === undefined || chat_id === null) {
+      throw new Error('chat_id required');
+    }
+    if (!animation) {
+      throw new Error('animation required');
+    }
+    const params = {
+      chat_id: serialize(chat_id),
+      business_connection_id,
+      message_thread_id,
+      direct_messages_topic_id,
+      duration,
+      width,
+      height,
+      caption,
+      parse_mode,
+      caption_entities: serialize(caption_entities),
+      show_caption_above_media,
+      has_spoiler,
+      disable_notification,
+      protect_content,
+      allow_paid_broadcast,
+      message_effect_id,
+      suggested_post_parameters: serialize(suggested_post_parameters),
+      reply_parameters: serialize(reply_parameters),
+      reply_markup: serialize(reply_markup),
+    };
+    const clean = Object.fromEntries(Object.entries(params).filter(([_, v]) => v !== undefined && v !== null));
+    const files = {};
+    if (animation instanceof Buffer || (animation && typeof animation.pipe === 'function')) {
+      files.animation = animation;
+    } else {
+      clean.animation = animation;
+    }
+    if (thumbnail) {
+      if (thumbnail instanceof Buffer || (thumbnail && typeof thumbnail.pipe === 'function')) {
+        files.thumbnail = thumbnail;
+      } else {
+        clean.thumbnail = thumbnail;
+      }
+    }
+    const result = await this._request('sendAnimation', clean, files);
+    return result;
+  }
+
+  async sendVoice(options = {}) {
+    const {
+      chat_id,
+      voice,
+      business_connection_id,
+      message_thread_id,
+      direct_messages_topic_id,
+      caption,
+      parse_mode,
+      caption_entities,
+      duration,
+      disable_notification,
+      protect_content,
+      allow_paid_broadcast,
+      message_effect_id,
+      suggested_post_parameters,
+      reply_parameters,
+      reply_markup,
+    } = options;
+    if (chat_id === undefined || chat_id === null) {
+      throw new Error('chat_id required');
+    }
+    if (!voice) {
+      throw new Error('voice required');
+    }
+    const params = {
+      chat_id: serialize(chat_id),
+      business_connection_id,
+      message_thread_id,
+      direct_messages_topic_id,
+      caption,
+      parse_mode,
+      caption_entities: serialize(caption_entities),
+      duration,
+      disable_notification,
+      protect_content,
+      allow_paid_broadcast,
+      message_effect_id,
+      suggested_post_parameters: serialize(suggested_post_parameters),
+      reply_parameters: serialize(reply_parameters),
+      reply_markup: serialize(reply_markup),
+    };
+    const clean = Object.fromEntries(Object.entries(params).filter(([_, v]) => v !== undefined && v !== null));
+    const files = {};
+    if (voice instanceof Buffer || (voice && typeof voice.pipe === 'function')) {
+      files.voice = voice;
+    } else {
+      clean.voice = voice;
+    }
+    const result = await this._request('sendVoice', clean, files);
+    return result;
+  }
+
+  async sendVideoNote(options = {}) {
+    const {
+      chat_id,
+      video_note,
+      business_connection_id,
+      message_thread_id,
+      direct_messages_topic_id,
+      duration,
+      length,
+      thumbnail,
+      disable_notification,
+      protect_content,
+      allow_paid_broadcast,
+      message_effect_id,
+      suggested_post_parameters,
+      reply_parameters,
+      reply_markup,
+    } = options;
+    if (chat_id === undefined || chat_id === null) {
+      throw new Error('chat_id required');
+    }
+    if (!video_note) {
+      throw new Error('video_note required');
+    }
+    const params = {
+      chat_id: serialize(chat_id),
+      business_connection_id,
+      message_thread_id,
+      direct_messages_topic_id,
+      duration,
+      length,
+      disable_notification,
+      protect_content,
+      allow_paid_broadcast,
+      message_effect_id,
+      suggested_post_parameters: serialize(suggested_post_parameters),
+      reply_parameters: serialize(reply_parameters),
+      reply_markup: serialize(reply_markup),
+    };
+    const clean = Object.fromEntries(Object.entries(params).filter(([_, v]) => v !== undefined && v !== null));
+    const files = {};
+    if (video_note instanceof Buffer || (video_note && typeof video_note.pipe === 'function')) {
+      files.video_note = video_note;
+    } else {
+      clean.video_note = video_note;
+    }
+    if (thumbnail) {
+      if (thumbnail instanceof Buffer || (thumbnail && typeof thumbnail.pipe === 'function')) {
+        files.thumbnail = thumbnail;
+      } else {
+        clean.thumbnail = thumbnail;
+      }
+    }
+    const result = await this._request('sendVideoNote', clean, files);
+    return result;
+  }
+
+  async sendPaidMedia(options = {}) {
+    const {
+      chat_id,
+      star_count,
+      media,
+      business_connection_id,
+      message_thread_id,
+      direct_messages_topic_id,
+      payload,
+      caption,
+      parse_mode,
+      caption_entities,
+      show_caption_above_media,
+      disable_notification,
+      protect_content,
+      allow_paid_broadcast,
+      suggested_post_parameters,
+      reply_parameters,
+      reply_markup,
+    } = options;
+
+    if (chat_id === undefined || chat_id === null) {
+      throw new Error('chat_id');
+    }
+    if (star_count === undefined || star_count === null) {
+      throw new Error('star_count');
+    }
+    if (media === undefined || media === null) {
+      throw new Error('media');
+    }
+
+    const params = {
+      chat_id: serialize(chat_id),
+      star_count: star_count,
+      media: serialize(media),
+      business_connection_id: business_connection_id,
+      message_thread_id: message_thread_id,
+      direct_messages_topic_id: direct_messages_topic_id,
+      payload: payload,
+      caption: caption,
+      parse_mode: parse_mode,
+      caption_entities: serialize(caption_entities),
+      show_caption_above_media: show_caption_above_media,
+      disable_notification: disable_notification,
+      protect_content: protect_content,
+      allow_paid_broadcast: allow_paid_broadcast,
+      suggested_post_parameters: serialize(suggested_post_parameters),
+      reply_parameters: serialize(reply_parameters),
+      reply_markup: serialize(reply_markup),
+    };
+    const clean = Object.fromEntries(Object.entries(params).filter(([_, v]) => v !== undefined && v !== null));
+    const result = await this._request('sendPaidMedia', clean);
+    return result;
+  }
+
+  async sendMediaGroup(options = {}) {
+    const {
+      chat_id,
+      media,
+      business_connection_id,
+      message_thread_id,
+      direct_messages_topic_id,
+      disable_notification,
+      protect_content,
+      allow_paid_broadcast,
+      message_effect_id,
+      reply_parameters,
+    } = options;
+
+    if (chat_id === undefined || chat_id === null) {
+      throw new Error('chat_id');
+    }
+    if (media === undefined || media === null) {
+      throw new Error('media');
+    }
+
+    const params = {
+      chat_id: serialize(chat_id),
+      media: serialize(media),
+      business_connection_id: business_connection_id,
+      message_thread_id: message_thread_id,
+      direct_messages_topic_id: direct_messages_topic_id,
+      disable_notification: disable_notification,
+      protect_content: protect_content,
+      allow_paid_broadcast: allow_paid_broadcast,
+      message_effect_id: message_effect_id,
+      reply_parameters: serialize(reply_parameters),
+    };
+    const clean = Object.fromEntries(Object.entries(params).filter(([_, v]) => v !== undefined && v !== null));
+    const result = await this._request('sendMediaGroup', clean);
+    return result;
+  }
+
+  async sendLocation(options = {}) {
+    const {
+      chat_id,
+      latitude,
+      longitude,
+      business_connection_id,
+      message_thread_id,
+      direct_messages_topic_id,
+      horizontal_accuracy,
+      live_period,
+      heading,
+      proximity_alert_radius,
+      disable_notification,
+      protect_content,
+      allow_paid_broadcast,
+      message_effect_id,
+      suggested_post_parameters,
+      reply_parameters,
+      reply_markup,
+    } = options;
+
+    if (chat_id === undefined || chat_id === null) {
+      throw new Error('chat_id');
+    }
+    if (latitude === undefined || latitude === null) {
+      throw new Error('latitude');
+    }
+    if (longitude === undefined || longitude === null) {
+      throw new Error('longitude');
+    }
+
+    const params = {
+      chat_id: serialize(chat_id),
+      latitude: latitude,
+      longitude: longitude,
+      business_connection_id: business_connection_id,
+      message_thread_id: message_thread_id,
+      direct_messages_topic_id: direct_messages_topic_id,
+      horizontal_accuracy: horizontal_accuracy,
+      live_period: live_period,
+      heading: heading,
+      proximity_alert_radius: proximity_alert_radius,
+      disable_notification: disable_notification,
+      protect_content: protect_content,
+      allow_paid_broadcast: allow_paid_broadcast,
+      message_effect_id: message_effect_id,
+      suggested_post_parameters: serialize(suggested_post_parameters),
+      reply_parameters: serialize(reply_parameters),
+      reply_markup: serialize(reply_markup),
+    };
+    const clean = Object.fromEntries(Object.entries(params).filter(([_, v]) => v !== undefined && v !== null));
+    const result = await this._request('sendLocation', clean);
+    return result;
+  }
+
+  async sendVenue(options = {}) {
+    const {
+      chat_id,
+      latitude,
+      longitude,
+      title,
+      address,
+      business_connection_id,
+      message_thread_id,
+      direct_messages_topic_id,
+      foursquare_id,
+      foursquare_type,
+      google_place_id,
+      google_place_type,
+      disable_notification,
+      protect_content,
+      allow_paid_broadcast,
+      message_effect_id,
+      suggested_post_parameters,
+      reply_parameters,
+      reply_markup,
+    } = options;
+
+    if (chat_id === undefined || chat_id === null) {
+      throw new Error('chat_id');
+    }
+    if (latitude === undefined || latitude === null) {
+      throw new Error('latitude');
+    }
+    if (longitude === undefined || longitude === null) {
+      throw new Error('longitude');
+    }
+    if (title === undefined || title === null) {
+      throw new Error('title');
+    }
+    if (address === undefined || address === null) {
+      throw new Error('address');
+    }
+
+    const params = {
+      chat_id: serialize(chat_id),
+      latitude: latitude,
+      longitude: longitude,
+      title: title,
+      address: address,
+      business_connection_id: business_connection_id,
+      message_thread_id: message_thread_id,
+      direct_messages_topic_id: direct_messages_topic_id,
+      foursquare_id: foursquare_id,
+      foursquare_type: foursquare_type,
+      google_place_id: google_place_id,
+      google_place_type: google_place_type,
+      disable_notification: disable_notification,
+      protect_content: protect_content,
+      allow_paid_broadcast: allow_paid_broadcast,
+      message_effect_id: message_effect_id,
+      suggested_post_parameters: serialize(suggested_post_parameters),
+      reply_parameters: serialize(reply_parameters),
+      reply_markup: serialize(reply_markup),
+    };
+    const clean = Object.fromEntries(Object.entries(params).filter(([_, v]) => v !== undefined && v !== null));
+    const result = await this._request('sendVenue', clean);
+    return result;
+  }
+
+  async sendContact(options = {}) {
+    const {
+      chat_id,
+      phone_number,
+      first_name,
+      business_connection_id,
+      message_thread_id,
+      direct_messages_topic_id,
+      last_name,
+      vcard,
+      disable_notification,
+      protect_content,
+      allow_paid_broadcast,
+      message_effect_id,
+      suggested_post_parameters,
+      reply_parameters,
+      reply_markup,
+    } = options;
+
+    if (chat_id === undefined || chat_id === null) {
+      throw new Error('chat_id');
+    }
+    if (phone_number === undefined || phone_number === null) {
+      throw new Error('phone_number');
+    }
+    if (first_name === undefined || first_name === null) {
+      throw new Error('first_name');
+    }
+
+    const params = {
+      chat_id: serialize(chat_id),
+      phone_number: phone_number,
+      first_name: first_name,
+      business_connection_id: business_connection_id,
+      message_thread_id: message_thread_id,
+      direct_messages_topic_id: direct_messages_topic_id,
+      last_name: last_name,
+      vcard: vcard,
+      disable_notification: disable_notification,
+      protect_content: protect_content,
+      allow_paid_broadcast: allow_paid_broadcast,
+      message_effect_id: message_effect_id,
+      suggested_post_parameters: serialize(suggested_post_parameters),
+      reply_parameters: serialize(reply_parameters),
+      reply_markup: serialize(reply_markup),
+    };
+    const clean = Object.fromEntries(Object.entries(params).filter(([_, v]) => v !== undefined && v !== null));
+    const result = await this._request('sendContact', clean);
+    return result;
+  }
+
+  async sendPoll(options = {}) {
+    const {
+      chat_id,
+      question,
+      options: poll_options,
+      business_connection_id,
+      message_thread_id,
+      question_parse_mode,
+      question_entities,
+      is_anonymous,
+      type,
+      allows_multiple_answers,
+      correct_option_id,
+      explanation,
+      explanation_parse_mode,
+      explanation_entities,
+      open_period,
+      close_date,
+      is_closed,
+      disable_notification,
+      protect_content,
+      allow_paid_broadcast,
+      message_effect_id,
+      reply_parameters,
+      reply_markup,
+    } = options;
+
+    if (chat_id === undefined || chat_id === null) {
+      throw new Error('chat_id');
+    }
+    if (question === undefined || question === null) {
+      throw new Error('question');
+    }
+    if (options === undefined || options === null) {
+      throw new Error('options');
+    }
+
+    const params = {
+      chat_id: serialize(chat_id),
+      question: question,
+      options: serialize(poll_options),
+      business_connection_id: business_connection_id,
+      message_thread_id: message_thread_id,
+      question_parse_mode: question_parse_mode,
+      question_entities: serialize(question_entities),
+      is_anonymous: is_anonymous,
+      type: type,
+      allows_multiple_answers: allows_multiple_answers,
+      correct_option_id: correct_option_id,
+      explanation: explanation,
+      explanation_parse_mode: explanation_parse_mode,
+      explanation_entities: serialize(explanation_entities),
+      open_period: open_period,
+      close_date: close_date,
+      is_closed: is_closed,
+      disable_notification: disable_notification,
+      protect_content: protect_content,
+      allow_paid_broadcast: allow_paid_broadcast,
+      message_effect_id: message_effect_id,
+      reply_parameters: serialize(reply_parameters),
+      reply_markup: serialize(reply_markup),
+    };
+    const clean = Object.fromEntries(Object.entries(params).filter(([_, v]) => v !== undefined && v !== null));
+    const result = await this._request('sendPoll', clean);
+    return result;
+  }
+
+  async sendChecklist(options = {}) {
+    const {
+      business_connection_id,
+      chat_id,
+      checklist,
+      disable_notification,
+      protect_content,
+      message_effect_id,
+      reply_parameters,
+      reply_markup,
+    } = options;
+
+    if (business_connection_id === undefined || business_connection_id === null) {
+      throw new Error('business_connection_id');
+    }
+    if (chat_id === undefined || chat_id === null) {
+      throw new Error('chat_id');
+    }
+    if (checklist === undefined || checklist === null) {
+      throw new Error('checklist');
+    }
+
+    const params = {
+      business_connection_id: business_connection_id,
+      chat_id: chat_id,
+      checklist: serialize(checklist),
+      disable_notification: disable_notification,
+      protect_content: protect_content,
+      message_effect_id: message_effect_id,
+      reply_parameters: serialize(reply_parameters),
+      reply_markup: serialize(reply_markup),
+    };
+    const clean = Object.fromEntries(Object.entries(params).filter(([_, v]) => v !== undefined && v !== null));
+    const result = await this._request('sendChecklist', clean);
+    return result;
+  }
+
+  async sendDice(options = {}) {
+    const {
+      chat_id,
+      business_connection_id,
+      message_thread_id,
+      direct_messages_topic_id,
+      emoji,
+      disable_notification,
+      protect_content,
+      allow_paid_broadcast,
+      message_effect_id,
+      suggested_post_parameters,
+      reply_parameters,
+      reply_markup,
+    } = options;
+
+    if (chat_id === undefined || chat_id === null) {
+      throw new Error('chat_id');
+    }
+
+    const params = {
+      chat_id: serialize(chat_id),
+      business_connection_id: business_connection_id,
+      message_thread_id: message_thread_id,
+      direct_messages_topic_id: direct_messages_topic_id,
+      emoji: emoji,
+      disable_notification: disable_notification,
+      protect_content: protect_content,
+      allow_paid_broadcast: allow_paid_broadcast,
+      message_effect_id: message_effect_id,
+      suggested_post_parameters: serialize(suggested_post_parameters),
+      reply_parameters: serialize(reply_parameters),
+      reply_markup: serialize(reply_markup),
+    };
+    const clean = Object.fromEntries(Object.entries(params).filter(([_, v]) => v !== undefined && v !== null));
+    const result = await this._request('sendDice', clean);
+    return result;
+  }
+
+  async sendMessageDraft(options = {}) {
+    const {
+      chat_id,
+      draft_id,
+      text,
+      message_thread_id,
+      parse_mode,
+      entities,
+    } = options;
+
+    if (chat_id === undefined || chat_id === null) {
+      throw new Error('chat_id');
+    }
+    if (draft_id === undefined || draft_id === null) {
+      throw new Error('draft_id');
+    }
+    if (text === undefined || text === null) {
+      throw new Error('text');
+    }
+
+    const params = {
+      chat_id: chat_id,
+      draft_id: draft_id,
+      text: text,
+      message_thread_id: message_thread_id,
+      parse_mode: parse_mode,
+      entities: serialize(entities),
+    };
+    const clean = Object.fromEntries(Object.entries(params).filter(([_, v]) => v !== undefined && v !== null));
+    const result = await this._request('sendMessageDraft', clean);
+    return !!result;
+  }
+
+  async sendChatAction(options = {}) {
+    const {
+      chat_id,
+      action,
+      business_connection_id,
+      message_thread_id,
+    } = options;
+
+    if (chat_id === undefined || chat_id === null) {
+      throw new Error('chat_id');
+    }
+    if (action === undefined || action === null) {
+      throw new Error('action');
+    }
+
+    const params = {
+      chat_id: serialize(chat_id),
+      action: action,
+      business_connection_id: business_connection_id,
+      message_thread_id: message_thread_id,
+    };
+    const clean = Object.fromEntries(Object.entries(params).filter(([_, v]) => v !== undefined && v !== null));
+    const result = await this._request('sendChatAction', clean);
+    return !!result;
+  }
+
+  async setMessageReaction(options = {}) {
+    const {
+      chat_id,
+      message_id,
+      reaction,
+      is_big,
+    } = options;
+
+    if (chat_id === undefined || chat_id === null) {
+      throw new Error('chat_id');
+    }
+    if (message_id === undefined || message_id === null) {
+      throw new Error('message_id');
+    }
+
+    const params = {
+      chat_id: serialize(chat_id),
+      message_id: message_id,
+      reaction: serialize(reaction),
+      is_big: is_big,
+    };
+    const clean = Object.fromEntries(Object.entries(params).filter(([_, v]) => v !== undefined && v !== null));
+    const result = await this._request('setMessageReaction', clean);
+    return !!result;
+  }
+
+  async getUserProfilePhotos(options = {}) {
+    const {
+      user_id,
+      offset,
+      limit,
+    } = options;
+
+    if (user_id === undefined || user_id === null) {
+      throw new Error('user_id');
+    }
+
+    const params = {
+      user_id: user_id,
+      offset: offset,
+      limit: limit,
+    };
+    const clean = Object.fromEntries(Object.entries(params).filter(([_, v]) => v !== undefined && v !== null));
+    const result = await this._request('getUserProfilePhotos', clean);
+    return result;
+  }
+
+  async setUserEmojiStatus(options = {}) {
+    const {
+      user_id,
+      emoji_status_custom_emoji_id,
+      emoji_status_expiration_date,
+    } = options;
+
+    if (user_id === undefined || user_id === null) {
+      throw new Error('user_id');
+    }
+
+    const params = {
+      user_id: user_id,
+      emoji_status_custom_emoji_id: emoji_status_custom_emoji_id,
+      emoji_status_expiration_date: emoji_status_expiration_date,
+    };
+    const clean = Object.fromEntries(Object.entries(params).filter(([_, v]) => v !== undefined && v !== null));
+    const result = await this._request('setUserEmojiStatus', clean);
+    return !!result;
+  }
+
+  async getFile(options = {}) {
+    const {
+      file_id,
+    } = options;
+
+    if (file_id === undefined || file_id === null) {
+      throw new Error('file_id');
+    }
+
+    const params = {
+      file_id: file_id,
+    };
+    const clean = Object.fromEntries(Object.entries(params).filter(([_, v]) => v !== undefined && v !== null));
+    const result = await this._request('getFile', clean);
+    return result;
+  }
+
+  async banChatMember(options = {}) {
+    const {
+      chat_id,
+      user_id,
+      until_date,
+      revoke_messages,
+    } = options;
+
+    if (chat_id === undefined || chat_id === null) {
+      throw new Error('chat_id');
+    }
+    if (user_id === undefined || user_id === null) {
+      throw new Error('user_id');
+    }
+
+    const params = {
+      chat_id: serialize(chat_id),
+      user_id: user_id,
+      until_date: until_date,
+      revoke_messages: revoke_messages,
+    };
+    const clean = Object.fromEntries(Object.entries(params).filter(([_, v]) => v !== undefined && v !== null));
+    const result = await this._request('banChatMember', clean);
+    return !!result;
+  }
+
+  async unbanChatMember(options = {}) {
+    const {
+      chat_id,
+      user_id,
+      only_if_banned,
+    } = options;
+
+    if (chat_id === undefined || chat_id === null) {
+      throw new Error('chat_id');
+    }
+    if (user_id === undefined || user_id === null) {
+      throw new Error('user_id');
+    }
+
+    const params = {
+      chat_id: serialize(chat_id),
+      user_id: user_id,
+      only_if_banned: only_if_banned,
+    };
+    const clean = Object.fromEntries(Object.entries(params).filter(([_, v]) => v !== undefined && v !== null));
+    const result = await this._request('unbanChatMember', clean);
+    return !!result;
+  }
+
+  async restrictChatMember(options = {}) {
+    const {
+      chat_id,
+      user_id,
+      permissions,
+      use_independent_chat_permissions,
+      until_date,
+    } = options;
+
+    if (chat_id === undefined || chat_id === null) {
+      throw new Error('chat_id');
+    }
+    if (user_id === undefined || user_id === null) {
+      throw new Error('user_id');
+    }
+    if (permissions === undefined || permissions === null) {
+      throw new Error('permissions');
+    }
+
+    const params = {
+      chat_id: serialize(chat_id),
+      user_id: user_id,
+      permissions: serialize(permissions),
+      use_independent_chat_permissions: use_independent_chat_permissions,
+      until_date: until_date,
+    };
+    const clean = Object.fromEntries(Object.entries(params).filter(([_, v]) => v !== undefined && v !== null));
+    const result = await this._request('restrictChatMember', clean);
+    return !!result;
+  }
+
+  async promoteChatMember(options = {}) {
+    const {
+      chat_id,
+      user_id,
+      is_anonymous,
+      can_manage_chat,
+      can_delete_messages,
+      can_manage_video_chats,
+      can_restrict_members,
+      can_promote_members,
+      can_change_info,
+      can_invite_users,
+      can_post_stories,
+      can_edit_stories,
+      can_delete_stories,
+      can_post_messages,
+      can_edit_messages,
+      can_pin_messages,
+      can_manage_topics,
+      can_manage_direct_messages,
+    } = options;
+
+    if (chat_id === undefined || chat_id === null) {
+      throw new Error('chat_id');
+    }
+    if (user_id === undefined || user_id === null) {
+      throw new Error('user_id');
+    }
+
+    const params = {
+      chat_id: serialize(chat_id),
+      user_id: user_id,
+      is_anonymous: is_anonymous,
+      can_manage_chat: can_manage_chat,
+      can_delete_messages: can_delete_messages,
+      can_manage_video_chats: can_manage_video_chats,
+      can_restrict_members: can_restrict_members,
+      can_promote_members: can_promote_members,
+      can_change_info: can_change_info,
+      can_invite_users: can_invite_users,
+      can_post_stories: can_post_stories,
+      can_edit_stories: can_edit_stories,
+      can_delete_stories: can_delete_stories,
+      can_post_messages: can_post_messages,
+      can_edit_messages: can_edit_messages,
+      can_pin_messages: can_pin_messages,
+      can_manage_topics: can_manage_topics,
+      can_manage_direct_messages: can_manage_direct_messages,
+    };
+    const clean = Object.fromEntries(Object.entries(params).filter(([_, v]) => v !== undefined && v !== null));
+    const result = await this._request('promoteChatMember', clean);
+    return !!result;
+  }
+
+  async setChatAdministratorCustomTitle(options = {}) {
+    const {
+      chat_id,
+      user_id,
+      custom_title,
+    } = options;
+
+    if (chat_id === undefined || chat_id === null) {
+      throw new Error('chat_id');
+    }
+    if (user_id === undefined || user_id === null) {
+      throw new Error('user_id');
+    }
+    if (custom_title === undefined || custom_title === null) {
+      throw new Error('custom_title');
+    }
+
+    const params = {
+      chat_id: serialize(chat_id),
+      user_id: user_id,
+      custom_title: custom_title,
+    };
+    const clean = Object.fromEntries(Object.entries(params).filter(([_, v]) => v !== undefined && v !== null));
+    const result = await this._request('setChatAdministratorCustomTitle', clean);
+    return !!result;
+  }
+
+  async banChatSenderChat(options = {}) {
+    const {
+      chat_id,
+      sender_chat_id,
+    } = options;
+
+    if (chat_id === undefined || chat_id === null) {
+      throw new Error('chat_id');
+    }
+    if (sender_chat_id === undefined || sender_chat_id === null) {
+      throw new Error('sender_chat_id');
+    }
+
+    const params = {
+      chat_id: serialize(chat_id),
+      sender_chat_id: sender_chat_id,
+    };
+    const clean = Object.fromEntries(Object.entries(params).filter(([_, v]) => v !== undefined && v !== null));
+    const result = await this._request('banChatSenderChat', clean);
+    return !!result;
+  }
+
+  async unbanChatSenderChat(options = {}) {
+    const {
+      chat_id,
+      sender_chat_id,
+    } = options;
+
+    if (chat_id === undefined || chat_id === null) {
+      throw new Error('chat_id');
+    }
+    if (sender_chat_id === undefined || sender_chat_id === null) {
+      throw new Error('sender_chat_id');
+    }
+
+    const params = {
+      chat_id: serialize(chat_id),
+      sender_chat_id: sender_chat_id,
+    };
+    const clean = Object.fromEntries(Object.entries(params).filter(([_, v]) => v !== undefined && v !== null));
+    const result = await this._request('unbanChatSenderChat', clean);
+    return !!result;
+  }
+
+  async setChatPermissions(options = {}) {
+    const {
+      chat_id,
+      permissions,
+      use_independent_chat_permissions,
+    } = options;
+
+    if (chat_id === undefined || chat_id === null) {
+      throw new Error('chat_id');
+    }
+    if (permissions === undefined || permissions === null) {
+      throw new Error('permissions');
+    }
+
+    const params = {
+      chat_id: serialize(chat_id),
+      permissions: serialize(permissions),
+      use_independent_chat_permissions: use_independent_chat_permissions,
+    };
+    const clean = Object.fromEntries(Object.entries(params).filter(([_, v]) => v !== undefined && v !== null));
+    const result = await this._request('setChatPermissions', clean);
+    return !!result;
+  }
+
+  async exportChatInviteLink(options = {}) {
+    const {
+      chat_id,
+    } = options;
+
+    if (chat_id === undefined || chat_id === null) {
+      throw new Error('chat_id');
+    }
+
+    const params = {
+      chat_id: serialize(chat_id),
+    };
+    const clean = Object.fromEntries(Object.entries(params).filter(([_, v]) => v !== undefined && v !== null));
+    const result = await this._request('exportChatInviteLink', clean);
+    return !!result;
+  }
+
+  async createChatInviteLink(options = {}) {
+    const {
+      chat_id,
+      name,
+      expire_date,
+      member_limit,
+      creates_join_request,
+    } = options;
+
+    if (chat_id === undefined || chat_id === null) {
+      throw new Error('chat_id');
+    }
+
+    const params = {
+      chat_id: serialize(chat_id),
+      name: name,
+      expire_date: expire_date,
+      member_limit: member_limit,
+      creates_join_request: creates_join_request,
+    };
+    const clean = Object.fromEntries(Object.entries(params).filter(([_, v]) => v !== undefined && v !== null));
+    const result = await this._request('createChatInviteLink', clean);
+    return result;
+  }
+
+  async editChatInviteLink(options = {}) {
+    const {
+      chat_id,
+      invite_link,
+      name,
+      expire_date,
+      member_limit,
+      creates_join_request,
+    } = options;
+
+    if (chat_id === undefined || chat_id === null) {
+      throw new Error('chat_id');
+    }
+    if (invite_link === undefined || invite_link === null) {
+      throw new Error('invite_link');
+    }
+
+    const params = {
+      chat_id: serialize(chat_id),
+      invite_link: invite_link,
+      name: name,
+      expire_date: expire_date,
+      member_limit: member_limit,
+      creates_join_request: creates_join_request,
+    };
+    const clean = Object.fromEntries(Object.entries(params).filter(([_, v]) => v !== undefined && v !== null));
+    const result = await this._request('editChatInviteLink', clean);
+    return result;
+  }
+
+  async createChatSubscriptionInviteLink(options = {}) {
+    const {
+      chat_id,
+      subscription_period,
+      subscription_price,
+      name,
+    } = options;
+
+    if (chat_id === undefined || chat_id === null) {
+      throw new Error('chat_id');
+    }
+    if (subscription_period === undefined || subscription_period === null) {
+      throw new Error('subscription_period');
+    }
+    if (subscription_price === undefined || subscription_price === null) {
+      throw new Error('subscription_price');
+    }
+
+    const params = {
+      chat_id: serialize(chat_id),
+      subscription_period: subscription_period,
+      subscription_price: subscription_price,
+      name: name,
+    };
+    const clean = Object.fromEntries(Object.entries(params).filter(([_, v]) => v !== undefined && v !== null));
+    const result = await this._request('createChatSubscriptionInviteLink', clean);
+    return result;
+  }
+
+  async editChatSubscriptionInviteLink(options = {}) {
+    const {
+      chat_id,
+      invite_link,
+      name,
+    } = options;
+
+    if (chat_id === undefined || chat_id === null) {
+      throw new Error('chat_id');
+    }
+    if (invite_link === undefined || invite_link === null) {
+      throw new Error('invite_link');
+    }
+
+    const params = {
+      chat_id: serialize(chat_id),
+      invite_link: invite_link,
+      name: name,
+    };
+    const clean = Object.fromEntries(Object.entries(params).filter(([_, v]) => v !== undefined && v !== null));
+    const result = await this._request('editChatSubscriptionInviteLink', clean);
+    return result;
+  }
+
+  async revokeChatInviteLink(options = {}) {
+    const {
+      chat_id,
+      invite_link,
+    } = options;
+
+    if (chat_id === undefined || chat_id === null) {
+      throw new Error('chat_id');
+    }
+    if (invite_link === undefined || invite_link === null) {
+      throw new Error('invite_link');
+    }
+
+    const params = {
+      chat_id: serialize(chat_id),
+      invite_link: invite_link,
+    };
+    const clean = Object.fromEntries(Object.entries(params).filter(([_, v]) => v !== undefined && v !== null));
+    const result = await this._request('revokeChatInviteLink', clean);
+    return result;
+  }
+
+  async approveChatJoinRequest(options = {}) {
+    const {
+      chat_id,
+      user_id,
+    } = options;
+
+    if (chat_id === undefined || chat_id === null) {
+      throw new Error('chat_id');
+    }
+    if (user_id === undefined || user_id === null) {
+      throw new Error('user_id');
+    }
+
+    const params = {
+      chat_id: serialize(chat_id),
+      user_id: user_id,
+    };
+    const clean = Object.fromEntries(Object.entries(params).filter(([_, v]) => v !== undefined && v !== null));
+    const result = await this._request('approveChatJoinRequest', clean);
+    return !!result;
+  }
+
+  async declineChatJoinRequest(options = {}) {
+    const {
+      chat_id,
+      user_id,
+    } = options;
+
+    if (chat_id === undefined || chat_id === null) {
+      throw new Error('chat_id');
+    }
+    if (user_id === undefined || user_id === null) {
+      throw new Error('user_id');
+    }
+
+    const params = {
+      chat_id: serialize(chat_id),
+      user_id: user_id,
+    };
+    const clean = Object.fromEntries(Object.entries(params).filter(([_, v]) => v !== undefined && v !== null));
+    const result = await this._request('declineChatJoinRequest', clean);
+    return !!result;
+  }
+
+  async deleteChatPhoto(options = {}) {
+    const {
+      chat_id,
+    } = options;
+
+    if (chat_id === undefined || chat_id === null) {
+      throw new Error('chat_id');
+    }
+
+    const params = {
+      chat_id: serialize(chat_id),
+    };
+    const clean = Object.fromEntries(Object.entries(params).filter(([_, v]) => v !== undefined && v !== null));
+    const result = await this._request('deleteChatPhoto', clean);
+    return !!result;
+  }
+
+  async setChatTitle(options = {}) {
+    const {
+      chat_id,
+      title,
+    } = options;
+
+    if (chat_id === undefined || chat_id === null) {
+      throw new Error('chat_id');
+    }
+    if (title === undefined || title === null) {
+      throw new Error('title');
+    }
+
+    const params = {
+      chat_id: serialize(chat_id),
+      title: title,
+    };
+    const clean = Object.fromEntries(Object.entries(params).filter(([_, v]) => v !== undefined && v !== null));
+    const result = await this._request('setChatTitle', clean);
+    return !!result;
+  }
+
+  async setChatDescription(options = {}) {
+    const {
+      chat_id,
+      description,
+    } = options;
+
+    if (chat_id === undefined || chat_id === null) {
+      throw new Error('chat_id');
+    }
+
+    const params = {
+      chat_id: serialize(chat_id),
+      description: description,
+    };
+    const clean = Object.fromEntries(Object.entries(params).filter(([_, v]) => v !== undefined && v !== null));
+    const result = await this._request('setChatDescription', clean);
+    return !!result;
+  }
+
+  async pinChatMessage(options = {}) {
+    const {
+      chat_id,
+      message_id,
+      business_connection_id,
+      disable_notification,
+    } = options;
+
+    if (chat_id === undefined || chat_id === null) {
+      throw new Error('chat_id');
+    }
+    if (message_id === undefined || message_id === null) {
+      throw new Error('message_id');
+    }
+
+    const params = {
+      chat_id: serialize(chat_id),
+      message_id: message_id,
+      business_connection_id: business_connection_id,
+      disable_notification: disable_notification,
+    };
+    const clean = Object.fromEntries(Object.entries(params).filter(([_, v]) => v !== undefined && v !== null));
+    const result = await this._request('pinChatMessage', clean);
+    return !!result;
+  }
+
+  async unpinChatMessage(options = {}) {
+    const {
+      chat_id,
+      business_connection_id,
+      message_id,
+    } = options;
+
+    if (chat_id === undefined || chat_id === null) {
+      throw new Error('chat_id');
+    }
+
+    const params = {
+      chat_id: serialize(chat_id),
+      business_connection_id: business_connection_id,
+      message_id: message_id,
+    };
+    const clean = Object.fromEntries(Object.entries(params).filter(([_, v]) => v !== undefined && v !== null));
+    const result = await this._request('unpinChatMessage', clean);
+    return !!result;
+  }
+
+  async unpinAllChatMessages(options = {}) {
+    const {
+      chat_id,
+    } = options;
+
+    if (chat_id === undefined || chat_id === null) {
+      throw new Error('chat_id');
+    }
+
+    const params = {
+      chat_id: serialize(chat_id),
+    };
+    const clean = Object.fromEntries(Object.entries(params).filter(([_, v]) => v !== undefined && v !== null));
+    const result = await this._request('unpinAllChatMessages', clean);
+    return !!result;
+  }
+
+  async leaveChat(options = {}) {
+    const {
+      chat_id,
+    } = options;
+
+    if (chat_id === undefined || chat_id === null) {
+      throw new Error('chat_id');
+    }
+
+    const params = {
+      chat_id: serialize(chat_id),
+    };
+    const clean = Object.fromEntries(Object.entries(params).filter(([_, v]) => v !== undefined && v !== null));
+    const result = await this._request('leaveChat', clean);
+    return !!result;
+  }
+
+  async getChat(options = {}) {
+    const {
+      chat_id,
+    } = options;
+
+    if (chat_id === undefined || chat_id === null) {
+      throw new Error('chat_id');
+    }
+
+    const params = {
+      chat_id: serialize(chat_id),
+    };
+    const clean = Object.fromEntries(Object.entries(params).filter(([_, v]) => v !== undefined && v !== null));
+    const result = await this._request('getChat', clean);
+    return result;
+  }
+
+  async getChatAdministrators(options = {}) {
+    const {
+      chat_id,
+    } = options;
+
+    if (chat_id === undefined || chat_id === null) {
+      throw new Error('chat_id');
+    }
+
+    const params = {
+      chat_id: serialize(chat_id),
+    };
+    const clean = Object.fromEntries(Object.entries(params).filter(([_, v]) => v !== undefined && v !== null));
+    const result = await this._request('getChatAdministrators', clean);
+    return result;
+  }
+
+  async getChatMemberCount(options = {}) {
+    const {
+      chat_id,
+    } = options;
+
+    if (chat_id === undefined || chat_id === null) {
+      throw new Error('chat_id');
+    }
+
+    const params = {
+      chat_id: serialize(chat_id),
+    };
+    const clean = Object.fromEntries(Object.entries(params).filter(([_, v]) => v !== undefined && v !== null));
+    const result = await this._request('getChatMemberCount', clean);
+    return result;
+  }
+
+  async getChatMember(options = {}) {
+    const {
+      chat_id,
+      user_id,
+    } = options;
+
+    if (chat_id === undefined || chat_id === null) {
+      throw new Error('chat_id');
+    }
+    if (user_id === undefined || user_id === null) {
+      throw new Error('user_id');
+    }
+
+    const params = {
+      chat_id: serialize(chat_id),
+      user_id: user_id,
+    };
+    const clean = Object.fromEntries(Object.entries(params).filter(([_, v]) => v !== undefined && v !== null));
+    const result = await this._request('getChatMember', clean);
+    return result;
+  }
+
+  async setChatStickerSet(options = {}) {
+    const {
+      chat_id,
+      sticker_set_name,
+    } = options;
+
+    if (chat_id === undefined || chat_id === null) {
+      throw new Error('chat_id');
+    }
+    if (sticker_set_name === undefined || sticker_set_name === null) {
+      throw new Error('sticker_set_name');
+    }
+
+    const params = {
+      chat_id: serialize(chat_id),
+      sticker_set_name: sticker_set_name,
+    };
+    const clean = Object.fromEntries(Object.entries(params).filter(([_, v]) => v !== undefined && v !== null));
+    const result = await this._request('setChatStickerSet', clean);
+    return !!result;
+  }
+
+  async deleteChatStickerSet(options = {}) {
+    const {
+      chat_id,
+    } = options;
+
+    if (chat_id === undefined || chat_id === null) {
+      throw new Error('chat_id');
+    }
+
+    const params = {
+      chat_id: serialize(chat_id),
+    };
+    const clean = Object.fromEntries(Object.entries(params).filter(([_, v]) => v !== undefined && v !== null));
+    const result = await this._request('deleteChatStickerSet', clean);
+    return !!result;
+  }
+
+  async getForumTopicIconStickers(_) {
+    const params = {
+    };
+    const clean = Object.fromEntries(Object.entries(params).filter(([_, v]) => v !== undefined && v !== null));
+    const result = await this._request('getForumTopicIconStickers', clean);
+    return result;
+  }
+
+  async createForumTopic(options = {}) {
+    const {
+      chat_id,
+      name,
+      icon_color,
+      icon_custom_emoji_id,
+    } = options;
+
+    if (chat_id === undefined || chat_id === null) {
+      throw new Error('chat_id');
+    }
+    if (name === undefined || name === null) {
+      throw new Error('name');
+    }
+
+    const params = {
+      chat_id: serialize(chat_id),
+      name: name,
+      icon_color: icon_color,
+      icon_custom_emoji_id: icon_custom_emoji_id,
+    };
+    const clean = Object.fromEntries(Object.entries(params).filter(([_, v]) => v !== undefined && v !== null));
+    const result = await this._request('createForumTopic', clean);
+    return result;
+  }
+
+  async editForumTopic(options = {}) {
+    const {
+      chat_id,
+      message_thread_id,
+      name,
+      icon_custom_emoji_id,
+    } = options;
+
+    if (chat_id === undefined || chat_id === null) {
+      throw new Error('chat_id');
+    }
+    if (message_thread_id === undefined || message_thread_id === null) {
+      throw new Error('message_thread_id');
+    }
+
+    const params = {
+      chat_id: serialize(chat_id),
+      message_thread_id: message_thread_id,
+      name: name,
+      icon_custom_emoji_id: icon_custom_emoji_id,
+    };
+    const clean = Object.fromEntries(Object.entries(params).filter(([_, v]) => v !== undefined && v !== null));
+    const result = await this._request('editForumTopic', clean);
+    return !!result;
+  }
+
+  async closeForumTopic(options = {}) {
+    const {
+      chat_id,
+      message_thread_id,
+    } = options;
+
+    if (chat_id === undefined || chat_id === null) {
+      throw new Error('chat_id');
+    }
+    if (message_thread_id === undefined || message_thread_id === null) {
+      throw new Error('message_thread_id');
+    }
+
+    const params = {
+      chat_id: serialize(chat_id),
+      message_thread_id: message_thread_id,
+    };
+    const clean = Object.fromEntries(Object.entries(params).filter(([_, v]) => v !== undefined && v !== null));
+    const result = await this._request('closeForumTopic', clean);
+    return !!result;
+  }
+
+  async reopenForumTopic(options = {}) {
+    const {
+      chat_id,
+      message_thread_id,
+    } = options;
+
+    if (chat_id === undefined || chat_id === null) {
+      throw new Error('chat_id');
+    }
+    if (message_thread_id === undefined || message_thread_id === null) {
+      throw new Error('message_thread_id');
+    }
+
+    const params = {
+      chat_id: serialize(chat_id),
+      message_thread_id: message_thread_id,
+    };
+    const clean = Object.fromEntries(Object.entries(params).filter(([_, v]) => v !== undefined && v !== null));
+    const result = await this._request('reopenForumTopic', clean);
+    return !!result;
+  }
+
+  async deleteForumTopic(options = {}) {
+    const {
+      chat_id,
+      message_thread_id,
+    } = options;
+
+    if (chat_id === undefined || chat_id === null) {
+      throw new Error('chat_id');
+    }
+    if (message_thread_id === undefined || message_thread_id === null) {
+      throw new Error('message_thread_id');
+    }
+
+    const params = {
+      chat_id: serialize(chat_id),
+      message_thread_id: message_thread_id,
+    };
+    const clean = Object.fromEntries(Object.entries(params).filter(([_, v]) => v !== undefined && v !== null));
+    const result = await this._request('deleteForumTopic', clean);
+    return !!result;
+  }
+
+  async unpinAllForumTopicMessages(options = {}) {
+    const {
+      chat_id,
+      message_thread_id,
+    } = options;
+
+    if (chat_id === undefined || chat_id === null) {
+      throw new Error('chat_id');
+    }
+    if (message_thread_id === undefined || message_thread_id === null) {
+      throw new Error('message_thread_id');
+    }
+
+    const params = {
+      chat_id: serialize(chat_id),
+      message_thread_id: message_thread_id,
+    };
+    const clean = Object.fromEntries(Object.entries(params).filter(([_, v]) => v !== undefined && v !== null));
+    const result = await this._request('unpinAllForumTopicMessages', clean);
+    return !!result;
+  }
+
+  async editGeneralForumTopic(options = {}) {
+    const {
+      chat_id,
+      name,
+    } = options;
+
+    if (chat_id === undefined || chat_id === null) {
+      throw new Error('chat_id');
+    }
+    if (name === undefined || name === null) {
+      throw new Error('name');
+    }
+
+    const params = {
+      chat_id: serialize(chat_id),
+      name: name,
+    };
+    const clean = Object.fromEntries(Object.entries(params).filter(([_, v]) => v !== undefined && v !== null));
+    const result = await this._request('editGeneralForumTopic', clean);
+    return !!result;
+  }
+
+  async closeGeneralForumTopic(options = {}) {
+    const {
+      chat_id,
+    } = options;
+
+    if (chat_id === undefined || chat_id === null) {
+      throw new Error('chat_id');
+    }
+
+    const params = {
+      chat_id: serialize(chat_id),
+    };
+    const clean = Object.fromEntries(Object.entries(params).filter(([_, v]) => v !== undefined && v !== null));
+    const result = await this._request('closeGeneralForumTopic', clean);
+    return !!result;
+  }
+
+  async reopenGeneralForumTopic(options = {}) {
+    const {
+      chat_id,
+    } = options;
+
+    if (chat_id === undefined || chat_id === null) {
+      throw new Error('chat_id');
+    }
+
+    const params = {
+      chat_id: serialize(chat_id),
+    };
+    const clean = Object.fromEntries(Object.entries(params).filter(([_, v]) => v !== undefined && v !== null));
+    const result = await this._request('reopenGeneralForumTopic', clean);
+    return !!result;
+  }
+
+  async hideGeneralForumTopic(options = {}) {
+    const {
+      chat_id,
+    } = options;
+
+    if (chat_id === undefined || chat_id === null) {
+      throw new Error('chat_id');
+    }
+
+    const params = {
+      chat_id: serialize(chat_id),
+    };
+    const clean = Object.fromEntries(Object.entries(params).filter(([_, v]) => v !== undefined && v !== null));
+    const result = await this._request('hideGeneralForumTopic', clean);
+    return !!result;
+  }
+
+  async unhideGeneralForumTopic(options = {}) {
+    const {
+      chat_id,
+    } = options;
+
+    if (chat_id === undefined || chat_id === null) {
+      throw new Error('chat_id');
+    }
+
+    const params = {
+      chat_id: serialize(chat_id),
+    };
+    const clean = Object.fromEntries(Object.entries(params).filter(([_, v]) => v !== undefined && v !== null));
+    const result = await this._request('unhideGeneralForumTopic', clean);
+    return !!result;
+  }
+
+  async unpinAllGeneralForumTopicMessages(options = {}) {
+    const {
+      chat_id,
+    } = options;
+
+    if (chat_id === undefined || chat_id === null) {
+      throw new Error('chat_id');
+    }
+
+    const params = {
+      chat_id: serialize(chat_id),
+    };
+    const clean = Object.fromEntries(Object.entries(params).filter(([_, v]) => v !== undefined && v !== null));
+    const result = await this._request('unpinAllGeneralForumTopicMessages', clean);
+    return !!result;
+  }
+
+  async answerCallbackQuery(options = {}) {
+    const {
+      callback_query_id,
+      text,
+      show_alert,
+      url,
+      cache_time,
+    } = options;
+
+    if (callback_query_id === undefined || callback_query_id === null) {
+      throw new Error('callback_query_id');
+    }
+
+    const params = {
+      callback_query_id: callback_query_id,
+      text: text,
+      show_alert: show_alert,
+      url: url,
+      cache_time: cache_time,
+    };
+    const clean = Object.fromEntries(Object.entries(params).filter(([_, v]) => v !== undefined && v !== null));
+    const result = await this._request('answerCallbackQuery', clean);
+    return !!result;
+  }
+
+  async getUserChatBoosts(options = {}) {
+    const {
+      chat_id,
+      user_id,
+    } = options;
+
+    if (chat_id === undefined || chat_id === null) {
+      throw new Error('chat_id');
+    }
+    if (user_id === undefined || user_id === null) {
+      throw new Error('user_id');
+    }
+
+    const params = {
+      chat_id: serialize(chat_id),
+      user_id: user_id,
+    };
+    const clean = Object.fromEntries(Object.entries(params).filter(([_, v]) => v !== undefined && v !== null));
+    const result = await this._request('getUserChatBoosts', clean);
+    return result;
+  }
+
+  async getBusinessConnection(options = {}) {
+    const {
+      business_connection_id,
+    } = options;
+
+    if (business_connection_id === undefined || business_connection_id === null) {
+      throw new Error('business_connection_id');
+    }
+
+    const params = {
+      business_connection_id: business_connection_id,
+    };
+    const clean = Object.fromEntries(Object.entries(params).filter(([_, v]) => v !== undefined && v !== null));
+    const result = await this._request('getBusinessConnection', clean);
+    return result;
+  }
+
+  async setMyCommands(options = {}) {
+    const {
+      commands,
+      scope,
+      language_code,
+    } = options;
+
+    if (commands === undefined || commands === null) {
+      throw new Error('commands');
+    }
+
+    const params = {
+      commands: serialize(commands),
+      scope: serialize(scope),
+      language_code: language_code,
+    };
+    const clean = Object.fromEntries(Object.entries(params).filter(([_, v]) => v !== undefined && v !== null));
+    const result = await this._request('setMyCommands', clean);
+    return !!result;
+  }
+
+  async deleteMyCommands(options = {}) {
+    const {
+      scope,
+      language_code,
+    } = options;
+
+    const params = {
+      scope: serialize(scope),
+      language_code: language_code,
+    };
+    const clean = Object.fromEntries(Object.entries(params).filter(([_, v]) => v !== undefined && v !== null));
+    const result = await this._request('deleteMyCommands', clean);
+    return !!result;
+  }
+
+  async getMyCommands(options = {}) {
+    const {
+      scope,
+      language_code,
+    } = options;
+
+    const params = {
+      scope: serialize(scope),
+      language_code: language_code,
+    };
+    const clean = Object.fromEntries(Object.entries(params).filter(([_, v]) => v !== undefined && v !== null));
+    const result = await this._request('getMyCommands', clean);
+    return result;
+  }
+
+  async setMyName(options = {}) {
+    const {
+      name,
+      language_code,
+    } = options;
+
+    const params = {
+      name: name,
+      language_code: language_code,
+    };
+    const clean = Object.fromEntries(Object.entries(params).filter(([_, v]) => v !== undefined && v !== null));
+    const result = await this._request('setMyName', clean);
+    return !!result;
+  }
+
+  async getMyName(options = {}) {
+    const {
+      language_code,
+    } = options;
+
+    const params = {
+      language_code: language_code,
+    };
+    const clean = Object.fromEntries(Object.entries(params).filter(([_, v]) => v !== undefined && v !== null));
+    const result = await this._request('getMyName', clean);
+    return result;
+  }
+
+  async setMyDescription(options = {}) {
+    const {
+      description,
+      language_code,
+    } = options;
+
+    const params = {
+      description: description,
+      language_code: language_code,
+    };
+    const clean = Object.fromEntries(Object.entries(params).filter(([_, v]) => v !== undefined && v !== null));
+    const result = await this._request('setMyDescription', clean);
+    return !!result;
+  }
+
+  async getMyDescription(options = {}) {
+    const {
+      language_code,
+    } = options;
+
+    const params = {
+      language_code: language_code,
+    };
+    const clean = Object.fromEntries(Object.entries(params).filter(([_, v]) => v !== undefined && v !== null));
+    const result = await this._request('getMyDescription', clean);
+    return result;
+  }
+
+  async setMyShortDescription(options = {}) {
+    const {
+      short_description,
+      language_code,
+    } = options;
+
+    const params = {
+      short_description: short_description,
+      language_code: language_code,
+    };
+    const clean = Object.fromEntries(Object.entries(params).filter(([_, v]) => v !== undefined && v !== null));
+    const result = await this._request('setMyShortDescription', clean);
+    return !!result;
+  }
+
+  async getMyShortDescription(options = {}) {
+    const {
+      language_code,
+    } = options;
+
+    const params = {
+      language_code: language_code,
+    };
+    const clean = Object.fromEntries(Object.entries(params).filter(([_, v]) => v !== undefined && v !== null));
+    const result = await this._request('getMyShortDescription', clean);
+    return result;
+  }
+
+  async setChatMenuButton(options = {}) {
+    const {
+      chat_id,
+      menu_button,
+    } = options;
+
+    const params = {
+      chat_id: chat_id,
+      menu_button: serialize(menu_button),
+    };
+    const clean = Object.fromEntries(Object.entries(params).filter(([_, v]) => v !== undefined && v !== null));
+    const result = await this._request('setChatMenuButton', clean);
+    return !!result;
+  }
+
+  async getChatMenuButton(options = {}) {
+    const {
+      chat_id,
+    } = options;
+
+    const params = {
+      chat_id: chat_id,
+    };
+    const clean = Object.fromEntries(Object.entries(params).filter(([_, v]) => v !== undefined && v !== null));
+    const result = await this._request('getChatMenuButton', clean);
+    return result;
+  }
+
+  async setMyDefaultAdministratorRights(options = {}) {
+    const {
+      rights,
+      for_channels,
+    } = options;
+
+    const params = {
+      rights: serialize(rights),
+      for_channels: for_channels,
+    };
+    const clean = Object.fromEntries(Object.entries(params).filter(([_, v]) => v !== undefined && v !== null));
+    const result = await this._request('setMyDefaultAdministratorRights', clean);
+    return !!result;
+  }
+
+  async getMyDefaultAdministratorRights(options = {}) {
+    const {
+      for_channels,
+    } = options;
+
+    const params = {
+      for_channels: for_channels,
+    };
+    const clean = Object.fromEntries(Object.entries(params).filter(([_, v]) => v !== undefined && v !== null));
+    const result = await this._request('getMyDefaultAdministratorRights', clean);
+    return result;
+  }
+
+  async getAvailableGifts(_) {
+    const params = {
+    };
+    const clean = Object.fromEntries(Object.entries(params).filter(([_, v]) => v !== undefined && v !== null));
+    const result = await this._request('getAvailableGifts', clean);
+    return result;
+  }
+
+  async sendGift(options = {}) {
+    const {
+      gift_id,
+      user_id,
+      chat_id,
+      pay_for_upgrade,
+      text,
+      text_parse_mode,
+      text_entities,
+    } = options;
+
+    if (gift_id === undefined || gift_id === null) {
+      throw new Error('gift_id');
+    }
+
+    const params = {
+      gift_id: gift_id,
+      user_id: user_id,
+      chat_id: serialize(chat_id),
+      pay_for_upgrade: pay_for_upgrade,
+      text: text,
+      text_parse_mode: text_parse_mode,
+      text_entities: serialize(text_entities),
+    };
+    const clean = Object.fromEntries(Object.entries(params).filter(([_, v]) => v !== undefined && v !== null));
+    const result = await this._request('sendGift', clean);
+    return result;
+  }
+
+  async giftPremiumSubscription(options = {}) {
+    const {
+      user_id,
+      month_count,
+      star_count,
+      text,
+      text_parse_mode,
+      text_entities,
+    } = options;
+
+    if (user_id === undefined || user_id === null) {
+      throw new Error('user_id');
+    }
+    if (month_count === undefined || month_count === null) {
+      throw new Error('month_count');
+    }
+    if (star_count === undefined || star_count === null) {
+      throw new Error('star_count');
+    }
+
+    const params = {
+      user_id: user_id,
+      month_count: month_count,
+      star_count: star_count,
+      text: text,
+      text_parse_mode: text_parse_mode,
+      text_entities: serialize(text_entities),
+    };
+    const clean = Object.fromEntries(Object.entries(params).filter(([_, v]) => v !== undefined && v !== null));
+    const result = await this._request('giftPremiumSubscription', clean);
+    return !!result;
+  }
+
+  async verifyUser(options = {}) {
+    const {
+      user_id,
+      custom_description,
+    } = options;
+
+    if (user_id === undefined || user_id === null) {
+      throw new Error('user_id');
+    }
+
+    const params = {
+      user_id: user_id,
+      custom_description: custom_description,
+    };
+    const clean = Object.fromEntries(Object.entries(params).filter(([_, v]) => v !== undefined && v !== null));
+    const result = await this._request('verifyUser', clean);
+    return !!result;
+  }
+
+  async verifyChat(options = {}) {
+    const {
+      chat_id,
+      custom_description,
+    } = options;
+
+    if (chat_id === undefined || chat_id === null) {
+      throw new Error('chat_id');
+    }
+
+    const params = {
+      chat_id: serialize(chat_id),
+      custom_description: custom_description,
+    };
+    const clean = Object.fromEntries(Object.entries(params).filter(([_, v]) => v !== undefined && v !== null));
+    const result = await this._request('verifyChat', clean);
+    return !!result;
+  }
+
+  async removeUserVerification(options = {}) {
+    const {
+      user_id,
+    } = options;
+
+    if (user_id === undefined || user_id === null) {
+      throw new Error('user_id');
+    }
+
+    const params = {
+      user_id: user_id,
+    };
+    const clean = Object.fromEntries(Object.entries(params).filter(([_, v]) => v !== undefined && v !== null));
+    const result = await this._request('removeUserVerification', clean);
+    return !!result;
+  }
+
+  async removeChatVerification(options = {}) {
+    const {
+      chat_id,
+    } = options;
+
+    if (chat_id === undefined || chat_id === null) {
+      throw new Error('chat_id');
+    }
+
+    const params = {
+      chat_id: serialize(chat_id),
+    };
+    const clean = Object.fromEntries(Object.entries(params).filter(([_, v]) => v !== undefined && v !== null));
+    const result = await this._request('removeChatVerification', clean);
+    return !!result;
+  }
+
+  async readBusinessMessage(options = {}) {
+    const {
+      business_connection_id,
+      chat_id,
+      message_id,
+    } = options;
+
+    if (business_connection_id === undefined || business_connection_id === null) {
+      throw new Error('business_connection_id');
+    }
+    if (chat_id === undefined || chat_id === null) {
+      throw new Error('chat_id');
+    }
+    if (message_id === undefined || message_id === null) {
+      throw new Error('message_id');
+    }
+
+    const params = {
+      business_connection_id: business_connection_id,
+      chat_id: chat_id,
+      message_id: message_id,
+    };
+    const clean = Object.fromEntries(Object.entries(params).filter(([_, v]) => v !== undefined && v !== null));
+    const result = await this._request('readBusinessMessage', clean);
+    return !!result;
+  }
+
+  async deleteBusinessMessages(options = {}) {
+    const {
+      business_connection_id,
+      message_ids,
+    } = options;
+
+    if (business_connection_id === undefined || business_connection_id === null) {
+      throw new Error('business_connection_id');
+    }
+    if (message_ids === undefined || message_ids === null) {
+      throw new Error('message_ids');
+    }
+
+    const params = {
+      business_connection_id: business_connection_id,
+      message_ids: serialize(message_ids),
+    };
+    const clean = Object.fromEntries(Object.entries(params).filter(([_, v]) => v !== undefined && v !== null));
+    const result = await this._request('deleteBusinessMessages', clean);
+    return !!result;
+  }
+
+  async setBusinessAccountName(options = {}) {
+    const {
+      business_connection_id,
+      first_name,
+      last_name,
+    } = options;
+
+    if (business_connection_id === undefined || business_connection_id === null) {
+      throw new Error('business_connection_id');
+    }
+    if (first_name === undefined || first_name === null) {
+      throw new Error('first_name');
+    }
+
+    const params = {
+      business_connection_id: business_connection_id,
+      first_name: first_name,
+      last_name: last_name,
+    };
+    const clean = Object.fromEntries(Object.entries(params).filter(([_, v]) => v !== undefined && v !== null));
+    const result = await this._request('setBusinessAccountName', clean);
+    return !!result;
+  }
+
+  async setBusinessAccountUsername(options = {}) {
+    const {
+      business_connection_id,
+      username,
+    } = options;
+
+    if (business_connection_id === undefined || business_connection_id === null) {
+      throw new Error('business_connection_id');
+    }
+
+    const params = {
+      business_connection_id: business_connection_id,
+      username: username,
+    };
+    const clean = Object.fromEntries(Object.entries(params).filter(([_, v]) => v !== undefined && v !== null));
+    const result = await this._request('setBusinessAccountUsername', clean);
+    return !!result;
+  }
+
+  async setBusinessAccountBio(options = {}) {
+    const {
+      business_connection_id,
+      bio,
+    } = options;
+
+    if (business_connection_id === undefined || business_connection_id === null) {
+      throw new Error('business_connection_id');
+    }
+
+    const params = {
+      business_connection_id: business_connection_id,
+      bio: bio,
+    };
+    const clean = Object.fromEntries(Object.entries(params).filter(([_, v]) => v !== undefined && v !== null));
+    const result = await this._request('setBusinessAccountBio', clean);
+    return !!result;
+  }
+
+  async setBusinessAccountProfilePhoto(options = {}) {
+    const {
+      business_connection_id,
+      photo,
+      is_public,
+    } = options;
+
+    if (business_connection_id === undefined || business_connection_id === null) {
+      throw new Error('business_connection_id');
+    }
+    if (photo === undefined || photo === null) {
+      throw new Error('photo');
+    }
+
+    const params = {
+      business_connection_id: business_connection_id,
+      photo: serialize(photo),
+      is_public: is_public,
+    };
+    const clean = Object.fromEntries(Object.entries(params).filter(([_, v]) => v !== undefined && v !== null));
+    const result = await this._request('setBusinessAccountProfilePhoto', clean);
+    return !!result;
+  }
+
+  async removeBusinessAccountProfilePhoto(options = {}) {
+    const {
+      business_connection_id,
+      is_public,
+    } = options;
+
+    if (business_connection_id === undefined || business_connection_id === null) {
+      throw new Error('business_connection_id');
+    }
+
+    const params = {
+      business_connection_id: business_connection_id,
+      is_public: is_public,
+    };
+    const clean = Object.fromEntries(Object.entries(params).filter(([_, v]) => v !== undefined && v !== null));
+    const result = await this._request('removeBusinessAccountProfilePhoto', clean);
+    return !!result;
+  }
+
+  async setBusinessAccountGiftSettings(options = {}) {
+    const {
+      business_connection_id,
+      show_gift_button,
+      accepted_gift_types,
+    } = options;
+
+    if (business_connection_id === undefined || business_connection_id === null) {
+      throw new Error('business_connection_id');
+    }
+    if (show_gift_button === undefined || show_gift_button === null) {
+      throw new Error('show_gift_button');
+    }
+    if (accepted_gift_types === undefined || accepted_gift_types === null) {
+      throw new Error('accepted_gift_types');
+    }
+
+    const params = {
+      business_connection_id: business_connection_id,
+      show_gift_button: show_gift_button,
+      accepted_gift_types: serialize(accepted_gift_types),
+    };
+    const clean = Object.fromEntries(Object.entries(params).filter(([_, v]) => v !== undefined && v !== null));
+    const result = await this._request('setBusinessAccountGiftSettings', clean);
+    return !!result;
+  }
+
+  async getBusinessAccountStarBalance(options = {}) {
+    const {
+      business_connection_id,
+    } = options;
+
+    if (business_connection_id === undefined || business_connection_id === null) {
+      throw new Error('business_connection_id');
+    }
+
+    const params = {
+      business_connection_id: business_connection_id,
+    };
+    const clean = Object.fromEntries(Object.entries(params).filter(([_, v]) => v !== undefined && v !== null));
+    const result = await this._request('getBusinessAccountStarBalance', clean);
+    return result;
+  }
+
+  async transferBusinessAccountStars(options = {}) {
+    const {
+      business_connection_id,
+      star_count,
+    } = options;
+
+    if (business_connection_id === undefined || business_connection_id === null) {
+      throw new Error('business_connection_id');
+    }
+    if (star_count === undefined || star_count === null) {
+      throw new Error('star_count');
+    }
+
+    const params = {
+      business_connection_id: business_connection_id,
+      star_count: star_count,
+    };
+    const clean = Object.fromEntries(Object.entries(params).filter(([_, v]) => v !== undefined && v !== null));
+    const result = await this._request('transferBusinessAccountStars', clean);
+    return !!result;
+  }
+
+  async getBusinessAccountGifts(options = {}) {
+    const {
+      business_connection_id,
+      exclude_unsaved,
+      exclude_saved,
+      exclude_unlimited,
+      exclude_limited_upgradable,
+      exclude_limited_non_upgradable,
+      exclude_unique,
+      exclude_from_blockchain,
+      sort_by_price,
+      offset,
+      limit,
+    } = options;
+
+    if (business_connection_id === undefined || business_connection_id === null) {
+      throw new Error('business_connection_id');
+    }
+
+    const params = {
+      business_connection_id: business_connection_id,
+      exclude_unsaved: exclude_unsaved,
+      exclude_saved: exclude_saved,
+      exclude_unlimited: exclude_unlimited,
+      exclude_limited_upgradable: exclude_limited_upgradable,
+      exclude_limited_non_upgradable: exclude_limited_non_upgradable,
+      exclude_unique: exclude_unique,
+      exclude_from_blockchain: exclude_from_blockchain,
+      sort_by_price: sort_by_price,
+      offset: offset,
+      limit: limit,
+    };
+    const clean = Object.fromEntries(Object.entries(params).filter(([_, v]) => v !== undefined && v !== null));
+    const result = await this._request('getBusinessAccountGifts', clean);
+    return result;
+  }
+
+  async getUserGifts(options = {}) {
+    const {
+      user_id,
+      exclude_unlimited,
+      exclude_limited_upgradable,
+      exclude_limited_non_upgradable,
+      exclude_from_blockchain,
+      exclude_unique,
+      sort_by_price,
+      offset,
+      limit,
+    } = options;
+
+    if (user_id === undefined || user_id === null) {
+      throw new Error('user_id');
+    }
+
+    const params = {
+      user_id: user_id,
+      exclude_unlimited: exclude_unlimited,
+      exclude_limited_upgradable: exclude_limited_upgradable,
+      exclude_limited_non_upgradable: exclude_limited_non_upgradable,
+      exclude_from_blockchain: exclude_from_blockchain,
+      exclude_unique: exclude_unique,
+      sort_by_price: sort_by_price,
+      offset: offset,
+      limit: limit,
+    };
+    const clean = Object.fromEntries(Object.entries(params).filter(([_, v]) => v !== undefined && v !== null));
+    const result = await this._request('getUserGifts', clean);
+    return result;
+  }
+
+  async getChatGifts(options = {}) {
+    const {
+      chat_id,
+      exclude_unsaved,
+      exclude_saved,
+      exclude_unlimited,
+      exclude_limited_upgradable,
+      exclude_limited_non_upgradable,
+      exclude_from_blockchain,
+      exclude_unique,
+      sort_by_price,
+      offset,
+      limit,
+    } = options;
+
+    if (chat_id === undefined || chat_id === null) {
+      throw new Error('chat_id');
+    }
+
+    const params = {
+      chat_id: serialize(chat_id),
+      exclude_unsaved: exclude_unsaved,
+      exclude_saved: exclude_saved,
+      exclude_unlimited: exclude_unlimited,
+      exclude_limited_upgradable: exclude_limited_upgradable,
+      exclude_limited_non_upgradable: exclude_limited_non_upgradable,
+      exclude_from_blockchain: exclude_from_blockchain,
+      exclude_unique: exclude_unique,
+      sort_by_price: sort_by_price,
+      offset: offset,
+      limit: limit,
+    };
+    const clean = Object.fromEntries(Object.entries(params).filter(([_, v]) => v !== undefined && v !== null));
+    const result = await this._request('getChatGifts', clean);
+    return result;
+  }
+
+  async convertGiftToStars(options = {}) {
+    const {
+      business_connection_id,
+      owned_gift_id,
+    } = options;
+
+    if (business_connection_id === undefined || business_connection_id === null) {
+      throw new Error('business_connection_id');
+    }
+    if (owned_gift_id === undefined || owned_gift_id === null) {
+      throw new Error('owned_gift_id');
+    }
+
+    const params = {
+      business_connection_id: business_connection_id,
+      owned_gift_id: owned_gift_id,
+    };
+    const clean = Object.fromEntries(Object.entries(params).filter(([_, v]) => v !== undefined && v !== null));
+    const result = await this._request('convertGiftToStars', clean);
+    return !!result;
+  }
+
+  async upgradeGift(options = {}) {
+    const {
+      business_connection_id,
+      owned_gift_id,
+      keep_original_details,
+      star_count,
+    } = options;
+
+    if (business_connection_id === undefined || business_connection_id === null) {
+      throw new Error('business_connection_id');
+    }
+    if (owned_gift_id === undefined || owned_gift_id === null) {
+      throw new Error('owned_gift_id');
+    }
+
+    const params = {
+      business_connection_id: business_connection_id,
+      owned_gift_id: owned_gift_id,
+      keep_original_details: keep_original_details,
+      star_count: star_count,
+    };
+    const clean = Object.fromEntries(Object.entries(params).filter(([_, v]) => v !== undefined && v !== null));
+    const result = await this._request('upgradeGift', clean);
+    return !!result;
+  }
+
+  async transferGift(options = {}) {
+    const {
+      business_connection_id,
+      owned_gift_id,
+      new_owner_chat_id,
+      star_count,
+    } = options;
+
+    if (business_connection_id === undefined || business_connection_id === null) {
+      throw new Error('business_connection_id');
+    }
+    if (owned_gift_id === undefined || owned_gift_id === null) {
+      throw new Error('owned_gift_id');
+    }
+    if (new_owner_chat_id === undefined || new_owner_chat_id === null) {
+      throw new Error('new_owner_chat_id');
+    }
+
+    const params = {
+      business_connection_id: business_connection_id,
+      owned_gift_id: owned_gift_id,
+      new_owner_chat_id: new_owner_chat_id,
+      star_count: star_count,
+    };
+    const clean = Object.fromEntries(Object.entries(params).filter(([_, v]) => v !== undefined && v !== null));
+    const result = await this._request('transferGift', clean);
+    return !!result;
+  }
+
+  async postStory(options = {}) {
+    const {
+      business_connection_id,
+      content,
+      active_period,
+      caption,
+      parse_mode,
+      caption_entities,
+      areas,
+      post_to_chat_page,
+      protect_content,
+    } = options;
+
+    if (business_connection_id === undefined || business_connection_id === null) {
+      throw new Error('business_connection_id');
+    }
+    if (content === undefined || content === null) {
+      throw new Error('content');
+    }
+    if (active_period === undefined || active_period === null) {
+      throw new Error('active_period');
+    }
+
+    const params = {
+      business_connection_id: business_connection_id,
+      content: serialize(content),
+      active_period: active_period,
+      caption: caption,
+      parse_mode: parse_mode,
+      caption_entities: serialize(caption_entities),
+      areas: serialize(areas),
+      post_to_chat_page: post_to_chat_page,
+      protect_content: protect_content,
+    };
+    const clean = Object.fromEntries(Object.entries(params).filter(([_, v]) => v !== undefined && v !== null));
+    const result = await this._request('postStory', clean);
+    return result;
+  }
+
+  async repostStory(options = {}) {
+    const {
+      business_connection_id,
+      from_chat_id,
+      from_story_id,
+      active_period,
+      post_to_chat_page,
+      protect_content,
+    } = options;
+
+    if (business_connection_id === undefined || business_connection_id === null) {
+      throw new Error('business_connection_id');
+    }
+    if (from_chat_id === undefined || from_chat_id === null) {
+      throw new Error('from_chat_id');
+    }
+    if (from_story_id === undefined || from_story_id === null) {
+      throw new Error('from_story_id');
+    }
+    if (active_period === undefined || active_period === null) {
+      throw new Error('active_period');
+    }
+
+    const params = {
+      business_connection_id: business_connection_id,
+      from_chat_id: from_chat_id,
+      from_story_id: from_story_id,
+      active_period: active_period,
+      post_to_chat_page: post_to_chat_page,
+      protect_content: protect_content,
+    };
+    const clean = Object.fromEntries(Object.entries(params).filter(([_, v]) => v !== undefined && v !== null));
+    const result = await this._request('repostStory', clean);
+    return result;
+  }
+
+  async editStory(options = {}) {
+    const {
+      business_connection_id,
+      story_id,
+      content,
+      caption,
+      parse_mode,
+      caption_entities,
+      areas,
+    } = options;
+
+    if (business_connection_id === undefined || business_connection_id === null) {
+      throw new Error('business_connection_id');
+    }
+    if (story_id === undefined || story_id === null) {
+      throw new Error('story_id');
+    }
+    if (content === undefined || content === null) {
+      throw new Error('content');
+    }
+
+    const params = {
+      business_connection_id: business_connection_id,
+      story_id: story_id,
+      content: serialize(content),
+      caption: caption,
+      parse_mode: parse_mode,
+      caption_entities: serialize(caption_entities),
+      areas: serialize(areas),
+    };
+    const clean = Object.fromEntries(Object.entries(params).filter(([_, v]) => v !== undefined && v !== null));
+    const result = await this._request('editStory', clean);
+    return result;
+  }
+
+  async deleteStory(options = {}) {
+    const {
+      business_connection_id,
+      story_id,
+    } = options;
+
+    if (business_connection_id === undefined || business_connection_id === null) {
+      throw new Error('business_connection_id');
+    }
+    if (story_id === undefined || story_id === null) {
+      throw new Error('story_id');
+    }
+
+    const params = {
+      business_connection_id: business_connection_id,
+      story_id: story_id,
+    };
+    const clean = Object.fromEntries(Object.entries(params).filter(([_, v]) => v !== undefined && v !== null));
+    const result = await this._request('deleteStory', clean);
+    return !!result;
+  }
+
+  async editMessageText(options = {}) {
+    const {
+      text,
+      business_connection_id,
+      chat_id,
+      message_id,
+      inline_message_id,
+      parse_mode,
+      entities,
+      link_preview_options,
+      reply_markup,
+    } = options;
+
+    if (text === undefined || text === null) {
+      throw new Error('text');
+    }
+
+    const params = {
+      text: text,
+      business_connection_id: business_connection_id,
+      chat_id: serialize(chat_id),
+      message_id: message_id,
+      inline_message_id: inline_message_id,
+      parse_mode: parse_mode,
+      entities: serialize(entities),
+      link_preview_options: serialize(link_preview_options),
+      reply_markup: serialize(reply_markup),
+    };
+    const clean = Object.fromEntries(Object.entries(params).filter(([_, v]) => v !== undefined && v !== null));
+    const result = await this._request('editMessageText', clean);
+    return result;
+  }
+
+  async editMessageCaption(options = {}) {
+    const {
+      business_connection_id,
+      chat_id,
+      message_id,
+      inline_message_id,
+      caption,
+      parse_mode,
+      caption_entities,
+      show_caption_above_media,
+      reply_markup,
+    } = options;
+
+    const params = {
+      business_connection_id: business_connection_id,
+      chat_id: serialize(chat_id),
+      message_id: message_id,
+      inline_message_id: inline_message_id,
+      caption: caption,
+      parse_mode: parse_mode,
+      caption_entities: serialize(caption_entities),
+      show_caption_above_media: show_caption_above_media,
+      reply_markup: serialize(reply_markup),
+    };
+    const clean = Object.fromEntries(Object.entries(params).filter(([_, v]) => v !== undefined && v !== null));
+    const result = await this._request('editMessageCaption', clean);
+    return result;
+  }
+
+  async editMessageMedia(options = {}) {
+    const {
+      media,
+      business_connection_id,
+      chat_id,
+      message_id,
+      inline_message_id,
+      reply_markup,
+    } = options;
+
+    if (media === undefined || media === null) {
+      throw new Error('media');
+    }
+
+    const params = {
+      media: serialize(media),
+      business_connection_id: business_connection_id,
+      chat_id: serialize(chat_id),
+      message_id: message_id,
+      inline_message_id: inline_message_id,
+      reply_markup: serialize(reply_markup),
+    };
+    const clean = Object.fromEntries(Object.entries(params).filter(([_, v]) => v !== undefined && v !== null));
+    const result = await this._request('editMessageMedia', clean);
+    return result;
+  }
+
+  async editMessageLiveLocation(options = {}) {
+    const {
+      latitude,
+      longitude,
+      business_connection_id,
+      chat_id,
+      message_id,
+      inline_message_id,
+      live_period,
+      horizontal_accuracy,
+      heading,
+      proximity_alert_radius,
+      reply_markup,
+    } = options;
+
+    if (latitude === undefined || latitude === null) {
+      throw new Error('latitude');
+    }
+    if (longitude === undefined || longitude === null) {
+      throw new Error('longitude');
+    }
+
+    const params = {
+      latitude: latitude,
+      longitude: longitude,
+      business_connection_id: business_connection_id,
+      chat_id: serialize(chat_id),
+      message_id: message_id,
+      inline_message_id: inline_message_id,
+      live_period: live_period,
+      horizontal_accuracy: horizontal_accuracy,
+      heading: heading,
+      proximity_alert_radius: proximity_alert_radius,
+      reply_markup: serialize(reply_markup),
+    };
+    const clean = Object.fromEntries(Object.entries(params).filter(([_, v]) => v !== undefined && v !== null));
+    const result = await this._request('editMessageLiveLocation', clean);
+    return !!result;
+  }
+
+  async stopMessageLiveLocation(options = {}) {
+    const {
+      business_connection_id,
+      chat_id,
+      message_id,
+      inline_message_id,
+      reply_markup,
+    } = options;
+
+    const params = {
+      business_connection_id: business_connection_id,
+      chat_id: serialize(chat_id),
+      message_id: message_id,
+      inline_message_id: inline_message_id,
+      reply_markup: serialize(reply_markup),
+    };
+    const clean = Object.fromEntries(Object.entries(params).filter(([_, v]) => v !== undefined && v !== null));
+    const result = await this._request('stopMessageLiveLocation', clean);
+    return result;
+  }
+
+  async editMessageChecklist(options = {}) {
+    const {
+      business_connection_id,
+      chat_id,
+      message_id,
+      checklist,
+      reply_markup,
+    } = options;
+
+    if (business_connection_id === undefined || business_connection_id === null) {
+      throw new Error('business_connection_id');
+    }
+    if (chat_id === undefined || chat_id === null) {
+      throw new Error('chat_id');
+    }
+    if (message_id === undefined || message_id === null) {
+      throw new Error('message_id');
+    }
+    if (checklist === undefined || checklist === null) {
+      throw new Error('checklist');
+    }
+
+    const params = {
+      business_connection_id: business_connection_id,
+      chat_id: chat_id,
+      message_id: message_id,
+      checklist: serialize(checklist),
+      reply_markup: serialize(reply_markup),
+    };
+    const clean = Object.fromEntries(Object.entries(params).filter(([_, v]) => v !== undefined && v !== null));
+    const result = await this._request('editMessageChecklist', clean);
+    return !!result;
+  }
+
+  async editMessageReplyMarkup(options = {}) {
+    const {
+      business_connection_id,
+      chat_id,
+      message_id,
+      inline_message_id,
+      reply_markup,
+    } = options;
+
+    const params = {
+      business_connection_id: business_connection_id,
+      chat_id: serialize(chat_id),
+      message_id: message_id,
+      inline_message_id: inline_message_id,
+      reply_markup: serialize(reply_markup),
+    };
+    const clean = Object.fromEntries(Object.entries(params).filter(([_, v]) => v !== undefined && v !== null));
+    const result = await this._request('editMessageReplyMarkup', clean);
+    return result;
+  }
+
+  async stopPoll(options = {}) {
+    const {
+      chat_id,
+      message_id,
+      business_connection_id,
+      reply_markup,
+    } = options;
+
+    if (chat_id === undefined || chat_id === null) {
+      throw new Error('chat_id');
+    }
+    if (message_id === undefined || message_id === null) {
+      throw new Error('message_id');
+    }
+
+    const params = {
+      chat_id: serialize(chat_id),
+      message_id: message_id,
+      business_connection_id: business_connection_id,
+      reply_markup: serialize(reply_markup),
+    };
+    const clean = Object.fromEntries(Object.entries(params).filter(([_, v]) => v !== undefined && v !== null));
+    const result = await this._request('stopPoll', clean);
+    return result;
+  }
+
+  async approveSuggestedPost(options = {}) {
+    const {
+      chat_id,
+      message_id,
+      send_date,
+    } = options;
+
+    if (chat_id === undefined || chat_id === null) {
+      throw new Error('chat_id');
+    }
+    if (message_id === undefined || message_id === null) {
+      throw new Error('message_id');
+    }
+
+    const params = {
+      chat_id: chat_id,
+      message_id: message_id,
+      send_date: send_date,
+    };
+    const clean = Object.fromEntries(Object.entries(params).filter(([_, v]) => v !== undefined && v !== null));
+    const result = await this._request('approveSuggestedPost', clean);
+    return !!result;
+  }
+
+  async declineSuggestedPost(options = {}) {
+    const {
+      chat_id,
+      message_id,
+      comment,
+    } = options;
+
+    if (chat_id === undefined || chat_id === null) {
+      throw new Error('chat_id');
+    }
+    if (message_id === undefined || message_id === null) {
+      throw new Error('message_id');
+    }
+
+    const params = {
+      chat_id: chat_id,
+      message_id: message_id,
+      comment: comment,
+    };
+    const clean = Object.fromEntries(Object.entries(params).filter(([_, v]) => v !== undefined && v !== null));
+    const result = await this._request('declineSuggestedPost', clean);
+    return !!result;
+  }
+
+  async deleteMessages(options = {}) {
+    const {
+      chat_id,
+      message_ids,
+    } = options;
+
+    if (chat_id === undefined || chat_id === null) {
+      throw new Error('chat_id');
+    }
+    if (message_ids === undefined || message_ids === null) {
+      throw new Error('message_ids');
+    }
+
+    const params = {
+      chat_id: serialize(chat_id),
+      message_ids: serialize(message_ids),
+    };
+    const clean = Object.fromEntries(Object.entries(params).filter(([_, v]) => v !== undefined && v !== null));
+    const result = await this._request('deleteMessages', clean);
+    return !!result;
+  }
+
+  async getStickerSet(options = {}) {
+    const {
+      name,
+    } = options;
+
+    if (name === undefined || name === null) {
+      throw new Error('name');
+    }
+
+    const params = {
+      name: name,
+    };
+    const clean = Object.fromEntries(Object.entries(params).filter(([_, v]) => v !== undefined && v !== null));
+    const result = await this._request('getStickerSet', clean);
+    return result;
+  }
+
+  async getCustomEmojiStickers(options = {}) {
+    const {
+      custom_emoji_ids,
+    } = options;
+
+    if (custom_emoji_ids === undefined || custom_emoji_ids === null) {
+      throw new Error('custom_emoji_ids');
+    }
+
+    const params = {
+      custom_emoji_ids: serialize(custom_emoji_ids),
+    };
+    const clean = Object.fromEntries(Object.entries(params).filter(([_, v]) => v !== undefined && v !== null));
+    const result = await this._request('getCustomEmojiStickers', clean);
+    return result;
+  }
+
+  async createNewStickerSet(options = {}) {
+    const {
+      user_id,
+      name,
+      title,
+      stickers,
+      sticker_type,
+      needs_repainting,
+    } = options;
+
+    if (user_id === undefined || user_id === null) {
+      throw new Error('user_id');
+    }
+    if (name === undefined || name === null) {
+      throw new Error('name');
+    }
+    if (title === undefined || title === null) {
+      throw new Error('title');
+    }
+    if (stickers === undefined || stickers === null) {
+      throw new Error('stickers');
+    }
+
+    const params = {
+      user_id: user_id,
+      name: name,
+      title: title,
+      stickers: serialize(stickers),
+      sticker_type: sticker_type,
+      needs_repainting: needs_repainting,
+    };
+    const clean = Object.fromEntries(Object.entries(params).filter(([_, v]) => v !== undefined && v !== null));
+    const result = await this._request('createNewStickerSet', clean);
+    return !!result;
+  }
+
+  async addStickerToSet(options = {}) {
+    const {
+      user_id,
+      name,
+      sticker,
+    } = options;
+
+    if (user_id === undefined || user_id === null) {
+      throw new Error('user_id');
+    }
+    if (name === undefined || name === null) {
+      throw new Error('name');
+    }
+    if (sticker === undefined || sticker === null) {
+      throw new Error('sticker');
+    }
+
+    const params = {
+      user_id: user_id,
+      name: name,
+      sticker: serialize(sticker),
+    };
+    const clean = Object.fromEntries(Object.entries(params).filter(([_, v]) => v !== undefined && v !== null));
+    const result = await this._request('addStickerToSet', clean);
+    return !!result;
+  }
+
+  async setStickerPositionInSet(options = {}) {
+    const {
+      sticker,
+      position,
+    } = options;
+
+    if (sticker === undefined || sticker === null) {
+      throw new Error('sticker');
+    }
+    if (position === undefined || position === null) {
+      throw new Error('position');
+    }
+
+    const params = {
+      sticker: sticker,
+      position: position,
+    };
+    const clean = Object.fromEntries(Object.entries(params).filter(([_, v]) => v !== undefined && v !== null));
+    const result = await this._request('setStickerPositionInSet', clean);
+    return !!result;
+  }
+
+  async deleteStickerFromSet(options = {}) {
+    const {
+      sticker,
+    } = options;
+
+    if (sticker === undefined || sticker === null) {
+      throw new Error('sticker');
+    }
+
+    const params = {
+      sticker: sticker,
+    };
+    const clean = Object.fromEntries(Object.entries(params).filter(([_, v]) => v !== undefined && v !== null));
+    const result = await this._request('deleteStickerFromSet', clean);
+    return !!result;
+  }
+
+  async replaceStickerInSet(options = {}) {
+    const {
+      user_id,
+      name,
+      old_sticker,
+      sticker,
+    } = options;
+
+    if (user_id === undefined || user_id === null) {
+      throw new Error('user_id');
+    }
+    if (name === undefined || name === null) {
+      throw new Error('name');
+    }
+    if (old_sticker === undefined || old_sticker === null) {
+      throw new Error('old_sticker');
+    }
+    if (sticker === undefined || sticker === null) {
+      throw new Error('sticker');
+    }
+
+    const params = {
+      user_id: user_id,
+      name: name,
+      old_sticker: old_sticker,
+      sticker: serialize(sticker),
+    };
+    const clean = Object.fromEntries(Object.entries(params).filter(([_, v]) => v !== undefined && v !== null));
+    const result = await this._request('replaceStickerInSet', clean);
+    return !!result;
+  }
+
+  async setStickerEmojiList(options = {}) {
+    const {
+      sticker,
+      emoji_list,
+    } = options;
+
+    if (sticker === undefined || sticker === null) {
+      throw new Error('sticker');
+    }
+    if (emoji_list === undefined || emoji_list === null) {
+      throw new Error('emoji_list');
+    }
+
+    const params = {
+      sticker: sticker,
+      emoji_list: serialize(emoji_list),
+    };
+    const clean = Object.fromEntries(Object.entries(params).filter(([_, v]) => v !== undefined && v !== null));
+    const result = await this._request('setStickerEmojiList', clean);
+    return !!result;
+  }
+
+  async setStickerKeywords(options = {}) {
+    const {
+      sticker,
+      keywords,
+    } = options;
+
+    if (sticker === undefined || sticker === null) {
+      throw new Error('sticker');
+    }
+
+    const params = {
+      sticker: sticker,
+      keywords: serialize(keywords),
+    };
+    const clean = Object.fromEntries(Object.entries(params).filter(([_, v]) => v !== undefined && v !== null));
+    const result = await this._request('setStickerKeywords', clean);
+    return !!result;
+  }
+
+  async setStickerMaskPosition(options = {}) {
+    const {
+      sticker,
+      mask_position,
+    } = options;
+
+    if (sticker === undefined || sticker === null) {
+      throw new Error('sticker');
+    }
+
+    const params = {
+      sticker: sticker,
+      mask_position: serialize(mask_position),
+    };
+    const clean = Object.fromEntries(Object.entries(params).filter(([_, v]) => v !== undefined && v !== null));
+    const result = await this._request('setStickerMaskPosition', clean);
+    return !!result;
+  }
+
+  async setStickerSetTitle(options = {}) {
+    const {
+      name,
+      title,
+    } = options;
+
+    if (name === undefined || name === null) {
+      throw new Error('name');
+    }
+    if (title === undefined || title === null) {
+      throw new Error('title');
+    }
+
+    const params = {
+      name: name,
+      title: title,
+    };
+    const clean = Object.fromEntries(Object.entries(params).filter(([_, v]) => v !== undefined && v !== null));
+    const result = await this._request('setStickerSetTitle', clean);
+    return !!result;
+  }
+
+  async setCustomEmojiStickerSetThumbnail(options = {}) {
+    const {
+      name,
+      custom_emoji_id,
+    } = options;
+
+    if (name === undefined || name === null) {
+      throw new Error('name');
+    }
+
+    const params = {
+      name: name,
+      custom_emoji_id: custom_emoji_id,
+    };
+    const clean = Object.fromEntries(Object.entries(params).filter(([_, v]) => v !== undefined && v !== null));
+    const result = await this._request('setCustomEmojiStickerSetThumbnail', clean);
+    return !!result;
+  }
+
+  async deleteStickerSet(options = {}) {
+    const {
+      name,
+    } = options;
+
+    if (name === undefined || name === null) {
+      throw new Error('name');
+    }
+
+    const params = {
+      name: name,
+    };
+    const clean = Object.fromEntries(Object.entries(params).filter(([_, v]) => v !== undefined && v !== null));
+    const result = await this._request('deleteStickerSet', clean);
+    return !!result;
+  }
+
+  async answerInlineQuery(options = {}) {
+    const {
+      inline_query_id,
+      results,
+      cache_time,
+      is_personal,
+      next_offset,
+      button,
+    } = options;
+
+    if (inline_query_id === undefined || inline_query_id === null) {
+      throw new Error('inline_query_id');
+    }
+    if (results === undefined || results === null) {
+      throw new Error('results');
+    }
+
+    const params = {
+      inline_query_id: inline_query_id,
+      results: serialize(results),
+      cache_time: cache_time,
+      is_personal: is_personal,
+      next_offset: next_offset,
+      button: serialize(button),
+    };
+    const clean = Object.fromEntries(Object.entries(params).filter(([_, v]) => v !== undefined && v !== null));
+    const result = await this._request('answerInlineQuery', clean);
+    return !!result;
+  }
+
+  async answerWebAppQuery(options = {}) {
+    const {
+      web_app_query_id,
+    } = options;
+
+    if (web_app_query_id === undefined || web_app_query_id === null) {
+      throw new Error('web_app_query_id');
+    }
+    if (result === undefined || result === null) {
+      throw new Error('result');
+    }
+
+    const params = {
+      web_app_query_id: web_app_query_id,
+      result: serialize(result),
+    };
+    const clean = Object.fromEntries(Object.entries(params).filter(([_, v]) => v !== undefined && v !== null));
+    const result = await this._request('answerWebAppQuery', clean);
+    return !!result;
+  }
+
+  async savePreparedInlineMessage(options = {}) {
+    const {
+      user_id,
+      allow_user_chats,
+      allow_bot_chats,
+      allow_group_chats,
+      allow_channel_chats,
+    } = options;
+
+    if (user_id === undefined || user_id === null) {
+      throw new Error('user_id');
+    }
+    if (result === undefined || result === null) {
+      throw new Error('result');
+    }
+
+    const params = {
+      user_id: user_id,
+      result: serialize(result),
+      allow_user_chats: allow_user_chats,
+      allow_bot_chats: allow_bot_chats,
+      allow_group_chats: allow_group_chats,
+      allow_channel_chats: allow_channel_chats,
+    };
+    const clean = Object.fromEntries(Object.entries(params).filter(([_, v]) => v !== undefined && v !== null));
+    const result = await this._request('savePreparedInlineMessage', clean);
+    return result;
+  }
+
+  async sendInvoice(options = {}) {
+    const {
+      chat_id,
+      title,
+      description,
+      payload,
+      currency,
+      prices,
+      message_thread_id,
+      direct_messages_topic_id,
+      provider_token,
+      max_tip_amount,
+      suggested_tip_amounts,
+      start_parameter,
+      provider_data,
+      photo_url,
+      photo_size,
+      photo_width,
+      photo_height,
+      need_name,
+      need_phone_number,
+      need_email,
+      need_shipping_address,
+      send_phone_number_to_provider,
+      send_email_to_provider,
+      is_flexible,
+      disable_notification,
+      protect_content,
+      allow_paid_broadcast,
+      message_effect_id,
+      suggested_post_parameters,
+      reply_parameters,
+      reply_markup,
+    } = options;
+
+    if (chat_id === undefined || chat_id === null) {
+      throw new Error('chat_id');
+    }
+    if (title === undefined || title === null) {
+      throw new Error('title');
+    }
+    if (description === undefined || description === null) {
+      throw new Error('description');
+    }
+    if (payload === undefined || payload === null) {
+      throw new Error('payload');
+    }
+    if (currency === undefined || currency === null) {
+      throw new Error('currency');
+    }
+    if (prices === undefined || prices === null) {
+      throw new Error('prices');
+    }
+
+    const params = {
+      chat_id: serialize(chat_id),
+      title: title,
+      description: description,
+      payload: payload,
+      currency: currency,
+      prices: serialize(prices),
+      message_thread_id: message_thread_id,
+      direct_messages_topic_id: direct_messages_topic_id,
+      provider_token: provider_token,
+      max_tip_amount: max_tip_amount,
+      suggested_tip_amounts: serialize(suggested_tip_amounts),
+      start_parameter: start_parameter,
+      provider_data: provider_data,
+      photo_url: photo_url,
+      photo_size: photo_size,
+      photo_width: photo_width,
+      photo_height: photo_height,
+      need_name: need_name,
+      need_phone_number: need_phone_number,
+      need_email: need_email,
+      need_shipping_address: need_shipping_address,
+      send_phone_number_to_provider: send_phone_number_to_provider,
+      send_email_to_provider: send_email_to_provider,
+      is_flexible: is_flexible,
+      disable_notification: disable_notification,
+      protect_content: protect_content,
+      allow_paid_broadcast: allow_paid_broadcast,
+      message_effect_id: message_effect_id,
+      suggested_post_parameters: serialize(suggested_post_parameters),
+      reply_parameters: serialize(reply_parameters),
+      reply_markup: serialize(reply_markup),
+    };
+    const clean = Object.fromEntries(Object.entries(params).filter(([_, v]) => v !== undefined && v !== null));
+    const result = await this._request('sendInvoice', clean);
+    return result;
+  }
+
+  async createInvoiceLink(options = {}) {
+    const {
+      title,
+      description,
+      payload,
+      currency,
+      prices,
+      business_connection_id,
+      provider_token,
+      subscription_period,
+      max_tip_amount,
+      suggested_tip_amounts,
+      provider_data,
+      photo_url,
+      photo_size,
+      photo_width,
+      photo_height,
+      need_name,
+      need_phone_number,
+      need_email,
+      need_shipping_address,
+      send_phone_number_to_provider,
+      send_email_to_provider,
+      is_flexible,
+    } = options;
+
+    if (title === undefined || title === null) {
+      throw new Error('title');
+    }
+    if (description === undefined || description === null) {
+      throw new Error('description');
+    }
+    if (payload === undefined || payload === null) {
+      throw new Error('payload');
+    }
+    if (currency === undefined || currency === null) {
+      throw new Error('currency');
+    }
+    if (prices === undefined || prices === null) {
+      throw new Error('prices');
+    }
+
+    const params = {
+      title: title,
+      description: description,
+      payload: payload,
+      currency: currency,
+      prices: serialize(prices),
+      business_connection_id: business_connection_id,
+      provider_token: provider_token,
+      subscription_period: subscription_period,
+      max_tip_amount: max_tip_amount,
+      suggested_tip_amounts: serialize(suggested_tip_amounts),
+      provider_data: provider_data,
+      photo_url: photo_url,
+      photo_size: photo_size,
+      photo_width: photo_width,
+      photo_height: photo_height,
+      need_name: need_name,
+      need_phone_number: need_phone_number,
+      need_email: need_email,
+      need_shipping_address: need_shipping_address,
+      send_phone_number_to_provider: send_phone_number_to_provider,
+      send_email_to_provider: send_email_to_provider,
+      is_flexible: is_flexible,
+    };
+    const clean = Object.fromEntries(Object.entries(params).filter(([_, v]) => v !== undefined && v !== null));
+    const result = await this._request('createInvoiceLink', clean);
+    return !!result;
+  }
+
+  async answerShippingQuery(options = {}) {
+    const {
+      shipping_query_id,
+      ok,
+      shipping_options,
+      error_message,
+    } = options;
+
+    if (shipping_query_id === undefined || shipping_query_id === null) {
+      throw new Error('shipping_query_id');
+    }
+    if (ok === undefined || ok === null) {
+      throw new Error('ok');
+    }
+
+    const params = {
+      shipping_query_id: shipping_query_id,
+      ok: ok,
+      shipping_options: serialize(shipping_options),
+      error_message: error_message,
+    };
+    const clean = Object.fromEntries(Object.entries(params).filter(([_, v]) => v !== undefined && v !== null));
+    const result = await this._request('answerShippingQuery', clean);
+    return !!result;
+  }
+
+  async answerPreCheckoutQuery(options = {}) {
+    const {
+      pre_checkout_query_id,
+      ok,
+      error_message,
+    } = options;
+
+    if (pre_checkout_query_id === undefined || pre_checkout_query_id === null) {
+      throw new Error('pre_checkout_query_id');
+    }
+    if (ok === undefined || ok === null) {
+      throw new Error('ok');
+    }
+
+    const params = {
+      pre_checkout_query_id: pre_checkout_query_id,
+      ok: ok,
+      error_message: error_message,
+    };
+    const clean = Object.fromEntries(Object.entries(params).filter(([_, v]) => v !== undefined && v !== null));
+    const result = await this._request('answerPreCheckoutQuery', clean);
+    return !!result;
+  }
+
+  async getMyStarBalance(_) {
+    const params = {
+    };
+    const clean = Object.fromEntries(Object.entries(params).filter(([_, v]) => v !== undefined && v !== null));
+    const result = await this._request('getMyStarBalance', clean);
+    return !!result;
+  }
+
+  async getStarTransactions(options = {}) {
+    const {
+      offset,
+      limit,
+    } = options;
+
+    const params = {
+      offset: offset,
+      limit: limit,
+    };
+    const clean = Object.fromEntries(Object.entries(params).filter(([_, v]) => v !== undefined && v !== null));
+    const result = await this._request('getStarTransactions', clean);
+    return !!result;
+  }
+
+  async refundStarPayment(options = {}) {
+    const {
+      user_id,
+      telegram_payment_charge_id,
+    } = options;
+
+    if (user_id === undefined || user_id === null) {
+      throw new Error('user_id');
+    }
+    if (telegram_payment_charge_id === undefined || telegram_payment_charge_id === null) {
+      throw new Error('telegram_payment_charge_id');
+    }
+
+    const params = {
+      user_id: user_id,
+      telegram_payment_charge_id: telegram_payment_charge_id,
+    };
+    const clean = Object.fromEntries(Object.entries(params).filter(([_, v]) => v !== undefined && v !== null));
+    const result = await this._request('refundStarPayment', clean);
+    return !!result;
+  }
+
+  async editUserStarSubscription(options = {}) {
+    const {
+      user_id,
+      telegram_payment_charge_id,
+      is_canceled,
+    } = options;
+
+    if (user_id === undefined || user_id === null) {
+      throw new Error('user_id');
+    }
+    if (telegram_payment_charge_id === undefined || telegram_payment_charge_id === null) {
+      throw new Error('telegram_payment_charge_id');
+    }
+    if (is_canceled === undefined || is_canceled === null) {
+      throw new Error('is_canceled');
+    }
+
+    const params = {
+      user_id: user_id,
+      telegram_payment_charge_id: telegram_payment_charge_id,
+      is_canceled: is_canceled,
+    };
+    const clean = Object.fromEntries(Object.entries(params).filter(([_, v]) => v !== undefined && v !== null));
+    const result = await this._request('editUserStarSubscription', clean);
+    return !!result;
+  }
+
+  async setPassportDataErrors(options = {}) {
+    const {
+      user_id,
+      errors,
+    } = options;
+
+    if (user_id === undefined || user_id === null) {
+      throw new Error('user_id');
+    }
+    if (errors === undefined || errors === null) {
+      throw new Error('errors');
+    }
+
+    const params = {
+      user_id: user_id,
+      errors: serialize(errors),
+    };
+    const clean = Object.fromEntries(Object.entries(params).filter(([_, v]) => v !== undefined && v !== null));
+    const result = await this._request('setPassportDataErrors', clean);
+    return !!result;
+  }
+
+  async sendGame(options = {}) {
+    const {
+      chat_id,
+      game_short_name,
+      business_connection_id,
+      message_thread_id,
+      disable_notification,
+      protect_content,
+      allow_paid_broadcast,
+      message_effect_id,
+      reply_parameters,
+      reply_markup,
+    } = options;
+
+    if (chat_id === undefined || chat_id === null) {
+      throw new Error('chat_id');
+    }
+    if (game_short_name === undefined || game_short_name === null) {
+      throw new Error('game_short_name');
+    }
+
+    const params = {
+      chat_id: chat_id,
+      game_short_name: game_short_name,
+      business_connection_id: business_connection_id,
+      message_thread_id: message_thread_id,
+      disable_notification: disable_notification,
+      protect_content: protect_content,
+      allow_paid_broadcast: allow_paid_broadcast,
+      message_effect_id: message_effect_id,
+      reply_parameters: serialize(reply_parameters),
+      reply_markup: serialize(reply_markup),
+    };
+    const clean = Object.fromEntries(Object.entries(params).filter(([_, v]) => v !== undefined && v !== null));
+    const result = await this._request('sendGame', clean);
+    return result;
+  }
+
+  async setGameScore(options = {}) {
+    const {
+      user_id,
+      score,
+      force,
+      disable_edit_message,
+      chat_id,
+      message_id,
+      inline_message_id,
+    } = options;
+
+    if (user_id === undefined || user_id === null) {
+      throw new Error('user_id');
+    }
+    if (score === undefined || score === null) {
+      throw new Error('score');
+    }
+
+    const params = {
+      user_id: user_id,
+      score: score,
+      force: force,
+      disable_edit_message: disable_edit_message,
+      chat_id: chat_id,
+      message_id: message_id,
+      inline_message_id: inline_message_id,
+    };
+    const clean = Object.fromEntries(Object.entries(params).filter(([_, v]) => v !== undefined && v !== null));
+    const result = await this._request('setGameScore', clean);
+    return !!result;
+  }
+
+  async getGameHighScores(options = {}) {
+    const {
+      user_id,
+      chat_id,
+      message_id,
+      inline_message_id,
+    } = options;
+
+    if (user_id === undefined || user_id === null) {
+      throw new Error('user_id');
+    }
+
+    const params = {
+      user_id: user_id,
+      chat_id: chat_id,
+      message_id: message_id,
+      inline_message_id: inline_message_id,
+    };
+    const clean = Object.fromEntries(Object.entries(params).filter(([_, v]) => v !== undefined && v !== null));
+    const result = await this._request('getGameHighScores', clean);
+    return result;
+  }
+
+  async sendSticker(options = {}) {
+    const {
+      chat_id,
+      sticker,
+      business_connection_id,
+      message_thread_id,
+      direct_messages_topic_id,
+      emoji,
+      disable_notification,
+      protect_content,
+      allow_paid_broadcast,
+      message_effect_id,
+      suggested_post_parameters,
+      reply_parameters,
+      reply_markup,
+    } = options;
+    if (chat_id === undefined || chat_id === null) {
+      throw new Error('chat_id required');
+    }
+    if (!sticker) {
+      throw new Error('sticker required');
+    }
+    const params = {
+      chat_id: serialize(chat_id),
+      business_connection_id,
+      message_thread_id,
+      direct_messages_topic_id,
+      emoji,
+      disable_notification,
+      protect_content,
+      allow_paid_broadcast,
+      message_effect_id,
+      suggested_post_parameters: serialize(suggested_post_parameters),
+      reply_parameters: serialize(reply_parameters),
+      reply_markup: serialize(reply_markup),
+    };
+    const clean = Object.fromEntries(Object.entries(params).filter(([_, v]) => v !== undefined && v !== null));
+    const files = {};
+    if (sticker instanceof Buffer || (sticker && typeof sticker.pipe === 'function')) {
+      files.sticker = sticker;
+    } else {
+      clean.sticker = sticker;
+    }
+    const result = await this._request('sendSticker', clean, files);
+    return result;
+  }
+
+  async setChatPhoto(options = {}) {
+    const {
+      chat_id,
+      photo,
+    } = options;
+    if (chat_id === undefined || chat_id === null) {
+      throw new Error('chat_id required');
+    }
+    if (!photo) {
+      throw new Error('photo required');
+    }
+    const params = {
+      chat_id: serialize(chat_id),
+    };
+    const clean = Object.fromEntries(Object.entries(params).filter(([_, v]) => v !== undefined && v !== null));
+    const files = {};
+    if (photo instanceof Buffer || (photo && typeof photo.pipe === 'function')) {
+      files.photo = photo;
+    } else {
+      clean.photo = photo;
+    }
+    const result = await this._request('setChatPhoto', clean, files);
+    return !!result;
+  }
+
+  async uploadStickerFile(options = {}) {
+    const {
+      user_id,
+      sticker,
+      sticker_format,
+    } = options;
+    if (user_id === undefined || user_id === null) {
+      throw new Error('user_id required');
+    }
+    if (!sticker) {
+      throw new Error('sticker required');
+    }
+    if (sticker_format === undefined || sticker_format === null) {
+      throw new Error('sticker_format required');
+    }
+    const params = {
+      user_id,
+      sticker_format,
+    };
+    const clean = Object.fromEntries(Object.entries(params).filter(([_, v]) => v !== undefined && v !== null));
+    const files = {};
+    if (sticker instanceof Buffer || (sticker && typeof sticker.pipe === 'function')) {
+      files.sticker = sticker;
+    } else {
+      clean.sticker = sticker;
+    }
+    const result = await this._request('uploadStickerFile', clean, files);
+    return result;
+  }
+
+  async setStickerSetThumbnail(options = {}) {
+    const {
+      name,
+      user_id,
+      format,
+      thumbnail,
+    } = options;
+    if (name === undefined || name === null) {
+      throw new Error('name required');
+    }
+    if (user_id === undefined || user_id === null) {
+      throw new Error('user_id required');
+    }
+    if (format === undefined || format === null) {
+      throw new Error('format required');
+    }
+    const params = {
+      name,
+      user_id,
+      format,
+    };
+    const clean = Object.fromEntries(Object.entries(params).filter(([_, v]) => v !== undefined && v !== null));
+    const files = {};
+    if (thumbnail) {
+      if (thumbnail instanceof Buffer || (thumbnail && typeof thumbnail.pipe === 'function')) {
+        files.thumbnail = thumbnail;
+      } else {
+        clean.thumbnail = thumbnail;
+      }
+    }
+    const result = await this._request('setStickerSetThumbnail', clean, files);
+    return !!result;
+  }
+}