@mtcute/core 0.17.1 → 0.18.0

package/highlevel/methods/chats/delete-group.js

@@ -0,0 +1,23 @@
+import { assertTrue } from "../../../utils/type-assertions.js";
+import { isInputPeerChat } from "../../utils/peer-utils.js";
+import { resolvePeer } from "../users/resolve-peer.js";
+import { MtInvalidPeerTypeError } from "../../types/errors.js";
+async function deleteGroup(client, chatId) {
+  const chat = await resolvePeer(client, chatId);
+  if (!isInputPeerChat(chat)) throw new MtInvalidPeerTypeError(chatId, "chat");
+  const res = await client.call({
+    _: "messages.deleteChatUser",
+    revokeHistory: true,
+    chatId: chat.chatId,
+    userId: { _: "inputUserSelf" }
+  });
+  client.handleClientUpdate(res);
+  const r = await client.call({
+    _: "messages.deleteChat",
+    chatId: chat.chatId
+  });
+  assertTrue("messages.deleteChat", r);
+}
+export {
+  deleteGroup
+};

package/highlevel/methods/chats/delete-history.cjs

@@ -0,0 +1,27 @@
+if (typeof globalThis !== "undefined" && !globalThis._MTCUTE_CJS_DEPRECATION_WARNED) {
+  globalThis._MTCUTE_CJS_DEPRECATION_WARNED = true;
+  console.warn("[mtcute-workspace] CommonJS support is deprecated and will be removed in 0.20.0. Please consider switching to ESM, it's " + (/* @__PURE__ */ new Date()).getFullYear() + " already.");
+  console.warn("[mtcute-workspace] Learn more about switching to ESM: https://gist.github.com/sindresorhus/a39789f98801d908bbc7ff3ecc99d99c");
+}
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const utils = require("../../updates/utils.cjs");
+const peerUtils = require("../../utils/peer-utils.cjs");
+const resolvePeer = require("../users/resolve-peer.cjs");
+async function deleteHistory(client, chat, params) {
+  const { mode = "delete", maxId = 0 } = params ?? {};
+  const peer = await resolvePeer.resolvePeer(client, chat);
+  const res = await client.call({
+    _: "messages.deleteHistory",
+    justClear: mode === "clear",
+    revoke: mode === "revoke",
+    peer,
+    maxId
+  });
+  if (peerUtils.isInputPeerChannel(peer)) {
+    client.handleClientUpdate(utils.createDummyUpdate(res.pts, res.ptsCount, peer.channelId));
+  } else {
+    client.handleClientUpdate(utils.createDummyUpdate(res.pts, res.ptsCount));
+  }
+}
+exports.deleteHistory = deleteHistory;

package/highlevel/methods/chats/delete-history.d.cts

@@ -0,0 +1,22 @@
+import { ITelegramClient } from '../../client.types.js';
+import { InputPeerLike } from '../../types/index.js';
+/**
+ * Delete communication history (for private chats and legacy groups)
+ */
+export declare function deleteHistory(client: ITelegramClient, chat: InputPeerLike, params?: {
+    /**
+     * Deletion mode. Can be:
+     * - `delete`: delete messages (only for yourself) AND the dialog itself
+     * - `clear`: delete messages (only for yourself), but keep the dialog in the list
+     * - `revoke`: delete messages for all users
+     *
+     * @default  'delete'
+     */
+    mode: 'delete' | 'clear' | 'revoke';
+    /**
+     * Maximum ID of message to delete.
+     *
+     * @default  0, i.e. remove all messages
+     */
+    maxId?: number;
+}): Promise<void>;

package/highlevel/methods/chats/delete-history.js

@@ -0,0 +1,22 @@
+import { createDummyUpdate } from "../../updates/utils.js";
+import { isInputPeerChannel } from "../../utils/peer-utils.js";
+import { resolvePeer } from "../users/resolve-peer.js";
+async function deleteHistory(client, chat, params) {
+  const { mode = "delete", maxId = 0 } = params ?? {};
+  const peer = await resolvePeer(client, chat);
+  const res = await client.call({
+    _: "messages.deleteHistory",
+    justClear: mode === "clear",
+    revoke: mode === "revoke",
+    peer,
+    maxId
+  });
+  if (isInputPeerChannel(peer)) {
+    client.handleClientUpdate(createDummyUpdate(res.pts, res.ptsCount, peer.channelId));
+  } else {
+    client.handleClientUpdate(createDummyUpdate(res.pts, res.ptsCount));
+  }
+}
+export {
+  deleteHistory
+};

package/highlevel/methods/chats/delete-user-history.cjs

@@ -0,0 +1,23 @@
+if (typeof globalThis !== "undefined" && !globalThis._MTCUTE_CJS_DEPRECATION_WARNED) {
+  globalThis._MTCUTE_CJS_DEPRECATION_WARNED = true;
+  console.warn("[mtcute-workspace] CommonJS support is deprecated and will be removed in 0.20.0. Please consider switching to ESM, it's " + (/* @__PURE__ */ new Date()).getFullYear() + " already.");
+  console.warn("[mtcute-workspace] Learn more about switching to ESM: https://gist.github.com/sindresorhus/a39789f98801d908bbc7ff3ecc99d99c");
+}
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const utils = require("../../updates/utils.cjs");
+const resolvePeer = require("../users/resolve-peer.cjs");
+async function deleteUserHistory(client, params) {
+  const { chatId, participantId, shouldDispatch } = params;
+  const channel = await resolvePeer.resolveChannel(client, chatId);
+  const peer = await resolvePeer.resolvePeer(client, participantId);
+  const res = await client.call({
+    _: "channels.deleteParticipantHistory",
+    channel,
+    participant: peer
+  });
+  if (!shouldDispatch) {
+    client.handleClientUpdate(utils.createDummyUpdate(res.pts, res.ptsCount, channel.channelId));
+  }
+}
+exports.deleteUserHistory = deleteUserHistory;

package/highlevel/methods/chats/delete-user-history.d.cts

@@ -0,0 +1,16 @@
+import { ITelegramClient } from '../../client.types.js';
+import { InputPeerLike } from '../../types/index.js';
+/**
+ * Delete all messages of a user (or channel) in a supergroup
+ */
+export declare function deleteUserHistory(client: ITelegramClient, params: {
+    /** Chat ID */
+    chatId: InputPeerLike;
+    /** User/channel ID whose messages to delete */
+    participantId: InputPeerLike;
+    /**
+     * Whether to dispatch the updates that will be generated by this call.
+     * Doesn't follow `disableNoDispatch`
+     */
+    shouldDispatch?: true;
+}): Promise<void>;

package/highlevel/methods/chats/delete-user-history.js

@@ -0,0 +1,18 @@
+import { createDummyUpdate } from "../../updates/utils.js";
+import { resolveChannel, resolvePeer } from "../users/resolve-peer.js";
+async function deleteUserHistory(client, params) {
+  const { chatId, participantId, shouldDispatch } = params;
+  const channel = await resolveChannel(client, chatId);
+  const peer = await resolvePeer(client, participantId);
+  const res = await client.call({
+    _: "channels.deleteParticipantHistory",
+    channel,
+    participant: peer
+  });
+  if (!shouldDispatch) {
+    client.handleClientUpdate(createDummyUpdate(res.pts, res.ptsCount, channel.channelId));
+  }
+}
+export {
+  deleteUserHistory
+};

package/highlevel/methods/chats/edit-admin-rights.cjs

@@ -0,0 +1,25 @@
+if (typeof globalThis !== "undefined" && !globalThis._MTCUTE_CJS_DEPRECATION_WARNED) {
+  globalThis._MTCUTE_CJS_DEPRECATION_WARNED = true;
+  console.warn("[mtcute-workspace] CommonJS support is deprecated and will be removed in 0.20.0. Please consider switching to ESM, it's " + (/* @__PURE__ */ new Date()).getFullYear() + " already.");
+  console.warn("[mtcute-workspace] Learn more about switching to ESM: https://gist.github.com/sindresorhus/a39789f98801d908bbc7ff3ecc99d99c");
+}
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const resolvePeer = require("../users/resolve-peer.cjs");
+async function editAdminRights(client, params) {
+  const { chatId, userId, rights, rank = "" } = params;
+  const chat = await resolvePeer.resolveChannel(client, chatId);
+  const user = await resolvePeer.resolveUser(client, userId);
+  const res = await client.call({
+    _: "channels.editAdmin",
+    channel: chat,
+    userId: user,
+    adminRights: {
+      _: "chatAdminRights",
+      ...rights
+    },
+    rank
+  });
+  client.handleClientUpdate(res);
+}
+exports.editAdminRights = editAdminRights;

package/highlevel/methods/chats/edit-admin-rights.d.cts

@@ -0,0 +1,16 @@
+import { tl } from '@mtcute/tl';
+import { ITelegramClient } from '../../client.types.js';
+import { InputPeerLike } from '../../types/index.js';
+/**
+ * Edit supergroup/channel admin rights of a user.
+ */
+export declare function editAdminRights(client: ITelegramClient, params: {
+    /** Chat ID */
+    chatId: InputPeerLike;
+    /** User ID */
+    userId: InputPeerLike;
+    /** New admin rights */
+    rights: Omit<tl.RawChatAdminRights, '_'>;
+    /** Custom admin rank */
+    rank?: string;
+}): Promise<void>;

package/highlevel/methods/chats/edit-admin-rights.js

@@ -0,0 +1,20 @@
+import { resolveChannel, resolveUser } from "../users/resolve-peer.js";
+async function editAdminRights(client, params) {
+  const { chatId, userId, rights, rank = "" } = params;
+  const chat = await resolveChannel(client, chatId);
+  const user = await resolveUser(client, userId);
+  const res = await client.call({
+    _: "channels.editAdmin",
+    channel: chat,
+    userId: user,
+    adminRights: {
+      _: "chatAdminRights",
+      ...rights
+    },
+    rank
+  });
+  client.handleClientUpdate(res);
+}
+export {
+  editAdminRights
+};

package/highlevel/methods/chats/get-chat-event-log.cjs

@@ -0,0 +1,42 @@
+if (typeof globalThis !== "undefined" && !globalThis._MTCUTE_CJS_DEPRECATION_WARNED) {
+  globalThis._MTCUTE_CJS_DEPRECATION_WARNED = true;
+  console.warn("[mtcute-workspace] CommonJS support is deprecated and will be removed in 0.20.0. Please consider switching to ESM, it's " + (/* @__PURE__ */ new Date()).getFullYear() + " already.");
+  console.warn("[mtcute-workspace] Learn more about switching to ESM: https://gist.github.com/sindresorhus/a39789f98801d908bbc7ff3ecc99d99c");
+}
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const Long = require("long");
+const filters = require("../../types/peers/chat-event/filters.cjs");
+const peerUtils = require("../../utils/peer-utils.cjs");
+const resolvePeerMany = require("../users/resolve-peer-many.cjs");
+const resolvePeer = require("../users/resolve-peer.cjs");
+const index = require("../../types/peers/chat-event/index.cjs");
+const peersIndex = require("../../types/peers/peers-index.cjs");
+async function getChatEventLog(client, chatId, params) {
+  const { maxId = Long.ZERO, minId = Long.ZERO, query = "", limit = 100, users, filters: filters$1 } = params ?? {};
+  const channel = await resolvePeer.resolveChannel(client, chatId);
+  const admins = users ? await resolvePeerMany.resolvePeerMany(client, users, peerUtils.toInputUser) : void 0;
+  const { serverFilter, localFilter } = filters.normalizeChatEventFilters(filters$1);
+  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 index.ChatEvent(evt, peers);
+    if (localFilter && (!parsed.action || !localFilter[parsed.action.type])) {
+      continue;
+    }
+    results.push(parsed);
+  }
+  return results;
+}
+exports.getChatEventLog = getChatEventLog;

package/highlevel/methods/chats/get-chat-event-log.d.cts

@@ -0,0 +1,61 @@
+import { tl } from '@mtcute/tl';
+import { ITelegramClient } from '../../client.types.js';
+import { InputPeerLike, ChatEvent } from '../../types/index.js';
+import { InputChatEventFilters } from '../../types/peers/chat-event/filters.js';
+/**
+ * Get chat event log ("Recent actions" in official clients).
+ *
+ * Only available for supergroups and channels, and
+ * requires (any) administrator rights.
+ *
+ * Results are returned in reverse chronological
+ * order (i.e. newest first) and event IDs are
+ * in direct chronological order (i.e. newer
+ * events have bigger event ID)
+ *
+ * @param params
+ */
+export declare function getChatEventLog(client: ITelegramClient, chatId: InputPeerLike, params?: {
+    /**
+     * Search query
+     */
+    query?: string;
+    /**
+     * Minimum event ID to return
+     */
+    minId?: tl.Long;
+    /**
+     * Maximum event ID to return,
+     * can be used as a base offset
+     */
+    maxId?: tl.Long;
+    /**
+     * List of users whose actions to return
+     */
+    users?: InputPeerLike[];
+    /**
+     * Event filters. Can be a TL object, or one or more
+     * action types.
+     *
+     * Note that some filters are grouped in TL
+     * (i.e. `info=true` will return `title_changed`,
+     * `username_changed` and many more),
+     * and when passing one or more action types,
+     * they will be filtered locally.
+     */
+    filters?: InputChatEventFilters;
+    /**
+     * Limit the number of events returned.
+     *
+     * > Note: when using filters, there will likely be
+     * > less events returned than specified here.
+     * > This limit is only used to limit the number of
+     * > events to fetch from the server.
+     * >
+     * > If you need to limit the number of events
+     * > returned, use {@link iterChatEventLog} instead.
+     *
+     * @default  100
+     */
+    limit?: number;
+}): Promise<ChatEvent[]>;

package/highlevel/methods/chats/get-chat-event-log.js

@@ -0,0 +1,37 @@
+import Long from "long";
+import { normalizeChatEventFilters } from "../../types/peers/chat-event/filters.js";
+import { toInputUser } from "../../utils/peer-utils.js";
+import { resolvePeerMany } from "../users/resolve-peer-many.js";
+import { resolveChannel } from "../users/resolve-peer.js";
+import { ChatEvent as ChatEvent$2 } from "../../types/peers/chat-event/index.js";
+import { PeersIndex } from "../../types/peers/peers-index.js";
+async function getChatEventLog(client, chatId, params) {
+  const { maxId = Long.ZERO, minId = Long.ZERO, query = "", limit = 100, users, filters } = params ?? {};
+  const channel = await resolveChannel(client, chatId);
+  const admins = users ? await resolvePeerMany(client, users, 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.from(res);
+  const results = [];
+  for (const evt of res.events) {
+    const parsed = new ChatEvent$2(evt, peers);
+    if (localFilter && (!parsed.action || !localFilter[parsed.action.type])) {
+      continue;
+    }
+    results.push(parsed);
+  }
+  return results;
+}
+export {
+  getChatEventLog
+};

package/highlevel/methods/chats/get-chat-member.cjs

@@ -0,0 +1,55 @@
+if (typeof globalThis !== "undefined" && !globalThis._MTCUTE_CJS_DEPRECATION_WARNED) {
+  globalThis._MTCUTE_CJS_DEPRECATION_WARNED = true;
+  console.warn("[mtcute-workspace] CommonJS support is deprecated and will be removed in 0.20.0. Please consider switching to ESM, it's " + (/* @__PURE__ */ new Date()).getFullYear() + " already.");
+  console.warn("[mtcute-workspace] Learn more about switching to ESM: https://gist.github.com/sindresorhus/a39789f98801d908bbc7ff3ecc99d99c");
+}
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const tl = require("@mtcute/tl");
+const typeAssertions = require("../../../utils/type-assertions.cjs");
+const peerUtils = require("../../utils/peer-utils.cjs");
+const resolvePeer = require("../users/resolve-peer.cjs");
+const chatMember = require("../../types/peers/chat-member.cjs");
+const errors = require("../../types/errors.cjs");
+const peersIndex = require("../../types/peers/peers-index.cjs");
+async function getChatMember(client, params) {
+  const { chatId, userId } = params;
+  const user = await resolvePeer.resolvePeer(client, userId);
+  const chat = await resolvePeer.resolvePeer(client, chatId);
+  if (peerUtils.isInputPeerChat(chat)) {
+    if (!peerUtils.isInputPeerUser(user)) {
+      throw new errors.MtInvalidPeerTypeError(userId, "user");
+    }
+    const res = await client.call({
+      _: "messages.getFullChat",
+      chatId: chat.chatId
+    });
+    typeAssertions.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 chatMember.ChatMember(m, peers);
+      }
+    }
+    return null;
+  } else if (peerUtils.isInputPeerChannel(chat)) {
+    try {
+      const res = await client.call({
+        _: "channels.getParticipant",
+        channel: peerUtils.toInputChannel(chat),
+        participant: user
+      });
+      const peers = peersIndex.PeersIndex.from(res);
+      return new chatMember.ChatMember(res.participant, peers);
+    } catch (e) {
+      if (tl.tl.RpcError.is(e, "USER_NOT_PARTICIPANT")) {
+        return null;
+      }
+      throw e;
+    }
+  } else {
+    throw new errors.MtInvalidPeerTypeError(chatId, "chat or channel");
+  }
+}
+exports.getChatMember = getChatMember;

package/highlevel/methods/chats/get-chat-member.d.cts

@@ -0,0 +1,15 @@
+import { ITelegramClient } from '../../client.types.js';
+import { InputPeerLike, ChatMember } from '../../types/index.js';
+/**
+ * Get information about a single chat member
+ *
+ * @param chatId  Chat ID or username
+ * @param userId  User ID, username, phone number, `"me"` or `"self"`
+ * @returns  Chat member, or `null` if user is not a member of the chat
+ */
+export declare function getChatMember(client: ITelegramClient, params: {
+    /** Chat ID or username */
+    chatId: InputPeerLike;
+    /** User ID, username, phone number, `"me"` or `"self"` */
+    userId: InputPeerLike;
+}): Promise<ChatMember | null>;

package/highlevel/methods/chats/get-chat-member.js

@@ -0,0 +1,50 @@
+import { tl } from "@mtcute/tl";
+import { assertTypeIs } from "../../../utils/type-assertions.js";
+import { isInputPeerChat, isInputPeerUser, isInputPeerChannel, toInputChannel } from "../../utils/peer-utils.js";
+import { resolvePeer } from "../users/resolve-peer.js";
+import { ChatMember as ChatMember$2 } from "../../types/peers/chat-member.js";
+import { MtInvalidPeerTypeError } from "../../types/errors.js";
+import { PeersIndex } from "../../types/peers/peers-index.js";
+async function getChatMember(client, params) {
+  const { chatId, userId } = params;
+  const user = await resolvePeer(client, userId);
+  const chat = await resolvePeer(client, chatId);
+  if (isInputPeerChat(chat)) {
+    if (!isInputPeerUser(user)) {
+      throw new MtInvalidPeerTypeError(userId, "user");
+    }
+    const res = await client.call({
+      _: "messages.getFullChat",
+      chatId: chat.chatId
+    });
+    assertTypeIs("getChatMember (@ messages.getFullChat)", res.fullChat, "chatFull");
+    const members = res.fullChat.participants._ === "chatParticipantsForbidden" ? [] : res.fullChat.participants.participants;
+    const peers = PeersIndex.from(res);
+    for (const m of members) {
+      if (user._ === "inputPeerSelf" && peers.user(m.userId).self || user._ === "inputPeerUser" && m.userId === user.userId) {
+        return new ChatMember$2(m, peers);
+      }
+    }
+    return null;
+  } else if (isInputPeerChannel(chat)) {
+    try {
+      const res = await client.call({
+        _: "channels.getParticipant",
+        channel: toInputChannel(chat),
+        participant: user
+      });
+      const peers = PeersIndex.from(res);
+      return new ChatMember$2(res.participant, peers);
+    } catch (e) {
+      if (tl.RpcError.is(e, "USER_NOT_PARTICIPANT")) {
+        return null;
+      }
+      throw e;
+    }
+  } else {
+    throw new MtInvalidPeerTypeError(chatId, "chat or channel");
+  }
+}
+export {
+  getChatMember
+};

package/highlevel/methods/chats/get-chat-members.cjs

@@ -0,0 +1,79 @@
+if (typeof globalThis !== "undefined" && !globalThis._MTCUTE_CJS_DEPRECATION_WARNED) {
+  globalThis._MTCUTE_CJS_DEPRECATION_WARNED = true;
+  console.warn("[mtcute-workspace] CommonJS support is deprecated and will be removed in 0.20.0. Please consider switching to ESM, it's " + (/* @__PURE__ */ new Date()).getFullYear() + " already.");
+  console.warn("[mtcute-workspace] Learn more about switching to ESM: https://gist.github.com/sindresorhus/a39789f98801d908bbc7ff3ecc99d99c");
+}
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const Long = require("long");
+const utils = require("../../../types/utils.cjs");
+const typeAssertions = require("../../../utils/type-assertions.cjs");
+const peerUtils = require("../../utils/peer-utils.cjs");
+const resolvePeer = require("../users/resolve-peer.cjs");
+const miscUtils = require("../../utils/misc-utils.cjs");
+const peersIndex = require("../../types/peers/peers-index.cjs");
+const chatMember = require("../../types/peers/chat-member.cjs");
+const errors = require("../../types/errors.cjs");
+async function getChatMembers(client, chatId, params) {
+  const { query = "", offset = 0, limit = 200, type = "recent" } = params ?? {};
+  const chat = await resolvePeer.resolvePeer(client, chatId);
+  if (peerUtils.isInputPeerChat(chat)) {
+    const res = await client.call({
+      _: "messages.getFullChat",
+      chatId: chat.chatId
+    });
+    typeAssertions.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 chatMember.ChatMember(m, peers));
+    return miscUtils.makeArrayWithTotal(ret, ret.length);
+  }
+  if (peerUtils.isInputPeerChannel(chat)) {
+    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:
+        utils.assertNever();
+    }
+    const res = await client.call({
+      _: "channels.getParticipants",
+      channel: peerUtils.toInputChannel(chat),
+      filter,
+      offset,
+      limit,
+      hash: Long.ZERO
+    });
+    typeAssertions.assertTypeIs("getChatMembers (@ channels.getParticipants)", res, "channels.channelParticipants");
+    const peers = peersIndex.PeersIndex.from(res);
+    const ret = res.participants.map((i) => new chatMember.ChatMember(i, peers));
+    return miscUtils.makeArrayWithTotal(ret, res.count);
+  }
+  throw new errors.MtInvalidPeerTypeError(chatId, "chat or channel");
+}
+exports.getChatMembers = getChatMembers;

package/highlevel/methods/chats/get-chat-members.d.cts

@@ -0,0 +1,51 @@
+import { ITelegramClient } from '../../client.types.js';
+import { ArrayWithTotal, InputPeerLike, ChatMember } from '../../types/index.js';
+/**
+ * Get a chunk of members of some chat.
+ *
+ * You can retrieve up to 200 members at once
+ *
+ * @param chatId  Chat ID or username
+ * @param params  Additional parameters
+ */
+export declare function getChatMembers(client: ITelegramClient, chatId: InputPeerLike, params?: {
+    /**
+     * Search query to filter members by their display names and usernames
+     *
+     * > **Note**: Only used for these values of `filter`:
+     * > `all, banned, restricted, mention, contacts`
+     *
+     * @default  `''` (empty string)
+     */
+    query?: string;
+    /**
+     * Sequential number of the first member to be returned.
+     */
+    offset?: number;
+    /**
+     * Maximum number of members to be retrieved.
+     *
+     * > **Note**: Telegram currently only allows you to ever retrieve at most
+     * > 200 members, regardless of offset/limit. I.e. when passing
+     * > `offset=201` nothing will ever be returned.
+     *
+     * @default  200
+     */
+    limit?: number;
+    /**
+     * Type of the query. Can be:
+     *  - `all`: get all members
+     *  - `banned`: get only banned members
+     *  - `restricted`: get only restricted members
+     *  - `bots`: get only bots
+     *  - `recent`: get recent members
+     *  - `admins`: get only administrators (and creator)
+     *  - `contacts`: get only contacts
+     *  - `mention`: get users that can be mentioned (see {@link tl.RawChannelParticipantsMentions})
+     *
+     *  Only used for channels and supergroups.
+     *
+     * @default  `recent`
+     */
+    type?: 'all' | 'banned' | 'restricted' | 'bots' | 'recent' | 'admins' | 'contacts' | 'mention';
+}): Promise<ArrayWithTotal<ChatMember>>;