@mtcute/core 0.16.7 → 0.16.10

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

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

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

@@ -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.ts

@@ -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.ts

@@ -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.ts

@@ -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.ts

@@ -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/chats/add-chat-members.d.ts

@@ -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.ts

@@ -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.ts

@@ -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.ts

@@ -0,0 +1,11 @@
+import { tl } from '@mtcute/tl';
+import { ITelegramClient } from '../../client.types.js';
+import { BatchedQuery } from '../../utils/query-batcher.js';
+/** @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.ts

@@ -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.ts

@@ -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.ts

@@ -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.ts

@@ -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.ts

@@ -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.ts

@@ -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.ts

@@ -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.ts

@@ -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.ts

@@ -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.ts

@@ -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.ts

@@ -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.ts

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

package/highlevel/methods/chats/get-chat-preview.d.ts

@@ -0,0 +1,12 @@
+import { ITelegramClient } from '../../client.types.js';
+import { ChatPreview } from '../../types/index.js';
+/**
+ * Get preview information about a private chat.
+ *
+ * @param inviteLink  Invite link
+ * @throws MtArgumentError  In case invite link has invalid format
+ * @throws MtPeerNotFoundError
+ *   In case you are trying to get info about private chat that you have already joined.
+ *   Use {@link getChat} or {@link getFullChat} instead.
+ */
+export declare function getChatPreview(client: ITelegramClient, inviteLink: string): Promise<ChatPreview>;

package/highlevel/methods/chats/get-chat.d.ts

@@ -0,0 +1,11 @@
+import { ITelegramClient } from '../../client.types.js';
+import { InputPeerLike, Chat } from '../../types/index.js';
+/**
+ * Get basic information about a chat.
+ *
+ * @param chatId  ID of the chat, its username or invite link
+ * @throws MtArgumentError
+ *   In case you are trying to get info about private chat that you haven't joined.
+ *   Use {@link getChatPreview} instead.
+ */
+export declare function getChat(client: ITelegramClient, chatId: InputPeerLike): Promise<Chat>;

package/highlevel/methods/chats/get-full-chat.d.ts

@@ -0,0 +1,11 @@
+import { ITelegramClient } from '../../client.types.js';
+import { InputPeerLike, FullChat } from '../../types/index.js';
+/**
+ * Get full information about a chat.
+ *
+ * @param chatId  ID of the chat, its username or invite link
+ * @throws MtArgumentError
+ *   In case you are trying to get info about private chat that you haven't joined.
+ *   Use {@link getChatPreview} instead.
+ */
+export declare function getFullChat(client: ITelegramClient, chatId: InputPeerLike): Promise<FullChat>;

package/highlevel/methods/chats/get-nearby-chats.d.ts

@@ -0,0 +1,9 @@
+import { ITelegramClient } from '../../client.types.js';
+import { Chat } from '../../types/index.js';
+/**
+ * Get nearby chats
+ *
+ * @param latitude  Latitude of the location
+ * @param longitude  Longitude of the location
+ */
+export declare function getNearbyChats(client: ITelegramClient, latitude: number, longitude: number): Promise<Chat[]>;

package/highlevel/methods/chats/get-similar-channels.d.ts

@@ -0,0 +1,12 @@
+import { ITelegramClient } from '../../client.types.js';
+import { ArrayWithTotal, InputPeerLike, Chat } from '../../types/index.js';
+/**
+ * Get channels that are similar to a given channel
+ *
+ * > **Note**: This method only returns the channels that the current user
+ * > is not subscribed to. For non-premium users, this method will only return
+ * > a few channels (with the total number of similar channels being specified in `.total`)
+ * >
+ * > Returns empty array in case there are no similar channels available.
+ */
+export declare function getSimilarChannels(client: ITelegramClient, channel: InputPeerLike): Promise<ArrayWithTotal<Chat>>;

package/highlevel/methods/chats/iter-chat-event-log.d.ts

@@ -0,0 +1,26 @@
+import { ITelegramClient } from '../../client.types.js';
+import { ChatEvent, InputPeerLike } from '../../types/index.js';
+import { getChatEventLog } from './get-chat-event-log.js';
+/**
+ * Iterate over chat event log.
+ *
+ * Small wrapper over {@link getChatEventLog}
+ *
+ * @param chatId  Chat ID
+ * @param params
+ */
+export declare function iterChatEventLog(client: ITelegramClient, chatId: InputPeerLike, params?: Parameters<typeof getChatEventLog>[2] & {
+    /**
+     * Total number of events to return.
+     *
+     * @default  Infinity
+     */
+    limit?: number;
+    /**
+     * Chunk size, passed as `limit` to {@link getChatEventLog}.
+     * Usually you don't need to touch this.
+     *
+     * @default  100
+     */
+    chunkSize?: number;
+}): AsyncIterableIterator<ChatEvent>;

package/highlevel/methods/chats/iter-chat-members.d.ts

@@ -0,0 +1,22 @@
+import { ITelegramClient } from '../../client.types.js';
+import { ChatMember, InputPeerLike } from '../../types/index.js';
+import { getChatMembers } from './get-chat-members.js';
+/**
+ * Iterate through chat members
+ *
+ * This method is a small wrapper over {@link getChatMembers},
+ * which also handles duplicate entries (i.e. does not yield
+ * the same member twice)
+ *
+ * @param chatId  Chat ID or username
+ * @param params  Additional parameters
+ */
+export declare function iterChatMembers(client: ITelegramClient, chatId: InputPeerLike, params?: Parameters<typeof getChatMembers>[2] & {
+    /**
+     * Chunk size, which will be passed as `limit` parameter
+     * to {@link getChatMembers}. Usually you shouldn't care about this.
+     *
+     * @default  `200`
+     */
+    chunkSize?: number;
+}): AsyncIterableIterator<ChatMember>;

package/highlevel/methods/chats/join-chat.d.ts

@@ -0,0 +1,14 @@
+import { ITelegramClient } from '../../client.types.js';
+import { InputPeerLike, Chat } from '../../types/index.js';
+/**
+ * Join a channel or supergroup
+ *
+ * When using with invite links, this method may throw RPC error
+ * `INVITE_REQUEST_SENT`, which means that you need to wait for admin approval.
+ * You will get into the chat once they do so.
+ *
+ * @param chatId
+ *   Chat identifier. Either an invite link (`t.me/joinchat/*`), a username (`@username`)
+ *   or ID of the linked supergroup or channel.
+ */
+export declare function joinChat(client: ITelegramClient, chatId: InputPeerLike): Promise<Chat>;

package/highlevel/methods/chats/kick-chat-member.d.ts

@@ -0,0 +1,15 @@
+import { ITelegramClient } from '../../client.types.js';
+import { InputPeerLike, Message } from '../../types/index.js';
+/**
+ * Kick a user from a chat.
+ *
+ * This effectively bans a user and immediately unbans them.
+ *
+ *  @returns  Service message about removed user, if one was generated.
+ */
+export declare function kickChatMember(client: ITelegramClient, params: {
+    /** Chat ID */
+    chatId: InputPeerLike;
+    /** User ID */
+    userId: InputPeerLike;
+}): Promise<Message | null>;