@mtcute/core 0.16.6 → 0.16.9

package/chunks/cjs/jFPoDILV.js

@@ -0,0 +1,4982 @@
+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";
+const platform = require("./j7rWn_1y.js");
+const tl = require("@mtcute/tl");
+const conditionVariable = require("./eX3zeDAz.js");
+const controllablePromise = require("./CZAB54t2.js");
+const storyViewer = require("./UVFvMVPt.js");
+const Long = require("long");
+const peersIndex = require("./ija5tZ1t.js");
+const fileId = require("@mtcute/file-id");
+const chat = require("./BijPAnvP.js");
+async function _onAuthorization(client, auth) {
+  const user = await client.notifyLoggedIn(auth);
+  return new storyViewer.User$2(user);
+}
+function isSelfPeer(client, peer) {
+  const state = client.storage.self.getCached();
+  if (!state) return false;
+  switch (peer._) {
+    case "inputPeerSelf":
+    case "inputUserSelf":
+      return true;
+    case "inputPeerUser":
+    case "inputPeerUserFromMessage":
+    case "inputUser":
+    case "inputUserFromMessage":
+    case "peerUser":
+      return peer.userId === state.userId;
+    default:
+      return false;
+  }
+}
+async function checkPassword(client, password) {
+  const res = await client.call({
+    _: "auth.checkPassword",
+    password: await client.computeSrpParams(
+      await client.call({
+        _: "account.getPassword"
+      }),
+      password
+    )
+  });
+  return _onAuthorization(client, res);
+}
+function getPasswordHint(client) {
+  return client.call({
+    _: "account.getPassword"
+  }).then((res) => res.hint ?? null);
+}
+async function logOut(client) {
+  const res = await client.call({ _: "auth.logOut" });
+  await client.notifyLoggedOut();
+  return {
+    futureAuthToken: res.futureAuthToken
+  };
+}
+async function recoverPassword(client, params) {
+  const { recoveryCode } = params;
+  const res = await client.call({
+    _: "auth.recoverPassword",
+    code: recoveryCode
+  });
+  return _onAuthorization(client, res);
+}
+async function resendCode(client, params) {
+  const { phone, phoneCodeHash, abortSignal } = params;
+  const res = await client.call(
+    {
+      _: "auth.resendCode",
+      phoneNumber: conditionVariable.normalizePhoneNumber(phone),
+      phoneCodeHash
+    },
+    { abortSignal }
+  );
+  controllablePromise.assertTypeIs("sendCode", res, "auth.sentCode");
+  return new storyViewer.SentCode$1(res);
+}
+function getMe(client) {
+  return client.call({
+    _: "users.getUsers",
+    id: [
+      {
+        _: "inputUserSelf"
+      }
+    ]
+  }).then(async ([user]) => {
+    controllablePromise.assertTypeIs("getMe (@ users.getUsers)", user, "user");
+    await client.storage.self.storeFrom(user);
+    return new storyViewer.User$2(user);
+  });
+}
+async function sendCode(client, params) {
+  const phone = conditionVariable.normalizePhoneNumber(params.phone);
+  const { id, hash } = await client.getApiCrenetials();
+  const res = await client.call(
+    {
+      _: "auth.sendCode",
+      phoneNumber: phone,
+      apiId: id,
+      apiHash: hash,
+      settings: {
+        _: "codeSettings",
+        logoutTokens: params.futureAuthTokens,
+        ...params.codeSettings
+      }
+    },
+    { abortSignal: params.abortSignal }
+  );
+  controllablePromise.assertTypeIs("sendCode", res, "auth.sentCode");
+  return new storyViewer.SentCode$1(res);
+}
+async function signIn(client, params) {
+  const { phone, phoneCodeHash, phoneCode, abortSignal } = params;
+  const res = await client.call(
+    {
+      _: "auth.signIn",
+      phoneNumber: conditionVariable.normalizePhoneNumber(phone),
+      phoneCodeHash,
+      phoneCode
+    },
+    { abortSignal }
+  );
+  return _onAuthorization(client, res);
+}
+async function signInBot(client, token) {
+  const { id, hash } = await client.getApiCrenetials();
+  const res = await client.call({
+    _: "auth.importBotAuthorization",
+    flags: 0,
+    apiId: id,
+    apiHash: hash,
+    botAuthToken: token
+  });
+  return _onAuthorization(client, res);
+}
+async function signInQr(client, params) {
+  const { onUrlUpdated, abortSignal, onQrScanned } = params;
+  let waiter;
+  const originalHandler = client.getServerUpdateHandler();
+  const onUpdate = (upd) => {
+    if (upd._ === "updateShort" && upd.update._ === "updateLoginToken") {
+      onQrScanned?.();
+      waiter?.resolve();
+      client.onServerUpdate(originalHandler);
+    }
+  };
+  client.onServerUpdate(onUpdate);
+  abortSignal?.addEventListener("abort", () => {
+    client.onServerUpdate(originalHandler);
+    waiter?.reject(abortSignal.reason);
+  });
+  async function handle2fa(input) {
+    const isDynamic = typeof input === "function";
+    while (true) {
+      const password = await conditionVariable.resolveMaybeDynamic(input);
+      try {
+        return await checkPassword(client, password);
+      } catch (e) {
+        if (tl.tl.RpcError.is(e, "PASSWORD_HASH_INVALID")) {
+          if (!isDynamic) {
+            throw e;
+          }
+          if (params.invalidPasswordCallback) {
+            await params.invalidPasswordCallback?.();
+          } else {
+            console.log("Invalid password. Please try again");
+          }
+          continue;
+        }
+        throw e;
+      }
+    }
+  }
+  try {
+    const { id, hash } = await client.getApiCrenetials();
+    const platform$1 = platform.getPlatform();
+    loop: while (true) {
+      let res;
+      try {
+        res = await client.call(
+          {
+            _: "auth.exportLoginToken",
+            apiId: id,
+            apiHash: hash,
+            exceptIds: []
+          },
+          { abortSignal }
+        );
+      } catch (e) {
+        if (tl.tl.RpcError.is(e, "SESSION_PASSWORD_NEEDED") && params.password) {
+          return await handle2fa(params.password);
+        }
+        throw e;
+      }
+      switch (res._) {
+        case "auth.loginToken":
+          onUrlUpdated(
+            `tg://login?token=${platform$1.base64Encode(res.token, true)}`,
+            new Date(res.expires * 1e3)
+          );
+          waiter = controllablePromise.createControllablePromise();
+          await Promise.race([waiter, conditionVariable.sleepWithAbort(res.expires * 1e3 - Date.now(), client.stopSignal)]);
+          break;
+        case "auth.loginTokenMigrateTo": {
+          await client.changePrimaryDc(res.dcId);
+          let res2;
+          try {
+            res2 = await client.call(
+              {
+                _: "auth.importLoginToken",
+                token: res.token
+              },
+              { abortSignal }
+            );
+          } catch (e) {
+            if (tl.tl.RpcError.is(e, "SESSION_PASSWORD_NEEDED") && params.password) {
+              return await handle2fa(params.password);
+            }
+            throw e;
+          }
+          controllablePromise.assertTypeIs("auth.importLoginToken", res2, "auth.loginTokenSuccess");
+          break loop;
+        }
+        case "auth.loginTokenSuccess":
+          break loop;
+      }
+    }
+    const [self] = await client.call(
+      {
+        _: "users.getUsers",
+        id: [{ _: "inputUserSelf" }]
+      },
+      { abortSignal }
+    );
+    controllablePromise.assertTypeIs("users.getUsers", self, "user");
+    await client.notifyLoggedIn(self);
+    return new storyViewer.User$2(self);
+  } finally {
+    client.onServerUpdate(originalHandler);
+  }
+}
+async function start(client, params) {
+  if (params.session) {
+    await client.importSession(params.session, params.sessionForce);
+  }
+  const { abortSignal } = params;
+  let has2fa = false;
+  let sentCode;
+  let phone = null;
+  try {
+    const me = await getMe(client);
+    client.log.info("Logged in as %s (ID: %s, username: %s, bot: %s)", me.displayName, me.id, me.username, me.isBot);
+    await client.notifyLoggedIn(me.raw);
+    return me;
+  } catch (e) {
+    if (tl.tl.RpcError.is(e)) {
+      if (e.text === "SESSION_PASSWORD_NEEDED") has2fa = true;
+      else if (e.text !== "AUTH_KEY_UNREGISTERED") throw e;
+    }
+  }
+  if (!has2fa && !params.qrCodeHandler) {
+    if (!params.phone && !params.botToken) {
+      throw new platform.MtArgumentError("Neither phone nor bot token were provided");
+    }
+    phone = params.phone ? await conditionVariable.resolveMaybeDynamic(params.phone) : null;
+    if (phone) {
+      phone = conditionVariable.normalizePhoneNumber(phone);
+      if (!params.code) {
+        throw new platform.MtArgumentError("You must pass `code` to use `phone`");
+      }
+    } else {
+      const botToken = params.botToken ? await conditionVariable.resolveMaybeDynamic(params.botToken) : null;
+      if (!botToken) {
+        throw new platform.MtArgumentError("Either bot token or phone number must be provided");
+      }
+      return signInBot(client, botToken);
+    }
+    try {
+      sentCode = await sendCode(client, {
+        phone,
+        futureAuthTokens: params.futureAuthTokens,
+        codeSettings: params.codeSettings,
+        abortSignal
+      });
+    } catch (e) {
+      if (tl.tl.RpcError.is(e, "SESSION_PASSWORD_NEEDED")) {
+        has2fa = true;
+      } else {
+        throw e;
+      }
+    }
+  }
+  if (sentCode) {
+    if (params.forceSms && (sentCode.type === "app" || sentCode.type === "email")) {
+      sentCode = await resendCode(client, {
+        phone,
+        phoneCodeHash: sentCode.phoneCodeHash,
+        abortSignal
+      });
+    }
+    if (params.codeSentCallback) {
+      await params.codeSentCallback(sentCode);
+    } else {
+      if (sentCode.type === "email_required") {
+        throw new platform.MtcuteError("Email login setup is required to sign in");
+      }
+      console.log(`The confirmation code has been sent via ${sentCode.type}.`);
+    }
+    for (; ; ) {
+      const code = await conditionVariable.resolveMaybeDynamic(params.code);
+      if (!code) throw new tl.tl.RpcError(400, "PHONE_CODE_EMPTY");
+      try {
+        return await signIn(client, {
+          phone,
+          phoneCodeHash: sentCode.phoneCodeHash,
+          phoneCode: code,
+          abortSignal
+        });
+      } catch (e) {
+        if (!tl.tl.RpcError.is(e)) throw e;
+        if (e.is("SESSION_PASSWORD_NEEDED")) {
+          has2fa = true;
+          break;
+        } else if (e.is("PHONE_CODE_EMPTY") || e.is("PHONE_CODE_EXPIRED") || e.is("PHONE_CODE_INVALID") || e.is("PHONE_CODE_HASH_EMPTY")) {
+          if (typeof params.code !== "function") {
+            throw new platform.MtArgumentError("Provided code was invalid");
+          }
+          if (params.invalidCodeCallback) {
+            await params.invalidCodeCallback("code");
+          } else {
+            console.log("Invalid code. Please try again");
+          }
+          continue;
+        } else {
+          throw e;
+        }
+      }
+      break;
+    }
+  }
+  if (has2fa) {
+    if (!params.password) {
+      throw new platform.MtArgumentError("2FA is enabled, but `password` was not provided.");
+    }
+    for (; ; ) {
+      const password = await conditionVariable.resolveMaybeDynamic(params.password);
+      try {
+        return await checkPassword(client, password);
+      } catch (e) {
+        if (typeof params.password !== "function") {
+          throw new platform.MtArgumentError("Provided password was invalid");
+        }
+        if (tl.tl.RpcError.is(e, "PASSWORD_HASH_INVALID")) {
+          if (params.invalidCodeCallback) {
+            await params.invalidCodeCallback("password");
+          } else {
+            console.log("Invalid password. Please try again");
+          }
+          continue;
+        } else {
+          throw e;
+        }
+      }
+    }
+  }
+  if (params.qrCodeHandler) {
+    return signInQr(client, {
+      onUrlUpdated: params.qrCodeHandler,
+      password: params.password,
+      invalidPasswordCallback: params.invalidCodeCallback ? () => params.invalidCodeCallback("password") : void 0,
+      abortSignal
+    });
+  }
+  throw new platform.MtArgumentError("Failed to log in with provided credentials");
+}
+function run(client, params, then) {
+  start(client, params).then(then).catch((err) => client.emitError(err));
+}
+function sendRecoveryCode(client) {
+  return client.call({
+    _: "auth.requestPasswordRecovery"
+  }).then((res) => res.emailPattern);
+}
+async function startTest(client, params) {
+  if (!params) params = {};
+  if (params.logout) {
+    try {
+      await logOut(client);
+    } catch {
+    }
+  }
+  const availableDcs = await client.call({
+    _: "help.getConfig"
+  }).then((res) => res.dcOptions);
+  let phone = params.phone;
+  if (phone) {
+    if (!phone.match(/^99966\d{5}/)) {
+      throw new platform.MtArgumentError(`${phone} is an invalid test phone number`);
+    }
+    const id = Number.parseInt(phone[5]);
+    if (!availableDcs.find((dc) => dc.id === id)) {
+      throw new platform.MtArgumentError(`${phone} has invalid DC ID (${id})`);
+    }
+  } else {
+    let dcId = await client.getPrimaryDcId();
+    if (params.dcId) {
+      if (!availableDcs.find((dc) => dc.id === params.dcId)) {
+        throw new platform.MtArgumentError(`DC ID is invalid (${dcId})`);
+      }
+      dcId = params.dcId;
+    }
+    let numbers = Math.floor(Math.random() * 9999).toString();
+    while (numbers.length !== 4) numbers += "0";
+    phone = `99966${dcId}${numbers}`;
+  }
+  let code = "";
+  return start(client, {
+    phone,
+    code: () => code,
+    codeSentCallback: (sent) => {
+      for (let i = 0; i < sent.length; i++) {
+        code += phone[5];
+      }
+    }
+  });
+}
+async function answerCallbackQuery(client, queryId, params) {
+  const { cacheTime = 0, text, alert, url } = params ?? {};
+  const r = await client.call({
+    _: "messages.setBotCallbackAnswer",
+    queryId: Long.isLong(queryId) ? queryId : queryId.id,
+    cacheTime,
+    alert,
+    message: text,
+    url
+  });
+  controllablePromise.assertTrue("messages.setBotCallbackAnswer", r);
+}
+async function answerInlineQuery(client, queryId, results, params) {
+  const { cacheTime = 300, gallery, private: priv, nextOffset, switchPm, switchWebview } = params ?? {};
+  const [defaultGallery, tlResults] = await storyViewer._convertToTl(client, results);
+  await client.call({
+    _: "messages.setInlineBotResults",
+    queryId: Long.isLong(queryId) ? queryId : queryId.id,
+    results: tlResults,
+    cacheTime,
+    gallery: gallery ?? defaultGallery,
+    private: priv,
+    nextOffset,
+    switchPm: switchPm ? {
+      _: "inlineBotSwitchPM",
+      text: switchPm.text,
+      startParam: switchPm.parameter
+    } : void 0,
+    switchWebview: switchWebview ? {
+      _: "inlineBotWebView",
+      text: switchWebview.text,
+      url: switchWebview.url
+    } : void 0
+  });
+}
+async function answerPreCheckoutQuery(client, queryId, params) {
+  const { error } = params ?? {};
+  const r = await client.call({
+    _: "messages.setBotPrecheckoutResults",
+    queryId: Long.isLong(queryId) ? queryId : queryId.queryId,
+    success: !error,
+    error
+  });
+  controllablePromise.assertTrue("messages.setBotPrecheckoutResults", r);
+}
+async function _normalizeCommandScope(client, scope) {
+  if (tl.tl.isAnyBotCommandScope(scope)) return scope;
+  switch (scope.type) {
+    case "peer":
+    case "peer_admins": {
+      const peer = await storyViewer.resolvePeer(client, scope.peer);
+      return {
+        _: scope.type === "peer" ? "botCommandScopePeer" : "botCommandScopePeerAdmins",
+        peer
+      };
+    }
+    case "member": {
+      const user = await storyViewer.resolveUser(client, scope.user);
+      const chat2 = await storyViewer.resolvePeer(client, scope.chat);
+      return {
+        _: "botCommandScopePeerUser",
+        peer: chat2,
+        userId: user
+      };
+    }
+    default:
+      conditionVariable.assertNever();
+  }
+}
+async function deleteMyCommands(client, params) {
+  const scope = params?.scope ? await _normalizeCommandScope(client, params.scope) : {
+    _: "botCommandScopeDefault"
+  };
+  await client.call({
+    _: "bots.resetBotCommands",
+    scope,
+    langCode: params?.langCode ?? ""
+  });
+}
+async function getBotInfo(client, params) {
+  const { bot, langCode = "" } = params;
+  return client.call({
+    _: "bots.getBotInfo",
+    bot: bot ? await storyViewer.resolveUser(client, bot) : void 0,
+    langCode
+  });
+}
+async function getBotMenuButton(client, user) {
+  return client.call({
+    _: "bots.getBotMenuButton",
+    userId: await storyViewer.resolveUser(client, user)
+  });
+}
+async function getCallbackAnswer(client, params) {
+  const { chatId, message } = storyViewer.normalizeInputMessageId(params);
+  const { data, game, timeout = 1e4, fireAndForget } = params;
+  let password;
+  if (params?.password) {
+    const pwd = await client.call({ _: "account.getPassword" });
+    password = await client.computeSrpParams(pwd, params.password);
+  }
+  const promise = client.call(
+    {
+      _: "messages.getBotCallbackAnswer",
+      peer: await storyViewer.resolvePeer(client, chatId),
+      msgId: message,
+      data: typeof data === "string" ? platform.getPlatform().utf8Encode(data) : data,
+      password,
+      game
+    },
+    { timeout, throw503: true }
+  );
+  if (fireAndForget) {
+    promise.catch(() => {
+    });
+    return {
+      _: "messages.botCallbackAnswer",
+      cacheTime: 0
+    };
+  }
+  return promise;
+}
+async function getGameHighScores(client, params) {
+  const { userId } = params;
+  const { chatId, message } = storyViewer.normalizeInputMessageId(params);
+  const chat2 = await storyViewer.resolvePeer(client, chatId);
+  let user;
+  if (userId) {
+    user = await storyViewer.resolveUser(client, userId);
+  } else {
+    user = { _: "inputUserEmpty" };
+  }
+  const res = await client.call({
+    _: "messages.getGameHighScores",
+    peer: chat2,
+    id: message,
+    userId: user
+  });
+  const peers = peersIndex.PeersIndex.from(res);
+  return res.scores.map((score) => new storyViewer.GameHighScore$2(score, peers));
+}
+async function getInlineGameHighScores(client, messageId, userId) {
+  const id = conditionVariable.normalizeInlineId(messageId);
+  let user;
+  if (userId) {
+    user = await storyViewer.resolveUser(client, userId);
+  } else {
+    user = { _: "inputUserEmpty" };
+  }
+  const res = await client.call(
+    {
+      _: "messages.getInlineGameHighScores",
+      id,
+      userId: user
+    },
+    { dcId: id.dcId }
+  );
+  const peers = peersIndex.PeersIndex.from(res);
+  return res.scores.map((score) => new storyViewer.GameHighScore$2(score, peers));
+}
+async function getMyCommands(client, params) {
+  return client.call({
+    _: "bots.getBotCommands",
+    scope: params?.scope ? await _normalizeCommandScope(client, params.scope) : {
+      _: "botCommandScopeDefault"
+    },
+    langCode: params?.langCode ?? ""
+  });
+}
+async function setBotInfo(client, params) {
+  const { bot, langCode = "", name, bio, description } = params;
+  const r = await client.call({
+    _: "bots.setBotInfo",
+    bot: bot ? await storyViewer.resolveUser(client, bot) : void 0,
+    langCode,
+    name,
+    about: bio,
+    description
+  });
+  controllablePromise.assertTrue("bots.setBotInfo", r);
+}
+async function setBotMenuButton(client, user, button) {
+  const r = await client.call({
+    _: "bots.setBotMenuButton",
+    userId: await storyViewer.resolveUser(client, user),
+    button
+  });
+  controllablePromise.assertTrue("bots.setBotMenuButton", r);
+}
+async function setGameScore(client, params) {
+  const { userId, score, noEdit, force, shouldDispatch } = params;
+  const { chatId, message } = storyViewer.normalizeInputMessageId(params);
+  const user = await storyViewer.resolveUser(client, userId);
+  const chat2 = await storyViewer.resolvePeer(client, chatId);
+  const res = await client.call({
+    _: "messages.setGameScore",
+    peer: chat2,
+    id: message,
+    userId: user,
+    score,
+    editMessage: !noEdit,
+    force
+  });
+  return storyViewer._findMessageInUpdate(client, res, true, !shouldDispatch);
+}
+async function setInlineGameScore(client, params) {
+  const { messageId, userId, score, noEdit, force } = params;
+  const user = await storyViewer.resolveUser(client, userId);
+  const id = conditionVariable.normalizeInlineId(messageId);
+  const r = await client.call(
+    {
+      _: "messages.setInlineGameScore",
+      id,
+      userId: user,
+      score,
+      editMessage: !noEdit,
+      force
+    },
+    { dcId: id.dcId }
+  );
+  controllablePromise.assertTrue("messages.setInlineGameScore", r);
+}
+async function setMyCommands(client, params) {
+  const scope = params.scope ? await _normalizeCommandScope(client, params.scope) : {
+    _: "botCommandScopeDefault"
+  };
+  if (params.commands?.length) {
+    const r = await client.call({
+      _: "bots.setBotCommands",
+      commands: params.commands,
+      scope,
+      langCode: params.langCode ?? ""
+    });
+    controllablePromise.assertTrue("bots.setBotCommands", r);
+  } else {
+    const r = await client.call({
+      _: "bots.resetBotCommands",
+      scope,
+      langCode: params.langCode ?? ""
+    });
+    controllablePromise.assertTrue("bots.resetBotCommands", r);
+  }
+}
+async function setMyDefaultRights(client, params) {
+  const { target, rights } = params;
+  const r = await client.call({
+    _: target === "group" ? "bots.setBotGroupDefaultAdminRights" : "bots.setBotBroadcastDefaultAdminRights",
+    adminRights: {
+      _: "chatAdminRights",
+      ...rights
+    }
+  });
+  controllablePromise.assertTrue("bots.setBotGroupDefaultAdminRights", r);
+}
+async function addChatMembers(client, chatId, users, params) {
+  const { forwardCount = 100 } = params;
+  const chat2 = await storyViewer.resolvePeer(client, chatId);
+  if (!Array.isArray(users)) users = [users];
+  if (conditionVariable.isInputPeerChat(chat2)) {
+    const missing = [];
+    for (const user of users) {
+      const p = await storyViewer.resolveUser(client, user);
+      const { updates, missingInvitees } = await client.call({
+        _: "messages.addChatUser",
+        chatId: chat2.chatId,
+        userId: p,
+        fwdLimit: forwardCount
+      });
+      client.handleClientUpdate(updates);
+      missing.push(...missingInvitees);
+    }
+    return missing;
+  } else if (conditionVariable.isInputPeerChannel(chat2)) {
+    const { updates, missingInvitees } = await client.call({
+      _: "channels.inviteToChannel",
+      channel: conditionVariable.toInputChannel(chat2),
+      users: await storyViewer.resolvePeerMany(client, users, conditionVariable.toInputUser)
+    });
+    client.handleClientUpdate(updates);
+    return missingInvitees;
+  }
+  throw new controllablePromise.MtInvalidPeerTypeError(chatId, "chat or channel");
+}
+async function archiveChats(client, chats) {
+  if (!Array.isArray(chats)) chats = [chats];
+  const resolvedPeers = await storyViewer.resolvePeerMany(client, chats);
+  const updates = await client.call({
+    _: "folders.editPeerFolders",
+    folderPeers: resolvedPeers.filter(controllablePromise.isPresent).map((peer) => ({
+      _: "inputFolderPeer",
+      peer,
+      folderId: 1
+    }))
+  });
+  client.handleClientUpdate(updates);
+}
+async function banChatMember(client, params) {
+  const { chatId, participantId, shouldDispatch } = params;
+  const chat2 = await storyViewer.resolvePeer(client, chatId);
+  const peer = await storyViewer.resolvePeer(client, participantId);
+  let res;
+  if (conditionVariable.isInputPeerChannel(chat2)) {
+    res = await client.call({
+      _: "channels.editBanned",
+      channel: conditionVariable.toInputChannel(chat2),
+      participant: peer,
+      bannedRights: {
+        _: "chatBannedRights",
+        untilDate: conditionVariable.normalizeDate(params?.untilDate) ?? 0,
+        viewMessages: true
+      }
+    });
+  } else if (conditionVariable.isInputPeerChat(chat2)) {
+    res = await client.call({
+      _: "messages.deleteChatUser",
+      chatId: chat2.chatId,
+      userId: conditionVariable.toInputUser(peer)
+    });
+  } else {
+    throw new controllablePromise.MtInvalidPeerTypeError(chatId, "chat or channel");
+  }
+  return storyViewer._findMessageInUpdate(client, res, false, !shouldDispatch, true);
+}
+async function createChannel(client, params) {
+  const { title, description = "" } = params;
+  const res = await client.call({
+    _: "channels.createChannel",
+    title,
+    about: description,
+    broadcast: true
+  });
+  storyViewer.assertIsUpdatesGroup("channels.createChannel", res);
+  client.handleClientUpdate(res);
+  return new storyViewer.Chat$2(res.chats[0]);
+}
+async function createGroup(client, params) {
+  const { title } = params;
+  let { users } = params;
+  if (!Array.isArray(users)) users = [users];
+  const peers = await storyViewer.resolvePeerMany(client, users, conditionVariable.toInputUser);
+  const { updates, missingInvitees } = await client.call({
+    _: "messages.createChat",
+    title,
+    users: peers
+  });
+  storyViewer.assertIsUpdatesGroup("messages.createChat", updates);
+  client.handleClientUpdate(updates);
+  return {
+    chat: new storyViewer.Chat$2(updates.chats[0]),
+    missing: missingInvitees
+  };
+}
+async function createSupergroup(client, params) {
+  const { title, description = "", forum, ttlPeriod = 0 } = params;
+  const res = await client.call({
+    _: "channels.createChannel",
+    title,
+    about: description,
+    megagroup: true,
+    forum,
+    ttlPeriod
+  });
+  storyViewer.assertIsUpdatesGroup("channels.createChannel", res);
+  client.handleClientUpdate(res);
+  return new storyViewer.Chat$2(res.chats[0]);
+}
+async function deleteChannel(client, chatId) {
+  const res = await client.call({
+    _: "channels.deleteChannel",
+    channel: await storyViewer.resolveChannel(client, chatId)
+  });
+  client.handleClientUpdate(res);
+}
+async function deleteChatPhoto(client, chatId) {
+  const chat2 = await storyViewer.resolvePeer(client, chatId);
+  let res;
+  if (conditionVariable.isInputPeerChat(chat2)) {
+    res = await client.call({
+      _: "messages.editChatPhoto",
+      chatId: chat2.chatId,
+      photo: { _: "inputChatPhotoEmpty" }
+    });
+  } else if (conditionVariable.isInputPeerChannel(chat2)) {
+    res = await client.call({
+      _: "channels.editPhoto",
+      channel: conditionVariable.toInputChannel(chat2),
+      photo: { _: "inputChatPhotoEmpty" }
+    });
+  } else {
+    throw new controllablePromise.MtInvalidPeerTypeError(chatId, "chat or channel");
+  }
+  client.handleClientUpdate(res);
+}
+async function deleteGroup(client, chatId) {
+  const chat2 = await storyViewer.resolvePeer(client, chatId);
+  if (!conditionVariable.isInputPeerChat(chat2)) throw new controllablePromise.MtInvalidPeerTypeError(chatId, "chat");
+  const res = await client.call({
+    _: "messages.deleteChatUser",
+    revokeHistory: true,
+    chatId: chat2.chatId,
+    userId: { _: "inputUserSelf" }
+  });
+  client.handleClientUpdate(res);
+  const r = await client.call({
+    _: "messages.deleteChat",
+    chatId: chat2.chatId
+  });
+  controllablePromise.assertTrue("messages.deleteChat", r);
+}
+async function deleteHistory(client, chat2, params) {
+  const { mode = "delete", maxId = 0 } = params ?? {};
+  const peer = await storyViewer.resolvePeer(client, chat2);
+  const res = await client.call({
+    _: "messages.deleteHistory",
+    justClear: mode === "clear",
+    revoke: mode === "revoke",
+    peer,
+    maxId
+  });
+  if (conditionVariable.isInputPeerChannel(peer)) {
+    client.handleClientUpdate(storyViewer.createDummyUpdate(res.pts, res.ptsCount, peer.channelId));
+  } else {
+    client.handleClientUpdate(storyViewer.createDummyUpdate(res.pts, res.ptsCount));
+  }
+}
+async function deleteUserHistory(client, params) {
+  const { chatId, participantId, shouldDispatch } = params;
+  const channel = await storyViewer.resolveChannel(client, chatId);
+  const peer = await storyViewer.resolvePeer(client, participantId);
+  const res = await client.call({
+    _: "channels.deleteParticipantHistory",
+    channel,
+    participant: peer
+  });
+  if (!shouldDispatch) {
+    client.handleClientUpdate(storyViewer.createDummyUpdate(res.pts, res.ptsCount, channel.channelId));
+  }
+}
+async function editAdminRights(client, params) {
+  const { chatId, userId, rights, rank = "" } = params;
+  const chat2 = await storyViewer.resolveChannel(client, chatId);
+  const user = await storyViewer.resolveUser(client, userId);
+  const res = await client.call({
+    _: "channels.editAdmin",
+    channel: chat2,
+    userId: user,
+    adminRights: {
+      _: "chatAdminRights",
+      ...rights
+    },
+    rank
+  });
+  client.handleClientUpdate(res);
+}
+function normalizeChatEventFilters(input) {
+  if (!input) {
+    return {};
+  }
+  if (typeof input === "string" || Array.isArray(input)) {
+    if (!Array.isArray(input)) input = [input];
+    const serverFilter = {
+      _: "channelAdminLogEventsFilter"
+    };
+    const localFilter = {};
+    input.forEach((type) => {
+      localFilter[type] = true;
+      switch (type) {
+        case "user_joined":
+        case "user_joined_invite":
+        case "user_joined_approved":
+          serverFilter.join = true;
+          break;
+        case "user_left":
+          serverFilter.leave = true;
+          break;
+        case "user_invited":
+          serverFilter.invite = true;
+          break;
+        case "title_changed":
+        case "description_changed":
+        case "linked_chat_changed":
+        case "location_changed":
+        case "photo_changed":
+        case "username_changed":
+        case "usernames_changed":
+        case "stickerset_changed":
+        case "slow_mode_changed":
+        case "ttl_changed":
+          serverFilter.info = true;
+          break;
+        case "invites_toggled":
+        case "history_toggled":
+        case "signatures_toggled":
+        case "def_perms_changed":
+        case "forum_toggled":
+        case "no_forwards_toggled":
+        case "signature_profiles_toggled":
+          serverFilter.settings = true;
+          break;
+        case "msg_pinned":
+          serverFilter.pinned = true;
+          break;
+        case "msg_edited":
+        case "poll_stopped":
+          serverFilter.edit = true;
+          break;
+        case "msg_deleted":
+          serverFilter.delete = true;
+          break;
+        case "user_perms_changed":
+          serverFilter.ban = true;
+          serverFilter.unban = true;
+          serverFilter.kick = true;
+          serverFilter.unkick = true;
+          break;
+        case "user_admin_perms_changed":
+          serverFilter.promote = true;
+          serverFilter.demote = true;
+          break;
+        case "call_started":
+        case "call_ended":
+          serverFilter.groupCall = true;
+          break;
+        case "call_setting_changed":
+          serverFilter.groupCall = true;
+          serverFilter.settings = true;
+          serverFilter.info = true;
+          break;
+        case "invite_deleted":
+        case "invite_edited":
+        case "invite_revoked":
+          serverFilter.invites = true;
+          break;
+        case "topic_created":
+        case "topic_edited":
+        case "topic_deleted":
+          serverFilter.forums = true;
+          break;
+        case "sub_extend":
+          serverFilter.invite = true;
+          serverFilter.invites = true;
+          serverFilter.join = true;
+          serverFilter.info = true;
+          serverFilter.settings = true;
+          break;
+        default:
+          conditionVariable.assertNever();
+      }
+    });
+    return {
+      serverFilter,
+      localFilter
+    };
+  }
+  if ("_" in input) {
+    return {
+      serverFilter: input
+    };
+  }
+  return input;
+}
+async function getChatEventLog(client, chatId, params) {
+  const { maxId = Long.ZERO, minId = Long.ZERO, query = "", limit = 100, users, filters } = params ?? {};
+  const channel = await storyViewer.resolveChannel(client, chatId);
+  const admins = users ? await storyViewer.resolvePeerMany(client, users, conditionVariable.toInputUser) : void 0;
+  const { serverFilter, localFilter } = normalizeChatEventFilters(filters);
+  const res = await client.call({
+    _: "channels.getAdminLog",
+    channel,
+    q: query,
+    eventsFilter: serverFilter,
+    admins,
+    maxId,
+    minId,
+    limit
+  });
+  if (!res.events.length) return [];
+  const peers = peersIndex.PeersIndex.from(res);
+  const results = [];
+  for (const evt of res.events) {
+    const parsed = new storyViewer.ChatEvent$2(evt, peers);
+    if (localFilter && (!parsed.action || !localFilter[parsed.action.type])) {
+      continue;
+    }
+    results.push(parsed);
+  }
+  return results;
+}
+async function getChatMember(client, params) {
+  const { chatId, userId } = params;
+  const user = await storyViewer.resolvePeer(client, userId);
+  const chat2 = await storyViewer.resolvePeer(client, chatId);
+  if (conditionVariable.isInputPeerChat(chat2)) {
+    if (!conditionVariable.isInputPeerUser(user)) {
+      throw new controllablePromise.MtInvalidPeerTypeError(userId, "user");
+    }
+    const res = await client.call({
+      _: "messages.getFullChat",
+      chatId: chat2.chatId
+    });
+    controllablePromise.assertTypeIs("getChatMember (@ messages.getFullChat)", res.fullChat, "chatFull");
+    const members = res.fullChat.participants._ === "chatParticipantsForbidden" ? [] : res.fullChat.participants.participants;
+    const peers = peersIndex.PeersIndex.from(res);
+    for (const m of members) {
+      if (user._ === "inputPeerSelf" && peers.user(m.userId).self || user._ === "inputPeerUser" && m.userId === user.userId) {
+        return new storyViewer.ChatMember$2(m, peers);
+      }
+    }
+    return null;
+  } else if (conditionVariable.isInputPeerChannel(chat2)) {
+    try {
+      const res = await client.call({
+        _: "channels.getParticipant",
+        channel: conditionVariable.toInputChannel(chat2),
+        participant: user
+      });
+      const peers = peersIndex.PeersIndex.from(res);
+      return new storyViewer.ChatMember$2(res.participant, peers);
+    } catch (e) {
+      if (tl.tl.RpcError.is(e, "USER_NOT_PARTICIPANT")) {
+        return null;
+      }
+      throw e;
+    }
+  } else {
+    throw new controllablePromise.MtInvalidPeerTypeError(chatId, "chat or channel");
+  }
+}
+async function getChatMembers(client, chatId, params) {
+  const { query = "", offset = 0, limit = 200, type = "recent" } = params ?? {};
+  const chat2 = await storyViewer.resolvePeer(client, chatId);
+  if (conditionVariable.isInputPeerChat(chat2)) {
+    const res = await client.call({
+      _: "messages.getFullChat",
+      chatId: chat2.chatId
+    });
+    controllablePromise.assertTypeIs("getChatMember (@ messages.getFullChat)", res.fullChat, "chatFull");
+    let members = res.fullChat.participants._ === "chatParticipantsForbidden" ? [] : res.fullChat.participants.participants;
+    if (offset) members = members.slice(offset);
+    if (limit) members = members.slice(0, limit);
+    const peers = peersIndex.PeersIndex.from(res);
+    const ret = members.map((m) => new storyViewer.ChatMember$2(m, peers));
+    return conditionVariable.makeArrayWithTotal(ret, ret.length);
+  }
+  if (conditionVariable.isInputPeerChannel(chat2)) {
+    const q = query;
+    let filter;
+    switch (type) {
+      case "all":
+        filter = { _: "channelParticipantsSearch", q };
+        break;
+      case "banned":
+        filter = { _: "channelParticipantsKicked", q };
+        break;
+      case "restricted":
+        filter = { _: "channelParticipantsBanned", q };
+        break;
+      case "mention":
+        filter = { _: "channelParticipantsMentions", q };
+        break;
+      case "bots":
+        filter = { _: "channelParticipantsBots" };
+        break;
+      case "recent":
+        filter = { _: "channelParticipantsRecent" };
+        break;
+      case "admins":
+        filter = { _: "channelParticipantsAdmins" };
+        break;
+      case "contacts":
+        filter = { _: "channelParticipantsContacts", q };
+        break;
+      default:
+        conditionVariable.assertNever();
+    }
+    const res = await client.call({
+      _: "channels.getParticipants",
+      channel: conditionVariable.toInputChannel(chat2),
+      filter,
+      offset,
+      limit,
+      hash: Long.ZERO
+    });
+    controllablePromise.assertTypeIs("getChatMembers (@ channels.getParticipants)", res, "channels.channelParticipants");
+    const peers = peersIndex.PeersIndex.from(res);
+    const ret = res.participants.map((i) => new storyViewer.ChatMember$2(i, peers));
+    return conditionVariable.makeArrayWithTotal(ret, res.count);
+  }
+  throw new controllablePromise.MtInvalidPeerTypeError(chatId, "chat or channel");
+}
+async function getChatPreview(client, inviteLink) {
+  const m = inviteLink.match(conditionVariable.INVITE_LINK_REGEX);
+  if (!m) throw new platform.MtArgumentError("Invalid invite link");
+  const res = await client.call({
+    _: "messages.checkChatInvite",
+    hash: m[1]
+  });
+  if (res._ !== "chatInvite") {
+    throw new controllablePromise.MtPeerNotFoundError("You have already joined this chat!");
+  }
+  return new storyViewer.ChatPreview$2(res, inviteLink);
+}
+async function getChat(client, chatId) {
+  if (typeof chatId === "string") {
+    const m = chatId.match(conditionVariable.INVITE_LINK_REGEX);
+    if (m) {
+      const res2 = await client.call({
+        _: "messages.checkChatInvite",
+        hash: m[1]
+      });
+      if (res2._ === "chatInvite") {
+        throw new platform.MtArgumentError(`You haven't joined ${JSON.stringify(res2.title)}`);
+      }
+      return new storyViewer.Chat$2(res2.chat);
+    }
+  }
+  const peer = await storyViewer.resolvePeer(client, chatId);
+  const res = await storyViewer._getRawPeerBatched(client, peer);
+  if (!res) throw new controllablePromise.MtPeerNotFoundError(`Chat ${JSON.stringify(chatId)} was not found`);
+  return new storyViewer.Chat$2(res);
+}
+async function getFullChat(client, chatId) {
+  if (typeof chatId === "string") {
+    const m = chatId.match(conditionVariable.INVITE_LINK_REGEX);
+    if (m) {
+      const res2 = await client.call({
+        _: "messages.checkChatInvite",
+        hash: m[1]
+      });
+      if (res2._ === "chatInvite") {
+        throw new platform.MtArgumentError(`You haven't joined ${JSON.stringify(res2.title)}`);
+      }
+      chatId = res2.chat.id;
+    }
+  }
+  const peer = await storyViewer.resolvePeer(client, chatId);
+  let res;
+  if (conditionVariable.isInputPeerChannel(peer)) {
+    res = await client.call({
+      _: "channels.getFullChannel",
+      channel: conditionVariable.toInputChannel(peer)
+    });
+  } else if (conditionVariable.isInputPeerUser(peer)) {
+    res = await client.call({
+      _: "users.getFullUser",
+      id: conditionVariable.toInputUser(peer)
+    });
+  } else if (conditionVariable.isInputPeerChat(peer)) {
+    res = await client.call({
+      _: "messages.getFullChat",
+      chatId: peer.chatId
+    });
+  } else {
+    throw new Error("should not happen");
+  }
+  return storyViewer.FullChat$2._parse(res);
+}
+async function getNearbyChats(client, latitude, longitude) {
+  const res = await client.call({
+    _: "contacts.getLocated",
+    geoPoint: {
+      _: "inputGeoPoint",
+      lat: latitude,
+      long: longitude
+    }
+  });
+  storyViewer.assertIsUpdatesGroup("contacts.getLocated", res);
+  client.handleClientUpdate(res, true);
+  if (!res.updates.length) return [];
+  controllablePromise.assertTypeIs("contacts.getLocated (@ .updates[0])", res.updates[0], "updatePeerLocated");
+  const chats = res.chats.map((it) => new storyViewer.Chat$2(it));
+  const index = {};
+  chats.forEach((c) => index[c.id] = c);
+  res.updates[0].peers.forEach((peer) => {
+    if (peer._ === "peerSelfLocated") return;
+    const id = conditionVariable.getMarkedPeerId(peer.peer);
+    if (index[id]) {
+      index[id].distance = peer.distance;
+    }
+  });
+  return chats;
+}
+async function getSimilarChannels(client, channel) {
+  const res = await client.call({
+    _: "channels.getChannelRecommendations",
+    channel: await storyViewer.resolveChannel(client, channel)
+  });
+  const parsed = res.chats.map((chat2) => new storyViewer.Chat$2(chat2));
+  switch (res._) {
+    case "messages.chatsSlice":
+      return conditionVariable.makeArrayWithTotal(parsed, res.count);
+    case "messages.chats":
+      return conditionVariable.makeArrayWithTotal(parsed, parsed.length);
+  }
+}
+async function* iterChatEventLog(client, chatId, params) {
+  if (!params) params = {};
+  const channel = await storyViewer.resolveChannel(client, chatId);
+  const { minId = Long.ZERO, query = "", limit = Infinity, chunkSize = 100, users, filters } = params;
+  const admins = users ? await storyViewer.resolvePeerMany(client, users, conditionVariable.toInputUser) : void 0;
+  const { serverFilter, localFilter } = normalizeChatEventFilters(filters);
+  let current = 0;
+  let maxId = params.maxId ?? Long.ZERO;
+  for (; ; ) {
+    const chunk = await getChatEventLog(client, channel, {
+      minId,
+      maxId,
+      query,
+      limit: localFilter ? chunkSize : Math.min(limit - current, chunkSize),
+      // provide already resolved users to avoid resolving them again
+      users: admins,
+      // local filters may mess with pagination
+      filters: { serverFilter }
+    });
+    if (!chunk.length) break;
+    const last = chunk[chunk.length - 1];
+    maxId = last.id;
+    for (const item of chunk) {
+      if (localFilter && (!item.action || !localFilter[item.action.type])) {
+        continue;
+      }
+      current += 1;
+      yield item;
+      if (current >= limit) break;
+    }
+  }
+}
+async function* iterChatMembers(client, chatId, params) {
+  if (!params) params = {};
+  let current = 0;
+  let total = params.limit || Infinity;
+  const limit = Math.min(params.chunkSize ?? 200, total);
+  let offset = params.offset ?? 0;
+  const yielded = /* @__PURE__ */ new Set();
+  const chat2 = await storyViewer.resolvePeer(client, chatId);
+  for (; ; ) {
+    const members = await getChatMembers(client, chat2, {
+      offset,
+      limit,
+      query: params.query,
+      type: params.type
+    });
+    if (!members.length) break;
+    if (conditionVariable.isInputPeerChat(chat2)) {
+      total = members.length;
+    }
+    offset += members.length;
+    for (const m of members) {
+      const uid = m.user.id;
+      if (yielded.has(uid)) continue;
+      yielded.add(uid);
+      yield m;
+      current += 1;
+      if (current >= total) return;
+    }
+  }
+}
+async function joinChat(client, chatId) {
+  if (typeof chatId === "string") {
+    const m = chatId.match(conditionVariable.INVITE_LINK_REGEX);
+    if (m) {
+      const res2 = await client.call({
+        _: "messages.importChatInvite",
+        hash: m[1]
+      });
+      storyViewer.assertIsUpdatesGroup("messages.importChatInvite", res2);
+      client.handleClientUpdate(res2);
+      return new storyViewer.Chat$2(res2.chats[0]);
+    }
+  }
+  const res = await client.call({
+    _: "channels.joinChannel",
+    channel: await storyViewer.resolveChannel(client, chatId)
+  });
+  storyViewer.assertIsUpdatesGroup("channels.joinChannel", res);
+  client.handleClientUpdate(res);
+  return new storyViewer.Chat$2(res.chats[0]);
+}
+async function unbanChatMember(client, params) {
+  const { chatId, participantId } = params;
+  const chat2 = await storyViewer.resolvePeer(client, chatId);
+  const peer = await storyViewer.resolvePeer(client, participantId);
+  if (conditionVariable.isInputPeerChannel(chat2)) {
+    const res = await client.call({
+      _: "channels.editBanned",
+      channel: conditionVariable.toInputChannel(chat2),
+      participant: peer,
+      bannedRights: {
+        _: "chatBannedRights",
+        untilDate: 0
+      }
+    });
+    client.handleClientUpdate(res);
+  } else if (conditionVariable.isInputPeerChat(chat2)) ;
+  else {
+    throw new controllablePromise.MtInvalidPeerTypeError(chatId, "chat or channel");
+  }
+}
+async function kickChatMember(client, params) {
+  const { chatId, userId } = params;
+  const chat2 = await storyViewer.resolvePeer(client, chatId);
+  const user = await storyViewer.resolvePeer(client, userId);
+  const msg = await banChatMember(client, { chatId: chat2, participantId: user });
+  if (conditionVariable.isInputPeerChannel(chat2)) {
+    await conditionVariable.sleepWithAbort(1e3, client.stopSignal);
+    await unbanChatMember(client, { chatId: chat2, participantId: user });
+  }
+  return msg;
+}
+async function leaveChat(client, chatId, params) {
+  const chat2 = await storyViewer.resolvePeer(client, chatId);
+  if (conditionVariable.isInputPeerChannel(chat2)) {
+    const res = await client.call({
+      _: "channels.leaveChannel",
+      channel: conditionVariable.toInputChannel(chat2)
+    });
+    client.handleClientUpdate(res);
+  } else if (conditionVariable.isInputPeerChat(chat2)) {
+    const res = await client.call({
+      _: "messages.deleteChatUser",
+      chatId: chat2.chatId,
+      userId: { _: "inputUserSelf" }
+    });
+    client.handleClientUpdate(res);
+    if (params?.clear) {
+      await deleteHistory(client, chat2);
+    }
+  } else {
+    throw new controllablePromise.MtInvalidPeerTypeError(chatId, "chat or channel");
+  }
+}
+async function markChatUnread(client, chatId) {
+  const r = await client.call({
+    _: "messages.markDialogUnread",
+    peer: {
+      _: "inputDialogPeer",
+      peer: await storyViewer.resolvePeer(client, chatId)
+    },
+    unread: true
+  });
+  controllablePromise.assertTrue("messages.markDialogUnread", r);
+}
+async function openChat(client, chat2) {
+  const peer = await storyViewer.resolvePeer(client, chat2);
+  if (conditionVariable.isInputPeerChannel(peer)) {
+    let pts;
+    if (!client.storage.self.getCached()?.isBot) {
+      const [dialog] = await storyViewer.getPeerDialogs(client, peer);
+      pts = dialog.raw.pts;
+    } else {
+      pts = await client.storage.updates.getChannelPts(peer.channelId) ?? void 0;
+    }
+    await client.notifyChannelOpened(peer.channelId, pts);
+  }
+}
+async function closeChat(client, chat2) {
+  const peer = await storyViewer.resolvePeer(client, chat2);
+  if (conditionVariable.isInputPeerChannel(peer)) {
+    await client.notifyChannelClosed(peer.channelId);
+  }
+}
+async function reorderUsernames(client, peerId, order) {
+  const peer = await storyViewer.resolvePeer(client, peerId);
+  if (conditionVariable.isInputPeerUser(peer)) {
+    if (isSelfPeer(client, peer)) {
+      const r2 = await client.call({
+        _: "account.reorderUsernames",
+        order
+      });
+      controllablePromise.assertTrue("account.reorderUsernames", r2);
+      return;
+    }
+    const r = await client.call({
+      _: "bots.reorderUsernames",
+      bot: conditionVariable.toInputUser(peer, peerId),
+      order
+    });
+    controllablePromise.assertTrue("bots.reorderUsernames", r);
+  } else if (conditionVariable.isInputPeerChannel(peer)) {
+    const r = await client.call({
+      _: "channels.reorderUsernames",
+      channel: conditionVariable.toInputChannel(peer, peerId),
+      order
+    });
+    controllablePromise.assertTrue("channels.reorderUsernames", r);
+  }
+}
+async function restrictChatMember(client, params) {
+  const { chatId, userId, restrictions, until = 0 } = params;
+  const chat2 = await storyViewer.resolvePeer(client, chatId);
+  if (!conditionVariable.isInputPeerChannel(chat2)) {
+    throw new controllablePromise.MtInvalidPeerTypeError(chatId, "channel");
+  }
+  const user = await storyViewer.resolvePeer(client, userId);
+  const res = await client.call({
+    _: "channels.editBanned",
+    channel: conditionVariable.toInputChannel(chat2),
+    participant: user,
+    bannedRights: {
+      _: "chatBannedRights",
+      untilDate: conditionVariable.normalizeDate(until) ?? 0,
+      ...restrictions
+    }
+  });
+  client.handleClientUpdate(res);
+}
+async function saveDraft(client, chatId, draft) {
+  const peer = await storyViewer.resolvePeer(client, chatId);
+  if (draft) {
+    await client.call({
+      _: "messages.saveDraft",
+      peer,
+      ...draft
+    });
+  } else {
+    await client.call({
+      _: "messages.saveDraft",
+      peer,
+      message: ""
+    });
+  }
+}
+async function setChatColor(client, params) {
+  const { color, backgroundEmojiId, forProfile } = params;
+  const peer = await storyViewer.resolvePeer(client, params.peer ?? "me");
+  if (conditionVariable.isInputPeerChannel(peer)) {
+    const res = await client.call({
+      _: "channels.updateColor",
+      channel: conditionVariable.toInputChannel(peer),
+      color,
+      backgroundEmojiId
+    });
+    client.handleClientUpdate(res);
+    return;
+  }
+  if (conditionVariable.isInputPeerUser(peer)) {
+    if (!isSelfPeer(client, peer)) {
+      throw new platform.MtTypeAssertionError("setChatColor", "self", peer._);
+    }
+    const r = await client.call({
+      _: "account.updateColor",
+      color,
+      backgroundEmojiId,
+      forProfile
+    });
+    controllablePromise.assertTrue("account.updateColor", r);
+  }
+  throw new controllablePromise.MtInvalidPeerTypeError(peer, "channel | user");
+}
+async function setChatDefaultPermissions(client, chatId, restrictions) {
+  const peer = await storyViewer.resolvePeer(client, chatId);
+  const res = await client.call({
+    _: "messages.editChatDefaultBannedRights",
+    peer,
+    bannedRights: {
+      _: "chatBannedRights",
+      untilDate: 0,
+      ...restrictions
+    }
+  });
+  storyViewer.assertIsUpdatesGroup("messages.editChatDefaultBannedRights", res);
+  client.handleClientUpdate(res);
+  return new storyViewer.Chat$2(res.chats[0]);
+}
+async function setChatDescription(client, chatId, description) {
+  const chat2 = await storyViewer.resolvePeer(client, chatId);
+  const r = await client.call({
+    _: "messages.editChatAbout",
+    peer: chat2,
+    about: description
+  });
+  controllablePromise.assertTrue("messages.editChatAbout", r);
+}
+async function setChatPhoto(client, params) {
+  const { chatId, type, media, previewSec } = params;
+  const chat2 = await storyViewer.resolvePeer(client, chatId);
+  if (!(conditionVariable.isInputPeerChannel(chat2) || conditionVariable.isInputPeerChat(chat2))) {
+    throw new controllablePromise.MtInvalidPeerTypeError(chatId, "chat or channel");
+  }
+  let photo;
+  let inputFile;
+  if (fileId.tdFileId.isFileIdLike(media)) {
+    if (typeof media === "string" && media.match(/^https?:\/\//)) {
+      throw new platform.MtArgumentError("Chat photo can't be external");
+    }
+    if (typeof media === "string" && media.match(/^file:/)) {
+      const uploaded = await storyViewer.uploadFile(client, {
+        file: media.substring(5)
+      });
+      inputFile = uploaded.inputFile;
+    } else {
+      const input = storyViewer.fileIdToInputPhoto(media);
+      photo = {
+        _: "inputChatPhoto",
+        id: input
+      };
+    }
+  } else if (typeof media === "object" && tl.tl.isAnyInputMedia(media)) {
+    if (media._ === "inputMediaPhoto") {
+      photo = {
+        _: "inputChatPhoto",
+        id: media.id
+      };
+    } else {
+      throw new platform.MtArgumentError("Chat photo can't be InputMedia");
+    }
+  } else if (storyViewer.isUploadedFile(media)) {
+    inputFile = media.inputFile;
+  } else if (typeof media === "object" && tl.tl.isAnyInputFile(media)) {
+    inputFile = media;
+  } else {
+    const uploaded = await storyViewer.uploadFile(client, {
+      file: media
+    });
+    inputFile = uploaded.inputFile;
+  }
+  if (!photo) {
+    photo = {
+      _: "inputChatUploadedPhoto",
+      [type === "photo" ? "file" : "video"]: inputFile,
+      videoStartTs: previewSec
+    };
+  }
+  let res;
+  if (conditionVariable.isInputPeerChat(chat2)) {
+    res = await client.call({
+      _: "messages.editChatPhoto",
+      chatId: chat2.chatId,
+      photo
+    });
+  } else {
+    res = await client.call({
+      _: "channels.editPhoto",
+      channel: conditionVariable.toInputChannel(chat2),
+      photo
+    });
+  }
+  client.handleClientUpdate(res);
+}
+async function setChatTitle(client, chatId, title) {
+  const chat2 = await storyViewer.resolvePeer(client, chatId);
+  let res;
+  if (conditionVariable.isInputPeerChat(chat2)) {
+    res = await client.call({
+      _: "messages.editChatTitle",
+      chatId: chat2.chatId,
+      title
+    });
+  } else if (conditionVariable.isInputPeerChannel(chat2)) {
+    res = await client.call({
+      _: "channels.editTitle",
+      channel: conditionVariable.toInputChannel(chat2),
+      title
+    });
+  } else {
+    throw new controllablePromise.MtInvalidPeerTypeError(chatId, "chat or channel");
+  }
+  client.handleClientUpdate(res);
+}
+async function setChatTtl(client, chatId, period) {
+  await client.call({
+    _: "messages.setHistoryTTL",
+    peer: await storyViewer.resolvePeer(client, chatId),
+    period
+  });
+}
+async function setChatUsername(client, chatId, username) {
+  const r = await client.call({
+    _: "channels.updateUsername",
+    channel: await storyViewer.resolveChannel(client, chatId),
+    username: username || ""
+  });
+  controllablePromise.assertTrue("channels.updateUsername", r);
+}
+async function setSlowMode(client, chatId, seconds = 0) {
+  const res = await client.call({
+    _: "channels.toggleSlowMode",
+    channel: await storyViewer.resolveChannel(client, chatId),
+    seconds
+  });
+  client.handleClientUpdate(res);
+}
+async function toggleContentProtection(client, chatId, enabled = false) {
+  const res = await client.call({
+    _: "messages.toggleNoForwards",
+    peer: await storyViewer.resolvePeer(client, chatId),
+    enabled
+  });
+  client.handleClientUpdate(res);
+}
+async function toggleFragmentUsername(client, params) {
+  const { peerId, username, active } = params;
+  const peer = await storyViewer.resolvePeer(client, peerId);
+  if (conditionVariable.isInputPeerUser(peer)) {
+    if (isSelfPeer(client, peer)) {
+      const r2 = await client.call({
+        _: "account.toggleUsername",
+        username,
+        active
+      });
+      controllablePromise.assertTrue("account.toggleUsername", r2);
+      return;
+    }
+    const r = await client.call({
+      _: "bots.toggleUsername",
+      bot: conditionVariable.toInputUser(peer, peerId),
+      username,
+      active
+    });
+    controllablePromise.assertTrue("bots.toggleUsername", r);
+  } else if (conditionVariable.isInputPeerChannel(peer)) {
+    const r = await client.call({
+      _: "channels.toggleUsername",
+      channel: conditionVariable.toInputChannel(peer, peerId),
+      username,
+      active
+    });
+    controllablePromise.assertTrue("channels.toggleUsername", r);
+  }
+}
+async function toggleJoinRequests(client, chatId, enabled = false) {
+  const res = await client.call({
+    _: "channels.toggleJoinRequest",
+    channel: await storyViewer.resolveChannel(client, chatId),
+    enabled
+  });
+  client.handleClientUpdate(res);
+}
+async function toggleJoinToSend(client, chatId, enabled = false) {
+  const res = await client.call({
+    _: "channels.toggleJoinToSend",
+    channel: await storyViewer.resolveChannel(client, chatId),
+    enabled
+  });
+  client.handleClientUpdate(res);
+}
+async function unarchiveChats(client, chats) {
+  if (!Array.isArray(chats)) chats = [chats];
+  const folderPeers = [];
+  for (const chat2 of chats) {
+    folderPeers.push({
+      _: "inputFolderPeer",
+      peer: await storyViewer.resolvePeer(client, chat2),
+      folderId: 0
+    });
+  }
+  const res = await client.call({
+    _: "folders.editPeerFolders",
+    folderPeers
+  });
+  client.handleClientUpdate(res);
+}
+async function addContact(client, params) {
+  const { userId, firstName, lastName = "", phone = "", sharePhone = false } = params;
+  const peer = await storyViewer.resolveUser(client, userId);
+  const res = await client.call({
+    _: "contacts.addContact",
+    id: peer,
+    firstName,
+    lastName,
+    phone,
+    addPhonePrivacyException: sharePhone
+  });
+  storyViewer.assertIsUpdatesGroup("contacts.addContact", res);
+  client.handleClientUpdate(res);
+  return new storyViewer.User$2(res.users[0]);
+}
+async function deleteContacts(client, userIds) {
+  if (!Array.isArray(userIds)) userIds = [userIds];
+  const inputPeers = await storyViewer.resolvePeerMany(client, userIds, conditionVariable.toInputUser);
+  if (!inputPeers.length) {
+    throw new controllablePromise.MtInvalidPeerTypeError("all provided ids", "user");
+  }
+  const res = await client.call({
+    _: "contacts.deleteContacts",
+    id: inputPeers
+  });
+  storyViewer.assertIsUpdatesGroup("contacts.deleteContacts", res);
+  client.handleClientUpdate(res);
+  return res.users.map((user) => new storyViewer.User$2(user));
+}
+async function getContacts(client) {
+  const res = await client.call({
+    _: "contacts.getContacts",
+    hash: Long.ZERO
+  });
+  controllablePromise.assertTypeIs("getContacts", res, "contacts.contacts");
+  return res.users.map((user) => new storyViewer.User$2(user));
+}
+async function importContacts(client, contacts) {
+  let seq = Long.ZERO;
+  const contactsNorm = contacts.map((input) => ({
+    _: "inputPhoneContact",
+    clientId: seq = seq.add(1),
+    ...input
+  }));
+  return client.call({
+    _: "contacts.importContacts",
+    contacts: contactsNorm
+  });
+}
+async function getFolders(client) {
+  return client.call({
+    _: "messages.getDialogFilters"
+  });
+}
+async function _normalizeInputFolder(client, folder) {
+  if (typeof folder === "string" || typeof folder === "number") {
+    const folders = await getFolders(client);
+    const found = folders.filters.find((it) => {
+      if (it._ === "dialogFilterDefault") {
+        return folder === 0;
+      }
+      return it.id === folder || it.title === folder;
+    });
+    if (!found) {
+      throw new platform.MtArgumentError(`Could not find folder ${folder}`);
+    }
+    return found;
+  }
+  return folder;
+}
+async function createFolder(client, folder) {
+  let id = folder.id;
+  if (!id) {
+    const old = await getFolders(client);
+    let max = 1;
+    old.filters.forEach((it) => {
+      if (it._ === "dialogFilter" && it.id > max) max = it.id;
+    });
+    id = max + 1;
+  }
+  const filter = {
+    _: "dialogFilter",
+    pinnedPeers: [],
+    includePeers: [],
+    excludePeers: [],
+    ...folder,
+    id
+  };
+  const r = await client.call({
+    _: "messages.updateDialogFilter",
+    id,
+    filter
+  });
+  controllablePromise.assertTrue("messages.updateDialogFilter", r);
+  return filter;
+}
+async function deleteFolder(client, id) {
+  const r = await client.call({
+    _: "messages.updateDialogFilter",
+    id: typeof id === "number" ? id : id.id
+  });
+  controllablePromise.assertTrue("messages.updateDialogFilter", r);
+}
+async function editFolder(client, params) {
+  const { modification } = params;
+  let { folder } = params;
+  if (folder === 0) {
+    throw new platform.MtArgumentError("Cannot modify default folder");
+  }
+  if (typeof folder === "number" || typeof folder === "string") {
+    const old = await getFolders(client);
+    const found = old.filters.find((it) => it._ === "dialogFilter" && (it.id === folder || it.title === folder));
+    if (!found) {
+      throw new platform.MtArgumentError(`Could not find a folder ${folder}`);
+    }
+    folder = found;
+  }
+  const filter = {
+    ...folder,
+    ...modification
+  };
+  const r = await client.call({
+    _: "messages.updateDialogFilter",
+    id: folder.id,
+    filter
+  });
+  controllablePromise.assertTrue("messages.updateDialogFilter", r);
+  return filter;
+}
+async function* iterDialogs(client, params) {
+  if (!params) params = {};
+  const { limit = Infinity, chunkSize = 100, folder, filter, pinned = "include" } = params;
+  let { offsetId = 0, offsetPeer = { _: "inputPeerEmpty" }, archived = "exclude" } = params;
+  let offsetDate = conditionVariable.normalizeDate(params.offsetDate) ?? 0;
+  let localFilters_;
+  if (folder) {
+    localFilters_ = await _normalizeInputFolder(client, folder);
+  }
+  if (filter) {
+    if (localFilters_ && localFilters_._ !== "dialogFilterDefault") {
+      localFilters_ = {
+        ...localFilters_,
+        ...filter
+      };
+    } else {
+      localFilters_ = {
+        _: "dialogFilter",
+        id: 0,
+        title: "",
+        pinnedPeers: [],
+        includePeers: [],
+        excludePeers: [],
+        ...params.filter
+      };
+    }
+  }
+  if (localFilters_?._ === "dialogFilterDefault") {
+    localFilters_ = void 0;
+  }
+  const localFilters = localFilters_;
+  if (localFilters?._ === "dialogFilterChatlist") {
+    if (offsetId !== 0 || offsetDate !== 0 || offsetPeer._ !== "inputPeerEmpty") {
+      throw new platform.MtArgumentError("Cannot use offset parameters with chatlist filters");
+    }
+    let remaining = Math.min(limit, localFilters.includePeers.length + localFilters.pinnedPeers.length);
+    if (pinned === "include" || pinned === "only") {
+      const peers = [];
+      for (const peer of localFilters.pinnedPeers) {
+        if (remaining <= 0) break;
+        remaining--;
+        peers.push({
+          _: "inputDialogPeer",
+          peer
+        });
+      }
+      const res = await client.call({
+        _: "messages.getPeerDialogs",
+        peers
+      });
+      res.dialogs.forEach((dialog) => dialog.pinned = true);
+      yield* storyViewer.Dialog$2.parseTlDialogs(res);
+    }
+    if (pinned === "only" || remaining <= 0) {
+      return;
+    }
+    let offset = 0;
+    while (remaining > 0) {
+      const peers = [];
+      for (let i = 0; i < chunkSize; i++) {
+        if (remaining <= 0) break;
+        remaining--;
+        peers.push({
+          _: "inputDialogPeer",
+          peer: localFilters.includePeers[offset + i]
+        });
+      }
+      offset += chunkSize;
+      const res = await client.call({
+        _: "messages.getPeerDialogs",
+        peers
+      });
+      yield* storyViewer.Dialog$2.parseTlDialogs(res);
+    }
+    return;
+  }
+  if (localFilters) {
+    archived = localFilters.excludeArchived ? "exclude" : "keep";
+  }
+  const fetchPinnedDialogsFromFolder = async () => {
+    if (!localFilters || !localFilters.pinnedPeers.length) {
+      return null;
+    }
+    const res = await client.call({
+      _: "messages.getPeerDialogs",
+      peers: localFilters.pinnedPeers.map((peer) => ({
+        _: "inputDialogPeer",
+        peer
+      }))
+    });
+    res.dialogs.forEach((dialog) => dialog.pinned = true);
+    return res;
+  };
+  if (pinned === "only") {
+    let res;
+    if (localFilters) {
+      res = await fetchPinnedDialogsFromFolder();
+    } else {
+      res = await client.call({
+        _: "messages.getPinnedDialogs",
+        folderId: archived === "exclude" ? 0 : 1
+      });
+    }
+    if (res) yield* storyViewer.Dialog$2.parseTlDialogs(res, limit);
+    return;
+  }
+  let current = 0;
+  if (localFilters?.pinnedPeers.length && pinned === "include" && offsetId === 0 && offsetDate === 0 && offsetPeer._ === "inputPeerEmpty") {
+    const res = await fetchPinnedDialogsFromFolder();
+    if (res) {
+      const dialogs = storyViewer.Dialog$2.parseTlDialogs(res, limit);
+      for (const d of dialogs) {
+        yield d;
+        if (++current >= limit) return;
+      }
+    }
+  }
+  const filterFolder = localFilters ? storyViewer.Dialog$2.filterFolder(localFilters, pinned !== "keep") : void 0;
+  let folderId;
+  if (archived === "keep") {
+    folderId = void 0;
+  } else if (archived === "only") {
+    folderId = 1;
+  } else {
+    folderId = 0;
+  }
+  for (; ; ) {
+    const dialogs = storyViewer.Dialog$2.parseTlDialogs(
+      await client.call({
+        _: "messages.getDialogs",
+        excludePinned: params.pinned === "exclude",
+        folderId,
+        offsetDate,
+        offsetId,
+        offsetPeer,
+        limit: filterFolder ? chunkSize : Math.min(limit - current, chunkSize),
+        hash: Long.ZERO
+      })
+    );
+    if (!dialogs.length) return;
+    const last = dialogs[dialogs.length - 1];
+    offsetPeer = last.chat.inputPeer;
+    offsetId = last.raw.topMessage;
+    if (last.lastMessage) {
+      offsetDate = last.lastMessage.raw.date;
+    }
+    for (const d of dialogs) {
+      if (filterFolder && !filterFolder(d)) continue;
+      yield d;
+      if (++current >= limit) return;
+    }
+  }
+}
+async function findDialogs(client, peers) {
+  if (!Array.isArray(peers)) peers = [peers];
+  const resolved = await storyViewer.resolvePeerMany(client, peers);
+  const notFoundIds = /* @__PURE__ */ new Map();
+  const notFoundUsernames = /* @__PURE__ */ new Map();
+  let notFoundCount = 0;
+  const foundInputPeers = [];
+  const foundIdxToOriginalIdx = /* @__PURE__ */ new Map();
+  for (let i = 0; i < peers.length; i++) {
+    const input = peers[i];
+    const resolvedPeer = resolved[i];
+    if (!resolvedPeer) {
+      if (typeof input === "number") {
+        notFoundIds.set(input, i);
+      } else {
+        notFoundUsernames.set(input, i);
+      }
+      notFoundCount += 1;
+      continue;
+    }
+    foundInputPeers.push(resolvedPeer);
+    foundIdxToOriginalIdx.set(foundInputPeers.length - 1, i);
+  }
+  if (foundInputPeers.length === 0) {
+    throw new controllablePromise.MtPeerNotFoundError(`Could not find dialogs with peers: ${peers.join(", ")}`);
+  }
+  const dialogs = await storyViewer.getPeerDialogs(client, foundInputPeers);
+  if (foundInputPeers.length === peers.length) {
+    return dialogs;
+  }
+  const ret = Array.from({ length: peers.length });
+  for (const [idx, origIdx] of foundIdxToOriginalIdx) {
+    ret[origIdx] = dialogs[idx];
+  }
+  for await (const dialog of iterDialogs(client, {
+    archived: "keep"
+  })) {
+    const chat2 = dialog.chat;
+    const idxById = notFoundIds.get(chat2.id);
+    if (idxById !== void 0) {
+      ret[idxById] = dialog;
+      notFoundIds.delete(chat2.id);
+      notFoundCount -= 1;
+    }
+    if (notFoundCount === 0) break;
+    if (!chat2.username) continue;
+    const idxByUsername = notFoundUsernames.get(chat2.username);
+    if (idxByUsername !== void 0) {
+      ret[idxByUsername] = dialog;
+      notFoundUsernames.delete(chat2.username);
+      notFoundCount -= 1;
+    }
+    if (notFoundCount === 0) break;
+  }
+  if (notFoundCount > 0) {
+    const notFound = [...notFoundIds.keys(), ...notFoundUsernames.keys()];
+    throw new controllablePromise.MtPeerNotFoundError(`Could not find dialogs with peers: ${notFound.join(", ")}`);
+  }
+  return ret;
+}
+async function findFolder(client, params) {
+  if (!params.title && !params.emoji && !params.id) {
+    throw new platform.MtArgumentError("One of search parameters must be passed");
+  }
+  const folders = await getFolders(client);
+  return folders.filters.find((it) => {
+    if (it._ === "dialogFilterDefault") return false;
+    if (params.id && it.id !== params.id) return false;
+    if (params.title && it.title !== params.title) return false;
+    if (params.emoji && it.emoticon !== params.emoji) return false;
+    return true;
+  }) ?? null;
+}
+async function getChatlistPreview(client, link) {
+  const res = await client.call({
+    _: "chatlists.checkChatlistInvite",
+    slug: link
+  });
+  return new storyViewer.ChatlistPreview$2(res);
+}
+async function joinChatlist(client, link, params) {
+  let peers;
+  if (params?.peers) {
+    const inputs = Array.isArray(params.peers) ? params.peers : [params.peers];
+    const all = await storyViewer.resolvePeerMany(client, inputs);
+    peers = all.filter(controllablePromise.isPresent);
+  } else {
+    const preview = await getChatlistPreview(client, link);
+    peers = preview.chats.filter((it) => !it.isUnavailable).map((it) => it.inputPeer);
+  }
+  const res = await client.call({
+    _: "chatlists.joinChatlistInvite",
+    slug: link,
+    peers
+  });
+  storyViewer.assertIsUpdatesGroup("joinChatlist", res);
+  client.handleClientUpdate(res);
+  const filter = res.updates.find((it) => it._ === "updateDialogFilter");
+  if (!filter?.filter) {
+    throw new platform.MtTypeAssertionError("joinChatlist", "updateDialogFilter", "nothing");
+  }
+  controllablePromise.assertTypeIs("joinChatlist", filter.filter, "dialogFilterChatlist");
+  return filter.filter;
+}
+async function setFoldersOrder(client, order) {
+  const r = await client.call({
+    _: "messages.updateDialogFiltersOrder",
+    order
+  });
+  controllablePromise.assertTrue("messages.updateDialogFiltersOrder", r);
+}
+const SMALL_FILE_MAX_SIZE = 131072;
+const REQUESTS_PER_CONNECTION = 3;
+async function* downloadAsIterable(client, input, params) {
+  const offset = params?.offset ?? 0;
+  if (offset % 4096 !== 0) {
+    throw new platform.MtArgumentError(`Invalid offset: ${offset}. Must be divisible by 4096`);
+  }
+  let dcId = params?.dcId;
+  let fileSize = params?.fileSize;
+  const abortSignal = params?.abortSignal;
+  let aborted = false;
+  let location;
+  if (input instanceof storyViewer.FileLocation$1) {
+    let locationInner = input.location;
+    if (typeof locationInner === "function") {
+      locationInner = locationInner();
+    }
+    if (ArrayBuffer.isView(locationInner)) {
+      yield locationInner;
+      return;
+    }
+    if (!dcId) dcId = input.dcId;
+    if (!fileSize) fileSize = input.fileSize;
+    location = locationInner;
+  } else if (typeof input === "string") {
+    const parsed = fileId.parseFileId(platform.getPlatform(), input);
+    if (parsed.location._ === "web") {
+      location = storyViewer.fileIdToInputWebFileLocation(parsed);
+    } else {
+      location = storyViewer.fileIdToInputFileLocation(parsed);
+    }
+  } else {
+    location = input;
+  }
+  const isWeb = tl.tl.isAnyInputWebFileLocation(location);
+  const primaryDcId = await client.getPrimaryDcId();
+  if (!dcId) dcId = primaryDcId;
+  const partSizeKb = params?.partSize ?? (fileSize ? conditionVariable.determinePartSize(fileSize) : 64);
+  if (partSizeKb % 4 !== 0) {
+    throw new platform.MtArgumentError(`Invalid part size: ${partSizeKb}. Must be divisible by 4.`);
+  }
+  const chunkSize = partSizeKb * 1024;
+  let limitBytes = params?.limit ?? fileSize ?? Infinity;
+  if (limitBytes === 0) return;
+  let numChunks = limitBytes === Infinity ? Infinity : ~~((limitBytes + chunkSize - offset - 1) / chunkSize);
+  let nextChunkIdx = 0;
+  let nextWorkerChunkIdx = 0;
+  const nextChunkCv = new conditionVariable.ConditionVariable();
+  const buffer = {};
+  const isSmall = fileSize && fileSize <= SMALL_FILE_MAX_SIZE;
+  let connectionKind;
+  if (isSmall) {
+    connectionKind = dcId === primaryDcId ? "main" : "downloadSmall";
+  } else {
+    connectionKind = "download";
+  }
+  const poolSize = await client.getPoolSize(connectionKind, dcId);
+  client.log.debug(
+    "Downloading file of size %d from dc %d using %s connection pool (pool size: %d)",
+    limitBytes,
+    dcId,
+    connectionKind,
+    poolSize
+  );
+  const downloadChunk = async (chunk = nextWorkerChunkIdx++) => {
+    let result;
+    if (aborted) {
+      return;
+    }
+    try {
+      result = await client.call(
+        {
+          _: isWeb ? "upload.getWebFile" : "upload.getFile",
+          // eslint-disable-next-line
+          location,
+          offset: chunkSize * chunk,
+          limit: chunkSize
+        },
+        {
+          dcId,
+          kind: connectionKind,
+          maxRetryCount: Infinity,
+          // retry until explicitly aborted (or finished)
+          abortSignal
+        }
+      );
+    } catch (e) {
+      if (e instanceof DOMException && e.name === "AbortError") return;
+      if (!tl.tl.RpcError.is(e)) throw e;
+      if (e.is("FILE_MIGRATE_%d")) {
+        dcId = e.newDc;
+        return downloadChunk(chunk);
+      } else if (e.is("FILEREF_UPGRADE_NEEDED")) {
+        throw new platform.MtUnsupportedError("File ref expired!");
+      } else {
+        throw e;
+      }
+    }
+    if (result._ === "upload.fileCdnRedirect") {
+      throw new platform.MtUnsupportedError("Received CDN redirect, which is not supported (yet)");
+    }
+    if (aborted) {
+      return;
+    }
+    if (result._ === "upload.webFile" && result.size && limitBytes === Infinity) {
+      limitBytes = result.size;
+      numChunks = ~~((limitBytes + chunkSize - offset - 1) / chunkSize);
+    }
+    buffer[chunk] = result.bytes;
+    if (chunk === nextChunkIdx) {
+      nextChunkCv.notify();
+    }
+    if (nextWorkerChunkIdx < numChunks && result.bytes.length === chunkSize) {
+      return downloadChunk();
+    }
+  };
+  let error;
+  void Promise.all(Array.from({ length: Math.min(poolSize * REQUESTS_PER_CONNECTION, numChunks) }, downloadChunk)).catch((e) => {
+    client.log.debug("download workers errored: %e", e);
+    error = e;
+    aborted = true;
+    nextChunkCv.notify();
+  }).then(() => {
+    client.log.debug("download workers finished");
+  });
+  abortSignal?.addEventListener("abort", () => {
+    client.log.debug("download aborted");
+    error = abortSignal.reason;
+    aborted = true;
+    nextChunkCv.notify();
+  });
+  let position = offset;
+  while (position < limitBytes) {
+    await nextChunkCv.wait();
+    if (error) throw error;
+    while (nextChunkIdx in buffer) {
+      const buf = buffer[nextChunkIdx];
+      delete buffer[nextChunkIdx];
+      position += buf.length;
+      params?.progressCallback?.(position, limitBytes);
+      yield buf;
+      nextChunkIdx++;
+      if (buf.length < chunkSize) {
+        return;
+      }
+    }
+  }
+}
+async function downloadAsBuffer(client, location, params) {
+  if (location instanceof storyViewer.FileLocation$1 && ArrayBuffer.isView(location.location)) {
+    return location.location;
+  }
+  const chunks = [];
+  for await (const chunk of downloadAsIterable(client, location, params)) {
+    chunks.push(chunk);
+  }
+  return conditionVariable.concatBuffers(chunks);
+}
+function downloadAsStream(client, location, params) {
+  if (location instanceof storyViewer.FileLocation$1 && ArrayBuffer.isView(location.location)) {
+    return conditionVariable.bufferToStream(location.location);
+  }
+  const cancel = new AbortController();
+  if (params?.abortSignal) {
+    params?.abortSignal.addEventListener("abort", () => {
+      cancel.abort();
+    });
+  }
+  return new ReadableStream({
+    start(controller) {
+      (async () => {
+        for await (const chunk of downloadAsIterable(client, location, params)) {
+          controller.enqueue(chunk);
+        }
+        controller.close();
+      })().catch((e) => controller.error(e));
+    },
+    cancel() {
+      cancel.abort();
+    }
+  });
+}
+async function uploadMedia(client, media, params = {}) {
+  const normMedia = await storyViewer._normalizeInputMedia(client, media, params, false);
+  switch (normMedia._) {
+    case "inputMediaEmpty":
+    case "inputMediaGeoPoint":
+    case "inputMediaGeoLive":
+    case "inputMediaContact":
+    case "inputMediaVenue":
+    case "inputMediaGame":
+    case "inputMediaInvoice":
+    case "inputMediaPoll":
+    case "inputMediaDice":
+    case "inputMediaPaidMedia":
+      throw new platform.MtArgumentError("This media can't be uploaded");
+  }
+  const res = await client.call({
+    _: "messages.uploadMedia",
+    peer: params.peer ? await storyViewer.resolvePeer(client, params.peer) : {
+      _: "inputPeerSelf"
+    },
+    media: normMedia
+  });
+  controllablePromise.assertTypeIsNot("uploadMedia", res, "messageMediaEmpty");
+  switch (normMedia._) {
+    case "inputMediaUploadedPhoto":
+    case "inputMediaPhoto":
+    case "inputMediaPhotoExternal":
+      controllablePromise.assertTypeIs("uploadMedia", res, "messageMediaPhoto");
+      controllablePromise.assertTypeIs("uploadMedia", res.photo, "photo");
+      return new storyViewer.Photo$2(res.photo);
+    case "inputMediaUploadedDocument":
+    case "inputMediaDocument":
+    case "inputMediaDocumentExternal":
+      controllablePromise.assertTypeIs("uploadMedia", res, "messageMediaDocument");
+      controllablePromise.assertTypeIs("uploadMedia", res.document, "document");
+      return storyViewer.parseDocument(res.document, res);
+    case "inputMediaStory":
+    case "inputMediaWebPage":
+      throw new platform.MtArgumentError(`This media (${normMedia._}) can't be uploaded`);
+    default:
+      conditionVariable.assertNever();
+  }
+}
+async function createForumTopic(client, params) {
+  const { chatId, title, icon, sendAs, shouldDispatch } = params;
+  const res = await client.call({
+    _: "channels.createForumTopic",
+    channel: await storyViewer.resolveChannel(client, chatId),
+    title,
+    iconColor: typeof icon === "number" ? icon : void 0,
+    iconEmojiId: typeof icon !== "number" ? icon : void 0,
+    sendAs: sendAs ? await storyViewer.resolvePeer(client, sendAs) : void 0,
+    randomId: conditionVariable.randomLong()
+  });
+  return storyViewer._findMessageInUpdate(client, res, false, !shouldDispatch);
+}
+async function deleteForumTopicHistory(client, chat2, topicId, params) {
+  const { shouldDispatch } = params ?? {};
+  const channel = await storyViewer.resolveChannel(client, chat2);
+  controllablePromise.assertTypeIsNot("deleteForumTopicHistory", channel, "inputChannelEmpty");
+  const res = await client.call({
+    _: "channels.deleteTopicHistory",
+    channel,
+    topMsgId: typeof topicId === "number" ? topicId : topicId.id
+  });
+  if (!shouldDispatch) {
+    client.handleClientUpdate(storyViewer.createDummyUpdate(res.pts, res.ptsCount, channel.channelId));
+  }
+}
+async function editForumTopic(client, params) {
+  const { chatId, topicId, title, icon, shouldDispatch } = params;
+  const res = await client.call({
+    _: "channels.editForumTopic",
+    channel: await storyViewer.resolveChannel(client, chatId),
+    topicId: typeof topicId === "number" ? topicId : topicId.id,
+    title,
+    iconEmojiId: icon ? icon ?? Long.ZERO : void 0
+  });
+  return storyViewer._findMessageInUpdate(client, res, false, shouldDispatch);
+}
+async function getForumTopicsById(client, chatId, ids) {
+  if (!Array.isArray(ids)) ids = [ids];
+  const res = await client.call({
+    _: "channels.getForumTopicsByID",
+    channel: await storyViewer.resolveChannel(client, chatId),
+    topics: ids
+  });
+  return storyViewer.ForumTopic$2.parseTlForumTopics(res);
+}
+const defaultOffset$3 = {
+  date: 0,
+  id: 0,
+  topic: 0
+};
+async function getForumTopics(client, chatId, params) {
+  if (!params) params = {};
+  const {
+    query,
+    offset: { date: offsetDate, id: offsetId, topic: offsetTopic } = defaultOffset$3,
+    limit = 100
+  } = params;
+  const res = await client.call({
+    _: "channels.getForumTopics",
+    channel: await storyViewer.resolveChannel(client, chatId),
+    q: query,
+    offsetDate,
+    offsetId,
+    offsetTopic,
+    limit
+  });
+  const topics = storyViewer.ForumTopic$2.parseTlForumTopics(res);
+  const last = topics[topics.length - 1];
+  const next = last ? {
+    date: res.orderByCreateDate ? last.raw.date : last.lastMessage.raw.date,
+    id: last.raw.topMessage,
+    topic: last.raw.id
+  } : void 0;
+  return conditionVariable.makeArrayPaginated(topics, res.count, next);
+}
+async function* iterForumTopics(client, chatId, params) {
+  if (!params) params = {};
+  const { query, limit = Infinity, chunkSize = 100 } = params;
+  const peer = await storyViewer.resolveChannel(client, chatId);
+  let { offset } = params;
+  let current = 0;
+  for (; ; ) {
+    const res = await getForumTopics(client, peer, {
+      query,
+      offset,
+      limit: Math.min(chunkSize, limit - current)
+    });
+    for (const topic of res) {
+      yield topic;
+      if (++current >= limit) return;
+    }
+    if (!res.next) return;
+    offset = res.next;
+  }
+}
+async function reorderPinnedForumTopics(client, params) {
+  const { chatId, order, force } = params;
+  await client.call({
+    _: "channels.reorderPinnedForumTopics",
+    channel: await storyViewer.resolveChannel(client, chatId),
+    order: order.map((it) => typeof it === "number" ? it : it.id),
+    force
+  });
+}
+async function toggleForumTopicClosed(client, parmas) {
+  const { chatId, topicId, closed, shouldDispatch } = parmas;
+  const res = await client.call({
+    _: "channels.editForumTopic",
+    channel: await storyViewer.resolveChannel(client, chatId),
+    topicId: typeof topicId === "number" ? topicId : topicId.id,
+    closed
+  });
+  return storyViewer._findMessageInUpdate(client, res, false, shouldDispatch);
+}
+async function toggleForumTopicPinned(client, params) {
+  const { chatId, topicId, pinned } = params;
+  await client.call({
+    _: "channels.updatePinnedForumTopic",
+    channel: await storyViewer.resolveChannel(client, chatId),
+    topicId: typeof topicId === "number" ? topicId : topicId.id,
+    pinned
+  });
+}
+async function toggleForum(client, chatId, enabled = false) {
+  const res = await client.call({
+    _: "channels.toggleForum",
+    channel: await storyViewer.resolveChannel(client, chatId),
+    enabled
+  });
+  client.handleClientUpdate(res);
+}
+async function toggleGeneralTopicHidden(client, params) {
+  const { chatId, hidden, shouldDispatch } = params;
+  const res = await client.call({
+    _: "channels.editForumTopic",
+    channel: await storyViewer.resolveChannel(client, chatId),
+    topicId: 1,
+    hidden
+  });
+  return storyViewer._findMessageInUpdate(client, res, false, shouldDispatch);
+}
+async function createInviteLink(client, chatId, params) {
+  if (!params) params = {};
+  const res = await client.call({
+    _: "messages.exportChatInvite",
+    peer: await storyViewer.resolvePeer(client, chatId),
+    expireDate: conditionVariable.normalizeDate(params.expires),
+    usageLimit: params.usageLimit,
+    requestNeeded: params.withApproval
+  });
+  return new storyViewer.ChatInviteLink$2(res);
+}
+async function editInviteLink(client, params) {
+  const { chatId, link, expires, usageLimit, withApproval } = params;
+  const res = await client.call({
+    _: "messages.editExportedChatInvite",
+    peer: await storyViewer.resolvePeer(client, chatId),
+    link: typeof link === "string" ? link : link.link,
+    expireDate: conditionVariable.normalizeDate(expires),
+    usageLimit,
+    requestNeeded: withApproval
+  });
+  const peers = peersIndex.PeersIndex.from(res);
+  return new storyViewer.ChatInviteLink$2(res.invite, peers);
+}
+async function exportInviteLink(client, chatId) {
+  const res = await client.call({
+    _: "messages.exportChatInvite",
+    peer: await storyViewer.resolvePeer(client, chatId),
+    legacyRevokePermanent: true
+  });
+  return new storyViewer.ChatInviteLink$2(res);
+}
+async function getInviteLinkMembers(client, chatId, params) {
+  const peer = await storyViewer.resolvePeer(client, chatId);
+  if (!params) params = {};
+  const { limit = 100, link, requestedSearch, requested = Boolean(requestedSearch) } = params;
+  const { offsetUser = { _: "inputUserEmpty" } } = params;
+  const offsetDate = conditionVariable.normalizeDate(params.offsetDate) ?? 0;
+  const res = await client.call({
+    _: "messages.getChatInviteImporters",
+    limit,
+    peer,
+    link: typeof link === "string" ? link : link?.link,
+    requested,
+    q: requestedSearch,
+    offsetDate,
+    offsetUser
+  });
+  const peers = peersIndex.PeersIndex.from(res);
+  const members = res.importers.map((it) => new storyViewer.ChatInviteLinkMember$2(it, peers));
+  const last = members[members.length - 1];
+  const nextOffset = last ? {
+    date: last.raw.date,
+    user: conditionVariable.toInputUser(last.user.inputPeer)
+  } : void 0;
+  return conditionVariable.makeArrayPaginated(members, res.count, nextOffset);
+}
+async function getInviteLink(client, chatId, link) {
+  const res = await client.call({
+    _: "messages.getExportedChatInvite",
+    peer: await storyViewer.resolvePeer(client, chatId),
+    link
+  });
+  const peers = peersIndex.PeersIndex.from(res);
+  return new storyViewer.ChatInviteLink$2(res.invite, peers);
+}
+async function getInviteLinks(client, chatId, params) {
+  if (!params) params = {};
+  const { revoked = false, limit = Infinity, admin, offset } = params;
+  const res = await client.call({
+    _: "messages.getExportedChatInvites",
+    peer: await storyViewer.resolvePeer(client, chatId),
+    revoked,
+    adminId: admin ? await storyViewer.resolveUser(client, admin) : { _: "inputUserSelf" },
+    limit,
+    offsetDate: offset?.date,
+    offsetLink: offset?.link
+  });
+  const peers = peersIndex.PeersIndex.from(res);
+  const links = res.invites.map((it) => new storyViewer.ChatInviteLink$2(it, peers));
+  const last = links[links.length - 1];
+  const nextOffset = last ? {
+    date: last.raw.date,
+    link: last.raw.link
+  } : void 0;
+  return conditionVariable.makeArrayPaginated(links, res.count, nextOffset);
+}
+async function getPrimaryInviteLink(client, chatId) {
+  const res = await client.call({
+    _: "messages.getExportedChatInvites",
+    peer: await storyViewer.resolvePeer(client, chatId),
+    adminId: { _: "inputUserSelf" },
+    limit: 1,
+    revoked: false
+  });
+  if (res.invites[0]?._ !== "chatInviteExported") {
+    throw new platform.MtTypeAssertionError(
+      "messages.getExportedChatInvites (@ .invites[0])",
+      "chatInviteExported",
+      res.invites[0]?._
+    );
+  }
+  if (!res.invites[0].permanent) {
+    throw new platform.MtTypeAssertionError("messages.getExportedChatInvites (@ .invites[0].permanent)", "true", "false");
+  }
+  const peers = peersIndex.PeersIndex.from(res);
+  return new storyViewer.ChatInviteLink$2(res.invites[0], peers);
+}
+async function hideAllJoinRequests(client, params) {
+  const { chatId, action, link } = params;
+  await client.call({
+    _: "messages.hideAllChatJoinRequests",
+    approved: action === "approve",
+    peer: await storyViewer.resolvePeer(client, chatId),
+    link: typeof link === "string" ? link : link?.link
+  });
+}
+async function hideJoinRequest(client, params) {
+  const { chatId, user, action } = params;
+  const userId = await storyViewer.resolveUser(client, user);
+  await client.call({
+    _: "messages.hideChatJoinRequest",
+    approved: action === "approve",
+    peer: await storyViewer.resolvePeer(client, chatId),
+    userId
+  });
+}
+async function* iterInviteLinkMembers(client, chatId, params) {
+  const peer = await storyViewer.resolvePeer(client, chatId);
+  if (!params) params = {};
+  const { limit = Infinity, chunkSize = 100, link, requestedSearch, requested = Boolean(requestedSearch) } = params;
+  let { offsetDate, offsetUser = { _: "inputUserEmpty" } } = params;
+  let current = 0;
+  for (; ; ) {
+    const items = await getInviteLinkMembers(client, peer, {
+      limit: Math.min(chunkSize, limit - current),
+      link,
+      requested,
+      requestedSearch,
+      offsetDate,
+      offsetUser
+    });
+    if (!items.length) break;
+    for (const it of items) {
+      yield it;
+      if (++current >= limit) return;
+    }
+    if (!items.next) return;
+    offsetDate = items.next.date;
+    offsetUser = items.next.user;
+  }
+}
+async function* iterInviteLinks(client, chatId, params) {
+  if (!params) params = {};
+  const { revoked = false, limit = Infinity, chunkSize = 100, admin } = params;
+  let { offset } = params;
+  let current = 0;
+  const peer = await storyViewer.resolvePeer(client, chatId);
+  const adminResolved = admin ? await storyViewer.resolvePeer(client, admin) : { _: "inputUserSelf" };
+  for (; ; ) {
+    const links = await getInviteLinks(client, peer, {
+      admin: adminResolved,
+      revoked,
+      limit: Math.min(chunkSize, limit - current),
+      offset
+    });
+    if (!links.length) return;
+    for (const link of links) {
+      yield link;
+      if (++current >= limit) break;
+    }
+    if (!links.next) return;
+    offset = links.next;
+  }
+}
+async function revokeInviteLink(client, chatId, link) {
+  const res = await client.call({
+    _: "messages.editExportedChatInvite",
+    peer: await storyViewer.resolvePeer(client, chatId),
+    link: typeof link === "string" ? link : link.link,
+    revoked: true
+  });
+  const peers = peersIndex.PeersIndex.from(res);
+  const invite = res._ === "messages.exportedChatInviteReplaced" ? res.newInvite : res.invite;
+  return new storyViewer.ChatInviteLink$2(invite, peers);
+}
+async function closePoll(client, params) {
+  const { chatId, message } = storyViewer.normalizeInputMessageId(params);
+  const res = await client.call({
+    _: "messages.editMessage",
+    peer: await storyViewer.resolvePeer(client, chatId),
+    id: message,
+    media: {
+      _: "inputMediaPoll",
+      poll: {
+        _: "poll",
+        id: Long.ZERO,
+        closed: true,
+        question: { _: "textWithEntities", text: "", entities: [] },
+        answers: []
+      }
+    }
+  });
+  storyViewer.assertIsUpdatesGroup("messages.editMessage", res);
+  client.handleClientUpdate(res, !params.shouldDispatch);
+  const upd = res.updates[0];
+  controllablePromise.assertTypeIs("messages.editMessage (@ .updates[0])", upd, "updateMessagePoll");
+  if (!upd.poll) {
+    throw new platform.MtTypeAssertionError("messages.editMessage (@ .updates[0].poll)", "poll", "undefined");
+  }
+  const peers = peersIndex.PeersIndex.from(res);
+  return new storyViewer.Poll$2(upd.poll, peers, upd.results);
+}
+async function deleteScheduledMessages(client, chatId, ids) {
+  const peer = await storyViewer.resolvePeer(client, chatId);
+  const res = await client.call({
+    _: "messages.deleteScheduledMessages",
+    peer,
+    id: ids
+  });
+  client.handleClientUpdate(res);
+}
+async function deleteMessagesById(client, chatId, ids, params) {
+  const { revoke = true, shouldDispatch } = params ?? {};
+  const peer = await storyViewer.resolvePeer(client, chatId);
+  let upd;
+  if (conditionVariable.isInputPeerChannel(peer)) {
+    const channel = conditionVariable.toInputChannel(peer);
+    const res = await client.call({
+      _: "channels.deleteMessages",
+      channel,
+      id: ids
+    });
+    upd = storyViewer.createDummyUpdate(res.pts, res.ptsCount, peer.channelId);
+  } else {
+    const res = await client.call({
+      _: "messages.deleteMessages",
+      id: ids,
+      revoke
+    });
+    upd = storyViewer.createDummyUpdate(res.pts, res.ptsCount);
+  }
+  if (!shouldDispatch) {
+    client.handleClientUpdate(upd);
+  }
+}
+async function deleteMessages(client, messages, params) {
+  if (messages.length === 1) {
+    return deleteMessagesById(client, messages[0].chat.inputPeer, [messages[0].id], params);
+  }
+  const byChat = /* @__PURE__ */ new Map();
+  const byChatScheduled = /* @__PURE__ */ new Map();
+  for (const msg of messages) {
+    const map = msg.isScheduled ? byChatScheduled : byChat;
+    if (!map.has(msg.chat.id)) {
+      map.set(msg.chat.id, [msg.chat.inputPeer, []]);
+    }
+    map.get(msg.chat.id)[1].push(msg.id);
+  }
+  for (const [peer, ids] of byChat.values()) {
+    await deleteMessagesById(client, peer, ids, params);
+  }
+  for (const [peer, ids] of byChatScheduled.values()) {
+    await deleteScheduledMessages(client, peer, ids);
+  }
+}
+async function editInlineMessage(client, params) {
+  let content;
+  let entities;
+  let media;
+  const id = conditionVariable.normalizeInlineId(params.messageId);
+  if (params.media) {
+    media = await storyViewer._normalizeInputMedia(client, params.media, params, true);
+    if ("caption" in params.media && params.media.caption !== void 0) {
+      [content, entities] = await storyViewer._normalizeInputText(client, params.media.caption);
+    }
+  } else if (params.text !== void 0) {
+    [content, entities] = await storyViewer._normalizeInputText(client, params.text);
+  }
+  let retries = 3;
+  while (retries--) {
+    try {
+      await client.call(
+        {
+          _: "messages.editInlineBotMessage",
+          id,
+          noWebpage: params.disableWebPreview,
+          replyMarkup: storyViewer._convertToTl$1(params.replyMarkup),
+          message: content,
+          entities,
+          media,
+          invertMedia: params.invertMedia
+        },
+        { dcId: id.dcId }
+      );
+      return;
+    } catch (e) {
+      if (tl.tl.RpcError.is(e, "MEDIA_EMPTY")) {
+        continue;
+      }
+      throw e;
+    }
+  }
+}
+async function editMessage(client, params) {
+  const { chatId, message } = storyViewer.normalizeInputMessageId(params);
+  let content;
+  let entities;
+  let media;
+  if (params.media) {
+    media = await storyViewer._normalizeInputMedia(client, params.media, params);
+    if ("caption" in params.media && params.media.caption !== void 0) {
+      [content, entities] = await storyViewer._normalizeInputText(client, params.media.caption);
+    }
+  }
+  if (params.text !== void 0) {
+    [content, entities] = await storyViewer._normalizeInputText(client, params.text);
+  }
+  const res = await storyViewer._maybeInvokeWithBusinessConnection(client, params.businessConnectionId, {
+    _: "messages.editMessage",
+    id: message,
+    peer: await storyViewer.resolvePeer(client, chatId),
+    noWebpage: params.disableWebPreview,
+    replyMarkup: storyViewer._convertToTl$1(params.replyMarkup),
+    message: content,
+    entities,
+    media,
+    invertMedia: params.invertMedia
+  });
+  return storyViewer._findMessageInUpdate(client, res, true, !params.shouldDispatch);
+}
+async function forwardMessagesById(client, params) {
+  const { messages, toChatId, fromChatId, silent, schedule, forbidForwards, sendAs, noAuthor, noCaption } = params;
+  if (messages.length > 100) {
+    throw new platform.MtArgumentError("You can forward no more than 100 messages at once");
+  }
+  const toPeer = await storyViewer.resolvePeer(client, toChatId);
+  const res = await client.call({
+    _: "messages.forwardMessages",
+    toPeer,
+    fromPeer: await storyViewer.resolvePeer(client, fromChatId),
+    id: messages,
+    silent,
+    scheduleDate: conditionVariable.normalizeDate(schedule),
+    randomId: Array.from({ length: messages.length }, () => conditionVariable.randomLong()),
+    dropAuthor: noAuthor,
+    dropMediaCaptions: noCaption,
+    noforwards: forbidForwards,
+    sendAs: sendAs ? await storyViewer.resolvePeer(client, sendAs) : void 0,
+    quickReplyShortcut: storyViewer._normalizeQuickReplyShortcut(params.quickReply)
+  });
+  storyViewer.assertIsUpdatesGroup("messages.forwardMessages", res);
+  client.handleClientUpdate(res, !params.shouldDispatch);
+  const peers = peersIndex.PeersIndex.from(res);
+  const forwarded = [];
+  res.updates.forEach((upd) => {
+    switch (upd._) {
+      case "updateNewMessage":
+      case "updateNewChannelMessage":
+      case "updateNewScheduledMessage":
+        forwarded.push(new storyViewer.Message$2(upd.message, peers, upd._ === "updateNewScheduledMessage"));
+        break;
+    }
+  });
+  return forwarded;
+}
+async function forwardMessages(client, params) {
+  const { messages, ...rest } = params;
+  return forwardMessagesById(client, {
+    ...rest,
+    fromChatId: messages[0].chat.inputPeer,
+    messages: messages.map((it) => it.id)
+  });
+}
+async function getAllScheduledMessages(client, chatId) {
+  const peer = await storyViewer.resolvePeer(client, chatId);
+  const res = await client.call({
+    _: "messages.getScheduledHistory",
+    peer,
+    hash: Long.ZERO
+  });
+  controllablePromise.assertTypeIsNot("getScheduledMessages", res, "messages.messagesNotModified");
+  const peers = peersIndex.PeersIndex.from(res);
+  const ret = res.messages.map((msg) => {
+    controllablePromise.assertTypeIsNot("getScheduledMessages", msg, "messageEmpty");
+    return new storyViewer.Message$2(msg, peers, true);
+  });
+  return ret;
+}
+async function getAvailableMessageEffects(client) {
+  const res = await client.call({
+    _: "messages.getAvailableEffects",
+    hash: 0
+  });
+  controllablePromise.assertTypeIsNot("getAvailableMessageEffects", res, "messages.availableEffectsNotModified");
+  const documentsMap = new conditionVariable.LongMap();
+  for (const doc of res.documents) {
+    if (doc._ !== "document") continue;
+    documentsMap.set(doc.id, doc);
+  }
+  return res.effects.map((effect) => new storyViewer.MessageEffect$2(effect, documentsMap));
+}
+async function getCallbackQueryMessage(client, id) {
+  let msgId;
+  let queryId;
+  let peer;
+  if ("_" in id) {
+    msgId = id.msgId;
+    queryId = id.queryId;
+    peer = await storyViewer.resolvePeer(client, id.peer);
+  } else if ("raw" in id) {
+    msgId = id.messageId;
+    queryId = id.id;
+    peer = id.chat.inputPeer;
+  } else {
+    msgId = id.messageId;
+    queryId = id.queryId;
+    peer = await storyViewer.resolvePeer(client, id.peer);
+  }
+  const inputMessage = {
+    _: "inputMessageCallbackQuery",
+    id: msgId,
+    queryId
+  };
+  const isChannel = conditionVariable.isInputPeerChannel(peer);
+  const res = await client.call(
+    isChannel ? {
+      _: "channels.getMessages",
+      id: [inputMessage],
+      channel: conditionVariable.toInputChannel(peer)
+    } : {
+      _: "messages.getMessages",
+      id: [inputMessage]
+    }
+  );
+  controllablePromise.assertTypeIsNot("getCallbackQueryMessage", res, "messages.messagesNotModified");
+  if (res.messages[0]._ === "messageEmpty") {
+    return null;
+  }
+  return new storyViewer.Message$2(res.messages[0], peersIndex.PeersIndex.from(res));
+}
+async function getFactCheck(client, chatId, msgIds) {
+  const res = await client.call({
+    _: "messages.getFactCheck",
+    peer: await storyViewer.resolvePeer(client, chatId),
+    msgId: Array.isArray(msgIds) ? msgIds : [msgIds]
+  });
+  return res.map((x) => {
+    if (x.hash.isZero()) {
+      return null;
+    }
+    return new storyViewer.FactCheck$2(x);
+  });
+}
+const defaultOffset$2 = {
+  id: 0,
+  date: 0
+};
+const defaultOffsetReverse = {
+  id: 1,
+  date: 0
+};
+async function getHistory(client, chatId, params) {
+  if (!params) params = {};
+  const {
+    reverse = false,
+    limit = 100,
+    offset: { id: offsetId, date: offsetDate } = reverse ? defaultOffsetReverse : defaultOffset$2,
+    addOffset = 0,
+    minId = 0,
+    maxId = 0
+  } = params;
+  const addOffsetAdjusted = addOffset + (reverse ? -limit : 0);
+  const peer = await storyViewer.resolvePeer(client, chatId);
+  const res = await client.call({
+    _: "messages.getHistory",
+    peer,
+    offsetId,
+    offsetDate,
+    addOffset: addOffsetAdjusted,
+    limit,
+    maxId,
+    minId,
+    hash: Long.ZERO
+  });
+  controllablePromise.assertTypeIsNot("getHistory", res, "messages.messagesNotModified");
+  const peers = peersIndex.PeersIndex.from(res);
+  const msgs = res.messages.filter((msg) => msg._ !== "messageEmpty").map((msg) => new storyViewer.Message$2(msg, peers));
+  if (reverse) msgs.reverse();
+  const last = msgs[msgs.length - 1];
+  const next = last ? {
+    id: last.id + (reverse ? 1 : 0),
+    date: last.raw.date
+  } : void 0;
+  return conditionVariable.makeArrayPaginated(msgs, res.count ?? msgs.length, next);
+}
+async function getMessageByLink(client, link) {
+  const parsed = chat.message.parse(link);
+  if (!parsed) {
+    throw new platform.MtArgumentError(`Invalid message link: ${link}`);
+  }
+  let peer;
+  if ("username" in parsed) {
+    peer = await storyViewer.resolvePeer(client, parsed.username);
+  } else {
+    peer = await storyViewer.resolvePeer(client, conditionVariable.toggleChannelIdMark(parsed.channelId));
+  }
+  let msgId = parsed.id;
+  if (parsed.commentId) {
+    [peer] = await storyViewer._getDiscussionMessage(client, peer, parsed.id);
+    msgId = parsed.commentId;
+  }
+  const [msg] = await storyViewer.getMessages(client, peer, msgId);
+  return msg;
+}
+async function getMessageGroup(client, params) {
+  const { chatId, message } = storyViewer.normalizeInputMessageId(params);
+  const peer = await storyViewer.resolvePeer(client, chatId);
+  const delta = conditionVariable.isInputPeerChannel(peer) ? 9 : 19;
+  const ids = [];
+  for (let i = Math.max(message - delta, 0); i <= message + delta; i++) {
+    ids.push(i);
+  }
+  const messages = await storyViewer.getMessages(client, chatId, ids);
+  const groupedId = messages.find((it) => it?.id === message).groupedId;
+  if (!groupedId) throw new platform.MtArgumentError("This message is not grouped");
+  return messages.filter(controllablePromise.isPresent).filter((it) => it.groupedId?.eq(groupedId));
+}
+async function getMessageReactionsById(client, chatId, messages) {
+  const res = await client.call({
+    _: "messages.getMessagesReactions",
+    peer: await storyViewer.resolvePeer(client, chatId),
+    id: messages
+  });
+  storyViewer.assertIsUpdatesGroup("messages.getMessagesReactions", res);
+  client.handleClientUpdate(res);
+  const index = {};
+  const peers = peersIndex.PeersIndex.from(res);
+  for (const update of res.updates) {
+    controllablePromise.assertTypeIs("messages.getMessagesReactions", update, "updateMessageReactions");
+    index[update.msgId] = new storyViewer.MessageReactions$2(update.msgId, conditionVariable.getMarkedPeerId(update.peer), update.reactions, peers);
+  }
+  return messages.map((messageId) => index[messageId] ?? null);
+}
+async function getMessageReactions(client, messages) {
+  return getMessageReactionsById(
+    client,
+    messages[0].chat.inputPeer,
+    messages.map((it) => it.id)
+  );
+}
+async function getMessagesUnsafe(client, messageIds, fromReply = false) {
+  if (!Array.isArray(messageIds)) messageIds = [messageIds];
+  const type = fromReply ? "inputMessageReplyTo" : "inputMessageID";
+  const ids = messageIds.map((it) => ({
+    _: type,
+    id: it
+  }));
+  const res = await client.call({
+    _: "messages.getMessages",
+    id: ids
+  });
+  controllablePromise.assertTypeIsNot("getMessagesUnsafe", res, "messages.messagesNotModified");
+  const peers = peersIndex.PeersIndex.from(res);
+  return res.messages.map((msg) => {
+    if (msg._ === "messageEmpty") return null;
+    return new storyViewer.Message$2(msg, peers);
+  });
+}
+async function getReactionUsers(client, params) {
+  const { limit = 100, offset, emoji } = params;
+  const { chatId, message } = storyViewer.normalizeInputMessageId(params);
+  const peer = await storyViewer.resolvePeer(client, chatId);
+  const reaction = storyViewer.normalizeInputReaction(emoji);
+  const res = await client.call({
+    _: "messages.getMessageReactionsList",
+    peer,
+    id: message,
+    reaction,
+    limit,
+    offset
+  });
+  const peers = peersIndex.PeersIndex.from(res);
+  return conditionVariable.makeArrayPaginated(
+    res.reactions.map((it) => new storyViewer.PeerReaction$2(it, peers)),
+    res.count,
+    res.nextOffset
+  );
+}
+async function getReplyTo(client, message) {
+  if (!message.replyToMessage?.id) {
+    return null;
+  }
+  if (message.raw.peerId._ === "peerChannel") {
+    const [msg2] = await storyViewer.getMessages(client, message.chat.inputPeer, message.id, true);
+    return msg2;
+  }
+  const [msg] = await getMessagesUnsafe(client, message.id, true);
+  return msg;
+}
+async function getScheduledMessages(client, chatId, messageIds) {
+  const peer = await storyViewer.resolvePeer(client, chatId);
+  if (!Array.isArray(messageIds)) messageIds = [messageIds];
+  const res = await client.call({
+    _: "messages.getScheduledMessages",
+    peer,
+    id: messageIds
+  });
+  controllablePromise.assertTypeIsNot("getScheduledMessages", res, "messages.messagesNotModified");
+  const peers = peersIndex.PeersIndex.from(res);
+  const ret = res.messages.map((msg) => {
+    if (msg._ === "messageEmpty") return null;
+    return new storyViewer.Message$2(msg, peers, true);
+  });
+  return ret;
+}
+async function* iterHistory(client, chatId, params) {
+  if (!params) params = {};
+  const { limit = Infinity, chunkSize = 100, minId = 0, maxId = 0, reverse = false } = params;
+  let { offset, addOffset = 0 } = params;
+  let current = 0;
+  const peer = await storyViewer.resolvePeer(client, chatId);
+  for (; ; ) {
+    const res = await getHistory(client, peer, {
+      offset,
+      addOffset,
+      limit: Math.min(chunkSize, limit - current),
+      maxId,
+      minId,
+      reverse
+    });
+    for (const msg of res) {
+      yield msg;
+      if (++current >= limit) return;
+    }
+    if (!res.next) return;
+    offset = res.next;
+    addOffset = 0;
+  }
+}
+async function* iterReactionUsers(client, params) {
+  const { chatId, message } = storyViewer.normalizeInputMessageId(params);
+  const peer = await storyViewer.resolvePeer(client, chatId);
+  const { limit = Infinity, chunkSize = 100 } = params;
+  let current = 0;
+  let { offset } = params;
+  const reaction = storyViewer.normalizeInputReaction(params.emoji);
+  for (; ; ) {
+    const res = await getReactionUsers(client, {
+      chatId: peer,
+      message,
+      emoji: reaction,
+      limit: Math.min(chunkSize, limit - current),
+      offset
+    });
+    offset = res.next;
+    for (const reaction2 of res) {
+      yield reaction2;
+      if (++current >= limit) break;
+    }
+  }
+}
+const defaultOffset$1 = {
+  rate: 0,
+  peer: { _: "inputPeerEmpty" },
+  id: 0
+};
+async function searchGlobal(client, params) {
+  if (!params) params = {};
+  const {
+    query = "",
+    filter = storyViewer.SearchFilters.Empty,
+    limit = 100,
+    offset: { rate: offsetRate, peer: offsetPeer, id: offsetId } = defaultOffset$1,
+    onlyChannels
+  } = params;
+  const minDate = conditionVariable.normalizeDate(params.minDate) ?? 0;
+  const maxDate = conditionVariable.normalizeDate(params.maxDate) ?? 0;
+  const res = await client.call({
+    _: "messages.searchGlobal",
+    q: query,
+    filter,
+    minDate,
+    maxDate,
+    offsetId,
+    offsetRate,
+    offsetPeer,
+    limit,
+    broadcastsOnly: onlyChannels
+  });
+  controllablePromise.assertTypeIsNot("searchGlobal", res, "messages.messagesNotModified");
+  const peers = peersIndex.PeersIndex.from(res);
+  const msgs = res.messages.filter((msg) => msg._ !== "messageEmpty").map((msg) => new storyViewer.Message$2(msg, peers));
+  const last = msgs[msgs.length - 1];
+  const next = last ? {
+    rate: res.nextRate ?? last.raw.date,
+    peer: last.chat.inputPeer,
+    id: last.id
+  } : void 0;
+  return conditionVariable.makeArrayPaginated(msgs, res.count ?? msgs.length, next);
+}
+async function* iterSearchGlobal(client, params) {
+  if (!params) params = {};
+  const { query = "", filter = storyViewer.SearchFilters.Empty, limit = Infinity, chunkSize = 100, onlyChannels } = params;
+  const minDate = conditionVariable.normalizeDate(params.minDate) ?? 0;
+  const maxDate = conditionVariable.normalizeDate(params.maxDate) ?? 0;
+  let { offset } = params;
+  let current = 0;
+  for (; ; ) {
+    const res = await searchGlobal(client, {
+      query,
+      filter,
+      limit: Math.min(chunkSize, limit - current),
+      minDate,
+      maxDate,
+      offset,
+      onlyChannels
+    });
+    if (!res.length) return;
+    for (const msg of res) {
+      yield msg;
+      if (++current >= limit) return;
+    }
+    if (!res.next) return;
+    offset = res.next;
+  }
+}
+async function searchMessages(client, params) {
+  if (!params) params = {};
+  const {
+    query = "",
+    chatId = { _: "inputPeerEmpty" },
+    offset = 0,
+    addOffset = 0,
+    minId = 0,
+    maxId = 0,
+    threadId,
+    limit = 100,
+    filter = storyViewer.SearchFilters.Empty
+  } = params;
+  const minDate = conditionVariable.normalizeDate(params.minDate) ?? 0;
+  const maxDate = conditionVariable.normalizeDate(params.maxDate) ?? 0;
+  const peer = await storyViewer.resolvePeer(client, chatId);
+  const fromUser = params.fromUser ? await storyViewer.resolvePeer(client, params.fromUser) : void 0;
+  const res = await client.call({
+    _: "messages.search",
+    peer,
+    q: query,
+    filter,
+    minDate,
+    maxDate,
+    offsetId: offset,
+    addOffset,
+    limit,
+    minId,
+    maxId,
+    fromId: fromUser,
+    topMsgId: threadId,
+    hash: Long.ZERO
+  });
+  controllablePromise.assertTypeIsNot("searchMessages", res, "messages.messagesNotModified");
+  const peers = peersIndex.PeersIndex.from(res);
+  const msgs = res.messages.filter((msg) => msg._ !== "messageEmpty").map((msg) => new storyViewer.Message$2(msg, peers));
+  const last = msgs[msgs.length - 1];
+  const next = last ? last.id : void 0;
+  return conditionVariable.makeArrayPaginated(msgs, res.count ?? msgs.length, next);
+}
+async function* iterSearchMessages(client, params) {
+  if (!params) params = {};
+  const {
+    query = "",
+    chatId = { _: "inputPeerEmpty" },
+    minId = 0,
+    maxId = 0,
+    threadId,
+    limit = Infinity,
+    chunkSize = 100,
+    filter = storyViewer.SearchFilters.Empty
+  } = params;
+  const minDate = conditionVariable.normalizeDate(params.minDate) ?? 0;
+  const maxDate = conditionVariable.normalizeDate(params.maxDate) ?? 0;
+  const peer = await storyViewer.resolvePeer(client, chatId);
+  const fromUser = params.fromUser ? await storyViewer.resolvePeer(client, params.fromUser) : void 0;
+  let { offset, addOffset } = params;
+  let current = 0;
+  for (; ; ) {
+    const res = await searchMessages(client, {
+      query,
+      chatId: peer,
+      offset,
+      addOffset,
+      minId,
+      maxId,
+      threadId,
+      filter,
+      fromUser,
+      minDate,
+      maxDate,
+      limit: Math.min(chunkSize, limit - current)
+    });
+    if (!res.length) break;
+    for (const msg of res) {
+      yield msg;
+      if (++current >= limit) return;
+    }
+    if (!res.next) break;
+    offset = res.next;
+    addOffset = void 0;
+  }
+}
+async function pinMessage(client, params) {
+  const { notify, bothSides, shouldDispatch } = params ?? {};
+  const { chatId, message } = storyViewer.normalizeInputMessageId(params);
+  const res = await client.call({
+    _: "messages.updatePinnedMessage",
+    peer: await storyViewer.resolvePeer(client, chatId),
+    id: message,
+    silent: !notify,
+    pmOneside: !bothSides
+  });
+  return storyViewer._findMessageInUpdate(client, res, false, !shouldDispatch, true);
+}
+async function readReactions(client, chatId, params) {
+  const { shouldDispatch } = params ?? {};
+  const res = await client.call({
+    _: "messages.readReactions",
+    peer: await storyViewer.resolvePeer(client, chatId)
+  });
+  if (!shouldDispatch) {
+    client.handleClientUpdate(storyViewer.createDummyUpdate(res.pts, res.ptsCount));
+  }
+}
+const defaultOffset = {
+  rate: 0,
+  peer: { _: "inputPeerEmpty" },
+  id: 0
+};
+async function searchHashtag(client, hashtag, params) {
+  const { offset: { rate: offsetRate, peer: offsetPeer, id: offsetId } = defaultOffset, limit = 100 } = params ?? {};
+  const res = await client.call({
+    _: "channels.searchPosts",
+    hashtag,
+    offsetId,
+    offsetRate,
+    offsetPeer,
+    limit
+  });
+  controllablePromise.assertTypeIsNot("searchHashtag", res, "messages.messagesNotModified");
+  const peers = peersIndex.PeersIndex.from(res);
+  const msgs = res.messages.filter((msg) => msg._ !== "messageEmpty").map((msg) => new storyViewer.Message$2(msg, peers));
+  const last = msgs[msgs.length - 1];
+  const next = last ? {
+    rate: res.nextRate ?? last.raw.date,
+    peer: last.chat.inputPeer,
+    id: last.id
+  } : void 0;
+  return conditionVariable.makeArrayPaginated(msgs, res.count ?? msgs.length, next);
+}
+async function* iterSearchHashtag(client, hashtag, params) {
+  if (!params) params = {};
+  const { limit = Infinity, chunkSize = 100 } = params;
+  let { offset } = params;
+  let current = 0;
+  for (; ; ) {
+    const res = await searchHashtag(client, hashtag, {
+      offset,
+      limit: Math.min(chunkSize, limit - current)
+    });
+    if (!res.length) return;
+    for (const msg of res) {
+      yield msg;
+      if (++current >= limit) return;
+    }
+    if (!res.next) return;
+    offset = res.next;
+  }
+}
+function answerText(client, message, ...params) {
+  if (!message.isTopicMessage || !message.replyToMessage?.threadId) {
+    return storyViewer.sendText(client, message.chat.inputPeer, ...params);
+  }
+  const [text, params_ = {}] = params;
+  params_.replyTo = message.replyToMessage.threadId;
+  return storyViewer.sendText(client, message.chat.inputPeer, text, params_);
+}
+function answerMedia(client, message, ...params) {
+  if (!message.isTopicMessage || !message.replyToMessage?.threadId) {
+    return storyViewer.sendMedia(client, message.chat.inputPeer, ...params);
+  }
+  const [media, params_ = {}] = params;
+  params_.replyTo = message.replyToMessage.threadId;
+  return storyViewer.sendMedia(client, message.chat.inputPeer, media, params_);
+}
+function answerMediaGroup(client, message, ...params) {
+  if (!message.isTopicMessage || !message.replyToMessage?.threadId) {
+    return storyViewer.sendMediaGroup(client, message.chat.inputPeer, ...params);
+  }
+  const [media, params_ = {}] = params;
+  params_.replyTo = message.replyToMessage.threadId;
+  return storyViewer.sendMediaGroup(client, message.chat.inputPeer, media, params_);
+}
+function replyText(client, message, ...params) {
+  const [text, params_ = {}] = params;
+  params_.replyTo = message.id;
+  return storyViewer.sendText(client, message.chat.inputPeer, text, params_);
+}
+function replyMedia(client, message, ...params) {
+  const [media, params_ = {}] = params;
+  params_.replyTo = message.id;
+  return storyViewer.sendMedia(client, message.chat.inputPeer, media, params_);
+}
+function replyMediaGroup(client, message, ...params) {
+  const [media, params_ = {}] = params;
+  params_.replyTo = message.id;
+  return storyViewer.sendMediaGroup(client, message.chat.inputPeer, media, params_);
+}
+function commentText(client, message, ...params) {
+  if (message.chat.chatType !== "channel") {
+    return replyText(client, message, ...params);
+  }
+  if (!message.replies || !message.replies.hasComments) {
+    throw new platform.MtArgumentError("This message does not have comments section");
+  }
+  const [text, params_ = {}] = params;
+  params_.commentTo = message.id;
+  return storyViewer.sendText(client, message.chat.inputPeer, text, params_);
+}
+function commentMedia(client, message, ...params) {
+  if (message.chat.chatType !== "channel") {
+    return replyMedia(client, message, ...params);
+  }
+  if (!message.replies || !message.replies.hasComments) {
+    throw new platform.MtArgumentError("This message does not have comments section");
+  }
+  const [media, params_ = {}] = params;
+  params_.commentTo = message.id;
+  return storyViewer.sendMedia(client, message.chat.inputPeer, media, params_);
+}
+function commentMediaGroup(client, message, ...params) {
+  if (message.chat.chatType !== "channel") {
+    return replyMediaGroup(client, message, ...params);
+  }
+  if (!message.replies || !message.replies.hasComments) {
+    throw new platform.MtArgumentError("This message does not have comments section");
+  }
+  const [media, params_ = {}] = params;
+  params_.commentTo = message.id;
+  return storyViewer.sendMediaGroup(client, message.chat.inputPeer, media, params_);
+}
+async function sendCopyGroup(client, params) {
+  const { toChatId, ...rest } = params;
+  let msgs;
+  if ("fromChatId" in params) {
+    const fromPeer = await storyViewer.resolvePeer(client, params.fromChatId);
+    msgs = await storyViewer.getMessages(client, fromPeer, params.messages).then((r) => r.filter(controllablePromise.isPresent));
+  } else {
+    msgs = params.messages;
+  }
+  const messageGroupId = msgs[0].groupedId;
+  for (let i = 1; i < msgs.length; i++) {
+    if (!msgs[i].groupedId?.eq(messageGroupId) || !msgs[i].media) {
+      throw new platform.MtArgumentError("All messages must be in the same message group");
+    }
+  }
+  return storyViewer.sendMediaGroup(
+    client,
+    toChatId,
+    msgs.map((msg) => {
+      const raw = msg.raw;
+      return {
+        type: "auto",
+        file: msg.media.inputMedia,
+        caption: raw.message,
+        entities: raw.entities
+      };
+    }),
+    rest
+  );
+}
+async function sendCopy(client, params) {
+  const { toChatId, ...rest } = params;
+  let msg;
+  if ("fromChatId" in params) {
+    const fromPeer = await storyViewer.resolvePeer(client, params.fromChatId);
+    [msg] = await storyViewer.getMessages(client, fromPeer, params.message);
+    if (!msg) {
+      throw new controllablePromise.MtMessageNotFoundError(conditionVariable.getMarkedPeerId(fromPeer), params.message, "to copy");
+    }
+  } else {
+    msg = params.message;
+  }
+  if (msg.raw._ === "messageService") {
+    throw new platform.MtArgumentError("Service messages can't be copied");
+  }
+  if (msg.media && msg.media.type !== "webpage" && msg.media.type !== "invoice") {
+    let caption = params.caption;
+    if (!caption) {
+      if (msg.raw.entities?.length) {
+        caption = {
+          text: msg.raw.message,
+          entities: msg.raw.entities
+        };
+      } else {
+        caption = msg.raw.message;
+      }
+    }
+    return storyViewer.sendMedia(
+      client,
+      toChatId,
+      {
+        type: "auto",
+        file: msg.media.inputMedia,
+        caption
+      },
+      rest
+    );
+  }
+  return storyViewer.sendText(client, toChatId, msg.raw.message, rest);
+}
+async function sendPaidReaction(client, params) {
+  const { anonymous, count = 1 } = params;
+  const { chatId, message } = storyViewer.normalizeInputMessageId(params);
+  const peer = await storyViewer.resolvePeer(client, chatId);
+  let res;
+  for (let i = 0; i < 3; i++) {
+    try {
+      res = await client.call({
+        _: "messages.sendPaidReaction",
+        peer,
+        msgId: message,
+        count,
+        private: anonymous,
+        randomId: await client.getMtprotoMessageId()
+      });
+      break;
+    } catch (e) {
+      if (tl.tl.RpcError.is(e, "RANDOM_ID_EXPIRED")) {
+        continue;
+      }
+      throw e;
+    }
+  }
+  if (!res) {
+    throw new platform.MtcuteError("Could not send paid reaction");
+  }
+  storyViewer.assertIsUpdatesGroup("messages.sendReaction", res);
+  const peers = peersIndex.PeersIndex.from(res);
+  const upd = res.updates[0];
+  controllablePromise.assertTypeIs("messages.sendPaidReaction (@ .updates[0])", upd, "updateMessageReactions");
+  return new storyViewer.MessageReactions$2(upd.msgId, conditionVariable.getMarkedPeerId(upd.peer), upd.reactions, peers);
+}
+function extractQuote(message, from, to) {
+  const { raw } = message;
+  if (raw._ === "messageService") throw new platform.MtArgumentError("Cannot quote service message");
+  if (!raw.message) throw new platform.MtArgumentError("Cannot quote empty message");
+  const text = raw.message;
+  if (from < 0) from = 0;
+  if (to > text.length) to = text.length;
+  if (from >= to) throw new platform.MtArgumentError("Invalid quote range");
+  if (!raw.entities) return { text: text.slice(from, to), entities: void 0 };
+  const entities = [];
+  for (const ent of raw.entities) {
+    const start2 = ent.offset;
+    const end = ent.offset + ent.length;
+    if (start2 >= to || end <= from) continue;
+    const newStart = Math.max(start2, from) - from;
+    const newEnd = Math.min(end, to) - from;
+    const newEnt = { ...ent, offset: newStart, length: newEnd - newStart };
+    entities.push(newEnt);
+  }
+  return { text: text.slice(from, to), entities };
+}
+function quoteWithText(client, message, params) {
+  const { toChatId = message.chat, start: start2, end, text, ...params__ } = params;
+  const params_ = params__;
+  params_.replyTo = message;
+  params_.quote = extractQuote(message, params.start, params.end);
+  params_.quoteOffset = params.start;
+  return storyViewer.sendText(client, toChatId, text, params_);
+}
+function quoteWithMedia(client, message, params) {
+  const { toChatId = message.chat, start: start2, end, media, ...params__ } = params;
+  const params_ = params__;
+  params_.replyTo = message;
+  params_.quote = extractQuote(message, params.start, params.end);
+  params_.quoteOffset = params.start;
+  return storyViewer.sendMedia(client, toChatId, media, params_);
+}
+function quoteWithMediaGroup(client, message, params) {
+  const { toChatId, start: start2, end, medias, ...params__ } = params;
+  const params_ = params__;
+  params_.replyTo = message;
+  params_.quote = extractQuote(message, params.start, params.end);
+  params_.quoteOffset = params.start;
+  return storyViewer.sendMediaGroup(client, message.chat.inputPeer, medias, params_);
+}
+async function sendReaction(client, params) {
+  const { emoji, big } = params;
+  const { chatId, message } = storyViewer.normalizeInputMessageId(params);
+  const emojis = Array.isArray(emoji) ? emoji : [emoji];
+  const reactions = emojis.map(storyViewer.normalizeInputReaction);
+  const res = await client.call({
+    _: "messages.sendReaction",
+    peer: await storyViewer.resolvePeer(client, chatId),
+    msgId: message,
+    reaction: reactions,
+    big
+  });
+  storyViewer.assertIsUpdatesGroup("messages.sendReaction", res);
+  return storyViewer._findMessageInUpdate(client, res, true, !params.shouldDispatch, true);
+}
+async function sendScheduled(client, peer, ids) {
+  if (!Array.isArray(ids)) ids = [ids];
+  const res = await client.call({
+    _: "messages.sendScheduledMessages",
+    peer: await storyViewer.resolvePeer(client, peer),
+    id: ids
+  });
+  storyViewer.assertIsUpdatesGroup("sendScheduled", res);
+  client.handleClientUpdate(res, true);
+  const peers = peersIndex.PeersIndex.from(res);
+  const msgs = res.updates.filter(
+    (u) => u._ === "updateNewMessage" || u._ === "updateNewChannelMessage"
+  ).map((u) => new storyViewer.Message$2(u.message, peers));
+  return msgs;
+}
+async function sendTyping(client, chatId, status = "typing", params) {
+  if (typeof status === "string") {
+    const progress = params?.progress ?? 0;
+    switch (status) {
+      case "typing":
+        status = { _: "sendMessageTypingAction" };
+        break;
+      case "cancel":
+        status = { _: "sendMessageCancelAction" };
+        break;
+      case "record_video":
+        status = { _: "sendMessageRecordVideoAction" };
+        break;
+      case "upload_video":
+        status = { _: "sendMessageUploadVideoAction", progress };
+        break;
+      case "record_voice":
+        status = { _: "sendMessageRecordAudioAction" };
+        break;
+      case "upload_voice":
+        status = { _: "sendMessageUploadAudioAction", progress };
+        break;
+      case "upload_photo":
+        status = { _: "sendMessageUploadPhotoAction", progress };
+        break;
+      case "upload_document":
+        status = { _: "sendMessageUploadDocumentAction", progress };
+        break;
+      case "geo":
+        status = { _: "sendMessageGeoLocationAction" };
+        break;
+      case "contact":
+        status = { _: "sendMessageChooseContactAction" };
+        break;
+      case "game":
+        status = { _: "sendMessageGamePlayAction" };
+        break;
+      case "record_round":
+        status = { _: "sendMessageRecordRoundAction" };
+        break;
+      case "upload_round":
+        status = { _: "sendMessageUploadRoundAction", progress };
+        break;
+      case "speak_call":
+        status = { _: "speakingInGroupCallAction" };
+        break;
+      case "history_import":
+        status = { _: "sendMessageHistoryImportAction", progress };
+        break;
+      case "sticker":
+        status = { _: "sendMessageChooseStickerAction" };
+        break;
+      default:
+        conditionVariable.assertNever();
+    }
+  }
+  const r = await storyViewer._maybeInvokeWithBusinessConnection(client, params?.businessConnectionId, {
+    _: "messages.setTyping",
+    peer: await storyViewer.resolvePeer(client, chatId),
+    action: status,
+    topMsgId: params?.threadId
+  });
+  controllablePromise.assertTrue("messages.setTyping", r);
+}
+async function sendVote(client, params) {
+  const { chatId, message } = storyViewer.normalizeInputMessageId(params);
+  let { options } = params;
+  if (options === null) options = [];
+  if (!Array.isArray(options)) options = [options];
+  const peer = await storyViewer.resolvePeer(client, chatId);
+  let poll;
+  if (options.some((it) => typeof it === "number")) {
+    const [msg] = await storyViewer.getMessages(client, peer, message);
+    if (!msg) {
+      throw new controllablePromise.MtMessageNotFoundError(conditionVariable.getMarkedPeerId(peer), message, "to vote in");
+    }
+    if (!(msg.media instanceof storyViewer.Poll$2)) {
+      throw new platform.MtArgumentError("This message does not contain a poll");
+    }
+    poll = msg.media;
+    options = options.map((opt) => {
+      if (typeof opt === "number") {
+        return poll.raw.answers[opt].option;
+      }
+      return opt;
+    });
+  }
+  const res = await client.call({
+    _: "messages.sendVote",
+    peer,
+    msgId: message,
+    options
+  });
+  storyViewer.assertIsUpdatesGroup("messages.sendVote", res);
+  client.handleClientUpdate(res, true);
+  const upd = res.updates[0];
+  controllablePromise.assertTypeIs("messages.sendVote (@ .updates[0])", upd, "updateMessagePoll");
+  if (!upd.poll) {
+    throw new platform.MtTypeAssertionError("messages.sendVote (@ .updates[0].poll)", "poll", "undefined");
+  }
+  const peers = peersIndex.PeersIndex.from(res);
+  return new storyViewer.Poll$2(upd.poll, peers, upd.results);
+}
+async function translateMessage(client, params) {
+  const { toLanguage } = params;
+  const { chatId, message } = storyViewer.normalizeInputMessageId(params);
+  const res = await client.call({
+    _: "messages.translateText",
+    peer: await storyViewer.resolvePeer(client, chatId),
+    id: [message],
+    toLang: toLanguage
+  });
+  return {
+    text: res.result[0].text,
+    entities: res.result[0].entities
+  };
+}
+async function translateText(client, text, toLanguage) {
+  const [message, entities] = await storyViewer._normalizeInputText(client, text);
+  const res = await client.call({
+    _: "messages.translateText",
+    text: [
+      {
+        _: "textWithEntities",
+        text: message,
+        entities: entities || []
+      }
+    ],
+    toLang: toLanguage
+  });
+  if (!res.result[0]) {
+    throw new platform.MtTypeAssertionError("messages.translateResult#result", "not empty", "empty");
+  }
+  return {
+    text: res.result[0].text,
+    entities: res.result[0].entities
+  };
+}
+async function unpinAllMessages(client, chatId, params) {
+  const { topicId, shouldDispatch } = params ?? {};
+  const peer = await storyViewer.resolvePeer(client, chatId);
+  const res = await client.call({
+    _: "messages.unpinAllMessages",
+    peer,
+    topMsgId: topicId
+  });
+  if (!shouldDispatch) {
+    if (conditionVariable.isInputPeerChannel(peer)) {
+      client.handleClientUpdate(storyViewer.createDummyUpdate(res.pts, res.ptsCount, peer.channelId));
+    } else {
+      client.handleClientUpdate(storyViewer.createDummyUpdate(res.pts, res.ptsCount));
+    }
+  }
+}
+async function unpinMessage(client, params) {
+  const { chatId, message } = storyViewer.normalizeInputMessageId(params);
+  const res = await client.call({
+    _: "messages.updatePinnedMessage",
+    peer: await storyViewer.resolvePeer(client, chatId),
+    id: message,
+    unpin: true
+  });
+  client.handleClientUpdate(res);
+}
+async function getCollectibleInfo(client, kind, item) {
+  const res = await client.call({
+    _: "fragment.getCollectibleInfo",
+    collectible: kind === "phone" ? {
+      _: "inputCollectiblePhone",
+      phone: conditionVariable.normalizePhoneNumber(item)
+    } : {
+      _: "inputCollectibleUsername",
+      username: item
+    }
+  });
+  return new storyViewer.CollectibleInfo$1(res);
+}
+async function initTakeoutSession(client, params) {
+  return new storyViewer.TakeoutSession$1(
+    client,
+    await client.call({
+      _: "account.initTakeoutSession",
+      ...params
+    })
+  );
+}
+async function _normalizePrivacyRules(client, rules) {
+  const res = [];
+  for (const rule of rules) {
+    if ("_" in rule) {
+      res.push(rule);
+      continue;
+    }
+    if ("users" in rule) {
+      const users = await storyViewer.resolvePeerMany(client, rule.users, conditionVariable.toInputUser);
+      res.push({
+        _: rule.allow ? "inputPrivacyValueAllowUsers" : "inputPrivacyValueDisallowUsers",
+        users
+      });
+      continue;
+    }
+    if ("chats" in rule) {
+      const chats = await storyViewer.resolvePeerMany(client, rule.chats);
+      res.push({
+        _: rule.allow ? "inputPrivacyValueAllowChatParticipants" : "inputPrivacyValueDisallowChatParticipants",
+        chats: chats.filter(controllablePromise.isPresent).map((peer) => {
+          if ("channelId" in peer) return peer.channelId;
+          if ("chatId" in peer) return peer.chatId;
+          throw new Error("UNREACHABLE");
+        })
+      });
+      continue;
+    }
+  }
+  return res;
+}
+async function changeCloudPassword(client, params) {
+  const { currentPassword, newPassword, hint } = params;
+  const pwd = await client.call({ _: "account.getPassword" });
+  if (!pwd.hasPassword) {
+    throw new platform.MtArgumentError("Cloud password is not enabled");
+  }
+  const algo = pwd.newAlgo;
+  const oldSrp = await client.computeSrpParams(pwd, currentPassword);
+  const newHash = await client.computeNewPasswordHash(algo, newPassword);
+  await client.call({
+    _: "account.updatePasswordSettings",
+    password: oldSrp,
+    newSettings: {
+      _: "account.passwordInputSettings",
+      newAlgo: algo,
+      newPasswordHash: newHash,
+      hint
+    }
+  });
+}
+async function enableCloudPassword(client, params) {
+  const { password, hint, email } = params;
+  const pwd = await client.call({ _: "account.getPassword" });
+  if (pwd.hasPassword) {
+    throw new platform.MtArgumentError("Cloud password is already enabled");
+  }
+  const algo = pwd.newAlgo;
+  controllablePromise.assertTypeIs("account.getPassword", algo, "passwordKdfAlgoSHA256SHA256PBKDF2HMACSHA512iter100000SHA256ModPow");
+  const newHash = await client.computeNewPasswordHash(algo, password);
+  await client.call({
+    _: "account.updatePasswordSettings",
+    password: { _: "inputCheckPasswordEmpty" },
+    newSettings: {
+      _: "account.passwordInputSettings",
+      newAlgo: algo,
+      newPasswordHash: newHash,
+      hint,
+      email
+    }
+  });
+}
+async function verifyPasswordEmail(client, code) {
+  const r = await client.call({
+    _: "account.confirmPasswordEmail",
+    code
+  });
+  controllablePromise.assertTrue("account.confirmPasswordEmail", r);
+}
+async function resendPasswordEmail(client) {
+  const r = await client.call({
+    _: "account.resendPasswordEmail"
+  });
+  controllablePromise.assertTrue("account.resendPasswordEmail", r);
+}
+async function cancelPasswordEmail(client) {
+  const r = await client.call({
+    _: "account.cancelPasswordEmail"
+  });
+  controllablePromise.assertTrue("account.cancelPasswordEmail", r);
+}
+async function removeCloudPassword(client, password) {
+  const pwd = await client.call({ _: "account.getPassword" });
+  if (!pwd.hasPassword) {
+    throw new platform.MtArgumentError("Cloud password is not enabled");
+  }
+  const oldSrp = await client.computeSrpParams(pwd, password);
+  await client.call({
+    _: "account.updatePasswordSettings",
+    password: oldSrp,
+    newSettings: {
+      _: "account.passwordInputSettings",
+      newAlgo: { _: "passwordKdfAlgoUnknown" },
+      newPasswordHash: new Uint8Array(0),
+      hint: ""
+    }
+  });
+}
+async function applyBoost(client, peerId) {
+  await client.call({
+    _: "premium.applyBoost",
+    peer: await storyViewer.resolvePeer(client, peerId)
+  });
+}
+async function getMyBoostSlots(client) {
+  const res = await client.call({
+    _: "premium.getMyBoosts"
+  });
+  const peers = peersIndex.PeersIndex.from(res);
+  return res.myBoosts.map((it) => new storyViewer.BoostSlot$2(it, peers));
+}
+async function canApplyBoost(client) {
+  const myBoosts = await getMyBoostSlots(client);
+  if (!myBoosts.length) {
+    return { can: false, reason: "need_premium", slots: myBoosts };
+  }
+  const emptySlots = myBoosts.filter((it) => !it.occupied);
+  if (emptySlots.length > 0) {
+    return { can: true, slots: myBoosts };
+  }
+  const replaceableSlots = myBoosts.filter((it) => it.cooldownUntil === null);
+  if (replaceableSlots.length) {
+    return { can: true, replace: replaceableSlots.map((it) => it.chat), slots: myBoosts };
+  }
+  return { can: false, reason: "no_slots", slots: myBoosts };
+}
+async function createBusinessChatLink(client, text, params) {
+  const [message, entities] = await storyViewer._normalizeInputText(client, text);
+  const res = await client.call({
+    _: "account.createBusinessChatLink",
+    link: {
+      _: "inputBusinessChatLink",
+      message,
+      entities,
+      title: params?.title
+    }
+  });
+  return new storyViewer.BusinessChatLink$2(res);
+}
+async function editBusinessChatLink(client, link, params) {
+  const [message, entities] = await storyViewer._normalizeInputText(client, params.text);
+  const res = await client.call({
+    _: "account.editBusinessChatLink",
+    slug: link instanceof storyViewer.BusinessChatLink$2 ? link.link : link,
+    link: {
+      _: "inputBusinessChatLink",
+      message,
+      entities,
+      title: params?.title
+    }
+  });
+  return new storyViewer.BusinessChatLink$2(res);
+}
+async function deleteBusinessChatLink(client, link) {
+  const res = await client.call({
+    _: "account.deleteBusinessChatLink",
+    slug: typeof link === "string" ? link : link.link
+  });
+  controllablePromise.assertTrue("account.deleteBusinessChatLink", res);
+}
+async function getBoostStats(client, peerId) {
+  const res = await client.call({
+    _: "premium.getBoostsStatus",
+    peer: await storyViewer.resolvePeer(client, peerId)
+  });
+  return new storyViewer.BoostStats$1(res);
+}
+async function getBoosts(client, peerId, params) {
+  const { offset = "", limit = 100 } = params ?? {};
+  const res = await client.call({
+    _: "premium.getBoostsList",
+    peer: await storyViewer.resolvePeer(client, peerId),
+    offset,
+    limit
+  });
+  const peers = peersIndex.PeersIndex.from(res);
+  return conditionVariable.makeArrayPaginated(
+    res.boosts.map((it) => new storyViewer.Boost$2(it, peers)),
+    res.count,
+    res.nextOffset
+  );
+}
+async function getBusinessChatLinks(client) {
+  const res = await client.call({ _: "account.getBusinessChatLinks" });
+  return res.links.map((x) => new storyViewer.BusinessChatLink$2(x));
+}
+async function getStarsTransactions(client, peerId, params) {
+  const { direction, sort, subscriptionId, offset = "", limit = 100 } = params ?? {};
+  const res = await client.call({
+    _: "payments.getStarsTransactions",
+    peer: await storyViewer.resolvePeer(client, peerId),
+    offset,
+    limit,
+    outbound: direction === "outgoing",
+    inbound: direction === "incoming",
+    ascending: sort === "asc",
+    subscriptionId
+  });
+  return new storyViewer.StarsStatus$2(res);
+}
+async function* iterBoosters(client, peerId, params) {
+  if (!params) params = {};
+  const { limit = Infinity, chunkSize = 100 } = params;
+  let { offset } = params;
+  let current = 0;
+  const peer = await storyViewer.resolvePeer(client, peerId);
+  for (; ; ) {
+    const res = await getBoosts(client, peer, {
+      offset,
+      limit: Math.min(limit - current, chunkSize)
+    });
+    for (const booster of res) {
+      yield booster;
+      if (++current >= limit) return;
+    }
+    if (!res.next) return;
+    offset = res.next;
+  }
+}
+async function* iterStarsTransactions(client, peerId, params) {
+  if (!params) params = {};
+  const { limit = Infinity, chunkSize = 100 } = params;
+  let { offset } = params;
+  let current = 0;
+  const peer = await storyViewer.resolvePeer(client, peerId);
+  for (; ; ) {
+    const res = await getStarsTransactions(client, peer, {
+      offset,
+      limit: Math.min(limit - current, chunkSize)
+    });
+    for (const transaction of res.transactions) {
+      yield transaction;
+      if (++current >= limit) return;
+    }
+    if (!res.transactionsNextOffset) return;
+    offset = res.transactionsNextOffset;
+  }
+}
+async function _normalizeFileToDocument(client, file, params) {
+  if (typeof file === "object" && tl.tl.isAnyInputDocument(file)) {
+    return file;
+  }
+  const media = await storyViewer._normalizeInputMedia(
+    client,
+    {
+      type: "document",
+      file
+    },
+    params,
+    true
+  );
+  controllablePromise.assertTypeIs("_normalizeFileToDocument", media, "inputMediaDocument");
+  controllablePromise.assertTypeIs("_normalizeFileToDocument", media.id, "inputDocument");
+  return media.id;
+}
+function isInputMediaSticker(media) {
+  return typeof media === "object" && media !== null && "type" in media && media.type === "sticker";
+}
+async function setBusinessIntro(client, intro) {
+  let tlIntro;
+  if (intro) {
+    let sticker;
+    if (intro.sticker) {
+      if (isInputMediaSticker(intro.sticker)) {
+        const media = await storyViewer._normalizeInputMedia(client, intro.sticker, void 0, true);
+        controllablePromise.assertTypeIs("_normalizeInputMedia", media, "inputMediaDocument");
+        sticker = media.id;
+      } else {
+        sticker = await _normalizeFileToDocument(client, intro.sticker, {});
+      }
+    }
+    tlIntro = {
+      _: "inputBusinessIntro",
+      title: intro.title ?? "",
+      description: intro.description ?? "",
+      sticker
+    };
+  }
+  const res = await client.call({
+    _: "account.updateBusinessIntro",
+    intro: tlIntro
+  });
+  controllablePromise.assertTrue("account.updateBusinessIntro", res);
+}
+async function setBusinessWorkHours(client, params) {
+  let businessWorkHours;
+  if (params) {
+    let weeklyOpen;
+    if ("hours" in params) {
+      weeklyOpen = storyViewer.businessWorkHoursDaysToRaw(params.hours);
+    } else {
+      weeklyOpen = params.intervals;
+    }
+    businessWorkHours = {
+      _: "businessWorkHours",
+      timezoneId: params.timezone,
+      weeklyOpen
+    };
+  }
+  const res = await client.call({
+    _: "account.updateBusinessWorkHours",
+    businessWorkHours
+  });
+  controllablePromise.assertTrue("account.updateBusinessWorkHours", res);
+}
+async function _normalizeInputStickerSetItem(client, sticker, params) {
+  return {
+    _: "inputStickerSetItem",
+    document: await _normalizeFileToDocument(client, sticker.file, params ?? {}),
+    emoji: sticker.emojis,
+    maskCoords: sticker.maskPosition ? {
+      _: "maskCoords",
+      n: storyViewer.MASK_POSITION_POINT_TO_TL[sticker.maskPosition.point],
+      x: sticker.maskPosition.x,
+      y: sticker.maskPosition.y,
+      zoom: sticker.maskPosition.scale
+    } : void 0
+  };
+}
+async function addStickerToSet(client, setId, sticker, params) {
+  const res = await client.call({
+    _: "stickers.addStickerToSet",
+    stickerset: storyViewer.normalizeInputStickerSet(setId),
+    sticker: await _normalizeInputStickerSetItem(client, sticker, params)
+  });
+  return new storyViewer.StickerSet$2(res);
+}
+async function createStickerSet(client, params) {
+  const owner = await storyViewer.resolveUser(client, params.owner);
+  const inputStickers = [];
+  let i = 0;
+  for (const sticker of params.stickers) {
+    const progressCallback = params.progressCallback?.bind(null, i);
+    inputStickers.push(await _normalizeInputStickerSetItem(client, sticker, { progressCallback }));
+    i += 1;
+  }
+  const res = await client.call({
+    _: "stickers.createStickerSet",
+    animated: params.sourceType === "animated",
+    videos: params.sourceType === "video",
+    masks: params.type === "mask",
+    emojis: params.type === "emoji",
+    textColor: params.adaptive,
+    userId: owner,
+    title: params.title,
+    shortName: params.shortName,
+    stickers: inputStickers,
+    thumb: params.thumb ? await _normalizeFileToDocument(client, params.thumb, {}) : void 0
+  });
+  return new storyViewer.StickerSet$2(res);
+}
+async function deleteStickerFromSet(client, sticker) {
+  if (fileId.tdFileId.isFileIdLike(sticker)) {
+    sticker = storyViewer.fileIdToInputDocument(sticker);
+  }
+  const res = await client.call({
+    _: "stickers.removeStickerFromSet",
+    sticker
+  });
+  return new storyViewer.StickerSet$2(res);
+}
+async function getCustomEmojis(client, ids) {
+  const res = await client.call({
+    _: "messages.getCustomEmojiDocuments",
+    documentId: ids
+  });
+  return res.map((it) => {
+    controllablePromise.assertTypeIs("getCustomEmojis", it, "document");
+    const doc = storyViewer.parseDocument(it);
+    if (doc.type !== "sticker") {
+      throw new platform.MtTypeAssertionError("getCustomEmojis", "sticker", doc.type);
+    }
+    return doc;
+  });
+}
+async function getCustomEmojisFromMessages(client, messages) {
+  const set = new conditionVariable.LongSet();
+  if (!Array.isArray(messages)) messages = [messages];
+  for (const { raw } of messages) {
+    if (raw._ === "messageService" || !raw.entities) continue;
+    for (const entity of raw.entities) {
+      if (entity._ === "messageEntityCustomEmoji") {
+        set.add(entity.documentId);
+      }
+    }
+  }
+  const arr = set.toArray();
+  if (!arr.length) return [];
+  return getCustomEmojis(client, arr);
+}
+async function getInstalledStickers(client) {
+  const res = await client.call({
+    _: "messages.getAllStickers",
+    hash: Long.ZERO
+  });
+  controllablePromise.assertTypeIs("getInstalledStickers", res, "messages.allStickers");
+  return res.sets.map((set) => new storyViewer.StickerSet$2(set));
+}
+async function getMyStickerSets(client, params) {
+  const res = await client.call({
+    _: "messages.getMyStickers",
+    offsetId: params?.offset ?? Long.ZERO,
+    limit: params?.limit ?? 100
+  });
+  const items = res.sets.map((x) => new storyViewer.StickerSet$2(x));
+  return conditionVariable.makeArrayPaginated(items, res.count, items[items.length - 1]?.brief.id);
+}
+async function getStickerSet(client, setId) {
+  const res = await client.call({
+    _: "messages.getStickerSet",
+    stickerset: storyViewer.normalizeInputStickerSet(setId),
+    hash: 0
+  });
+  return new storyViewer.StickerSet$2(res);
+}
+async function moveStickerInSet(client, sticker, position) {
+  if (fileId.tdFileId.isFileIdLike(sticker)) {
+    sticker = storyViewer.fileIdToInputDocument(sticker);
+  }
+  const res = await client.call({
+    _: "stickers.changeStickerPosition",
+    sticker,
+    position
+  });
+  return new storyViewer.StickerSet$2(res);
+}
+async function replaceStickerInSet(client, sticker, newSticker, params) {
+  if (fileId.tdFileId.isFileIdLike(sticker)) {
+    sticker = storyViewer.fileIdToInputDocument(sticker);
+  }
+  const res = await client.call({
+    _: "stickers.replaceSticker",
+    sticker,
+    newSticker: await _normalizeInputStickerSetItem(client, newSticker, params)
+  });
+  return new storyViewer.StickerSet$2(res);
+}
+async function setChatStickerSet(client, chatId, setId) {
+  const r = await client.call({
+    _: "channels.setStickers",
+    channel: await storyViewer.resolveChannel(client, chatId),
+    stickerset: storyViewer.normalizeInputStickerSet(setId)
+  });
+  controllablePromise.assertTrue("channels.setStickers", r);
+}
+async function setStickerSetThumb(client, id, thumb, params) {
+  const res = await client.call({
+    _: "stickers.setStickerSetThumb",
+    stickerset: storyViewer.normalizeInputStickerSet(id),
+    thumb: await _normalizeFileToDocument(client, thumb, params ?? {})
+  });
+  return new storyViewer.StickerSet$2(res);
+}
+async function canSendStory(client, peerId) {
+  try {
+    const res = await client.call({
+      _: "stories.canSendStory",
+      peer: await storyViewer.resolvePeer(client, peerId)
+    });
+    if (!res) return "need_admin";
+    return true;
+  } catch (e) {
+    if (tl.tl.RpcError.is(e, "CHAT_ADMIN_REQUIRED")) {
+      return "need_admin";
+    }
+    if (tl.tl.RpcError.is(e, "BOOSTS_REQUIRED")) {
+      return "need_boosts";
+    }
+    throw e;
+  }
+}
+async function deleteStories(client, params) {
+  const { ids, peer = "me" } = params;
+  return client.call({
+    _: "stories.deleteStories",
+    peer: await storyViewer.resolvePeer(client, peer),
+    id: Array.isArray(ids) ? ids : [ids]
+  });
+}
+function _findStoryInUpdate(client, res) {
+  storyViewer.assertIsUpdatesGroup("_findStoryInUpdate", res);
+  client.handleClientUpdate(res, true);
+  const peers = peersIndex.PeersIndex.from(res);
+  const updateStory = res.updates.find(controllablePromise.hasValueAtKey("_", "updateStory"));
+  if (!updateStory) {
+    throw new platform.MtTypeAssertionError("_findStoryInUpdate (@ .updates[*])", "updateStory", "none");
+  }
+  controllablePromise.assertTypeIs("updateStory.story", updateStory.story, "storyItem");
+  return new storyViewer.Story$2(updateStory.story, peers);
+}
+async function editStory(client, params) {
+  const { id, peer = "me", interactiveElements } = params;
+  let caption;
+  let entities;
+  let media;
+  if (params.media) {
+    media = await storyViewer._normalizeInputMedia(client, params.media);
+    if ("caption" in params.media && params.media.caption !== void 0) {
+      [caption, entities] = await storyViewer._normalizeInputText(client, params.media.caption);
+    }
+  }
+  if (params.caption) {
+    [caption, entities] = await storyViewer._normalizeInputText(client, params.caption);
+  }
+  const privacyRules = params.privacyRules ? await _normalizePrivacyRules(client, params.privacyRules) : void 0;
+  const res = await client.call({
+    _: "stories.editStory",
+    peer: await storyViewer.resolvePeer(client, peer),
+    id,
+    media,
+    mediaAreas: interactiveElements,
+    caption,
+    entities,
+    privacyRules
+  });
+  return _findStoryInUpdate(client, res);
+}
+async function getAllStories(client, params) {
+  if (!params) params = {};
+  const { offset, archived } = params;
+  const res = await client.call({
+    _: "stories.getAllStories",
+    state: offset,
+    next: Boolean(offset),
+    hidden: archived
+  });
+  controllablePromise.assertTypeIsNot("getAllStories", res, "stories.allStoriesNotModified");
+  return new storyViewer.AllStories$2(res);
+}
+async function getPeerStories(client, peerId) {
+  const res = await client.call({
+    _: "stories.getPeerStories",
+    peer: await storyViewer.resolvePeer(client, peerId)
+  });
+  const peers = peersIndex.PeersIndex.from(res);
+  return new storyViewer.PeerStories$2(res.stories, peers);
+}
+async function getProfileStories(client, peerId, params) {
+  if (!params) params = {};
+  const { kind = "pinned", offsetId = 0, limit = 100 } = params;
+  const res = await client.call({
+    _: kind === "pinned" ? "stories.getPinnedStories" : "stories.getStoriesArchive",
+    peer: await storyViewer.resolvePeer(client, peerId),
+    offsetId,
+    limit
+  });
+  const peers = peersIndex.PeersIndex.from(res);
+  const stories = res.stories.map((it) => {
+    controllablePromise.assertTypeIs("getProfileStories", it, "storyItem");
+    return new storyViewer.Story$2(it, peers);
+  });
+  const last = stories[stories.length - 1];
+  const next = last?.id;
+  return conditionVariable.makeArrayPaginated(stories, res.count, next);
+}
+async function getStoriesById(client, peerId, storyIds) {
+  if (!Array.isArray(storyIds)) storyIds = [storyIds];
+  const res = await client.call({
+    _: "stories.getStoriesByID",
+    peer: await storyViewer.resolvePeer(client, peerId),
+    id: storyIds
+  });
+  const peers = peersIndex.PeersIndex.from(res);
+  const stories = res.stories.map((it) => {
+    controllablePromise.assertTypeIs("getProfileStories", it, "storyItem");
+    return new storyViewer.Story$2(it, peers);
+  });
+  return stories;
+}
+async function getStoriesInteractions(client, peerId, storyIds) {
+  if (!Array.isArray(storyIds)) storyIds = [storyIds];
+  const res = await client.call({
+    _: "stories.getStoriesViews",
+    peer: await storyViewer.resolvePeer(client, peerId),
+    id: storyIds
+  });
+  const peers = peersIndex.PeersIndex.from(res);
+  const infos = res.views.map((it) => new storyViewer.StoryInteractions$2(it, peers));
+  return infos;
+}
+async function getStoryLink(client, peerId, storyId) {
+  return client.call({
+    _: "stories.exportStoryLink",
+    peer: await storyViewer.resolvePeer(client, peerId),
+    id: storyId
+  }).then((r) => r.link);
+}
+async function getStoryViewers(client, peerId, storyId, params) {
+  if (!params) params = {};
+  const { onlyContacts, sortBy = "reaction", query, offset = "", limit = 100 } = params;
+  const res = await client.call({
+    _: "stories.getStoryViewsList",
+    peer: await storyViewer.resolvePeer(client, peerId),
+    justContacts: onlyContacts,
+    reactionsFirst: sortBy === "reaction",
+    q: query,
+    id: storyId,
+    offset,
+    limit
+  });
+  return new storyViewer.StoryViewersList$2(res);
+}
+async function hideMyStoriesViews(client, params) {
+  const { past = true, future = true } = params ?? {};
+  const res = await client.call({
+    _: "stories.activateStealthMode",
+    past,
+    future
+  });
+  storyViewer.assertIsUpdatesGroup("hideMyStoriesViews", res);
+  client.handleClientUpdate(res, true);
+  const upd = res.updates.find(controllablePromise.hasValueAtKey("_", "updateStoriesStealthMode"));
+  if (!upd) {
+    throw new platform.MtTypeAssertionError("hideMyStoriesViews (@ res.updates[*])", "updateStoriesStealthMode", "none");
+  }
+  return new storyViewer.StoriesStealthMode$1(upd.stealthMode);
+}
+async function incrementStoriesViews(client, peerId, ids) {
+  const r = await client.call({
+    _: "stories.incrementStoryViews",
+    peer: await storyViewer.resolvePeer(client, peerId),
+    id: Array.isArray(ids) ? ids : [ids]
+  });
+  controllablePromise.assertTrue("stories.incrementStoryViews", r);
+}
+async function* iterAllStories(client, params) {
+  if (!params) params = {};
+  const { archived, limit = Infinity } = params;
+  let { offset } = params;
+  let current = 0;
+  for (; ; ) {
+    const res = await getAllStories(client, {
+      offset,
+      archived
+    });
+    for (const peer of res.peerStories) {
+      yield peer;
+      if (++current >= limit) return;
+    }
+    if (!res.hasMore) return;
+    offset = res.next;
+  }
+}
+async function* iterProfileStories(client, peerId, params) {
+  if (!params) params = {};
+  const { kind = "pinned", limit = Infinity, chunkSize = 100 } = params;
+  let { offsetId } = params;
+  let current = 0;
+  const peer = await storyViewer.resolvePeer(client, peerId);
+  for (; ; ) {
+    const res = await getProfileStories(client, peer, {
+      kind,
+      offsetId,
+      limit: Math.min(limit - current, chunkSize)
+    });
+    for (const peer2 of res) {
+      yield peer2;
+      if (++current >= limit) return;
+    }
+    if (!res.next) return;
+    offsetId = res.next;
+  }
+}
+async function* iterStoryViewers(client, peerId, storyId, params) {
+  if (!params) params = {};
+  const { onlyContacts, sortBy = "reaction", query, limit = Infinity, chunkSize = 100 } = params;
+  let { offset = "" } = params;
+  let current = 0;
+  const peer = await storyViewer.resolvePeer(client, peerId);
+  for (; ; ) {
+    const res = await getStoryViewers(client, peer, storyId, {
+      onlyContacts,
+      sortBy,
+      query,
+      offset,
+      limit: Math.min(limit - current, chunkSize)
+    });
+    for (const peer2 of res.viewers) {
+      yield peer2;
+      if (++current >= limit) return;
+    }
+    if (!res.next) return;
+    offset = res.next;
+  }
+}
+async function readStories(client, peerId, maxId) {
+  return client.call({
+    _: "stories.readStories",
+    peer: await storyViewer.resolvePeer(client, peerId),
+    maxId
+  });
+}
+async function reportStory(client, peerId, storyIds, params) {
+  const { reason = { _: "inputReportReasonSpam" }, message = "" } = params ?? {};
+  const r = await client.call({
+    _: "stories.report",
+    peer: await storyViewer.resolvePeer(client, peerId),
+    id: Array.isArray(storyIds) ? storyIds : [storyIds],
+    message,
+    reason
+  });
+  controllablePromise.assertTrue("stories.report", r);
+}
+async function sendStoryReaction(client, params) {
+  const { peerId, storyId, reaction, addToRecent } = params;
+  const res = await client.call({
+    _: "stories.sendReaction",
+    peer: await storyViewer.resolvePeer(client, peerId),
+    storyId,
+    reaction: storyViewer.normalizeInputReaction(reaction),
+    addToRecent
+  });
+  client.handleClientUpdate(res, true);
+}
+async function sendStory(client, params) {
+  const { peer = "me", pinned, forbidForwards, interactiveElements, period } = params;
+  let { media } = params;
+  if (typeof media === "string") {
+    media = {
+      type: "auto",
+      file: media
+    };
+  }
+  const inputMedia = await storyViewer._normalizeInputMedia(client, media);
+  const privacyRules = params.privacyRules ? await _normalizePrivacyRules(client, params.privacyRules) : [{ _: "inputPrivacyValueAllowAll" }];
+  const [caption, entities] = await storyViewer._normalizeInputText(
+    client,
+    // some types dont have `caption` field, and ts warns us,
+    // but since it's JS, they'll just be `undefined` and properly handled by the method
+    params.caption || media.caption
+  );
+  const res = await client.call({
+    _: "stories.sendStory",
+    pinned,
+    noforwards: forbidForwards,
+    peer: await storyViewer.resolvePeer(client, peer),
+    media: inputMedia,
+    mediaAreas: interactiveElements,
+    caption,
+    entities,
+    privacyRules,
+    randomId: conditionVariable.randomLong(),
+    period
+  });
+  return _findStoryInUpdate(client, res);
+}
+async function togglePeerStoriesArchived(client, peerId, archived) {
+  const r = await client.call({
+    _: "stories.togglePeerStoriesHidden",
+    peer: await storyViewer.resolvePeer(client, peerId),
+    hidden: archived
+  });
+  controllablePromise.assertTrue("stories.togglePeerStoriesHidden", r);
+}
+async function toggleStoriesPinned(client, params) {
+  const { ids, pinned, peer = "me" } = params;
+  return client.call({
+    _: "stories.togglePinned",
+    peer: await storyViewer.resolvePeer(client, peer),
+    id: Array.isArray(ids) ? ids : [ids],
+    pinned
+  });
+}
+async function blockUser(client, id) {
+  const r = await client.call({
+    _: "contacts.block",
+    id: await storyViewer.resolvePeer(client, id)
+  });
+  controllablePromise.assertTrue("contacts.block", r);
+}
+async function deleteProfilePhotos(client, ids) {
+  if (!Array.isArray(ids)) ids = [ids];
+  const photos = ids.map((id) => {
+    if (typeof id === "string") {
+      return storyViewer.fileIdToInputPhoto(id);
+    }
+    return id;
+  });
+  await client.call({
+    _: "photos.deletePhotos",
+    id: photos
+  });
+}
+async function editCloseFriendsRaw(client, ids) {
+  const r = await client.call({
+    _: "contacts.editCloseFriends",
+    id: ids
+  });
+  controllablePromise.assertTrue("contacts.editCloseFriends", r);
+}
+async function editCloseFriends(client, ids) {
+  const r = await client.call({
+    _: "contacts.editCloseFriends",
+    id: await storyViewer.resolvePeerMany(client, ids, conditionVariable.toInputUser).then(
+      (r2) => r2.map((u) => {
+        if ("userId" in u) return u.userId;
+        return 0;
+      })
+    )
+  });
+  controllablePromise.assertTrue("contacts.editCloseFriends", r);
+}
+async function getCommonChats(client, userId) {
+  return client.call({
+    _: "messages.getCommonChats",
+    userId: await storyViewer.resolveUser(client, userId),
+    maxId: 0,
+    limit: 100
+  }).then((res) => res.chats.map((it) => new storyViewer.Chat$2(it)));
+}
+async function getGlobalTtl(client) {
+  return client.call({
+    _: "messages.getDefaultHistoryTTL"
+  }).then((r) => r.period);
+}
+async function getMyUsername(client) {
+  return client.storage.self.fetch().then((self) => self?.usernames[0] ?? null);
+}
+async function getProfilePhoto(client, userId, photoId) {
+  const res = await client.call({
+    _: "photos.getUserPhotos",
+    userId: await storyViewer.resolveUser(client, userId),
+    offset: -1,
+    limit: 1,
+    maxId: photoId
+  });
+  const photo = res.photos[0];
+  controllablePromise.assertTypeIs("getProfilePhotos", photo, "photo");
+  return new storyViewer.Photo$2(photo);
+}
+async function getProfilePhotos(client, userId, params) {
+  if (!params) params = {};
+  const { offset = 0, limit = 100 } = params;
+  const res = await client.call({
+    _: "photos.getUserPhotos",
+    userId: await storyViewer.resolveUser(client, userId),
+    offset,
+    limit,
+    maxId: Long.ZERO
+  });
+  return conditionVariable.makeArrayPaginated(
+    res.photos.map((it) => {
+      controllablePromise.assertTypeIs("getProfilePhotos", it, "photo");
+      return new storyViewer.Photo$2(it);
+    }),
+    res.count ?? res.photos.length,
+    offset + res.photos.length
+  );
+}
+async function getUsers(client, ids) {
+  if (!Array.isArray(ids)) {
+    const res2 = await storyViewer._getUsersBatched(client, await storyViewer.resolveUser(client, ids));
+    return [res2 ? new storyViewer.User$2(res2) : null];
+  }
+  const inputPeers = await storyViewer.resolvePeerMany(client, ids, conditionVariable.toInputUser);
+  const res = await Promise.all(inputPeers.map((peer) => storyViewer._getUsersBatched(client, peer)));
+  return res.map((it) => it ? new storyViewer.User$2(it) : null);
+}
+async function* iterProfilePhotos(client, userId, params) {
+  if (!params) params = {};
+  const peer = await storyViewer.resolveUser(client, userId);
+  const { limit = Infinity, chunkSize = 100 } = params;
+  let { offset } = params;
+  let current = 0;
+  for (; ; ) {
+    const res = await getProfilePhotos(client, peer, {
+      offset,
+      limit: Math.min(chunkSize, limit - current)
+    });
+    for (const it of res) {
+      yield it;
+      if (++current >= limit) return;
+    }
+    if (!res.next) return;
+    offset = res.next;
+  }
+}
+async function setGlobalTtl(client, period) {
+  const r = await client.call({
+    _: "messages.setDefaultHistoryTTL",
+    period
+  });
+  controllablePromise.assertTrue("messages.setDefaultHistoryTTL", r);
+}
+async function setMyBirthday(client, birthday) {
+  const res = await client.call({
+    _: "account.updateBirthday",
+    birthday: birthday ? {
+      _: "birthday",
+      ...birthday
+    } : void 0
+  });
+  controllablePromise.assertTrue("account.updateBirthday", res);
+}
+async function setMyEmojiStatus(client, emoji, params) {
+  const { until } = params ?? {};
+  let emojiStatus;
+  if (emoji === null) {
+    emojiStatus = { _: "emojiStatusEmpty" };
+  } else if (until) {
+    emojiStatus = {
+      _: "emojiStatusUntil",
+      documentId: emoji,
+      until: conditionVariable.normalizeDate(until)
+    };
+  } else {
+    emojiStatus = {
+      _: "emojiStatus",
+      documentId: emoji
+    };
+  }
+  const r = await client.call({
+    _: "account.updateEmojiStatus",
+    emojiStatus
+  });
+  controllablePromise.assertTrue("account.updateEmojiStatus", r);
+}
+async function setMyProfilePhoto(client, params) {
+  const { type, previewSec } = params;
+  let { media } = params;
+  if (fileId.tdFileId.isFileIdLike(media) || typeof media === "object" && tl.tl.isAnyInputPhoto(media)) {
+    if (typeof media === "string" && media.match(/^https?:\/\//)) {
+      throw new platform.MtArgumentError("Profile photo can't be set from URL.");
+    }
+    if (typeof media !== "string" || !media.match(/^file:/)) {
+      if (fileId.tdFileId.isFileIdLike(media)) {
+        media = storyViewer.fileIdToInputPhoto(media);
+      }
+      const res2 = await client.call({
+        _: "photos.updateProfilePhoto",
+        id: media
+      });
+      return new storyViewer.Photo$2(res2.photo);
+    }
+  }
+  const res = await client.call({
+    _: "photos.uploadProfilePhoto",
+    [type === "photo" ? "file" : "video"]: await storyViewer._normalizeInputFile(client, media, {}),
+    videoStartTs: previewSec
+  });
+  return new storyViewer.Photo$2(res.photo);
+}
+async function setMyUsername(client, username) {
+  if (username === null) username = "";
+  const res = await client.call({
+    _: "account.updateUsername",
+    username
+  });
+  await client.storage.self.update({ username });
+  return new storyViewer.User$2(res);
+}
+async function setOffline(client, offline = true) {
+  await client.call({
+    _: "account.updateStatus",
+    offline
+  });
+}
+async function unblockUser(client, id) {
+  const r = await client.call({
+    _: "contacts.unblock",
+    id: await storyViewer.resolvePeer(client, id)
+  });
+  controllablePromise.assertTrue("contacts.unblock", r);
+}
+async function updateProfile(client, params) {
+  const res = await client.call({
+    _: "account.updateProfile",
+    firstName: params.firstName,
+    lastName: params.lastName,
+    about: params.bio
+  });
+  return new storyViewer.User$2(res);
+}
+exports._normalizePrivacyRules = _normalizePrivacyRules;
+exports.addChatMembers = addChatMembers;
+exports.addContact = addContact;
+exports.addStickerToSet = addStickerToSet;
+exports.answerCallbackQuery = answerCallbackQuery;
+exports.answerInlineQuery = answerInlineQuery;
+exports.answerMedia = answerMedia;
+exports.answerMediaGroup = answerMediaGroup;
+exports.answerPreCheckoutQuery = answerPreCheckoutQuery;
+exports.answerText = answerText;
+exports.applyBoost = applyBoost;
+exports.archiveChats = archiveChats;
+exports.banChatMember = banChatMember;
+exports.blockUser = blockUser;
+exports.canApplyBoost = canApplyBoost;
+exports.canSendStory = canSendStory;
+exports.cancelPasswordEmail = cancelPasswordEmail;
+exports.changeCloudPassword = changeCloudPassword;
+exports.checkPassword = checkPassword;
+exports.closeChat = closeChat;
+exports.closePoll = closePoll;
+exports.commentMedia = commentMedia;
+exports.commentMediaGroup = commentMediaGroup;
+exports.commentText = commentText;
+exports.createBusinessChatLink = createBusinessChatLink;
+exports.createChannel = createChannel;
+exports.createFolder = createFolder;
+exports.createForumTopic = createForumTopic;
+exports.createGroup = createGroup;
+exports.createInviteLink = createInviteLink;
+exports.createStickerSet = createStickerSet;
+exports.createSupergroup = createSupergroup;
+exports.deleteBusinessChatLink = deleteBusinessChatLink;
+exports.deleteChannel = deleteChannel;
+exports.deleteChatPhoto = deleteChatPhoto;
+exports.deleteContacts = deleteContacts;
+exports.deleteFolder = deleteFolder;
+exports.deleteForumTopicHistory = deleteForumTopicHistory;
+exports.deleteGroup = deleteGroup;
+exports.deleteHistory = deleteHistory;
+exports.deleteMessages = deleteMessages;
+exports.deleteMessagesById = deleteMessagesById;
+exports.deleteMyCommands = deleteMyCommands;
+exports.deleteProfilePhotos = deleteProfilePhotos;
+exports.deleteScheduledMessages = deleteScheduledMessages;
+exports.deleteStickerFromSet = deleteStickerFromSet;
+exports.deleteStories = deleteStories;
+exports.deleteUserHistory = deleteUserHistory;
+exports.downloadAsBuffer = downloadAsBuffer;
+exports.downloadAsIterable = downloadAsIterable;
+exports.downloadAsStream = downloadAsStream;
+exports.editAdminRights = editAdminRights;
+exports.editBusinessChatLink = editBusinessChatLink;
+exports.editCloseFriends = editCloseFriends;
+exports.editCloseFriendsRaw = editCloseFriendsRaw;
+exports.editFolder = editFolder;
+exports.editForumTopic = editForumTopic;
+exports.editInlineMessage = editInlineMessage;
+exports.editInviteLink = editInviteLink;
+exports.editMessage = editMessage;
+exports.editStory = editStory;
+exports.enableCloudPassword = enableCloudPassword;
+exports.exportInviteLink = exportInviteLink;
+exports.findDialogs = findDialogs;
+exports.findFolder = findFolder;
+exports.forwardMessages = forwardMessages;
+exports.forwardMessagesById = forwardMessagesById;
+exports.getAllScheduledMessages = getAllScheduledMessages;
+exports.getAllStories = getAllStories;
+exports.getAvailableMessageEffects = getAvailableMessageEffects;
+exports.getBoostStats = getBoostStats;
+exports.getBoosts = getBoosts;
+exports.getBotInfo = getBotInfo;
+exports.getBotMenuButton = getBotMenuButton;
+exports.getBusinessChatLinks = getBusinessChatLinks;
+exports.getCallbackAnswer = getCallbackAnswer;
+exports.getCallbackQueryMessage = getCallbackQueryMessage;
+exports.getChat = getChat;
+exports.getChatEventLog = getChatEventLog;
+exports.getChatMember = getChatMember;
+exports.getChatMembers = getChatMembers;
+exports.getChatPreview = getChatPreview;
+exports.getChatlistPreview = getChatlistPreview;
+exports.getCollectibleInfo = getCollectibleInfo;
+exports.getCommonChats = getCommonChats;
+exports.getContacts = getContacts;
+exports.getCustomEmojis = getCustomEmojis;
+exports.getCustomEmojisFromMessages = getCustomEmojisFromMessages;
+exports.getFactCheck = getFactCheck;
+exports.getFolders = getFolders;
+exports.getForumTopics = getForumTopics;
+exports.getForumTopicsById = getForumTopicsById;
+exports.getFullChat = getFullChat;
+exports.getGameHighScores = getGameHighScores;
+exports.getGlobalTtl = getGlobalTtl;
+exports.getHistory = getHistory;
+exports.getInlineGameHighScores = getInlineGameHighScores;
+exports.getInstalledStickers = getInstalledStickers;
+exports.getInviteLink = getInviteLink;
+exports.getInviteLinkMembers = getInviteLinkMembers;
+exports.getInviteLinks = getInviteLinks;
+exports.getMe = getMe;
+exports.getMessageByLink = getMessageByLink;
+exports.getMessageGroup = getMessageGroup;
+exports.getMessageReactions = getMessageReactions;
+exports.getMessageReactionsById = getMessageReactionsById;
+exports.getMessagesUnsafe = getMessagesUnsafe;
+exports.getMyBoostSlots = getMyBoostSlots;
+exports.getMyCommands = getMyCommands;
+exports.getMyStickerSets = getMyStickerSets;
+exports.getMyUsername = getMyUsername;
+exports.getNearbyChats = getNearbyChats;
+exports.getPasswordHint = getPasswordHint;
+exports.getPeerStories = getPeerStories;
+exports.getPrimaryInviteLink = getPrimaryInviteLink;
+exports.getProfilePhoto = getProfilePhoto;
+exports.getProfilePhotos = getProfilePhotos;
+exports.getProfileStories = getProfileStories;
+exports.getReactionUsers = getReactionUsers;
+exports.getReplyTo = getReplyTo;
+exports.getScheduledMessages = getScheduledMessages;
+exports.getSimilarChannels = getSimilarChannels;
+exports.getStarsTransactions = getStarsTransactions;
+exports.getStickerSet = getStickerSet;
+exports.getStoriesById = getStoriesById;
+exports.getStoriesInteractions = getStoriesInteractions;
+exports.getStoryLink = getStoryLink;
+exports.getStoryViewers = getStoryViewers;
+exports.getUsers = getUsers;
+exports.hideAllJoinRequests = hideAllJoinRequests;
+exports.hideJoinRequest = hideJoinRequest;
+exports.hideMyStoriesViews = hideMyStoriesViews;
+exports.importContacts = importContacts;
+exports.incrementStoriesViews = incrementStoriesViews;
+exports.initTakeoutSession = initTakeoutSession;
+exports.isSelfPeer = isSelfPeer;
+exports.iterAllStories = iterAllStories;
+exports.iterBoosters = iterBoosters;
+exports.iterChatEventLog = iterChatEventLog;
+exports.iterChatMembers = iterChatMembers;
+exports.iterDialogs = iterDialogs;
+exports.iterForumTopics = iterForumTopics;
+exports.iterHistory = iterHistory;
+exports.iterInviteLinkMembers = iterInviteLinkMembers;
+exports.iterInviteLinks = iterInviteLinks;
+exports.iterProfilePhotos = iterProfilePhotos;
+exports.iterProfileStories = iterProfileStories;
+exports.iterReactionUsers = iterReactionUsers;
+exports.iterSearchGlobal = iterSearchGlobal;
+exports.iterSearchHashtag = iterSearchHashtag;
+exports.iterSearchMessages = iterSearchMessages;
+exports.iterStarsTransactions = iterStarsTransactions;
+exports.iterStoryViewers = iterStoryViewers;
+exports.joinChat = joinChat;
+exports.joinChatlist = joinChatlist;
+exports.kickChatMember = kickChatMember;
+exports.leaveChat = leaveChat;
+exports.logOut = logOut;
+exports.markChatUnread = markChatUnread;
+exports.moveStickerInSet = moveStickerInSet;
+exports.openChat = openChat;
+exports.pinMessage = pinMessage;
+exports.quoteWithMedia = quoteWithMedia;
+exports.quoteWithMediaGroup = quoteWithMediaGroup;
+exports.quoteWithText = quoteWithText;
+exports.readReactions = readReactions;
+exports.readStories = readStories;
+exports.recoverPassword = recoverPassword;
+exports.removeCloudPassword = removeCloudPassword;
+exports.reorderPinnedForumTopics = reorderPinnedForumTopics;
+exports.reorderUsernames = reorderUsernames;
+exports.replaceStickerInSet = replaceStickerInSet;
+exports.replyMedia = replyMedia;
+exports.replyMediaGroup = replyMediaGroup;
+exports.replyText = replyText;
+exports.reportStory = reportStory;
+exports.resendCode = resendCode;
+exports.resendPasswordEmail = resendPasswordEmail;
+exports.restrictChatMember = restrictChatMember;
+exports.revokeInviteLink = revokeInviteLink;
+exports.run = run;
+exports.saveDraft = saveDraft;
+exports.searchGlobal = searchGlobal;
+exports.searchHashtag = searchHashtag;
+exports.searchMessages = searchMessages;
+exports.sendCode = sendCode;
+exports.sendCopy = sendCopy;
+exports.sendCopyGroup = sendCopyGroup;
+exports.sendPaidReaction = sendPaidReaction;
+exports.sendReaction = sendReaction;
+exports.sendRecoveryCode = sendRecoveryCode;
+exports.sendScheduled = sendScheduled;
+exports.sendStory = sendStory;
+exports.sendStoryReaction = sendStoryReaction;
+exports.sendTyping = sendTyping;
+exports.sendVote = sendVote;
+exports.setBotInfo = setBotInfo;
+exports.setBotMenuButton = setBotMenuButton;
+exports.setBusinessIntro = setBusinessIntro;
+exports.setBusinessWorkHours = setBusinessWorkHours;
+exports.setChatColor = setChatColor;
+exports.setChatDefaultPermissions = setChatDefaultPermissions;
+exports.setChatDescription = setChatDescription;
+exports.setChatPhoto = setChatPhoto;
+exports.setChatStickerSet = setChatStickerSet;
+exports.setChatTitle = setChatTitle;
+exports.setChatTtl = setChatTtl;
+exports.setChatUsername = setChatUsername;
+exports.setFoldersOrder = setFoldersOrder;
+exports.setGameScore = setGameScore;
+exports.setGlobalTtl = setGlobalTtl;
+exports.setInlineGameScore = setInlineGameScore;
+exports.setMyBirthday = setMyBirthday;
+exports.setMyCommands = setMyCommands;
+exports.setMyDefaultRights = setMyDefaultRights;
+exports.setMyEmojiStatus = setMyEmojiStatus;
+exports.setMyProfilePhoto = setMyProfilePhoto;
+exports.setMyUsername = setMyUsername;
+exports.setOffline = setOffline;
+exports.setSlowMode = setSlowMode;
+exports.setStickerSetThumb = setStickerSetThumb;
+exports.signIn = signIn;
+exports.signInBot = signInBot;
+exports.signInQr = signInQr;
+exports.start = start;
+exports.startTest = startTest;
+exports.toggleContentProtection = toggleContentProtection;
+exports.toggleForum = toggleForum;
+exports.toggleForumTopicClosed = toggleForumTopicClosed;
+exports.toggleForumTopicPinned = toggleForumTopicPinned;
+exports.toggleFragmentUsername = toggleFragmentUsername;
+exports.toggleGeneralTopicHidden = toggleGeneralTopicHidden;
+exports.toggleJoinRequests = toggleJoinRequests;
+exports.toggleJoinToSend = toggleJoinToSend;
+exports.togglePeerStoriesArchived = togglePeerStoriesArchived;
+exports.toggleStoriesPinned = toggleStoriesPinned;
+exports.translateMessage = translateMessage;
+exports.translateText = translateText;
+exports.unarchiveChats = unarchiveChats;
+exports.unbanChatMember = unbanChatMember;
+exports.unblockUser = unblockUser;
+exports.unpinAllMessages = unpinAllMessages;
+exports.unpinMessage = unpinMessage;
+exports.updateProfile = updateProfile;
+exports.uploadMedia = uploadMedia;
+exports.verifyPasswordEmail = verifyPasswordEmail;