@mtcute/core 0.16.6 → 0.16.9

package/client.cjs

@@ -0,0 +1,1378 @@
+if (typeof globalThis !== "undefined" && !globalThis._MTCUTE_CJS_DEPRECATION_WARNED) {
+  globalThis._MTCUTE_CJS_DEPRECATION_WARNED = true;
+  console.warn("[@mtcute/core] CommonJS support is deprecated and will be removed soon. Please consider switching to ESM, it's " + (/* @__PURE__ */ new Date()).getFullYear() + " already.");
+  console.warn("[@mtcute/core] Learn more about switching to ESM: https://gist.github.com/sindresorhus/a39789f98801d908bbc7ff3ecc99d99c");
+}
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const EventEmitter = require("node:events");
+const tl = require("@mtcute/tl");
+const client = require("./chunks/cjs/CS5mxbeO.js");
+const platform = require("./chunks/cjs/j7rWn_1y.js");
+const sortedArray = require("./chunks/cjs/C1cFqHcW.js");
+const logger = require("./chunks/cjs/D4qcXFYA.js");
+const controllablePromise = require("./chunks/cjs/CZAB54t2.js");
+require("@mtcute/tl-runtime");
+const tlJson = require("./chunks/cjs/BQETTb_8.js");
+const conditionVariable = require("./chunks/cjs/eX3zeDAz.js");
+const storyViewer = require("./chunks/cjs/UVFvMVPt.js");
+const updateProfile = require("./chunks/cjs/jFPoDILV.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(client2) {
+    this.client = client2;
+  }
+  _reloadable = new client.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 = tlJson.tlJsonToJson((await this._reloadable.get()).config);
+    if (!obj || typeof obj !== "object") {
+      throw new platform.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.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 logger.LogManager("client");
+    this.mt = new client.MtClient({
+      ...this.params,
+      logger: this.log.create("mtproto")
+    });
+    if (!params.disableUpdates && params.updates !== false) {
+      this.updates = new client.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 client.TelegramStorageManager(this.mt.storage, {
+      provider: this.params.storage,
+      ...this.params.storageOptions
+    });
+  }
+  updates;
+  _serverUpdatesHandler = () => {
+  };
+  _connectionStateHandler = () => {
+  };
+  log;
+  mt;
+  crypto;
+  storage;
+  appConfig = new AppConfigManager(this);
+  _prepare = sortedArray.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 = sortedArray.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 (controllablePromise.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" ? tlJson.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 tlJson.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 platform.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 tlJson.computeSrpParams(this.crypto, request, password);
+  }
+  computeNewPasswordHash(algo, password) {
+    return tlJson.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 storyViewer.Message$2(update.message, peers, update._ === "updateNewScheduledMessage")
+      };
+    case "updateEditMessage":
+    case "updateEditChannelMessage":
+      return { name: "edit_message", data: new storyViewer.Message$2(update.message, peers) };
+    case "updateChatParticipant":
+    case "updateChannelParticipant":
+      return { name: "chat_member", data: new client.ChatMemberUpdate$2(update, peers) };
+    case "updateBotInlineQuery":
+      return { name: "inline_query", data: new client.InlineQuery$2(update, peers) };
+    case "updateBotInlineSend":
+      return { name: "chosen_inline_result", data: new client.ChosenInlineResult$2(update, peers) };
+    case "updateBotCallbackQuery":
+      return { name: "callback_query", data: new client.CallbackQuery$2(update, peers) };
+    case "updateInlineBotCallbackQuery":
+      return { name: "inline_callback_query", data: new client.InlineCallbackQuery$2(update, peers) };
+    case "updateMessagePoll":
+      return { name: "poll", data: new client.PollUpdate$2(update, peers) };
+    case "updateMessagePollVote":
+      return { name: "poll_vote", data: new client.PollVoteUpdate$2(update, peers) };
+    case "updateUserStatus":
+      return { name: "user_status", data: new client.UserStatusUpdate$2(update) };
+    case "updateChannelUserTyping":
+    case "updateChatUserTyping":
+    case "updateUserTyping":
+      return { name: "user_typing", data: new client.UserTypingUpdate$1(update) };
+    case "updateDeleteChannelMessages":
+    case "updateDeleteMessages":
+      return { name: "delete_message", data: new client.DeleteMessageUpdate$1(update) };
+    case "updateReadHistoryInbox":
+    case "updateReadHistoryOutbox":
+    case "updateReadChannelInbox":
+    case "updateReadChannelOutbox":
+    case "updateReadChannelDiscussionInbox":
+    case "updateReadChannelDiscussionOutbox":
+      return { name: "history_read", data: new client.HistoryReadUpdate$1(update) };
+    case "updateBotStopped":
+      return { name: "bot_stopped", data: new client.BotStoppedUpdate$2(update, peers) };
+    case "updateBotChatInviteRequester":
+      return { name: "bot_chat_join_request", data: new client.BotChatJoinRequestUpdate$2(update, peers) };
+    case "updatePendingJoinRequests":
+      return { name: "chat_join_request", data: new client.ChatJoinRequestUpdate$2(update, peers) };
+    case "updateBotPrecheckoutQuery":
+      return { name: "pre_checkout_query", data: new client.PreCheckoutQuery$2(update, peers) };
+    case "updateStory": {
+      const story = update.story;
+      if (story._ === "storyItemDeleted") {
+        return { name: "delete_story", data: new client.DeleteStoryUpdate$2(update, peers) };
+      }
+      return {
+        name: "story",
+        data: new client.StoryUpdate$2(update, peers)
+      };
+    }
+    case "updateBotMessageReaction":
+      return { name: "bot_reaction", data: new client.BotReactionUpdate$2(update, peers) };
+    case "updateBotMessageReactions":
+      return { name: "bot_reaction_count", data: new client.BotReactionCountUpdate$2(update, peers) };
+    case "updateBotBusinessConnect":
+      return { name: "business_connection", data: new storyViewer.BusinessConnection$2(update.connection, peers) };
+    case "updateBotNewBusinessMessage":
+      return { name: "new_business_message", data: new client.BusinessMessage(update, peers) };
+    case "updateBotEditBusinessMessage":
+      return { name: "edit_business_message", data: new client.BusinessMessage(update, peers) };
+    case "updateBotDeleteBusinessMessage":
+      return { name: "delete_business_message", data: new client.DeleteBusinessMessageUpdate$2(update, peers) };
+    case "updateBusinessBotCallbackQuery":
+      return { name: "business_callback_query", data: new client.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 = conditionVariable.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(client2, params) {
+  const wrappedCall = (message, extraParams) => client2.call(message, extraParams ? { ...params, ...extraParams } : params);
+  const proxy = new Proxy(client2, {
+    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 platform.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 (client.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 updateProfile.checkPassword(this._client, ...args);
+};
+TelegramClient.prototype.getPasswordHint = function(...args) {
+  return updateProfile.getPasswordHint(this._client, ...args);
+};
+TelegramClient.prototype.logOut = function(...args) {
+  return updateProfile.logOut(this._client, ...args);
+};
+TelegramClient.prototype.recoverPassword = function(...args) {
+  return updateProfile.recoverPassword(this._client, ...args);
+};
+TelegramClient.prototype.resendCode = function(...args) {
+  return updateProfile.resendCode(this._client, ...args);
+};
+TelegramClient.prototype.run = function(...args) {
+  return updateProfile.run(this._client, ...args);
+};
+TelegramClient.prototype.sendCode = function(...args) {
+  return updateProfile.sendCode(this._client, ...args);
+};
+TelegramClient.prototype.sendRecoveryCode = function(...args) {
+  return updateProfile.sendRecoveryCode(this._client, ...args);
+};
+TelegramClient.prototype.signInBot = function(...args) {
+  return updateProfile.signInBot(this._client, ...args);
+};
+TelegramClient.prototype.signInQr = function(...args) {
+  return updateProfile.signInQr(this._client, ...args);
+};
+TelegramClient.prototype.signIn = function(...args) {
+  return updateProfile.signIn(this._client, ...args);
+};
+TelegramClient.prototype.startTest = function(...args) {
+  return updateProfile.startTest(this._client, ...args);
+};
+TelegramClient.prototype.start = function(...args) {
+  return updateProfile.start(this._client, ...args);
+};
+TelegramClient.prototype.isSelfPeer = function(...args) {
+  return updateProfile.isSelfPeer(this._client, ...args);
+};
+TelegramClient.prototype.answerCallbackQuery = function(...args) {
+  return updateProfile.answerCallbackQuery(this._client, ...args);
+};
+TelegramClient.prototype.answerInlineQuery = function(...args) {
+  return updateProfile.answerInlineQuery(this._client, ...args);
+};
+TelegramClient.prototype.answerPreCheckoutQuery = function(...args) {
+  return updateProfile.answerPreCheckoutQuery(this._client, ...args);
+};
+TelegramClient.prototype.deleteMyCommands = function(...args) {
+  return updateProfile.deleteMyCommands(this._client, ...args);
+};
+TelegramClient.prototype.getBotInfo = function(...args) {
+  return updateProfile.getBotInfo(this._client, ...args);
+};
+TelegramClient.prototype.getBotMenuButton = function(...args) {
+  return updateProfile.getBotMenuButton(this._client, ...args);
+};
+TelegramClient.prototype.getCallbackAnswer = function(...args) {
+  return updateProfile.getCallbackAnswer(this._client, ...args);
+};
+TelegramClient.prototype.getGameHighScores = function(...args) {
+  return updateProfile.getGameHighScores(this._client, ...args);
+};
+TelegramClient.prototype.getInlineGameHighScores = function(...args) {
+  return updateProfile.getInlineGameHighScores(this._client, ...args);
+};
+TelegramClient.prototype.getMyCommands = function(...args) {
+  return updateProfile.getMyCommands(this._client, ...args);
+};
+TelegramClient.prototype.setBotInfo = function(...args) {
+  return updateProfile.setBotInfo(this._client, ...args);
+};
+TelegramClient.prototype.setBotMenuButton = function(...args) {
+  return updateProfile.setBotMenuButton(this._client, ...args);
+};
+TelegramClient.prototype.setGameScore = function(...args) {
+  return updateProfile.setGameScore(this._client, ...args);
+};
+TelegramClient.prototype.setInlineGameScore = function(...args) {
+  return updateProfile.setInlineGameScore(this._client, ...args);
+};
+TelegramClient.prototype.setMyCommands = function(...args) {
+  return updateProfile.setMyCommands(this._client, ...args);
+};
+TelegramClient.prototype.setMyDefaultRights = function(...args) {
+  return updateProfile.setMyDefaultRights(this._client, ...args);
+};
+TelegramClient.prototype.addChatMembers = function(...args) {
+  return updateProfile.addChatMembers(this._client, ...args);
+};
+TelegramClient.prototype.archiveChats = function(...args) {
+  return updateProfile.archiveChats(this._client, ...args);
+};
+TelegramClient.prototype.banChatMember = function(...args) {
+  return updateProfile.banChatMember(this._client, ...args);
+};
+TelegramClient.prototype.createChannel = function(...args) {
+  return updateProfile.createChannel(this._client, ...args);
+};
+TelegramClient.prototype.createGroup = function(...args) {
+  return updateProfile.createGroup(this._client, ...args);
+};
+TelegramClient.prototype.createSupergroup = function(...args) {
+  return updateProfile.createSupergroup(this._client, ...args);
+};
+TelegramClient.prototype.deleteChannel = function(...args) {
+  return updateProfile.deleteChannel(this._client, ...args);
+};
+TelegramClient.prototype.deleteSupergroup = function(...args) {
+  return updateProfile.deleteChannel(this._client, ...args);
+};
+TelegramClient.prototype.deleteChatPhoto = function(...args) {
+  return updateProfile.deleteChatPhoto(this._client, ...args);
+};
+TelegramClient.prototype.deleteGroup = function(...args) {
+  return updateProfile.deleteGroup(this._client, ...args);
+};
+TelegramClient.prototype.deleteHistory = function(...args) {
+  return updateProfile.deleteHistory(this._client, ...args);
+};
+TelegramClient.prototype.deleteUserHistory = function(...args) {
+  return updateProfile.deleteUserHistory(this._client, ...args);
+};
+TelegramClient.prototype.editAdminRights = function(...args) {
+  return updateProfile.editAdminRights(this._client, ...args);
+};
+TelegramClient.prototype.getChatEventLog = function(...args) {
+  return updateProfile.getChatEventLog(this._client, ...args);
+};
+TelegramClient.prototype.getChatMember = function(...args) {
+  return updateProfile.getChatMember(this._client, ...args);
+};
+TelegramClient.prototype.getChatMembers = function(...args) {
+  return updateProfile.getChatMembers(this._client, ...args);
+};
+TelegramClient.prototype.getChatPreview = function(...args) {
+  return updateProfile.getChatPreview(this._client, ...args);
+};
+TelegramClient.prototype.getChat = function(...args) {
+  return updateProfile.getChat(this._client, ...args);
+};
+TelegramClient.prototype.getFullChat = function(...args) {
+  return updateProfile.getFullChat(this._client, ...args);
+};
+TelegramClient.prototype.getNearbyChats = function(...args) {
+  return updateProfile.getNearbyChats(this._client, ...args);
+};
+TelegramClient.prototype.getSimilarChannels = function(...args) {
+  return updateProfile.getSimilarChannels(this._client, ...args);
+};
+TelegramClient.prototype.iterChatEventLog = function(...args) {
+  return updateProfile.iterChatEventLog(this._client, ...args);
+};
+TelegramClient.prototype.iterChatMembers = function(...args) {
+  return updateProfile.iterChatMembers(this._client, ...args);
+};
+TelegramClient.prototype.joinChat = function(...args) {
+  return updateProfile.joinChat(this._client, ...args);
+};
+TelegramClient.prototype.kickChatMember = function(...args) {
+  return updateProfile.kickChatMember(this._client, ...args);
+};
+TelegramClient.prototype.leaveChat = function(...args) {
+  return updateProfile.leaveChat(this._client, ...args);
+};
+TelegramClient.prototype.markChatUnread = function(...args) {
+  return updateProfile.markChatUnread(this._client, ...args);
+};
+TelegramClient.prototype.openChat = function(...args) {
+  return updateProfile.openChat(this._client, ...args);
+};
+TelegramClient.prototype.closeChat = function(...args) {
+  return updateProfile.closeChat(this._client, ...args);
+};
+TelegramClient.prototype.reorderUsernames = function(...args) {
+  return updateProfile.reorderUsernames(this._client, ...args);
+};
+TelegramClient.prototype.restrictChatMember = function(...args) {
+  return updateProfile.restrictChatMember(this._client, ...args);
+};
+TelegramClient.prototype.saveDraft = function(...args) {
+  return updateProfile.saveDraft(this._client, ...args);
+};
+TelegramClient.prototype.setChatColor = function(...args) {
+  return updateProfile.setChatColor(this._client, ...args);
+};
+TelegramClient.prototype.setChatDefaultPermissions = function(...args) {
+  return updateProfile.setChatDefaultPermissions(this._client, ...args);
+};
+TelegramClient.prototype.setChatDescription = function(...args) {
+  return updateProfile.setChatDescription(this._client, ...args);
+};
+TelegramClient.prototype.setChatPhoto = function(...args) {
+  return updateProfile.setChatPhoto(this._client, ...args);
+};
+TelegramClient.prototype.setChatTitle = function(...args) {
+  return updateProfile.setChatTitle(this._client, ...args);
+};
+TelegramClient.prototype.setChatTtl = function(...args) {
+  return updateProfile.setChatTtl(this._client, ...args);
+};
+TelegramClient.prototype.setChatUsername = function(...args) {
+  return updateProfile.setChatUsername(this._client, ...args);
+};
+TelegramClient.prototype.setSlowMode = function(...args) {
+  return updateProfile.setSlowMode(this._client, ...args);
+};
+TelegramClient.prototype.toggleContentProtection = function(...args) {
+  return updateProfile.toggleContentProtection(this._client, ...args);
+};
+TelegramClient.prototype.toggleFragmentUsername = function(...args) {
+  return updateProfile.toggleFragmentUsername(this._client, ...args);
+};
+TelegramClient.prototype.toggleJoinRequests = function(...args) {
+  return updateProfile.toggleJoinRequests(this._client, ...args);
+};
+TelegramClient.prototype.toggleJoinToSend = function(...args) {
+  return updateProfile.toggleJoinToSend(this._client, ...args);
+};
+TelegramClient.prototype.unarchiveChats = function(...args) {
+  return updateProfile.unarchiveChats(this._client, ...args);
+};
+TelegramClient.prototype.unbanChatMember = function(...args) {
+  return updateProfile.unbanChatMember(this._client, ...args);
+};
+TelegramClient.prototype.unrestrictChatMember = function(...args) {
+  return updateProfile.unbanChatMember(this._client, ...args);
+};
+TelegramClient.prototype.addContact = function(...args) {
+  return updateProfile.addContact(this._client, ...args);
+};
+TelegramClient.prototype.deleteContacts = function(...args) {
+  return updateProfile.deleteContacts(this._client, ...args);
+};
+TelegramClient.prototype.getContacts = function(...args) {
+  return updateProfile.getContacts(this._client, ...args);
+};
+TelegramClient.prototype.importContacts = function(...args) {
+  return updateProfile.importContacts(this._client, ...args);
+};
+TelegramClient.prototype.createFolder = function(...args) {
+  return updateProfile.createFolder(this._client, ...args);
+};
+TelegramClient.prototype.deleteFolder = function(...args) {
+  return updateProfile.deleteFolder(this._client, ...args);
+};
+TelegramClient.prototype.editFolder = function(...args) {
+  return updateProfile.editFolder(this._client, ...args);
+};
+TelegramClient.prototype.findDialogs = function(...args) {
+  return updateProfile.findDialogs(this._client, ...args);
+};
+TelegramClient.prototype.findFolder = function(...args) {
+  return updateProfile.findFolder(this._client, ...args);
+};
+TelegramClient.prototype.getChatlistPreview = function(...args) {
+  return updateProfile.getChatlistPreview(this._client, ...args);
+};
+TelegramClient.prototype.getFolders = function(...args) {
+  return updateProfile.getFolders(this._client, ...args);
+};
+TelegramClient.prototype.getPeerDialogs = function(...args) {
+  return storyViewer.getPeerDialogs(this._client, ...args);
+};
+TelegramClient.prototype.iterDialogs = function(...args) {
+  return updateProfile.iterDialogs(this._client, ...args);
+};
+TelegramClient.prototype.joinChatlist = function(...args) {
+  return updateProfile.joinChatlist(this._client, ...args);
+};
+TelegramClient.prototype.setFoldersOrder = function(...args) {
+  return updateProfile.setFoldersOrder(this._client, ...args);
+};
+TelegramClient.prototype.downloadAsBuffer = function(...args) {
+  return updateProfile.downloadAsBuffer(this._client, ...args);
+};
+TelegramClient.prototype.downloadAsIterable = function(...args) {
+  return updateProfile.downloadAsIterable(this._client, ...args);
+};
+TelegramClient.prototype.downloadAsStream = function(...args) {
+  return updateProfile.downloadAsStream(this._client, ...args);
+};
+TelegramClient.prototype._normalizeInputFile = function(...args) {
+  return storyViewer._normalizeInputFile(this._client, ...args);
+};
+TelegramClient.prototype._normalizeInputMedia = function(...args) {
+  return storyViewer._normalizeInputMedia(this._client, ...args);
+};
+TelegramClient.prototype.uploadFile = function(...args) {
+  return storyViewer.uploadFile(this._client, ...args);
+};
+TelegramClient.prototype.uploadMedia = function(...args) {
+  return updateProfile.uploadMedia(this._client, ...args);
+};
+TelegramClient.prototype.createForumTopic = function(...args) {
+  return updateProfile.createForumTopic(this._client, ...args);
+};
+TelegramClient.prototype.deleteForumTopicHistory = function(...args) {
+  return updateProfile.deleteForumTopicHistory(this._client, ...args);
+};
+TelegramClient.prototype.editForumTopic = function(...args) {
+  return updateProfile.editForumTopic(this._client, ...args);
+};
+TelegramClient.prototype.getForumTopicsById = function(...args) {
+  return updateProfile.getForumTopicsById(this._client, ...args);
+};
+TelegramClient.prototype.getForumTopics = function(...args) {
+  return updateProfile.getForumTopics(this._client, ...args);
+};
+TelegramClient.prototype.iterForumTopics = function(...args) {
+  return updateProfile.iterForumTopics(this._client, ...args);
+};
+TelegramClient.prototype.reorderPinnedForumTopics = function(...args) {
+  return updateProfile.reorderPinnedForumTopics(this._client, ...args);
+};
+TelegramClient.prototype.toggleForumTopicClosed = function(...args) {
+  return updateProfile.toggleForumTopicClosed(this._client, ...args);
+};
+TelegramClient.prototype.toggleForumTopicPinned = function(...args) {
+  return updateProfile.toggleForumTopicPinned(this._client, ...args);
+};
+TelegramClient.prototype.toggleForum = function(...args) {
+  return updateProfile.toggleForum(this._client, ...args);
+};
+TelegramClient.prototype.toggleGeneralTopicHidden = function(...args) {
+  return updateProfile.toggleGeneralTopicHidden(this._client, ...args);
+};
+TelegramClient.prototype.createInviteLink = function(...args) {
+  return updateProfile.createInviteLink(this._client, ...args);
+};
+TelegramClient.prototype.editInviteLink = function(...args) {
+  return updateProfile.editInviteLink(this._client, ...args);
+};
+TelegramClient.prototype.exportInviteLink = function(...args) {
+  return updateProfile.exportInviteLink(this._client, ...args);
+};
+TelegramClient.prototype.getInviteLinkMembers = function(...args) {
+  return updateProfile.getInviteLinkMembers(this._client, ...args);
+};
+TelegramClient.prototype.getInviteLink = function(...args) {
+  return updateProfile.getInviteLink(this._client, ...args);
+};
+TelegramClient.prototype.getInviteLinks = function(...args) {
+  return updateProfile.getInviteLinks(this._client, ...args);
+};
+TelegramClient.prototype.getPrimaryInviteLink = function(...args) {
+  return updateProfile.getPrimaryInviteLink(this._client, ...args);
+};
+TelegramClient.prototype.hideAllJoinRequests = function(...args) {
+  return updateProfile.hideAllJoinRequests(this._client, ...args);
+};
+TelegramClient.prototype.hideJoinRequest = function(...args) {
+  return updateProfile.hideJoinRequest(this._client, ...args);
+};
+TelegramClient.prototype.iterInviteLinkMembers = function(...args) {
+  return updateProfile.iterInviteLinkMembers(this._client, ...args);
+};
+TelegramClient.prototype.iterInviteLinks = function(...args) {
+  return updateProfile.iterInviteLinks(this._client, ...args);
+};
+TelegramClient.prototype.revokeInviteLink = function(...args) {
+  return updateProfile.revokeInviteLink(this._client, ...args);
+};
+TelegramClient.prototype.closePoll = function(...args) {
+  return updateProfile.closePoll(this._client, ...args);
+};
+TelegramClient.prototype.deleteMessagesById = function(...args) {
+  return updateProfile.deleteMessagesById(this._client, ...args);
+};
+TelegramClient.prototype.deleteMessages = function(...args) {
+  return updateProfile.deleteMessages(this._client, ...args);
+};
+TelegramClient.prototype.deleteScheduledMessages = function(...args) {
+  return updateProfile.deleteScheduledMessages(this._client, ...args);
+};
+TelegramClient.prototype.editInlineMessage = function(...args) {
+  return updateProfile.editInlineMessage(this._client, ...args);
+};
+TelegramClient.prototype.editMessage = function(...args) {
+  return updateProfile.editMessage(this._client, ...args);
+};
+TelegramClient.prototype.forwardMessagesById = function(...args) {
+  return updateProfile.forwardMessagesById(this._client, ...args);
+};
+TelegramClient.prototype.forwardMessages = function(...args) {
+  return updateProfile.forwardMessages(this._client, ...args);
+};
+TelegramClient.prototype.getAllScheduledMessages = function(...args) {
+  return updateProfile.getAllScheduledMessages(this._client, ...args);
+};
+TelegramClient.prototype.getAvailableMessageEffects = function(...args) {
+  return updateProfile.getAvailableMessageEffects(this._client, ...args);
+};
+TelegramClient.prototype.getCallbackQueryMessage = function(...args) {
+  return updateProfile.getCallbackQueryMessage(this._client, ...args);
+};
+TelegramClient.prototype.getDiscussionMessage = function(...args) {
+  return storyViewer.getDiscussionMessage(this._client, ...args);
+};
+TelegramClient.prototype.getFactCheck = function(...args) {
+  return updateProfile.getFactCheck(this._client, ...args);
+};
+TelegramClient.prototype.getHistory = function(...args) {
+  return updateProfile.getHistory(this._client, ...args);
+};
+TelegramClient.prototype.getMessageByLink = function(...args) {
+  return updateProfile.getMessageByLink(this._client, ...args);
+};
+TelegramClient.prototype.getMessageGroup = function(...args) {
+  return updateProfile.getMessageGroup(this._client, ...args);
+};
+TelegramClient.prototype.getMessageReactionsById = function(...args) {
+  return updateProfile.getMessageReactionsById(this._client, ...args);
+};
+TelegramClient.prototype.getMessageReactions = function(...args) {
+  return updateProfile.getMessageReactions(this._client, ...args);
+};
+TelegramClient.prototype.getMessagesUnsafe = function(...args) {
+  return updateProfile.getMessagesUnsafe(this._client, ...args);
+};
+TelegramClient.prototype.getMessages = function(...args) {
+  return storyViewer.getMessages(this._client, ...args);
+};
+TelegramClient.prototype.getReactionUsers = function(...args) {
+  return updateProfile.getReactionUsers(this._client, ...args);
+};
+TelegramClient.prototype.getReplyTo = function(...args) {
+  return updateProfile.getReplyTo(this._client, ...args);
+};
+TelegramClient.prototype.getScheduledMessages = function(...args) {
+  return updateProfile.getScheduledMessages(this._client, ...args);
+};
+TelegramClient.prototype.iterHistory = function(...args) {
+  return updateProfile.iterHistory(this._client, ...args);
+};
+TelegramClient.prototype.iterReactionUsers = function(...args) {
+  return updateProfile.iterReactionUsers(this._client, ...args);
+};
+TelegramClient.prototype.iterSearchGlobal = function(...args) {
+  return updateProfile.iterSearchGlobal(this._client, ...args);
+};
+TelegramClient.prototype.iterSearchMessages = function(...args) {
+  return updateProfile.iterSearchMessages(this._client, ...args);
+};
+TelegramClient.prototype.pinMessage = function(...args) {
+  return updateProfile.pinMessage(this._client, ...args);
+};
+TelegramClient.prototype.readHistory = function(...args) {
+  return storyViewer.readHistory(this._client, ...args);
+};
+TelegramClient.prototype.readReactions = function(...args) {
+  return updateProfile.readReactions(this._client, ...args);
+};
+TelegramClient.prototype.searchGlobal = function(...args) {
+  return updateProfile.searchGlobal(this._client, ...args);
+};
+TelegramClient.prototype.searchHashtag = function(...args) {
+  return updateProfile.searchHashtag(this._client, ...args);
+};
+TelegramClient.prototype.iterSearchHashtag = function(...args) {
+  return updateProfile.iterSearchHashtag(this._client, ...args);
+};
+TelegramClient.prototype.searchMessages = function(...args) {
+  return updateProfile.searchMessages(this._client, ...args);
+};
+TelegramClient.prototype.answerText = function(...args) {
+  return updateProfile.answerText(this._client, ...args);
+};
+TelegramClient.prototype.answerMedia = function(...args) {
+  return updateProfile.answerMedia(this._client, ...args);
+};
+TelegramClient.prototype.answerMediaGroup = function(...args) {
+  return updateProfile.answerMediaGroup(this._client, ...args);
+};
+TelegramClient.prototype.commentText = function(...args) {
+  return updateProfile.commentText(this._client, ...args);
+};
+TelegramClient.prototype.commentMedia = function(...args) {
+  return updateProfile.commentMedia(this._client, ...args);
+};
+TelegramClient.prototype.commentMediaGroup = function(...args) {
+  return updateProfile.commentMediaGroup(this._client, ...args);
+};
+TelegramClient.prototype.sendCopyGroup = function(...args) {
+  return updateProfile.sendCopyGroup(this._client, ...args);
+};
+TelegramClient.prototype.sendCopy = function(...args) {
+  return updateProfile.sendCopy(this._client, ...args);
+};
+TelegramClient.prototype.sendMediaGroup = function(...args) {
+  return storyViewer.sendMediaGroup(this._client, ...args);
+};
+TelegramClient.prototype.sendMedia = function(...args) {
+  return storyViewer.sendMedia(this._client, ...args);
+};
+TelegramClient.prototype.sendPaidReaction = function(...args) {
+  return updateProfile.sendPaidReaction(this._client, ...args);
+};
+TelegramClient.prototype.quoteWithText = function(...args) {
+  return updateProfile.quoteWithText(this._client, ...args);
+};
+TelegramClient.prototype.quoteWithMedia = function(...args) {
+  return updateProfile.quoteWithMedia(this._client, ...args);
+};
+TelegramClient.prototype.quoteWithMediaGroup = function(...args) {
+  return updateProfile.quoteWithMediaGroup(this._client, ...args);
+};
+TelegramClient.prototype.sendReaction = function(...args) {
+  return updateProfile.sendReaction(this._client, ...args);
+};
+TelegramClient.prototype.replyText = function(...args) {
+  return updateProfile.replyText(this._client, ...args);
+};
+TelegramClient.prototype.replyMedia = function(...args) {
+  return updateProfile.replyMedia(this._client, ...args);
+};
+TelegramClient.prototype.replyMediaGroup = function(...args) {
+  return updateProfile.replyMediaGroup(this._client, ...args);
+};
+TelegramClient.prototype.sendScheduled = function(...args) {
+  return updateProfile.sendScheduled(this._client, ...args);
+};
+TelegramClient.prototype.sendText = function(...args) {
+  return storyViewer.sendText(this._client, ...args);
+};
+TelegramClient.prototype.sendTyping = function(...args) {
+  return updateProfile.sendTyping(this._client, ...args);
+};
+TelegramClient.prototype.sendVote = function(...args) {
+  return updateProfile.sendVote(this._client, ...args);
+};
+TelegramClient.prototype.translateMessage = function(...args) {
+  return updateProfile.translateMessage(this._client, ...args);
+};
+TelegramClient.prototype.translateText = function(...args) {
+  return updateProfile.translateText(this._client, ...args);
+};
+TelegramClient.prototype.unpinAllMessages = function(...args) {
+  return updateProfile.unpinAllMessages(this._client, ...args);
+};
+TelegramClient.prototype.unpinMessage = function(...args) {
+  return updateProfile.unpinMessage(this._client, ...args);
+};
+TelegramClient.prototype.getCollectibleInfo = function(...args) {
+  return updateProfile.getCollectibleInfo(this._client, ...args);
+};
+TelegramClient.prototype.initTakeoutSession = function(...args) {
+  return updateProfile.initTakeoutSession(this._client, ...args);
+};
+TelegramClient.prototype._normalizePrivacyRules = function(...args) {
+  return updateProfile._normalizePrivacyRules(this._client, ...args);
+};
+TelegramClient.prototype.changeCloudPassword = function(...args) {
+  return updateProfile.changeCloudPassword(this._client, ...args);
+};
+TelegramClient.prototype.enableCloudPassword = function(...args) {
+  return updateProfile.enableCloudPassword(this._client, ...args);
+};
+TelegramClient.prototype.verifyPasswordEmail = function(...args) {
+  return updateProfile.verifyPasswordEmail(this._client, ...args);
+};
+TelegramClient.prototype.resendPasswordEmail = function(...args) {
+  return updateProfile.resendPasswordEmail(this._client, ...args);
+};
+TelegramClient.prototype.cancelPasswordEmail = function(...args) {
+  return updateProfile.cancelPasswordEmail(this._client, ...args);
+};
+TelegramClient.prototype.removeCloudPassword = function(...args) {
+  return updateProfile.removeCloudPassword(this._client, ...args);
+};
+TelegramClient.prototype.applyBoost = function(...args) {
+  return updateProfile.applyBoost(this._client, ...args);
+};
+TelegramClient.prototype.canApplyBoost = function(...args) {
+  return updateProfile.canApplyBoost(this._client, ...args);
+};
+TelegramClient.prototype.createBusinessChatLink = function(...args) {
+  return updateProfile.createBusinessChatLink(this._client, ...args);
+};
+TelegramClient.prototype.editBusinessChatLink = function(...args) {
+  return updateProfile.editBusinessChatLink(this._client, ...args);
+};
+TelegramClient.prototype.deleteBusinessChatLink = function(...args) {
+  return updateProfile.deleteBusinessChatLink(this._client, ...args);
+};
+TelegramClient.prototype.getBoostStats = function(...args) {
+  return updateProfile.getBoostStats(this._client, ...args);
+};
+TelegramClient.prototype.getBoosts = function(...args) {
+  return updateProfile.getBoosts(this._client, ...args);
+};
+TelegramClient.prototype.getBusinessChatLinks = function(...args) {
+  return updateProfile.getBusinessChatLinks(this._client, ...args);
+};
+TelegramClient.prototype.getBusinessConnection = function(...args) {
+  return storyViewer.getBusinessConnection(this._client, ...args);
+};
+TelegramClient.prototype.getMyBoostSlots = function(...args) {
+  return updateProfile.getMyBoostSlots(this._client, ...args);
+};
+TelegramClient.prototype.getStarsTransactions = function(...args) {
+  return updateProfile.getStarsTransactions(this._client, ...args);
+};
+TelegramClient.prototype.iterBoosters = function(...args) {
+  return updateProfile.iterBoosters(this._client, ...args);
+};
+TelegramClient.prototype.iterStarsTransactions = function(...args) {
+  return updateProfile.iterStarsTransactions(this._client, ...args);
+};
+TelegramClient.prototype.setBusinessIntro = function(...args) {
+  return updateProfile.setBusinessIntro(this._client, ...args);
+};
+TelegramClient.prototype.setBusinessWorkHours = function(...args) {
+  return updateProfile.setBusinessWorkHours(this._client, ...args);
+};
+TelegramClient.prototype.addStickerToSet = function(...args) {
+  return updateProfile.addStickerToSet(this._client, ...args);
+};
+TelegramClient.prototype.createStickerSet = function(...args) {
+  return updateProfile.createStickerSet(this._client, ...args);
+};
+TelegramClient.prototype.deleteStickerFromSet = function(...args) {
+  return updateProfile.deleteStickerFromSet(this._client, ...args);
+};
+TelegramClient.prototype.getCustomEmojis = function(...args) {
+  return updateProfile.getCustomEmojis(this._client, ...args);
+};
+TelegramClient.prototype.getCustomEmojisFromMessages = function(...args) {
+  return updateProfile.getCustomEmojisFromMessages(this._client, ...args);
+};
+TelegramClient.prototype.getInstalledStickers = function(...args) {
+  return updateProfile.getInstalledStickers(this._client, ...args);
+};
+TelegramClient.prototype.getMyStickerSets = function(...args) {
+  return updateProfile.getMyStickerSets(this._client, ...args);
+};
+TelegramClient.prototype.getStickerSet = function(...args) {
+  return updateProfile.getStickerSet(this._client, ...args);
+};
+TelegramClient.prototype.moveStickerInSet = function(...args) {
+  return updateProfile.moveStickerInSet(this._client, ...args);
+};
+TelegramClient.prototype.replaceStickerInSet = function(...args) {
+  return updateProfile.replaceStickerInSet(this._client, ...args);
+};
+TelegramClient.prototype.setChatStickerSet = function(...args) {
+  return updateProfile.setChatStickerSet(this._client, ...args);
+};
+TelegramClient.prototype.setStickerSetThumb = function(...args) {
+  return updateProfile.setStickerSetThumb(this._client, ...args);
+};
+TelegramClient.prototype.canSendStory = function(...args) {
+  return updateProfile.canSendStory(this._client, ...args);
+};
+TelegramClient.prototype.deleteStories = function(...args) {
+  return updateProfile.deleteStories(this._client, ...args);
+};
+TelegramClient.prototype.editStory = function(...args) {
+  return updateProfile.editStory(this._client, ...args);
+};
+TelegramClient.prototype.getAllStories = function(...args) {
+  return updateProfile.getAllStories(this._client, ...args);
+};
+TelegramClient.prototype.getPeerStories = function(...args) {
+  return updateProfile.getPeerStories(this._client, ...args);
+};
+TelegramClient.prototype.getProfileStories = function(...args) {
+  return updateProfile.getProfileStories(this._client, ...args);
+};
+TelegramClient.prototype.getStoriesById = function(...args) {
+  return updateProfile.getStoriesById(this._client, ...args);
+};
+TelegramClient.prototype.getStoriesInteractions = function(...args) {
+  return updateProfile.getStoriesInteractions(this._client, ...args);
+};
+TelegramClient.prototype.getStoryLink = function(...args) {
+  return updateProfile.getStoryLink(this._client, ...args);
+};
+TelegramClient.prototype.getStoryViewers = function(...args) {
+  return updateProfile.getStoryViewers(this._client, ...args);
+};
+TelegramClient.prototype.hideMyStoriesViews = function(...args) {
+  return updateProfile.hideMyStoriesViews(this._client, ...args);
+};
+TelegramClient.prototype.incrementStoriesViews = function(...args) {
+  return updateProfile.incrementStoriesViews(this._client, ...args);
+};
+TelegramClient.prototype.iterAllStories = function(...args) {
+  return updateProfile.iterAllStories(this._client, ...args);
+};
+TelegramClient.prototype.iterProfileStories = function(...args) {
+  return updateProfile.iterProfileStories(this._client, ...args);
+};
+TelegramClient.prototype.iterStoryViewers = function(...args) {
+  return updateProfile.iterStoryViewers(this._client, ...args);
+};
+TelegramClient.prototype.readStories = function(...args) {
+  return updateProfile.readStories(this._client, ...args);
+};
+TelegramClient.prototype.reportStory = function(...args) {
+  return updateProfile.reportStory(this._client, ...args);
+};
+TelegramClient.prototype.sendStoryReaction = function(...args) {
+  return updateProfile.sendStoryReaction(this._client, ...args);
+};
+TelegramClient.prototype.sendStory = function(...args) {
+  return updateProfile.sendStory(this._client, ...args);
+};
+TelegramClient.prototype.togglePeerStoriesArchived = function(...args) {
+  return updateProfile.togglePeerStoriesArchived(this._client, ...args);
+};
+TelegramClient.prototype.toggleStoriesPinned = function(...args) {
+  return updateProfile.toggleStoriesPinned(this._client, ...args);
+};
+TelegramClient.prototype.blockUser = function(...args) {
+  return updateProfile.blockUser(this._client, ...args);
+};
+TelegramClient.prototype.deleteProfilePhotos = function(...args) {
+  return updateProfile.deleteProfilePhotos(this._client, ...args);
+};
+TelegramClient.prototype.editCloseFriendsRaw = function(...args) {
+  return updateProfile.editCloseFriendsRaw(this._client, ...args);
+};
+TelegramClient.prototype.editCloseFriends = function(...args) {
+  return updateProfile.editCloseFriends(this._client, ...args);
+};
+TelegramClient.prototype.getCommonChats = function(...args) {
+  return updateProfile.getCommonChats(this._client, ...args);
+};
+TelegramClient.prototype.getGlobalTtl = function(...args) {
+  return updateProfile.getGlobalTtl(this._client, ...args);
+};
+TelegramClient.prototype.getMe = function(...args) {
+  return updateProfile.getMe(this._client, ...args);
+};
+TelegramClient.prototype.getMyUsername = function(...args) {
+  return updateProfile.getMyUsername(this._client, ...args);
+};
+TelegramClient.prototype.getProfilePhoto = function(...args) {
+  return updateProfile.getProfilePhoto(this._client, ...args);
+};
+TelegramClient.prototype.getProfilePhotos = function(...args) {
+  return updateProfile.getProfilePhotos(this._client, ...args);
+};
+TelegramClient.prototype.getUsers = function(...args) {
+  return updateProfile.getUsers(this._client, ...args);
+};
+TelegramClient.prototype.iterProfilePhotos = function(...args) {
+  return updateProfile.iterProfilePhotos(this._client, ...args);
+};
+TelegramClient.prototype.resolvePeerMany = function(...args) {
+  return storyViewer.resolvePeerMany(this._client, ...args);
+};
+TelegramClient.prototype.resolvePeer = function(...args) {
+  return storyViewer.resolvePeer(this._client, ...args);
+};
+TelegramClient.prototype.resolveUser = function(...args) {
+  return storyViewer.resolveUser(this._client, ...args);
+};
+TelegramClient.prototype.resolveChannel = function(...args) {
+  return storyViewer.resolveChannel(this._client, ...args);
+};
+TelegramClient.prototype.setGlobalTtl = function(...args) {
+  return updateProfile.setGlobalTtl(this._client, ...args);
+};
+TelegramClient.prototype.setMyBirthday = function(...args) {
+  return updateProfile.setMyBirthday(this._client, ...args);
+};
+TelegramClient.prototype.setMyEmojiStatus = function(...args) {
+  return updateProfile.setMyEmojiStatus(this._client, ...args);
+};
+TelegramClient.prototype.setMyProfilePhoto = function(...args) {
+  return updateProfile.setMyProfilePhoto(this._client, ...args);
+};
+TelegramClient.prototype.setMyUsername = function(...args) {
+  return updateProfile.setMyUsername(this._client, ...args);
+};
+TelegramClient.prototype.setOffline = function(...args) {
+  return updateProfile.setOffline(this._client, ...args);
+};
+TelegramClient.prototype.unblockUser = function(...args) {
+  return updateProfile.unblockUser(this._client, ...args);
+};
+TelegramClient.prototype.updateProfile = function(...args) {
+  return updateProfile.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");
+};
+exports.BaseTelegramClient = BaseTelegramClient;
+exports.TelegramClient = TelegramClient;