@mtcute/core 0.16.7 → 0.16.9

package/client.js

@@ -1 +1,1373 @@
-export * from './esm/highlevel/client.js'
+import EventEmitter from "node:events";
+import { tl } from "@mtcute/tl";
+import { Reloadable, MtClient, UpdatesManager, TelegramStorageManager, BusinessCallbackQuery$2, DeleteBusinessMessageUpdate$2, BusinessMessage, BotReactionCountUpdate$2, BotReactionUpdate$2, DeleteStoryUpdate$2, StoryUpdate$2, PreCheckoutQuery$2, ChatJoinRequestUpdate$2, BotChatJoinRequestUpdate$2, BotStoppedUpdate$2, HistoryReadUpdate$1, DeleteMessageUpdate$1, UserTypingUpdate$1, UserStatusUpdate$2, PollVoteUpdate$2, PollUpdate$2, InlineCallbackQuery$2, CallbackQuery$2, ChosenInlineResult$2, InlineQuery$2, ChatMemberUpdate$2, Conversation } from "./chunks/es/BbjNWA_t.js";
+import { MtTypeAssertionError, MtArgumentError, MtUnsupportedError } from "./chunks/es/DBMBgE7t.js";
+import { asyncResettable } from "./chunks/es/CO4G3ySK.js";
+import { LogManager } from "./chunks/es/BRgz_-S8.js";
+import { isTlRpcError } from "./chunks/es/BN3qj7tU.js";
+import "@mtcute/tl-runtime";
+import { tlJsonToJson, readStringSession, writeStringSession, computeSrpParams, computeNewPasswordHash } from "./chunks/es/hecWgeql.js";
+import { setTimeoutWrap } from "./chunks/es/DY1E3mHM.js";
+import { BusinessConnection$2, Message$2, getPeerDialogs, _normalizeInputFile, _normalizeInputMedia, uploadFile, getDiscussionMessage, getMessages, readHistory, sendMediaGroup, sendMedia, sendText, getBusinessConnection, resolvePeerMany, resolvePeer, resolveUser, resolveChannel } from "./chunks/es/CPnecqvf.js";
+import { checkPassword, getPasswordHint, logOut, recoverPassword, resendCode, run, sendCode, sendRecoveryCode, signInBot, signInQr, signIn, startTest, start, isSelfPeer, answerCallbackQuery, answerInlineQuery, answerPreCheckoutQuery, deleteMyCommands, getBotInfo, getBotMenuButton, getCallbackAnswer, getGameHighScores, getInlineGameHighScores, getMyCommands, setBotInfo, setBotMenuButton, setGameScore, setInlineGameScore, setMyCommands, setMyDefaultRights, addChatMembers, archiveChats, banChatMember, createChannel, createGroup, createSupergroup, deleteChannel, deleteChatPhoto, deleteGroup, deleteHistory, deleteUserHistory, editAdminRights, getChatEventLog, getChatMember, getChatMembers, getChatPreview, getChat, getFullChat, getNearbyChats, getSimilarChannels, iterChatEventLog, iterChatMembers, joinChat, kickChatMember, leaveChat, markChatUnread, openChat, closeChat, reorderUsernames, restrictChatMember, saveDraft, setChatColor, setChatDefaultPermissions, setChatDescription, setChatPhoto, setChatTitle, setChatTtl, setChatUsername, setSlowMode, toggleContentProtection, toggleFragmentUsername, toggleJoinRequests, toggleJoinToSend, unarchiveChats, unbanChatMember, addContact, deleteContacts, getContacts, importContacts, createFolder, deleteFolder, editFolder, findDialogs, findFolder, getChatlistPreview, getFolders, iterDialogs, joinChatlist, setFoldersOrder, downloadAsBuffer, downloadAsIterable, downloadAsStream, uploadMedia, createForumTopic, deleteForumTopicHistory, editForumTopic, getForumTopicsById, getForumTopics, iterForumTopics, reorderPinnedForumTopics, toggleForumTopicClosed, toggleForumTopicPinned, toggleForum, toggleGeneralTopicHidden, createInviteLink, editInviteLink, exportInviteLink, getInviteLinkMembers, getInviteLink, getInviteLinks, getPrimaryInviteLink, hideAllJoinRequests, hideJoinRequest, iterInviteLinkMembers, iterInviteLinks, revokeInviteLink, closePoll, deleteMessagesById, deleteMessages, deleteScheduledMessages, editInlineMessage, editMessage, forwardMessagesById, forwardMessages, getAllScheduledMessages, getAvailableMessageEffects, getCallbackQueryMessage, getFactCheck, getHistory, getMessageByLink, getMessageGroup, getMessageReactionsById, getMessageReactions, getMessagesUnsafe, getReactionUsers, getReplyTo, getScheduledMessages, iterHistory, iterReactionUsers, iterSearchGlobal, iterSearchMessages, pinMessage, readReactions, searchGlobal, searchHashtag, iterSearchHashtag, searchMessages, answerText, answerMedia, answerMediaGroup, commentText, commentMedia, commentMediaGroup, sendCopyGroup, sendCopy, sendPaidReaction, quoteWithText, quoteWithMedia, quoteWithMediaGroup, sendReaction, replyText, replyMedia, replyMediaGroup, sendScheduled, sendTyping, sendVote, translateMessage, translateText, unpinAllMessages, unpinMessage, getCollectibleInfo, initTakeoutSession, _normalizePrivacyRules, changeCloudPassword, enableCloudPassword, verifyPasswordEmail, resendPasswordEmail, cancelPasswordEmail, removeCloudPassword, applyBoost, canApplyBoost, createBusinessChatLink, editBusinessChatLink, deleteBusinessChatLink, getBoostStats, getBoosts, getBusinessChatLinks, getMyBoostSlots, getStarsTransactions, iterBoosters, iterStarsTransactions, setBusinessIntro, setBusinessWorkHours, addStickerToSet, createStickerSet, deleteStickerFromSet, getCustomEmojis, getCustomEmojisFromMessages, getInstalledStickers, getMyStickerSets, getStickerSet, moveStickerInSet, replaceStickerInSet, setChatStickerSet, setStickerSetThumb, canSendStory, deleteStories, editStory, getAllStories, getPeerStories, getProfileStories, getStoriesById, getStoriesInteractions, getStoryLink, getStoryViewers, hideMyStoriesViews, incrementStoriesViews, iterAllStories, iterProfileStories, iterStoryViewers, readStories, reportStory, sendStoryReaction, sendStory, togglePeerStoriesArchived, toggleStoriesPinned, blockUser, deleteProfilePhotos, editCloseFriendsRaw, editCloseFriends, getCommonChats, getGlobalTtl, getMe, getMyUsername, getProfilePhoto, getProfilePhotos, getUsers, iterProfilePhotos, setGlobalTtl, setMyBirthday, setMyEmojiStatus, setMyProfilePhoto, setMyUsername, setOffline, unblockUser, updateProfile } from "./chunks/es/D_f8sDLe.js";
+function reportUnknownError(log, error, method) {
+  if (typeof fetch !== "function") return;
+  fetch(`https://rpc.pwrtelegram.xyz/?code=${error.code}&method=${method}&error=${error.text}`).then((r) => r.json()).then((r) => {
+    if (r.ok) {
+      log.info("telerpc responded with error info for %s: %s", error.text, r.result);
+    } else {
+      log.info(
+        "Reported error %s to telerpc. You can disable this using `enableErrorReporting: false`",
+        error.text
+      );
+    }
+  }).catch((e) => {
+    log.debug("failed to report error %s to telerpc: %e", error.text, e);
+  });
+}
+class AppConfigManager {
+  constructor(client) {
+    this.client = client;
+  }
+  _reloadable = new Reloadable({
+    reload: this._reload.bind(this),
+    getExpiresAt: () => 36e5,
+    disableAutoReload: true
+  });
+  async _reload(old) {
+    const res = await this.client.call({
+      _: "help.getAppConfig",
+      hash: old?.hash ?? 0
+    });
+    if (res._ === "help.appConfigNotModified") return old;
+    return res;
+  }
+  _object;
+  async get() {
+    if (!this._reloadable.isStale && this._object) return this._object;
+    const obj = tlJsonToJson((await this._reloadable.get()).config);
+    if (!obj || typeof obj !== "object") {
+      throw new MtTypeAssertionError("appConfig", "object", typeof obj);
+    }
+    this._object = obj;
+    return this._object;
+  }
+  async getField(field, fallback) {
+    const obj = await this.get();
+    return obj[field] ?? fallback;
+  }
+}
+function makeRpcError(raw, stack, method) {
+  const error = tl.RpcError.fromTl(raw);
+  error.stack = `RpcError (${error.code} ${error.text}): ${error.message}
+    at ${method}
+${stack.split("\n").slice(2).join("\n")}`;
+  return error;
+}
+class BaseTelegramClient {
+  constructor(params) {
+    this.params = params;
+    this.log = this.params.logger ?? new LogManager("client");
+    this.mt = new MtClient({
+      ...this.params,
+      logger: this.log.create("mtproto")
+    });
+    if (!params.disableUpdates && params.updates !== false) {
+      this.updates = new UpdatesManager(this, params.updates);
+      this._serverUpdatesHandler = this.updates.handleUpdate.bind(this.updates);
+      this.updates.onCatchingUp((catchingUp) => {
+        this._connectionStateHandler(catchingUp ? "updating" : "connected");
+      });
+    }
+    this.mt.on("update", (update) => {
+      this._serverUpdatesHandler(update);
+    });
+    this.mt.on("usable", () => {
+      this._connectionStateHandler("connected");
+    });
+    this.mt.on("wait", () => {
+      this._connectionStateHandler("connecting");
+    });
+    this.mt.on("networkChanged", (connected) => {
+      if (!connected) {
+        this._connectionStateHandler("offline");
+      }
+    });
+    this.crypto = this.mt.crypto;
+    this.storage = new TelegramStorageManager(this.mt.storage, {
+      provider: this.params.storage,
+      ...this.params.storageOptions
+    });
+  }
+  updates;
+  _serverUpdatesHandler = () => {
+  };
+  _connectionStateHandler = () => {
+  };
+  log;
+  mt;
+  crypto;
+  storage;
+  appConfig = new AppConfigManager(this);
+  _prepare = asyncResettable(async () => {
+    await this.mt.prepare();
+    const self = await this.storage.self.fetch();
+    this.log.prefix = `[USER ${self?.userId ?? "n/a"}] `;
+    this.mt.network.setIsPremium(self?.isPremium ?? false);
+    await this.updates?.prepare();
+  });
+  /**
+   * **ADVANCED**
+   *
+   * Do all the preparations, but don't connect just yet.
+   * Useful when you want to do some preparations before
+   * connecting, like setting up session.
+   *
+   * Call {@link connect} to actually connect.
+   */
+  prepare() {
+    return this._prepare.run();
+  }
+  // used in a hot path, avoid extra function calls
+  _connected = false;
+  _connect = asyncResettable(async () => {
+    await this._prepare.run();
+    await this.mt.connect();
+    this._connected = true;
+  });
+  /**
+   * Initialize the connection to the primary DC.
+   *
+   * You shouldn't usually call this method directly as it is called
+   * implicitly the first time you call {@link call}.
+   */
+  async connect() {
+    return this._connect.run();
+  }
+  get isConnected() {
+    return this._connected;
+  }
+  async close() {
+    this._connected = false;
+    await this.mt.close();
+    this.updates?.stopLoop();
+    this._prepare.reset();
+    this._connect.reset();
+  }
+  async notifyLoggedIn(auth) {
+    const user = this.mt.network.notifyLoggedIn(auth);
+    this.log.prefix = `[USER ${user.id}] `;
+    const self = await this.storage.self.storeFrom(user);
+    this.updates?.notifyLoggedIn(self);
+    return user;
+  }
+  async notifyLoggedOut() {
+    this.mt.network.notifyLoggedOut();
+    this.log.prefix = "[USER n/a] ";
+    await this.storage.self.store(null);
+  }
+  async notifyChannelOpened(channelId, pts) {
+    return this.updates?.notifyChannelOpened(channelId, pts) ?? false;
+  }
+  async notifyChannelClosed(channelId) {
+    return this.updates?.notifyChannelClosed(channelId) ?? false;
+  }
+  async startUpdatesLoop() {
+    await this.updates?.startLoop();
+  }
+  async stopUpdatesLoop() {
+    this.updates?.stopLoop();
+  }
+  /**
+   * Make an RPC call
+   *
+   * This method is still quite low-level and you shouldn't use this
+   * when using high-level API provided by `@mtcute/client`.
+   *
+   * @param message  RPC method to call
+   * @param params  Additional call parameters
+   */
+  async call(message, params) {
+    if (!this._connected) {
+      await this._connect.run();
+    }
+    const res = await this.mt.call(message, params);
+    if (isTlRpcError(res)) {
+      const error = makeRpcError(res, new Error().stack ?? "", message._);
+      if (error.unknown && this.params.enableErrorReporting) {
+        reportUnknownError(this.log, error, message._);
+      }
+      throw error;
+    }
+    await this.storage.peers.updatePeersFrom(res);
+    return res;
+  }
+  /**
+   * Import the session from the given session string.
+   *
+   * Note that the session will only be imported in case
+   * the storage is missing authorization (i.e. does not contain
+   * auth key for the primary DC), otherwise it will be ignored (unless `force`).
+   *
+   * @param session  Session string to import
+   * @param force  Whether to overwrite existing session
+   */
+  async importSession(session, force = false) {
+    await this.prepare();
+    const defaultDcAuthKey = await this.mt.storage.provider.authKeys.get(this.mt._defaultDcs.main.id);
+    if (defaultDcAuthKey && !force) return;
+    const data = typeof session === "string" ? readStringSession(session) : session;
+    if (data.testMode && !this.params.testMode) {
+      throw new Error(
+        `This session string is not for the current backend. Session is ${data.testMode ? "test" : "prod"}, but the client is ${this.params.testMode ? "test" : "prod"}`
+      );
+    }
+    this.mt._defaultDcs = data.primaryDcs;
+    await this.mt.storage.dcs.store(data.primaryDcs);
+    if (data.self) {
+      await this.storage.self.store(data.self);
+    }
+    await this.mt.storage.provider.authKeys.set(data.primaryDcs.main.id, data.authKey);
+    await this.mt.storage.save();
+  }
+  /**
+   * Export current session to a single *LONG* string, containing
+   * all the needed information.
+   *
+   * > **Warning!** Anyone with this string will be able
+   * > to authorize as you and do anything. Treat this
+   * > as your password, and never give it away!
+   * >
+   * > In case you have accidentally leaked this string,
+   * > make sure to revoke this session in account settings:
+   * > "Privacy & Security" > "Active sessions" >
+   * > find the one containing `mtcute` > Revoke,
+   * > or, in case this is a bot, revoke bot token
+   * > with [@BotFather](//t.me/botfather)
+   */
+  async exportSession() {
+    await this._prepare.run();
+    const primaryDcs = await this.mt.storage.dcs.fetch() ?? this.mt._defaultDcs;
+    const authKey = await this.mt.storage.provider.authKeys.get(primaryDcs.main.id);
+    if (!authKey) throw new Error("Auth key is not ready yet");
+    return writeStringSession({
+      version: 3,
+      self: await this.storage.self.fetch(),
+      testMode: Boolean(this.params.testMode),
+      primaryDcs,
+      authKey
+    });
+  }
+  /**
+   * Register an error handler for the client
+   *
+   * @param handler  Error handler.
+   */
+  onError(handler) {
+    this.mt.onError(handler);
+  }
+  emitError(err) {
+    this.mt.emitError(err);
+  }
+  handleClientUpdate(updates, noDispatch) {
+    this.updates?.handleClientUpdate(updates, noDispatch);
+  }
+  onServerUpdate(handler) {
+    this._serverUpdatesHandler = handler;
+  }
+  getServerUpdateHandler() {
+    return this._serverUpdatesHandler;
+  }
+  onUpdate(handler) {
+    if (!this.updates) {
+      throw new MtArgumentError("Updates manager is disabled");
+    }
+    this.updates.setHandler(handler);
+  }
+  onConnectionState(handler) {
+    this._connectionStateHandler = handler;
+  }
+  async getApiCrenetials() {
+    return {
+      id: this.params.apiId,
+      hash: this.params.apiHash
+    };
+  }
+  async getPoolSize(kind, dcId) {
+    if (!this._connected) {
+      await this._connect.run();
+    }
+    return this.mt.network.getPoolSize(kind, dcId);
+  }
+  async getPrimaryDcId() {
+    if (!this._connected) {
+      await this._connect.run();
+    }
+    return this.mt.network.getPrimaryDcId();
+  }
+  computeSrpParams(request, password) {
+    return computeSrpParams(this.crypto, request, password);
+  }
+  computeNewPasswordHash(algo, password) {
+    return computeNewPasswordHash(this.crypto, algo, password);
+  }
+  get stopSignal() {
+    return this.mt.stopSignal;
+  }
+  changePrimaryDc(dcId) {
+    return this.mt.network.changePrimaryDc(dcId);
+  }
+  async getMtprotoMessageId() {
+    return this.mt.network.getMtprotoMessageId();
+  }
+}
+function _parseUpdate(update, peers) {
+  switch (update._) {
+    case "updateNewMessage":
+    case "updateNewChannelMessage":
+    case "updateNewScheduledMessage":
+      return {
+        name: "new_message",
+        data: new Message$2(update.message, peers, update._ === "updateNewScheduledMessage")
+      };
+    case "updateEditMessage":
+    case "updateEditChannelMessage":
+      return { name: "edit_message", data: new Message$2(update.message, peers) };
+    case "updateChatParticipant":
+    case "updateChannelParticipant":
+      return { name: "chat_member", data: new ChatMemberUpdate$2(update, peers) };
+    case "updateBotInlineQuery":
+      return { name: "inline_query", data: new InlineQuery$2(update, peers) };
+    case "updateBotInlineSend":
+      return { name: "chosen_inline_result", data: new ChosenInlineResult$2(update, peers) };
+    case "updateBotCallbackQuery":
+      return { name: "callback_query", data: new CallbackQuery$2(update, peers) };
+    case "updateInlineBotCallbackQuery":
+      return { name: "inline_callback_query", data: new InlineCallbackQuery$2(update, peers) };
+    case "updateMessagePoll":
+      return { name: "poll", data: new PollUpdate$2(update, peers) };
+    case "updateMessagePollVote":
+      return { name: "poll_vote", data: new PollVoteUpdate$2(update, peers) };
+    case "updateUserStatus":
+      return { name: "user_status", data: new UserStatusUpdate$2(update) };
+    case "updateChannelUserTyping":
+    case "updateChatUserTyping":
+    case "updateUserTyping":
+      return { name: "user_typing", data: new UserTypingUpdate$1(update) };
+    case "updateDeleteChannelMessages":
+    case "updateDeleteMessages":
+      return { name: "delete_message", data: new DeleteMessageUpdate$1(update) };
+    case "updateReadHistoryInbox":
+    case "updateReadHistoryOutbox":
+    case "updateReadChannelInbox":
+    case "updateReadChannelOutbox":
+    case "updateReadChannelDiscussionInbox":
+    case "updateReadChannelDiscussionOutbox":
+      return { name: "history_read", data: new HistoryReadUpdate$1(update) };
+    case "updateBotStopped":
+      return { name: "bot_stopped", data: new BotStoppedUpdate$2(update, peers) };
+    case "updateBotChatInviteRequester":
+      return { name: "bot_chat_join_request", data: new BotChatJoinRequestUpdate$2(update, peers) };
+    case "updatePendingJoinRequests":
+      return { name: "chat_join_request", data: new ChatJoinRequestUpdate$2(update, peers) };
+    case "updateBotPrecheckoutQuery":
+      return { name: "pre_checkout_query", data: new PreCheckoutQuery$2(update, peers) };
+    case "updateStory": {
+      const story = update.story;
+      if (story._ === "storyItemDeleted") {
+        return { name: "delete_story", data: new DeleteStoryUpdate$2(update, peers) };
+      }
+      return {
+        name: "story",
+        data: new StoryUpdate$2(update, peers)
+      };
+    }
+    case "updateBotMessageReaction":
+      return { name: "bot_reaction", data: new BotReactionUpdate$2(update, peers) };
+    case "updateBotMessageReactions":
+      return { name: "bot_reaction_count", data: new BotReactionCountUpdate$2(update, peers) };
+    case "updateBotBusinessConnect":
+      return { name: "business_connection", data: new BusinessConnection$2(update.connection, peers) };
+    case "updateBotNewBusinessMessage":
+      return { name: "new_business_message", data: new BusinessMessage(update, peers) };
+    case "updateBotEditBusinessMessage":
+      return { name: "edit_business_message", data: new BusinessMessage(update, peers) };
+    case "updateBotDeleteBusinessMessage":
+      return { name: "delete_business_message", data: new DeleteBusinessMessageUpdate$2(update, peers) };
+    case "updateBusinessBotCallbackQuery":
+      return { name: "business_callback_query", data: new BusinessCallbackQuery$2(update, peers) };
+    default:
+      return null;
+  }
+}
+function makeParsedUpdateHandler(params) {
+  const { messageGroupingInterval, onUpdate, onRawUpdate = () => {
+  } } = params;
+  if (!messageGroupingInterval) {
+    return (update, peers) => {
+      const parsed = _parseUpdate(update, peers);
+      onRawUpdate(update, peers);
+      if (parsed) onUpdate(parsed);
+    };
+  }
+  const pending = /* @__PURE__ */ new Map();
+  return (update, peers) => {
+    const parsed = _parseUpdate(update, peers);
+    onRawUpdate(update, peers);
+    if (parsed) {
+      if (parsed.name === "new_message" || parsed.name === "new_business_message") {
+        const group = parsed.data.groupedIdUnique;
+        if (group) {
+          const isBusiness = parsed.name === "new_business_message";
+          const pendingGroup = pending.get(group);
+          if (pendingGroup) {
+            pendingGroup[0].push(parsed.data);
+          } else {
+            const messages = [parsed.data];
+            const timeout = setTimeoutWrap(() => {
+              pending.delete(group);
+              if (isBusiness) {
+                onUpdate({ name: "business_message_group", data: messages });
+              } else {
+                onUpdate({ name: "message_group", data: messages });
+              }
+            }, messageGroupingInterval);
+            pending.set(group, [messages, timeout]);
+          }
+          return;
+        }
+      }
+      onUpdate(parsed);
+    }
+  };
+}
+function withParams(client, params) {
+  const wrappedCall = (message, extraParams) => client.call(message, extraParams ? { ...params, ...extraParams } : params);
+  const proxy = new Proxy(client, {
+    get: (target, prop, receiver) => {
+      if (prop === "call") {
+        return wrappedCall;
+      }
+      if (prop === "_client") {
+        return proxy;
+      }
+      return Reflect.get(target, prop, receiver);
+    }
+  });
+  return proxy;
+}
+class TelegramClient extends EventEmitter {
+  _client;
+  constructor(opts) {
+    super();
+    if ("client" in opts) {
+      this._client = opts.client;
+    } else {
+      if (!opts.storage || typeof opts.storage === "string" || !opts.transport || !opts.crypto) {
+        throw new MtUnsupportedError(
+          "You need to explicitly provide storage, transport and crypto for @mtcute/core"
+        );
+      }
+      this._client = new BaseTelegramClient(opts);
+    }
+    this.log = this._client.log;
+    this.storage = this._client.storage;
+    Object.defineProperty(this, "stopSignal", {
+      get: () => this._client.stopSignal
+    });
+    Object.defineProperty(this, "appConfig", {
+      get: () => this._client.appConfig
+    });
+    if (!opts.disableUpdates) {
+      const skipConversationUpdates = opts.skipConversationUpdates ?? true;
+      const { messageGroupingInterval } = opts.updates ?? {};
+      this._client.onUpdate(
+        makeParsedUpdateHandler({
+          messageGroupingInterval,
+          onUpdate: (update) => {
+            if (Conversation.handleUpdate(this, update) && skipConversationUpdates) return;
+            this.emit("update", update);
+            this.emit(update.name, update.data);
+          },
+          onRawUpdate: (update, peers) => {
+            this.emit("raw_update", update, peers);
+          }
+        })
+      );
+    }
+  }
+  withParams(params) {
+    return withParams(this, params);
+  }
+}
+TelegramClient.prototype.checkPassword = function(...args) {
+  return checkPassword(this._client, ...args);
+};
+TelegramClient.prototype.getPasswordHint = function(...args) {
+  return getPasswordHint(this._client, ...args);
+};
+TelegramClient.prototype.logOut = function(...args) {
+  return logOut(this._client, ...args);
+};
+TelegramClient.prototype.recoverPassword = function(...args) {
+  return recoverPassword(this._client, ...args);
+};
+TelegramClient.prototype.resendCode = function(...args) {
+  return resendCode(this._client, ...args);
+};
+TelegramClient.prototype.run = function(...args) {
+  return run(this._client, ...args);
+};
+TelegramClient.prototype.sendCode = function(...args) {
+  return sendCode(this._client, ...args);
+};
+TelegramClient.prototype.sendRecoveryCode = function(...args) {
+  return sendRecoveryCode(this._client, ...args);
+};
+TelegramClient.prototype.signInBot = function(...args) {
+  return signInBot(this._client, ...args);
+};
+TelegramClient.prototype.signInQr = function(...args) {
+  return signInQr(this._client, ...args);
+};
+TelegramClient.prototype.signIn = function(...args) {
+  return signIn(this._client, ...args);
+};
+TelegramClient.prototype.startTest = function(...args) {
+  return startTest(this._client, ...args);
+};
+TelegramClient.prototype.start = function(...args) {
+  return start(this._client, ...args);
+};
+TelegramClient.prototype.isSelfPeer = function(...args) {
+  return isSelfPeer(this._client, ...args);
+};
+TelegramClient.prototype.answerCallbackQuery = function(...args) {
+  return answerCallbackQuery(this._client, ...args);
+};
+TelegramClient.prototype.answerInlineQuery = function(...args) {
+  return answerInlineQuery(this._client, ...args);
+};
+TelegramClient.prototype.answerPreCheckoutQuery = function(...args) {
+  return answerPreCheckoutQuery(this._client, ...args);
+};
+TelegramClient.prototype.deleteMyCommands = function(...args) {
+  return deleteMyCommands(this._client, ...args);
+};
+TelegramClient.prototype.getBotInfo = function(...args) {
+  return getBotInfo(this._client, ...args);
+};
+TelegramClient.prototype.getBotMenuButton = function(...args) {
+  return getBotMenuButton(this._client, ...args);
+};
+TelegramClient.prototype.getCallbackAnswer = function(...args) {
+  return getCallbackAnswer(this._client, ...args);
+};
+TelegramClient.prototype.getGameHighScores = function(...args) {
+  return getGameHighScores(this._client, ...args);
+};
+TelegramClient.prototype.getInlineGameHighScores = function(...args) {
+  return getInlineGameHighScores(this._client, ...args);
+};
+TelegramClient.prototype.getMyCommands = function(...args) {
+  return getMyCommands(this._client, ...args);
+};
+TelegramClient.prototype.setBotInfo = function(...args) {
+  return setBotInfo(this._client, ...args);
+};
+TelegramClient.prototype.setBotMenuButton = function(...args) {
+  return setBotMenuButton(this._client, ...args);
+};
+TelegramClient.prototype.setGameScore = function(...args) {
+  return setGameScore(this._client, ...args);
+};
+TelegramClient.prototype.setInlineGameScore = function(...args) {
+  return setInlineGameScore(this._client, ...args);
+};
+TelegramClient.prototype.setMyCommands = function(...args) {
+  return setMyCommands(this._client, ...args);
+};
+TelegramClient.prototype.setMyDefaultRights = function(...args) {
+  return setMyDefaultRights(this._client, ...args);
+};
+TelegramClient.prototype.addChatMembers = function(...args) {
+  return addChatMembers(this._client, ...args);
+};
+TelegramClient.prototype.archiveChats = function(...args) {
+  return archiveChats(this._client, ...args);
+};
+TelegramClient.prototype.banChatMember = function(...args) {
+  return banChatMember(this._client, ...args);
+};
+TelegramClient.prototype.createChannel = function(...args) {
+  return createChannel(this._client, ...args);
+};
+TelegramClient.prototype.createGroup = function(...args) {
+  return createGroup(this._client, ...args);
+};
+TelegramClient.prototype.createSupergroup = function(...args) {
+  return createSupergroup(this._client, ...args);
+};
+TelegramClient.prototype.deleteChannel = function(...args) {
+  return deleteChannel(this._client, ...args);
+};
+TelegramClient.prototype.deleteSupergroup = function(...args) {
+  return deleteChannel(this._client, ...args);
+};
+TelegramClient.prototype.deleteChatPhoto = function(...args) {
+  return deleteChatPhoto(this._client, ...args);
+};
+TelegramClient.prototype.deleteGroup = function(...args) {
+  return deleteGroup(this._client, ...args);
+};
+TelegramClient.prototype.deleteHistory = function(...args) {
+  return deleteHistory(this._client, ...args);
+};
+TelegramClient.prototype.deleteUserHistory = function(...args) {
+  return deleteUserHistory(this._client, ...args);
+};
+TelegramClient.prototype.editAdminRights = function(...args) {
+  return editAdminRights(this._client, ...args);
+};
+TelegramClient.prototype.getChatEventLog = function(...args) {
+  return getChatEventLog(this._client, ...args);
+};
+TelegramClient.prototype.getChatMember = function(...args) {
+  return getChatMember(this._client, ...args);
+};
+TelegramClient.prototype.getChatMembers = function(...args) {
+  return getChatMembers(this._client, ...args);
+};
+TelegramClient.prototype.getChatPreview = function(...args) {
+  return getChatPreview(this._client, ...args);
+};
+TelegramClient.prototype.getChat = function(...args) {
+  return getChat(this._client, ...args);
+};
+TelegramClient.prototype.getFullChat = function(...args) {
+  return getFullChat(this._client, ...args);
+};
+TelegramClient.prototype.getNearbyChats = function(...args) {
+  return getNearbyChats(this._client, ...args);
+};
+TelegramClient.prototype.getSimilarChannels = function(...args) {
+  return getSimilarChannels(this._client, ...args);
+};
+TelegramClient.prototype.iterChatEventLog = function(...args) {
+  return iterChatEventLog(this._client, ...args);
+};
+TelegramClient.prototype.iterChatMembers = function(...args) {
+  return iterChatMembers(this._client, ...args);
+};
+TelegramClient.prototype.joinChat = function(...args) {
+  return joinChat(this._client, ...args);
+};
+TelegramClient.prototype.kickChatMember = function(...args) {
+  return kickChatMember(this._client, ...args);
+};
+TelegramClient.prototype.leaveChat = function(...args) {
+  return leaveChat(this._client, ...args);
+};
+TelegramClient.prototype.markChatUnread = function(...args) {
+  return markChatUnread(this._client, ...args);
+};
+TelegramClient.prototype.openChat = function(...args) {
+  return openChat(this._client, ...args);
+};
+TelegramClient.prototype.closeChat = function(...args) {
+  return closeChat(this._client, ...args);
+};
+TelegramClient.prototype.reorderUsernames = function(...args) {
+  return reorderUsernames(this._client, ...args);
+};
+TelegramClient.prototype.restrictChatMember = function(...args) {
+  return restrictChatMember(this._client, ...args);
+};
+TelegramClient.prototype.saveDraft = function(...args) {
+  return saveDraft(this._client, ...args);
+};
+TelegramClient.prototype.setChatColor = function(...args) {
+  return setChatColor(this._client, ...args);
+};
+TelegramClient.prototype.setChatDefaultPermissions = function(...args) {
+  return setChatDefaultPermissions(this._client, ...args);
+};
+TelegramClient.prototype.setChatDescription = function(...args) {
+  return setChatDescription(this._client, ...args);
+};
+TelegramClient.prototype.setChatPhoto = function(...args) {
+  return setChatPhoto(this._client, ...args);
+};
+TelegramClient.prototype.setChatTitle = function(...args) {
+  return setChatTitle(this._client, ...args);
+};
+TelegramClient.prototype.setChatTtl = function(...args) {
+  return setChatTtl(this._client, ...args);
+};
+TelegramClient.prototype.setChatUsername = function(...args) {
+  return setChatUsername(this._client, ...args);
+};
+TelegramClient.prototype.setSlowMode = function(...args) {
+  return setSlowMode(this._client, ...args);
+};
+TelegramClient.prototype.toggleContentProtection = function(...args) {
+  return toggleContentProtection(this._client, ...args);
+};
+TelegramClient.prototype.toggleFragmentUsername = function(...args) {
+  return toggleFragmentUsername(this._client, ...args);
+};
+TelegramClient.prototype.toggleJoinRequests = function(...args) {
+  return toggleJoinRequests(this._client, ...args);
+};
+TelegramClient.prototype.toggleJoinToSend = function(...args) {
+  return toggleJoinToSend(this._client, ...args);
+};
+TelegramClient.prototype.unarchiveChats = function(...args) {
+  return unarchiveChats(this._client, ...args);
+};
+TelegramClient.prototype.unbanChatMember = function(...args) {
+  return unbanChatMember(this._client, ...args);
+};
+TelegramClient.prototype.unrestrictChatMember = function(...args) {
+  return unbanChatMember(this._client, ...args);
+};
+TelegramClient.prototype.addContact = function(...args) {
+  return addContact(this._client, ...args);
+};
+TelegramClient.prototype.deleteContacts = function(...args) {
+  return deleteContacts(this._client, ...args);
+};
+TelegramClient.prototype.getContacts = function(...args) {
+  return getContacts(this._client, ...args);
+};
+TelegramClient.prototype.importContacts = function(...args) {
+  return importContacts(this._client, ...args);
+};
+TelegramClient.prototype.createFolder = function(...args) {
+  return createFolder(this._client, ...args);
+};
+TelegramClient.prototype.deleteFolder = function(...args) {
+  return deleteFolder(this._client, ...args);
+};
+TelegramClient.prototype.editFolder = function(...args) {
+  return editFolder(this._client, ...args);
+};
+TelegramClient.prototype.findDialogs = function(...args) {
+  return findDialogs(this._client, ...args);
+};
+TelegramClient.prototype.findFolder = function(...args) {
+  return findFolder(this._client, ...args);
+};
+TelegramClient.prototype.getChatlistPreview = function(...args) {
+  return getChatlistPreview(this._client, ...args);
+};
+TelegramClient.prototype.getFolders = function(...args) {
+  return getFolders(this._client, ...args);
+};
+TelegramClient.prototype.getPeerDialogs = function(...args) {
+  return getPeerDialogs(this._client, ...args);
+};
+TelegramClient.prototype.iterDialogs = function(...args) {
+  return iterDialogs(this._client, ...args);
+};
+TelegramClient.prototype.joinChatlist = function(...args) {
+  return joinChatlist(this._client, ...args);
+};
+TelegramClient.prototype.setFoldersOrder = function(...args) {
+  return setFoldersOrder(this._client, ...args);
+};
+TelegramClient.prototype.downloadAsBuffer = function(...args) {
+  return downloadAsBuffer(this._client, ...args);
+};
+TelegramClient.prototype.downloadAsIterable = function(...args) {
+  return downloadAsIterable(this._client, ...args);
+};
+TelegramClient.prototype.downloadAsStream = function(...args) {
+  return downloadAsStream(this._client, ...args);
+};
+TelegramClient.prototype._normalizeInputFile = function(...args) {
+  return _normalizeInputFile(this._client, ...args);
+};
+TelegramClient.prototype._normalizeInputMedia = function(...args) {
+  return _normalizeInputMedia(this._client, ...args);
+};
+TelegramClient.prototype.uploadFile = function(...args) {
+  return uploadFile(this._client, ...args);
+};
+TelegramClient.prototype.uploadMedia = function(...args) {
+  return uploadMedia(this._client, ...args);
+};
+TelegramClient.prototype.createForumTopic = function(...args) {
+  return createForumTopic(this._client, ...args);
+};
+TelegramClient.prototype.deleteForumTopicHistory = function(...args) {
+  return deleteForumTopicHistory(this._client, ...args);
+};
+TelegramClient.prototype.editForumTopic = function(...args) {
+  return editForumTopic(this._client, ...args);
+};
+TelegramClient.prototype.getForumTopicsById = function(...args) {
+  return getForumTopicsById(this._client, ...args);
+};
+TelegramClient.prototype.getForumTopics = function(...args) {
+  return getForumTopics(this._client, ...args);
+};
+TelegramClient.prototype.iterForumTopics = function(...args) {
+  return iterForumTopics(this._client, ...args);
+};
+TelegramClient.prototype.reorderPinnedForumTopics = function(...args) {
+  return reorderPinnedForumTopics(this._client, ...args);
+};
+TelegramClient.prototype.toggleForumTopicClosed = function(...args) {
+  return toggleForumTopicClosed(this._client, ...args);
+};
+TelegramClient.prototype.toggleForumTopicPinned = function(...args) {
+  return toggleForumTopicPinned(this._client, ...args);
+};
+TelegramClient.prototype.toggleForum = function(...args) {
+  return toggleForum(this._client, ...args);
+};
+TelegramClient.prototype.toggleGeneralTopicHidden = function(...args) {
+  return toggleGeneralTopicHidden(this._client, ...args);
+};
+TelegramClient.prototype.createInviteLink = function(...args) {
+  return createInviteLink(this._client, ...args);
+};
+TelegramClient.prototype.editInviteLink = function(...args) {
+  return editInviteLink(this._client, ...args);
+};
+TelegramClient.prototype.exportInviteLink = function(...args) {
+  return exportInviteLink(this._client, ...args);
+};
+TelegramClient.prototype.getInviteLinkMembers = function(...args) {
+  return getInviteLinkMembers(this._client, ...args);
+};
+TelegramClient.prototype.getInviteLink = function(...args) {
+  return getInviteLink(this._client, ...args);
+};
+TelegramClient.prototype.getInviteLinks = function(...args) {
+  return getInviteLinks(this._client, ...args);
+};
+TelegramClient.prototype.getPrimaryInviteLink = function(...args) {
+  return getPrimaryInviteLink(this._client, ...args);
+};
+TelegramClient.prototype.hideAllJoinRequests = function(...args) {
+  return hideAllJoinRequests(this._client, ...args);
+};
+TelegramClient.prototype.hideJoinRequest = function(...args) {
+  return hideJoinRequest(this._client, ...args);
+};
+TelegramClient.prototype.iterInviteLinkMembers = function(...args) {
+  return iterInviteLinkMembers(this._client, ...args);
+};
+TelegramClient.prototype.iterInviteLinks = function(...args) {
+  return iterInviteLinks(this._client, ...args);
+};
+TelegramClient.prototype.revokeInviteLink = function(...args) {
+  return revokeInviteLink(this._client, ...args);
+};
+TelegramClient.prototype.closePoll = function(...args) {
+  return closePoll(this._client, ...args);
+};
+TelegramClient.prototype.deleteMessagesById = function(...args) {
+  return deleteMessagesById(this._client, ...args);
+};
+TelegramClient.prototype.deleteMessages = function(...args) {
+  return deleteMessages(this._client, ...args);
+};
+TelegramClient.prototype.deleteScheduledMessages = function(...args) {
+  return deleteScheduledMessages(this._client, ...args);
+};
+TelegramClient.prototype.editInlineMessage = function(...args) {
+  return editInlineMessage(this._client, ...args);
+};
+TelegramClient.prototype.editMessage = function(...args) {
+  return editMessage(this._client, ...args);
+};
+TelegramClient.prototype.forwardMessagesById = function(...args) {
+  return forwardMessagesById(this._client, ...args);
+};
+TelegramClient.prototype.forwardMessages = function(...args) {
+  return forwardMessages(this._client, ...args);
+};
+TelegramClient.prototype.getAllScheduledMessages = function(...args) {
+  return getAllScheduledMessages(this._client, ...args);
+};
+TelegramClient.prototype.getAvailableMessageEffects = function(...args) {
+  return getAvailableMessageEffects(this._client, ...args);
+};
+TelegramClient.prototype.getCallbackQueryMessage = function(...args) {
+  return getCallbackQueryMessage(this._client, ...args);
+};
+TelegramClient.prototype.getDiscussionMessage = function(...args) {
+  return getDiscussionMessage(this._client, ...args);
+};
+TelegramClient.prototype.getFactCheck = function(...args) {
+  return getFactCheck(this._client, ...args);
+};
+TelegramClient.prototype.getHistory = function(...args) {
+  return getHistory(this._client, ...args);
+};
+TelegramClient.prototype.getMessageByLink = function(...args) {
+  return getMessageByLink(this._client, ...args);
+};
+TelegramClient.prototype.getMessageGroup = function(...args) {
+  return getMessageGroup(this._client, ...args);
+};
+TelegramClient.prototype.getMessageReactionsById = function(...args) {
+  return getMessageReactionsById(this._client, ...args);
+};
+TelegramClient.prototype.getMessageReactions = function(...args) {
+  return getMessageReactions(this._client, ...args);
+};
+TelegramClient.prototype.getMessagesUnsafe = function(...args) {
+  return getMessagesUnsafe(this._client, ...args);
+};
+TelegramClient.prototype.getMessages = function(...args) {
+  return getMessages(this._client, ...args);
+};
+TelegramClient.prototype.getReactionUsers = function(...args) {
+  return getReactionUsers(this._client, ...args);
+};
+TelegramClient.prototype.getReplyTo = function(...args) {
+  return getReplyTo(this._client, ...args);
+};
+TelegramClient.prototype.getScheduledMessages = function(...args) {
+  return getScheduledMessages(this._client, ...args);
+};
+TelegramClient.prototype.iterHistory = function(...args) {
+  return iterHistory(this._client, ...args);
+};
+TelegramClient.prototype.iterReactionUsers = function(...args) {
+  return iterReactionUsers(this._client, ...args);
+};
+TelegramClient.prototype.iterSearchGlobal = function(...args) {
+  return iterSearchGlobal(this._client, ...args);
+};
+TelegramClient.prototype.iterSearchMessages = function(...args) {
+  return iterSearchMessages(this._client, ...args);
+};
+TelegramClient.prototype.pinMessage = function(...args) {
+  return pinMessage(this._client, ...args);
+};
+TelegramClient.prototype.readHistory = function(...args) {
+  return readHistory(this._client, ...args);
+};
+TelegramClient.prototype.readReactions = function(...args) {
+  return readReactions(this._client, ...args);
+};
+TelegramClient.prototype.searchGlobal = function(...args) {
+  return searchGlobal(this._client, ...args);
+};
+TelegramClient.prototype.searchHashtag = function(...args) {
+  return searchHashtag(this._client, ...args);
+};
+TelegramClient.prototype.iterSearchHashtag = function(...args) {
+  return iterSearchHashtag(this._client, ...args);
+};
+TelegramClient.prototype.searchMessages = function(...args) {
+  return searchMessages(this._client, ...args);
+};
+TelegramClient.prototype.answerText = function(...args) {
+  return answerText(this._client, ...args);
+};
+TelegramClient.prototype.answerMedia = function(...args) {
+  return answerMedia(this._client, ...args);
+};
+TelegramClient.prototype.answerMediaGroup = function(...args) {
+  return answerMediaGroup(this._client, ...args);
+};
+TelegramClient.prototype.commentText = function(...args) {
+  return commentText(this._client, ...args);
+};
+TelegramClient.prototype.commentMedia = function(...args) {
+  return commentMedia(this._client, ...args);
+};
+TelegramClient.prototype.commentMediaGroup = function(...args) {
+  return commentMediaGroup(this._client, ...args);
+};
+TelegramClient.prototype.sendCopyGroup = function(...args) {
+  return sendCopyGroup(this._client, ...args);
+};
+TelegramClient.prototype.sendCopy = function(...args) {
+  return sendCopy(this._client, ...args);
+};
+TelegramClient.prototype.sendMediaGroup = function(...args) {
+  return sendMediaGroup(this._client, ...args);
+};
+TelegramClient.prototype.sendMedia = function(...args) {
+  return sendMedia(this._client, ...args);
+};
+TelegramClient.prototype.sendPaidReaction = function(...args) {
+  return sendPaidReaction(this._client, ...args);
+};
+TelegramClient.prototype.quoteWithText = function(...args) {
+  return quoteWithText(this._client, ...args);
+};
+TelegramClient.prototype.quoteWithMedia = function(...args) {
+  return quoteWithMedia(this._client, ...args);
+};
+TelegramClient.prototype.quoteWithMediaGroup = function(...args) {
+  return quoteWithMediaGroup(this._client, ...args);
+};
+TelegramClient.prototype.sendReaction = function(...args) {
+  return sendReaction(this._client, ...args);
+};
+TelegramClient.prototype.replyText = function(...args) {
+  return replyText(this._client, ...args);
+};
+TelegramClient.prototype.replyMedia = function(...args) {
+  return replyMedia(this._client, ...args);
+};
+TelegramClient.prototype.replyMediaGroup = function(...args) {
+  return replyMediaGroup(this._client, ...args);
+};
+TelegramClient.prototype.sendScheduled = function(...args) {
+  return sendScheduled(this._client, ...args);
+};
+TelegramClient.prototype.sendText = function(...args) {
+  return sendText(this._client, ...args);
+};
+TelegramClient.prototype.sendTyping = function(...args) {
+  return sendTyping(this._client, ...args);
+};
+TelegramClient.prototype.sendVote = function(...args) {
+  return sendVote(this._client, ...args);
+};
+TelegramClient.prototype.translateMessage = function(...args) {
+  return translateMessage(this._client, ...args);
+};
+TelegramClient.prototype.translateText = function(...args) {
+  return translateText(this._client, ...args);
+};
+TelegramClient.prototype.unpinAllMessages = function(...args) {
+  return unpinAllMessages(this._client, ...args);
+};
+TelegramClient.prototype.unpinMessage = function(...args) {
+  return unpinMessage(this._client, ...args);
+};
+TelegramClient.prototype.getCollectibleInfo = function(...args) {
+  return getCollectibleInfo(this._client, ...args);
+};
+TelegramClient.prototype.initTakeoutSession = function(...args) {
+  return initTakeoutSession(this._client, ...args);
+};
+TelegramClient.prototype._normalizePrivacyRules = function(...args) {
+  return _normalizePrivacyRules(this._client, ...args);
+};
+TelegramClient.prototype.changeCloudPassword = function(...args) {
+  return changeCloudPassword(this._client, ...args);
+};
+TelegramClient.prototype.enableCloudPassword = function(...args) {
+  return enableCloudPassword(this._client, ...args);
+};
+TelegramClient.prototype.verifyPasswordEmail = function(...args) {
+  return verifyPasswordEmail(this._client, ...args);
+};
+TelegramClient.prototype.resendPasswordEmail = function(...args) {
+  return resendPasswordEmail(this._client, ...args);
+};
+TelegramClient.prototype.cancelPasswordEmail = function(...args) {
+  return cancelPasswordEmail(this._client, ...args);
+};
+TelegramClient.prototype.removeCloudPassword = function(...args) {
+  return removeCloudPassword(this._client, ...args);
+};
+TelegramClient.prototype.applyBoost = function(...args) {
+  return applyBoost(this._client, ...args);
+};
+TelegramClient.prototype.canApplyBoost = function(...args) {
+  return canApplyBoost(this._client, ...args);
+};
+TelegramClient.prototype.createBusinessChatLink = function(...args) {
+  return createBusinessChatLink(this._client, ...args);
+};
+TelegramClient.prototype.editBusinessChatLink = function(...args) {
+  return editBusinessChatLink(this._client, ...args);
+};
+TelegramClient.prototype.deleteBusinessChatLink = function(...args) {
+  return deleteBusinessChatLink(this._client, ...args);
+};
+TelegramClient.prototype.getBoostStats = function(...args) {
+  return getBoostStats(this._client, ...args);
+};
+TelegramClient.prototype.getBoosts = function(...args) {
+  return getBoosts(this._client, ...args);
+};
+TelegramClient.prototype.getBusinessChatLinks = function(...args) {
+  return getBusinessChatLinks(this._client, ...args);
+};
+TelegramClient.prototype.getBusinessConnection = function(...args) {
+  return getBusinessConnection(this._client, ...args);
+};
+TelegramClient.prototype.getMyBoostSlots = function(...args) {
+  return getMyBoostSlots(this._client, ...args);
+};
+TelegramClient.prototype.getStarsTransactions = function(...args) {
+  return getStarsTransactions(this._client, ...args);
+};
+TelegramClient.prototype.iterBoosters = function(...args) {
+  return iterBoosters(this._client, ...args);
+};
+TelegramClient.prototype.iterStarsTransactions = function(...args) {
+  return iterStarsTransactions(this._client, ...args);
+};
+TelegramClient.prototype.setBusinessIntro = function(...args) {
+  return setBusinessIntro(this._client, ...args);
+};
+TelegramClient.prototype.setBusinessWorkHours = function(...args) {
+  return setBusinessWorkHours(this._client, ...args);
+};
+TelegramClient.prototype.addStickerToSet = function(...args) {
+  return addStickerToSet(this._client, ...args);
+};
+TelegramClient.prototype.createStickerSet = function(...args) {
+  return createStickerSet(this._client, ...args);
+};
+TelegramClient.prototype.deleteStickerFromSet = function(...args) {
+  return deleteStickerFromSet(this._client, ...args);
+};
+TelegramClient.prototype.getCustomEmojis = function(...args) {
+  return getCustomEmojis(this._client, ...args);
+};
+TelegramClient.prototype.getCustomEmojisFromMessages = function(...args) {
+  return getCustomEmojisFromMessages(this._client, ...args);
+};
+TelegramClient.prototype.getInstalledStickers = function(...args) {
+  return getInstalledStickers(this._client, ...args);
+};
+TelegramClient.prototype.getMyStickerSets = function(...args) {
+  return getMyStickerSets(this._client, ...args);
+};
+TelegramClient.prototype.getStickerSet = function(...args) {
+  return getStickerSet(this._client, ...args);
+};
+TelegramClient.prototype.moveStickerInSet = function(...args) {
+  return moveStickerInSet(this._client, ...args);
+};
+TelegramClient.prototype.replaceStickerInSet = function(...args) {
+  return replaceStickerInSet(this._client, ...args);
+};
+TelegramClient.prototype.setChatStickerSet = function(...args) {
+  return setChatStickerSet(this._client, ...args);
+};
+TelegramClient.prototype.setStickerSetThumb = function(...args) {
+  return setStickerSetThumb(this._client, ...args);
+};
+TelegramClient.prototype.canSendStory = function(...args) {
+  return canSendStory(this._client, ...args);
+};
+TelegramClient.prototype.deleteStories = function(...args) {
+  return deleteStories(this._client, ...args);
+};
+TelegramClient.prototype.editStory = function(...args) {
+  return editStory(this._client, ...args);
+};
+TelegramClient.prototype.getAllStories = function(...args) {
+  return getAllStories(this._client, ...args);
+};
+TelegramClient.prototype.getPeerStories = function(...args) {
+  return getPeerStories(this._client, ...args);
+};
+TelegramClient.prototype.getProfileStories = function(...args) {
+  return getProfileStories(this._client, ...args);
+};
+TelegramClient.prototype.getStoriesById = function(...args) {
+  return getStoriesById(this._client, ...args);
+};
+TelegramClient.prototype.getStoriesInteractions = function(...args) {
+  return getStoriesInteractions(this._client, ...args);
+};
+TelegramClient.prototype.getStoryLink = function(...args) {
+  return getStoryLink(this._client, ...args);
+};
+TelegramClient.prototype.getStoryViewers = function(...args) {
+  return getStoryViewers(this._client, ...args);
+};
+TelegramClient.prototype.hideMyStoriesViews = function(...args) {
+  return hideMyStoriesViews(this._client, ...args);
+};
+TelegramClient.prototype.incrementStoriesViews = function(...args) {
+  return incrementStoriesViews(this._client, ...args);
+};
+TelegramClient.prototype.iterAllStories = function(...args) {
+  return iterAllStories(this._client, ...args);
+};
+TelegramClient.prototype.iterProfileStories = function(...args) {
+  return iterProfileStories(this._client, ...args);
+};
+TelegramClient.prototype.iterStoryViewers = function(...args) {
+  return iterStoryViewers(this._client, ...args);
+};
+TelegramClient.prototype.readStories = function(...args) {
+  return readStories(this._client, ...args);
+};
+TelegramClient.prototype.reportStory = function(...args) {
+  return reportStory(this._client, ...args);
+};
+TelegramClient.prototype.sendStoryReaction = function(...args) {
+  return sendStoryReaction(this._client, ...args);
+};
+TelegramClient.prototype.sendStory = function(...args) {
+  return sendStory(this._client, ...args);
+};
+TelegramClient.prototype.togglePeerStoriesArchived = function(...args) {
+  return togglePeerStoriesArchived(this._client, ...args);
+};
+TelegramClient.prototype.toggleStoriesPinned = function(...args) {
+  return toggleStoriesPinned(this._client, ...args);
+};
+TelegramClient.prototype.blockUser = function(...args) {
+  return blockUser(this._client, ...args);
+};
+TelegramClient.prototype.deleteProfilePhotos = function(...args) {
+  return deleteProfilePhotos(this._client, ...args);
+};
+TelegramClient.prototype.editCloseFriendsRaw = function(...args) {
+  return editCloseFriendsRaw(this._client, ...args);
+};
+TelegramClient.prototype.editCloseFriends = function(...args) {
+  return editCloseFriends(this._client, ...args);
+};
+TelegramClient.prototype.getCommonChats = function(...args) {
+  return getCommonChats(this._client, ...args);
+};
+TelegramClient.prototype.getGlobalTtl = function(...args) {
+  return getGlobalTtl(this._client, ...args);
+};
+TelegramClient.prototype.getMe = function(...args) {
+  return getMe(this._client, ...args);
+};
+TelegramClient.prototype.getMyUsername = function(...args) {
+  return getMyUsername(this._client, ...args);
+};
+TelegramClient.prototype.getProfilePhoto = function(...args) {
+  return getProfilePhoto(this._client, ...args);
+};
+TelegramClient.prototype.getProfilePhotos = function(...args) {
+  return getProfilePhotos(this._client, ...args);
+};
+TelegramClient.prototype.getUsers = function(...args) {
+  return getUsers(this._client, ...args);
+};
+TelegramClient.prototype.iterProfilePhotos = function(...args) {
+  return iterProfilePhotos(this._client, ...args);
+};
+TelegramClient.prototype.resolvePeerMany = function(...args) {
+  return resolvePeerMany(this._client, ...args);
+};
+TelegramClient.prototype.resolvePeer = function(...args) {
+  return resolvePeer(this._client, ...args);
+};
+TelegramClient.prototype.resolveUser = function(...args) {
+  return resolveUser(this._client, ...args);
+};
+TelegramClient.prototype.resolveChannel = function(...args) {
+  return resolveChannel(this._client, ...args);
+};
+TelegramClient.prototype.setGlobalTtl = function(...args) {
+  return setGlobalTtl(this._client, ...args);
+};
+TelegramClient.prototype.setMyBirthday = function(...args) {
+  return setMyBirthday(this._client, ...args);
+};
+TelegramClient.prototype.setMyEmojiStatus = function(...args) {
+  return setMyEmojiStatus(this._client, ...args);
+};
+TelegramClient.prototype.setMyProfilePhoto = function(...args) {
+  return setMyProfilePhoto(this._client, ...args);
+};
+TelegramClient.prototype.setMyUsername = function(...args) {
+  return setMyUsername(this._client, ...args);
+};
+TelegramClient.prototype.setOffline = function(...args) {
+  return setOffline(this._client, ...args);
+};
+TelegramClient.prototype.unblockUser = function(...args) {
+  return unblockUser(this._client, ...args);
+};
+TelegramClient.prototype.updateProfile = function(...args) {
+  return updateProfile(this._client, ...args);
+};
+TelegramClient.prototype.prepare = function(...args) {
+  return this._client.prepare(...args);
+};
+TelegramClient.prototype.connect = function(...args) {
+  return this._client.connect(...args);
+};
+TelegramClient.prototype.close = function(...args) {
+  return this._client.close(...args);
+};
+TelegramClient.prototype.notifyLoggedIn = function(...args) {
+  return this._client.notifyLoggedIn(...args);
+};
+TelegramClient.prototype.notifyLoggedOut = function(...args) {
+  return this._client.notifyLoggedOut(...args);
+};
+TelegramClient.prototype.notifyChannelOpened = function(...args) {
+  return this._client.notifyChannelOpened(...args);
+};
+TelegramClient.prototype.notifyChannelClosed = function(...args) {
+  return this._client.notifyChannelClosed(...args);
+};
+TelegramClient.prototype.startUpdatesLoop = function(...args) {
+  return this._client.startUpdatesLoop(...args);
+};
+TelegramClient.prototype.stopUpdatesLoop = function(...args) {
+  return this._client.stopUpdatesLoop(...args);
+};
+TelegramClient.prototype.call = function(...args) {
+  return this._client.call(...args);
+};
+TelegramClient.prototype.importSession = function(...args) {
+  return this._client.importSession(...args);
+};
+TelegramClient.prototype.exportSession = function(...args) {
+  return this._client.exportSession(...args);
+};
+TelegramClient.prototype.onError = function(...args) {
+  return this._client.onError(...args);
+};
+TelegramClient.prototype.emitError = function(...args) {
+  return this._client.emitError(...args);
+};
+TelegramClient.prototype.handleClientUpdate = function(...args) {
+  return this._client.handleClientUpdate(...args);
+};
+TelegramClient.prototype.getApiCrenetials = function(...args) {
+  return this._client.getApiCrenetials(...args);
+};
+TelegramClient.prototype.getPoolSize = function(...args) {
+  return this._client.getPoolSize(...args);
+};
+TelegramClient.prototype.getPrimaryDcId = function(...args) {
+  return this._client.getPrimaryDcId(...args);
+};
+TelegramClient.prototype.computeSrpParams = function(...args) {
+  return this._client.computeSrpParams(...args);
+};
+TelegramClient.prototype.computeNewPasswordHash = function(...args) {
+  return this._client.computeNewPasswordHash(...args);
+};
+TelegramClient.prototype.onConnectionState = function(...args) {
+  return this._client.onConnectionState(...args);
+};
+TelegramClient.prototype.getServerUpdateHandler = function(...args) {
+  return this._client.getServerUpdateHandler(...args);
+};
+TelegramClient.prototype.changePrimaryDc = function(...args) {
+  return this._client.changePrimaryDc(...args);
+};
+TelegramClient.prototype.getMtprotoMessageId = function(...args) {
+  return this._client.getMtprotoMessageId(...args);
+};
+TelegramClient.prototype.onServerUpdate = function() {
+  throw new Error("onServerUpdate is not available for TelegramClient, use .on() methods instead");
+};
+TelegramClient.prototype.onUpdate = function() {
+  throw new Error("onUpdate is not available for TelegramClient, use .on() methods instead");
+};
+export {
+  BaseTelegramClient,
+  TelegramClient
+};