@mtcute/core 0.18.0-rc.5 → 0.19.0

package/highlevel/methods/bots/get-game-high-scores.d.cts

@@ -0,0 +1,17 @@
+import { tl } from '@mtcute/tl';
+import { ITelegramClient } from '../../client.types.js';
+import { InputMessageId, InputPeerLike, GameHighScore } from '../../types/index.js';
+/**
+ * Get high scores of a game
+ */
+export declare function getGameHighScores(client: ITelegramClient, params: InputMessageId & {
+    /** ID of the user to find high scores for */
+    userId?: InputPeerLike;
+}): Promise<GameHighScore[]>;
+/**
+ * Get high scores of a game from an inline message
+ *
+ * @param messageId  ID of the inline message containing the game
+ * @param userId  ID of the user to find high scores for
+ */
+export declare function getInlineGameHighScores(client: ITelegramClient, messageId: string | tl.TypeInputBotInlineMessageID, userId?: InputPeerLike): Promise<GameHighScore[]>;

package/highlevel/methods/bots/get-my-commands.d.cts

@@ -0,0 +1,21 @@
+import { tl } from '@mtcute/tl';
+import { ITelegramClient } from '../../client.types.js';
+import { BotCommands } from '../../types/index.js';
+/**
+ * Get a list of current bot's commands for the given command scope
+ * and user language. If they are not set, empty set is returned.
+ *
+ * Learn more about scopes in the [Bot API docs](https://core.telegram.org/bots/api#botcommandscope)
+ */
+export declare function getMyCommands(client: ITelegramClient, params?: {
+    /**
+     * Scope of the commands.
+     *
+     * @default  `BotScope.default_` (i.e. `botCommandScopeDefault`)
+     */
+    scope?: tl.TypeBotCommandScope | BotCommands.IntermediateScope;
+    /**
+     * User language applied to the scope.
+     */
+    langCode?: string;
+}): Promise<tl.RawBotCommand[]>;

package/highlevel/methods/bots/normalize-command-scope.d.cts

@@ -0,0 +1,5 @@
+import { ITelegramClient } from '../../client.types.js';
+import { BotCommands } from '../../types/index.js';
+import { tl } from '@mtcute/tl';
+/** @internal */
+export declare function _normalizeCommandScope(client: ITelegramClient, scope: tl.TypeBotCommandScope | BotCommands.IntermediateScope): Promise<tl.TypeBotCommandScope>;

package/highlevel/methods/bots/open-webview.d.cts

@@ -0,0 +1,73 @@
+import { tl } from '@mtcute/tl';
+import { ITelegramClient } from '../../client.types.js';
+import { InputPeerLike } from '../../types/index.js';
+import { InputWebview, WebviewResult } from '../../types/bots/webview.js';
+/**
+ * Open a webview.
+ */
+export declare function openWebview(client: ITelegramClient, params: {
+    /** Information about the webview to open */
+    webview: InputWebview;
+    /**
+     * Bot whose webview to open
+     */
+    bot: InputPeerLike;
+    /**
+     * Chat to report to the server as the "currently open chat",
+     * also the chat to which the message will be sent in case of
+     * `from_inline_keyboard`, `from_bot_menu` and `from_attach_menu` webviews
+     */
+    chat?: InputPeerLike;
+    /**
+     * Theme parameters to pass to the mini app
+     *
+     * Each value should be a string (hex-encoded RGB, no alpha)
+     */
+    theme?: tl.TypeDataJSON | {
+        /** Background color */
+        bg_color?: string;
+        /** Secondary background color */
+        secondary_bg_color?: string;
+        /** Text color */
+        text_color?: string;
+        /** Hint text color */
+        hint_color?: string;
+        /** Link color */
+        link_color?: string;
+        /** Button color */
+        button_color?: string;
+        /** Button text color */
+        button_text_color?: string;
+        /** Header background color */
+        header_bg_color?: string;
+        /** Accent text color */
+        accent_text_color?: string;
+        /** Section background color */
+        section_bg_color?: string;
+        /** Section header text color */
+        section_header_text_color?: string;
+        /** Section separator color */
+        section_separator_color?: string;
+        /** Sub title text color */
+        subtitle_text_color?: string;
+        /** Text color for destructive action buttons in prompts */
+        destructive_text_color?: string;
+    };
+    /**
+     * Webview platform to use in the init data
+     *
+     * Some of the known values:
+     *  - `android` - Android clients
+     *  - `ios` - iOS clients
+     *  - `tdesktop` - Telegram Desktop
+     *  - `macos` - Telegram for macOS
+     *  - `unigram` - Unigram
+     */
+    platform: 'android' | 'ios' | 'tdesktop' | 'macos' | 'unigram' | (string & {});
+}): Promise<WebviewResult>;
+/**
+ * Close a webview previously opened by {@link openWebview} method.
+ *
+ * @param webview  Webview result returned by {@link openWebview}, or its `.queryId`
+ */
+export declare function closeWebview(client: ITelegramClient, webview: WebviewResult | tl.Long): Promise<void>;

package/highlevel/methods/bots/prepare-inline-message.d.cts

@@ -0,0 +1,32 @@
+import { tl } from '@mtcute/tl';
+import { ITelegramClient } from '../../client.types.js';
+import { InputInlineResult } from '../../types/bots/inline-result/types.js';
+import { InputPeerLike } from '../../types/index.js';
+/**
+ * Prepare an inline message result to be sent later via the
+ * `shareMessage` [mini-app api method](https://core.telegram.org/bots/webapps#initializing-mini-apps).
+ */
+export declare function prepareInlineMessage(client: ITelegramClient, params: {
+    userId: InputPeerLike;
+    result: InputInlineResult;
+    /**
+     * Filters for the client to use when prompting the user for the
+     * chat to send the inline message to.
+     *
+     * Note that this is just a hint for the client, and the client is free to ignore it.
+     */
+    filter?: tl.TypeInlineQueryPeerType[] | {
+        /** private chat with the bot itself */
+        botSelf?: boolean;
+        /** private chats */
+        private?: boolean;
+        /** private chats with other bots */
+        bots?: boolean;
+        /** "basic" chats */
+        chats?: boolean;
+        /** supergroups */
+        supergroups?: boolean;
+        /** broadcast channels */
+        channels?: boolean;
+    };
+}): Promise<tl.messages.TypeBotPreparedInlineMessage>;

package/highlevel/methods/bots/set-bot-info.d.cts

@@ -0,0 +1,23 @@
+import { ITelegramClient } from '../../client.types.js';
+import { InputPeerLike } from '../../types/index.js';
+/**
+ * Sets information about a bot the current uzer owns (or the current bot)
+ */
+export declare function setBotInfo(client: ITelegramClient, params: {
+    /**
+     * When called by a user, a bot the user owns must be specified.
+     * When called by a bot, must be empty
+     */
+    bot?: InputPeerLike;
+    /**
+     * If passed, will update the bot's description in the given language.
+     * If left empty, will change the fallback description.
+     */
+    langCode?: string;
+    /** New bot name */
+    name?: string;
+    /** New bio text (displayed in the profile) */
+    bio?: string;
+    /** New description text (displayed when the chat is empty) */
+    description?: string;
+}): Promise<void>;

package/highlevel/methods/bots/set-bot-menu-button.d.cts

@@ -0,0 +1,7 @@
+import { tl } from '@mtcute/tl';
+import { ITelegramClient } from '../../client.types.js';
+import { InputPeerLike } from '../../types/index.js';
+/**
+ * Sets a menu button for the given user.
+ */
+export declare function setBotMenuButton(client: ITelegramClient, user: InputPeerLike, button: tl.TypeBotMenuButton): Promise<void>;

package/highlevel/methods/bots/set-game-score.d.cts

@@ -0,0 +1,54 @@
+import { tl } from '@mtcute/tl';
+import { ITelegramClient } from '../../client.types.js';
+import { InputMessageId, InputPeerLike, Message } from '../../types/index.js';
+/**
+ * Set a score of a user in a game
+ *
+ * @param params
+ * @returns  The modified message
+ */
+export declare function setGameScore(client: ITelegramClient, params: InputMessageId & {
+    /** ID of the user who has scored */
+    userId: InputPeerLike;
+    /** The new score (must be >0) */
+    score: number;
+    /**
+     * When `true`, the game message will not be modified
+     * to include the new score
+     */
+    noEdit?: boolean;
+    /**
+     * Whether to allow user's score to decrease.
+     * This can be useful when fixing mistakes or banning cheaters
+     */
+    force?: boolean;
+    /**
+     * Whether to dispatch the edit message event
+     * to the client's update handler.
+     */
+    shouldDispatch?: true;
+}): Promise<Message>;
+/**
+ * Set a score of a user in a game contained in
+ * an inline message
+ *
+ * @param params
+ */
+export declare function setInlineGameScore(client: ITelegramClient, params: {
+    /** ID of the inline message */
+    messageId: string | tl.TypeInputBotInlineMessageID;
+    /** ID of the user who has scored */
+    userId: InputPeerLike;
+    /** The new score (must be >0) */
+    score: number;
+    /**
+     * When `true`, the game message will not be modified
+     * to include the new score
+     */
+    noEdit?: boolean;
+    /**
+     * Whether to allow user's score to decrease.
+     * This can be useful when fixing mistakes or banning cheaters
+     */
+    force?: boolean;
+}): Promise<void>;

package/highlevel/methods/bots/set-my-commands.d.cts

@@ -0,0 +1,26 @@
+import { tl } from '@mtcute/tl';
+import { ITelegramClient } from '../../client.types.js';
+import { BotCommands } from '../../types/index.js';
+/**
+ * Set or delete commands for the current bot and the given scope
+ *
+ * Learn more about scopes in the [Bot API docs](https://core.telegram.org/bots/api#botcommandscope)
+ */
+export declare function setMyCommands(client: ITelegramClient, params: {
+    /**
+     * New list of bot commands for the given scope.
+     *
+     * Pass empty array or `null` to delete them.
+     */
+    commands: tl.RawBotCommand[] | null;
+    /**
+     * Scope of the commands.
+     *
+     * @default  `BotScope.default_` (i.e. `botCommandScopeDefault`)
+     */
+    scope?: tl.TypeBotCommandScope | BotCommands.IntermediateScope;
+    /**
+     * User language applied to the scope.
+     */
+    langCode?: string;
+}): Promise<void>;

package/highlevel/methods/bots/set-my-default-rights.d.cts

@@ -0,0 +1,11 @@
+import { tl } from '@mtcute/tl';
+import { ITelegramClient } from '../../client.types.js';
+/**
+ * Sets the default chat permissions for the bot in the supergroup or channel.
+ */
+export declare function setMyDefaultRights(client: ITelegramClient, params: {
+    /** Whether to target groups or channels. */
+    target: 'channel' | 'group';
+    /** The default chat permissions. */
+    rights: Omit<tl.RawChatAdminRights, '_'>;
+}): Promise<void>;

package/highlevel/methods/bots/toggle-emoji-status-permission.d.cts

@@ -0,0 +1,11 @@
+import { ITelegramClient } from '../../client.types.js';
+import { InputPeerLike } from '../../types/index.js';
+/**
+ * Give or revoke permission for a bot to update emoji status for your account
+ */
+export declare function toggleEmojiStatusPermission(client: ITelegramClient, params: {
+    /** Bot to which the permission should be granted/revoked */
+    userId: InputPeerLike;
+    /** Whether to grant or revoke permission */
+    allow: boolean;
+}): Promise<void>;

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

@@ -0,0 +1,20 @@
+import { tl } from '@mtcute/tl';
+import { MaybeArray } from '../../../types/utils.js';
+import { ITelegramClient } from '../../client.types.js';
+import { InputPeerLike } from '../../types/index.js';
+/**
+ * Add one or more new members to a group, supergroup or channel.
+ *
+ * @param chatId  ID of the chat or its username
+ * @param users ID(s) of the user(s) to add
+ * @returns  List of users that were failed to be invited (may be empty)
+ */
+export declare function addChatMembers(client: ITelegramClient, chatId: InputPeerLike, users: MaybeArray<InputPeerLike>, params: {
+    /**
+     * Number of old messages to be forwarded (0-100).
+     * Only applicable to legacy groups, ignored for supergroups and channels
+     *
+     * @default 100
+     */
+    forwardCount?: number;
+}): Promise<tl.RawMissingInvitee[]>;

package/highlevel/methods/chats/archive-chats.d.cts

@@ -0,0 +1,9 @@
+import { MaybeArray } from '../../../types/utils.js';
+import { ITelegramClient } from '../../client.types.js';
+import { InputPeerLike } from '../../types/index.js';
+/**
+ * Archive one or more chats
+ *
+ * @param chats  Chat ID(s), username(s), phone number(s), `"me"` or `"self"`
+ */
+export declare function archiveChats(client: ITelegramClient, chats: MaybeArray<InputPeerLike>): Promise<void>;

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

@@ -0,0 +1,24 @@
+import { ITelegramClient } from '../../client.types.js';
+import { InputPeerLike, Message } from '../../types/index.js';
+/**
+ * Ban a user/channel from a legacy group, a supergroup or a channel.
+ * They will not be able to re-join the group on their own,
+ * manual administrator's action will be required.
+ *
+ * When banning a channel, the user won't be able to use
+ * any of their channels to post until the ban is lifted.
+ *
+ * @returns  Service message about removed user, if one was generated.
+ */
+export declare function banChatMember(client: ITelegramClient, params: {
+    /** Chat ID */
+    chatId: InputPeerLike;
+    /** ID of the user/channel to ban */
+    participantId: InputPeerLike;
+    untilDate?: number | Date;
+    /**
+     * Whether to dispatch the returned service message (if any)
+     * to the client's update handler.
+     */
+    shouldDispatch?: true;
+}): Promise<Message | null>;

package/highlevel/methods/chats/batched-queries.d.cts

@@ -0,0 +1,11 @@
+import { ITelegramClient } from '../../client.types.js';
+import { BatchedQuery } from '../../utils/query-batcher.js';
+import { tl } from '@mtcute/tl';
+/** @internal */
+export declare const _getUsersBatched: BatchedQuery<tl.TypeInputUser, tl.TypeUser>;
+/** @internal */
+export declare const _getChatsBatched: BatchedQuery<number, tl.RawChat>;
+/** @internal */
+export declare const _getChannelsBatched: BatchedQuery<tl.TypeInputChannel, tl.RawChannel | tl.RawChannelForbidden>;
+/** @internal */
+export declare function _getRawPeerBatched(client: ITelegramClient, peer: tl.TypeInputPeer): Promise<tl.TypeUser | tl.TypeChat | null>;

package/highlevel/methods/chats/create-channel.d.cts

@@ -0,0 +1,17 @@
+import { ITelegramClient } from '../../client.types.js';
+import { Chat } from '../../types/index.js';
+/**
+ * Create a new broadcast channel
+ *
+ * @returns  Newly created channel
+ */
+export declare function createChannel(client: ITelegramClient, params: {
+    /**
+     * Channel title
+     */
+    title: string;
+    /**
+     * Channel description
+     */
+    description?: string;
+}): Promise<Chat>;

package/highlevel/methods/chats/create-group.d.cts

@@ -0,0 +1,33 @@
+import { tl } from '@mtcute/tl';
+import { MaybeArray } from '../../../types/utils.js';
+import { ITelegramClient } from '../../client.types.js';
+import { InputPeerLike, Chat } from '../../types/index.js';
+export interface CreateGroupResult {
+    /** Chat that was created */
+    chat: Chat;
+    /** Users that were failed to be invited */
+    missing: tl.RawMissingInvitee[];
+}
+/**
+ * Create a legacy group chat
+ *
+ * If you want to create a supergroup, use {@link createSupergroup}
+ * instead.
+ */
+export declare function createGroup(client: ITelegramClient, params: {
+    /**
+     * Group title
+     */
+    title: string;
+    /**
+     * User(s) to be invited in the group (ID(s), username(s) or phone number(s)).
+     * Due to Telegram limitations, you can't create a legacy group with just yourself.
+     */
+    users: MaybeArray<InputPeerLike>;
+    /**
+     * TTL period (in seconds) for the newly created chat
+     *
+     * @default 0 (i.e. messages don't expire)
+     */
+    ttlPeriod?: number;
+}): Promise<CreateGroupResult>;

package/highlevel/methods/chats/create-supergroup.d.cts

@@ -0,0 +1,27 @@
+import { ITelegramClient } from '../../client.types.js';
+import { Chat } from '../../types/index.js';
+/**
+ * Create a new supergroup
+ *
+ * @returns  Newly created supergroup
+ */
+export declare function createSupergroup(client: ITelegramClient, params: {
+    /**
+     * Supergroup title
+     */
+    title: string;
+    /**
+     * Supergroup description
+     */
+    description?: string;
+    /**
+     * Whether to create a forum
+     */
+    forum?: boolean;
+    /**
+     * TTL period (in seconds) for the newly created supergroup
+     *
+     * @default 0 (i.e. messages don't expire)
+     */
+    ttlPeriod?: number;
+}): Promise<Chat>;

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

@@ -0,0 +1,8 @@
+import { ITelegramClient } from '../../client.types.js';
+import { InputPeerLike } from '../../types/index.js';
+/**
+ * Delete a channel or a supergroup
+ *
+ * @param chatId  Chat ID or username
+ */
+export declare function deleteChannel(client: ITelegramClient, chatId: InputPeerLike): Promise<void>;

package/highlevel/methods/chats/delete-chat-photo.d.cts

@@ -0,0 +1,10 @@
+import { ITelegramClient } from '../../client.types.js';
+import { InputPeerLike } from '../../types/index.js';
+/**
+ * Delete a chat photo
+ *
+ * You must be an administrator and have the appropriate permissions.
+ *
+ * @param chatId  Chat ID or username
+ */
+export declare function deleteChatPhoto(client: ITelegramClient, chatId: InputPeerLike): Promise<void>;

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

@@ -0,0 +1,8 @@
+import { ITelegramClient } from '../../client.types.js';
+import { InputPeerLike } from '../../types/index.js';
+/**
+ * Delete a legacy group chat for all members
+ *
+ * @param chatId  Chat ID
+ */
+export declare function deleteGroup(client: ITelegramClient, chatId: InputPeerLike): Promise<void>;

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-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/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/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-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-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>>;