@mtcute/core 0.18.0-rc.5 → 0.18.0

package/highlevel/methods/messages/get-discussion-message.d.cts

@@ -0,0 +1,21 @@
+import { tl } from '@mtcute/tl';
+import { ITelegramClient } from '../../client.types.js';
+import { InputMessageId, Message } from '../../types/messages/index.js';
+import { InputPeerLike } from '../../types/peers/index.js';
+/** @internal */
+export declare function _getDiscussionMessage(client: ITelegramClient, peer: InputPeerLike, message: number): Promise<[tl.TypeInputPeer, number]>;
+/**
+ * Get discussion message for some channel post.
+ *
+ * Returns `null` if the post does not have a discussion
+ * message.
+ *
+ * This method might throw `FLOOD_WAIT_X` error in case
+ * the discussion message was not *yet* created. Error
+ * is usually handled by the client, but if you disabled that,
+ * you'll need to handle it manually.
+ *
+ * @param peer  Channel where the post was found
+ * @param message  ID of the channel post
+ */
+export declare function getDiscussionMessage(client: ITelegramClient, params: InputMessageId): Promise<Message | null>;

package/highlevel/methods/messages/get-fact-check.d.cts

@@ -0,0 +1,11 @@
+import { MaybeArray } from '../../../types/utils.js';
+import { ITelegramClient } from '../../client.types.js';
+import { InputPeerLike } from '../../types/index.js';
+import { FactCheck } from '../../types/messages/fact-check.js';
+/**
+ * Get fact check information for one or more messages in a chat
+ *
+ * @param chatId  Chat where the messages are located
+ * @param msgIds  One or more message IDs
+ */
+export declare function getFactCheck(client: ITelegramClient, chatId: InputPeerLike, msgIds: MaybeArray<number>): Promise<(FactCheck | null)[]>;

package/highlevel/methods/messages/get-history.d.cts

@@ -0,0 +1,59 @@
+import { ITelegramClient } from '../../client.types.js';
+import { ArrayPaginated, InputPeerLike, Message } from '../../types/index.js';
+export interface GetHistoryOffset {
+    id: number;
+    date: number;
+}
+/**
+ * Get chat history.
+ *
+ * @param chatId  Chat's marked ID, its username, phone or `"me"` or `"self"`.
+ * @param params  Additional fetch parameters
+ */
+export declare function getHistory(client: ITelegramClient, chatId: InputPeerLike, params?: {
+    /**
+     * Limits the number of messages to be retrieved.
+     *
+     * @default  100
+     */
+    limit?: number;
+    /**
+     * Offset for pagination
+     */
+    offset?: GetHistoryOffset;
+    /**
+     * Additional offset from {@link offset}, in resulting messages.
+     *
+     * This can be used for advanced use cases, like:
+     * - Loading 20 messages newer than message with ID `MSGID`:
+     *   `offset = MSGID, addOffset = -20, limit = 20`
+     * - Loading 20 messages around message with ID `MSGID`:
+     *   `offset = MSGID, addOffset = -10, limit = 20`
+     *
+     * @default  `0` (disabled)
+     */
+    addOffset?: number;
+    /**
+     * Minimum message ID to return
+     *
+     * @default  `0` (disabled).
+     */
+    minId?: number;
+    /**
+     * Maximum message ID to return.
+     *
+     * @default  `0` (disabled).
+     */
+    maxId?: number;
+    /**
+     * Whether to retrieve messages in reversed order (from older to recent),
+     * starting from {@link offset} (inclusive).
+     *
+     * > **Note**: Using `reverse=true` requires you to pass offset from which to start
+     * > fetching the messages "downwards". If you call `getHistory` with `reverse=true`
+     * > and without any offset, it will return an empty array.
+     *
+     * @default false
+     */
+    reverse?: boolean;
+}): Promise<ArrayPaginated<Message, GetHistoryOffset>>;

package/highlevel/methods/messages/get-message-by-link.d.cts

@@ -0,0 +1,6 @@
+import { ITelegramClient } from '../../client.types.js';
+import { Message } from '../../types/messages/index.js';
+/**
+ * Given a message link (e.g. `t.me/durov/1`), fetch the relevant message.
+ */
+export declare function getMessageByLink(client: ITelegramClient, link: string): Promise<Message | null>;

package/highlevel/methods/messages/get-message-group.d.cts

@@ -0,0 +1,9 @@
+import { ITelegramClient } from '../../client.types.js';
+import { InputMessageId, Message } from '../../types/index.js';
+/**
+ * Get all messages inside of a message group
+ *
+ * @param chatId  Chat ID
+ * @param message  ID of one of the messages in the group
+ */
+export declare function getMessageGroup(client: ITelegramClient, params: InputMessageId): Promise<Message[]>;

package/highlevel/methods/messages/get-message-reactions.d.cts

@@ -0,0 +1,28 @@
+import { ITelegramClient } from '../../client.types.js';
+import { InputPeerLike, Message, MessageReactions } from '../../types/index.js';
+/**
+ * Get reactions to messages by their IDs.
+ *
+ * > Apps should short-poll reactions for visible messages
+ * > (that weren't sent by the user) once every 15-30 seconds,
+ * > but only if `message.reactions` is set
+ *
+ * @param chatId  ID of the chat with messages
+ * @param messages  Message IDs
+ * @returns  Reactions to corresponding messages, or `null` if there are none
+ */
+export declare function getMessageReactionsById(client: ITelegramClient, chatId: InputPeerLike, messages: number[]): Promise<(MessageReactions | null)[]>;
+/**
+ * Get reactions to {@link Message}s.
+ *
+ * > **Note**: messages must all be from the same chat.
+ *
+ * > Apps should short-poll reactions for visible messages
+ * > (that weren't sent by the user) once every 15-30 seconds,
+ * > but only if `message.reactions` is set
+ *
+ * @param chatId  ID of the chat with messages
+ * @param messages  Message IDs
+ * @returns  Reactions to corresponding messages, or `null` if there are none
+ */
+export declare function getMessageReactions(client: ITelegramClient, messages: Message[]): Promise<(MessageReactions | null)[]>;

package/highlevel/methods/messages/get-messages-unsafe.d.cts

@@ -0,0 +1,19 @@
+import { MaybeArray } from '../../../types/utils.js';
+import { ITelegramClient } from '../../client.types.js';
+import { Message } from '../../types/index.js';
+/**
+ * Get messages from PM or legacy group by their IDs.
+ * For channels, use {@link getMessages}.
+ *
+ * Unlike {@link getMessages}, this method does not
+ * check if the message belongs to some chat.
+ *
+ * Fot messages that were not found, `null` will be
+ * returned at that position.
+ *
+ * @param messageIds  Messages IDs
+ * @param [fromReply]
+ *     Whether the reply to a given message should be fetched
+ *     (i.e. `getMessages(msg.chat.id, msg.id, true).id === msg.replyToMessageId`)
+ */
+export declare function getMessagesUnsafe(client: ITelegramClient, messageIds: MaybeArray<number>, fromReply?: boolean): Promise<(Message | null)[]>;

package/highlevel/methods/messages/get-messages.d.cts

@@ -0,0 +1,17 @@
+import { MaybeArray } from '../../../types/utils.js';
+import { ITelegramClient } from '../../client.types.js';
+import { InputPeerLike } from '../../types/peers/index.js';
+import { Message } from '../../types/messages/index.js';
+/**
+ * Get messages in chat by their IDs
+ *
+ * Fot messages that were not found, `null` will be
+ * returned at that position.
+ *
+ * @param chatId  Chat's marked ID, its username, phone or `"me"` or `"self"`
+ * @param messageIds  Messages IDs
+ * @param [fromReply]
+ *     Whether the reply to a given message should be fetched
+ *     (i.e. `getMessages(msg.chat.id, msg.id, true).id === msg.replyToMessageId`)
+ */
+export declare function getMessages(client: ITelegramClient, chatId: InputPeerLike, messageIds: MaybeArray<number>, fromReply?: boolean): Promise<(Message | null)[]>;

package/highlevel/methods/messages/get-reaction-users.d.cts

@@ -0,0 +1,24 @@
+import { ITelegramClient } from '../../client.types.js';
+import { ArrayPaginated, InputMessageId, InputReaction, PeerReaction } from '../../types/index.js';
+export type GetReactionUsersOffset = string;
+/**
+ * Get users who have reacted to the message.
+ *
+ * @param params
+ */
+export declare function getReactionUsers(client: ITelegramClient, params: InputMessageId & {
+    /**
+     * Get only reactions with the specified emoji
+     */
+    emoji?: InputReaction;
+    /**
+     * Limit the number of users returned.
+     *
+     * @default  100
+     */
+    limit?: number;
+    /**
+     * Offset for pagination
+     */
+    offset?: GetReactionUsersOffset;
+}): Promise<ArrayPaginated<PeerReaction, GetReactionUsersOffset>>;

package/highlevel/methods/messages/get-reply-to.d.cts

@@ -0,0 +1,10 @@
+import { ITelegramClient } from '../../client.types.js';
+import { Message } from '../../types/messages/index.js';
+/**
+ * For messages containing a reply, fetch the message that is being replied.
+ *
+ * Note that even if a message has {@link replyToMessage},
+ * the message itself may have been deleted, in which case
+ * this method will also return `null`.
+ */
+export declare function getReplyTo(client: ITelegramClient, message: Message): Promise<Message | null>;

package/highlevel/methods/messages/get-scheduled-messages.d.cts

@@ -0,0 +1,13 @@
+import { MaybeArray } from '../../../types/utils.js';
+import { ITelegramClient } from '../../client.types.js';
+import { InputPeerLike, Message } from '../../types/index.js';
+/**
+ * Get scheduled messages in chat by their IDs
+ *
+ * Fot messages that were not found, `null` will be
+ * returned at that position.
+ *
+ * @param chatId  Chat's marked ID, its username, phone or `"me"` or `"self"`
+ * @param messageIds  Scheduled messages IDs
+ */
+export declare function getScheduledMessages(client: ITelegramClient, chatId: InputPeerLike, messageIds: MaybeArray<number>): Promise<(Message | null)[]>;

package/highlevel/methods/messages/iter-history.d.cts

@@ -0,0 +1,23 @@
+import { ITelegramClient } from '../../client.types.js';
+import { InputPeerLike, Message } from '../../types/index.js';
+import { getHistory } from './get-history.js';
+/**
+ * Iterate over chat history. Wrapper over {@link getHistory}
+ *
+ * @param chatId  Chat's marked ID, its username, phone or `"me"` or `"self"`.
+ * @param params  Additional fetch parameters
+ */
+export declare function iterHistory(client: ITelegramClient, chatId: InputPeerLike, params?: Parameters<typeof getHistory>[2] & {
+    /**
+     * Limits the number of messages to be retrieved.
+     *
+     * @default  Infinity, i.e. all messages
+     */
+    limit?: number;
+    /**
+     * Chunk size. Usually you shouldn't care about this.
+     *
+     * @default  100
+     */
+    chunkSize?: number;
+}): AsyncIterableIterator<Message>;

package/highlevel/methods/messages/iter-reaction-users.d.cts

@@ -0,0 +1,26 @@
+import { ITelegramClient } from '../../client.types.js';
+import { PeerReaction } from '../../types/index.js';
+import { getReactionUsers } from './get-reaction-users.js';
+/**
+ * Iterate over users who have reacted to the message.
+ *
+ * Wrapper over {@link getReactionUsers}.
+ *
+ * @param chatId  Chat ID
+ * @param messageId  Message ID
+ * @param params
+ */
+export declare function iterReactionUsers(client: ITelegramClient, params: Parameters<typeof getReactionUsers>[1] & {
+    /**
+     * Limit the number of events returned.
+     *
+     * @default  `Infinity`, i.e. all events are returned
+     */
+    limit?: number;
+    /**
+     * Chunk size, usually not needed.
+     *
+     * @default  100
+     */
+    chunkSize?: number;
+}): AsyncIterableIterator<PeerReaction>;

package/highlevel/methods/messages/iter-search-global.d.cts

@@ -0,0 +1,27 @@
+import { ITelegramClient } from '../../client.types.js';
+import { Message } from '../../types/index.js';
+import { searchGlobal } from './search-global.js';
+/**
+ * Search for messages globally from all of your chats.
+ *
+ * Iterable version of {@link searchGlobal}
+ *
+ * **Note**: Due to Telegram limitations, you can only get up to ~10000 messages
+ *
+ * @param params  Search parameters
+ */
+export declare function iterSearchGlobal(client: ITelegramClient, params?: Parameters<typeof searchGlobal>[1] & {
+    /**
+     * Limits the number of messages to be retrieved.
+     *
+     * @default  `Infinity`, i.e. all messages are returned
+     */
+    limit?: number;
+    /**
+     * Chunk size, which will be passed as `limit` parameter
+     * for `messages.search`. Usually you shouldn't care about this.
+     *
+     * @default  100
+     */
+    chunkSize?: number;
+}): AsyncIterableIterator<Message>;

package/highlevel/methods/messages/iter-search-messages.d.cts

@@ -0,0 +1,26 @@
+import { ITelegramClient } from '../../client.types.js';
+import { Message } from '../../types/index.js';
+import { searchMessages } from './search-messages.js';
+/**
+ * Search for messages inside a specific chat
+ *
+ * Iterable version of {@link searchMessages}
+ *
+ * @param chatId  Chat's marked ID, its username, phone or `"me"` or `"self"`.
+ * @param params  Additional search parameters
+ */
+export declare function iterSearchMessages(client: ITelegramClient, params?: Parameters<typeof searchMessages>[1] & {
+    /**
+     * Limits the number of messages to be retrieved.
+     *
+     * @default  `Infinity`, i.e. all messages are returned
+     */
+    limit?: number;
+    /**
+     * Chunk size, which will be passed as `limit` parameter
+     * for `messages.search`. Usually you shouldn't care about this.
+     *
+     * @default  `100`
+     */
+    chunkSize?: number;
+}): AsyncIterableIterator<Message>;

package/highlevel/methods/messages/pin-message.d.cts

@@ -0,0 +1,21 @@
+import { ITelegramClient } from '../../client.types.js';
+import { InputMessageId, Message } from '../../types/index.js';
+/**
+ * Pin a message in a group, supergroup, channel or PM.
+ *
+ * For supergroups/channels, you must have appropriate permissions,
+ * either as an admin, or as default permissions
+ *
+ * @returns  Service message about pinned message, if one was generated.
+ */
+export declare function pinMessage(client: ITelegramClient, params: InputMessageId & {
+    /** Whether to send a notification (only for legacy groups and supergroups) */
+    notify?: boolean;
+    /** Whether to pin for both sides (only for private chats) */
+    bothSides?: boolean;
+    /**
+     * Whether to dispatch the returned service message (if any)
+     * to the client's update handler.
+     */
+    shouldDispatch?: true;
+}): Promise<Message | null>;

package/highlevel/methods/messages/read-history.d.cts

@@ -0,0 +1,24 @@
+import { ITelegramClient } from '../../client.types.js';
+import { InputPeerLike } from '../../types/index.js';
+/**
+ * Mark chat history as read.
+ *
+ * @param chatId  Chat ID
+ */
+export declare function readHistory(client: ITelegramClient, chatId: InputPeerLike, params?: {
+    /**
+     * Message up until which to read history
+     *
+     * @default  0, i.e. read everything
+     */
+    maxId?: number;
+    /**
+     * Whether to also clear all mentions in the chat
+     */
+    clearMentions?: boolean;
+    /**
+     * Whether to dispatch updates that will be generated by this call.
+     * Doesn't follow `disableNoDispatch`
+     */
+    shouldDispatch?: true;
+}): Promise<void>;

package/highlevel/methods/messages/read-reactions.d.cts

@@ -0,0 +1,14 @@
+import { ITelegramClient } from '../../client.types.js';
+import { InputPeerLike } from '../../types/index.js';
+/**
+ * Mark all reactions in chat as read.
+ *
+ * @param chatId  Chat ID
+ */
+export declare function readReactions(client: ITelegramClient, chatId: InputPeerLike, params?: {
+    /**
+     * Whether to dispatch updates that will be generated by this call.
+     * Doesn't follow `disableNoDispatch`
+     */
+    shouldDispatch?: true;
+}): Promise<void>;

package/highlevel/methods/messages/search-global.d.cts

@@ -0,0 +1,51 @@
+import { tl } from '@mtcute/tl';
+import { ITelegramClient } from '../../client.types.js';
+import { ArrayPaginated, Message } from '../../types/index.js';
+export interface SearchGlobalOffset {
+    rate: number;
+    peer: tl.TypeInputPeer;
+    id: number;
+}
+/**
+ * Search for messages globally from all of your chats
+ *
+ * **Note**: Due to Telegram limitations, you can only get up to ~10000 messages
+ *
+ * @param params  Search parameters
+ */
+export declare function searchGlobal(client: ITelegramClient, params?: {
+    /**
+     * Text query string. Use `"@"` to search for mentions.
+     *
+     * @default `""` (empty string)
+     */
+    query?: string;
+    /**
+     * Limits the number of messages to be retrieved.
+     *
+     * @default  100
+     */
+    limit?: number;
+    /**
+     * Filter the results using some filter. (see {@link SearchFilters})
+     *
+     * @default  {@link SearchFilters.Empty} (i.e. will return all messages)
+     */
+    filter?: tl.TypeMessagesFilter;
+    /**
+     * Offset data used for pagination
+     */
+    offset?: SearchGlobalOffset;
+    /**
+     * Only return messages newer than this date
+     */
+    minDate?: Date | number;
+    /**
+     * Only return messages older than this date
+     */
+    maxDate?: Date | number;
+    /**
+     * Whether to only search across broadcast channels
+     */
+    onlyChannels?: boolean;
+}): Promise<ArrayPaginated<Message, SearchGlobalOffset>>;

package/highlevel/methods/messages/search-hashtag.d.cts

@@ -0,0 +1,44 @@
+import { tl } from '@mtcute/tl';
+import { ITelegramClient } from '../../client.types.js';
+import { ArrayPaginated } from '../../types/utils.js';
+import { Message } from '../../types/index.js';
+export interface SearchHashtagOffset {
+    rate: number;
+    peer: tl.TypeInputPeer;
+    id: number;
+}
+/**
+ * Perform a global hashtag search, across the entire Telegram
+ *
+ * @param hashtag  Hashtag to search for
+ * @param params  Additional parameters
+ */
+export declare function searchHashtag(client: ITelegramClient, hashtag: string, params?: {
+    /** Offset for the search */
+    offset?: SearchHashtagOffset;
+    /** Limit the number of results */
+    limit?: number;
+}): Promise<ArrayPaginated<Message, SearchHashtagOffset>>;
+/**
+ * Perform a global hashtag search, across the entire Telegram
+ *
+ * Iterable version of {@link searchHashtag}
+ *
+ * @param hashtag  Hashtag to search for
+ * @param params  Additional parameters
+ */
+export declare function iterSearchHashtag(client: ITelegramClient, hashtag: string, params?: Parameters<typeof searchHashtag>[2] & {
+    /**
+     * Limits the number of messages to be retrieved.
+     *
+     * @default  `Infinity`, i.e. all messages are returned
+     */
+    limit?: number;
+    /**
+     * Chunk size, which will be passed as `limit` parameter
+     * for `messages.search`. Usually you shouldn't care about this.
+     *
+     * @default  100
+     */
+    chunkSize?: number;
+}): AsyncIterableIterator<Message>;

package/highlevel/methods/messages/search-messages.d.cts

@@ -0,0 +1,93 @@
+import { tl } from '@mtcute/tl';
+import { ITelegramClient } from '../../client.types.js';
+import { ArrayPaginated, InputPeerLike, Message } from '../../types/index.js';
+export type SearchMessagesOffset = number;
+/**
+ * Search for messages inside a specific chat
+ *
+ * @param chatId  Chat's marked ID, its username, phone or `"me"` or `"self"`.
+ * @param params  Additional search parameters
+ */
+export declare function searchMessages(client: ITelegramClient, params?: {
+    /**
+     * Text query string. Required for text-only messages,
+     * optional for media.
+     *
+     * @default  `""` (empty string)
+     */
+    query?: string;
+    /**
+     * Chat where to search for messages.
+     *
+     * When empty, will search across common message box (i.e. private messages and legacy chats)
+     */
+    chatId?: InputPeerLike;
+    /**
+     * Offset ID for the search. Only messages earlier than this ID will be returned.
+     *
+     * @default  `0` (starting from the latest message).
+     */
+    offset?: SearchMessagesOffset;
+    /**
+     * Additional offset from {@link offset}, in resulting messages.
+     *
+     * This can be used for advanced use cases, like:
+     * - Loading 20 results newer than message with ID `MSGID`:
+     *   `offset = MSGID, addOffset = -20, limit = 20`
+     * - Loading 20 results around message with ID `MSGID`:
+     *   `offset = MSGID, addOffset = -10, limit = 20`
+     *
+     * When {@link offset} is not set, this will be relative to the last message
+     *
+     * @default  `0` (disabled)
+     */
+    addOffset?: number;
+    /**
+     * Minimum message ID to return
+     *
+     * @default  `0` (disabled).
+     */
+    minId?: number;
+    /**
+     * Maximum message ID to return.
+     *
+     * Unless {@link addOffset} is used, this will work the same as {@link offset}.
+     *
+     * @default  `0` (disabled).
+     */
+    maxId?: number;
+    /**
+     * Minimum message date to return
+     *
+     * @default  `0` (disabled).
+     */
+    minDate?: number | Date;
+    /**
+     * Maximum message date to return
+     *
+     * @default  `0` (disabled).
+     */
+    maxDate?: number | Date;
+    /**
+     * Thread ID to return only messages from this thread.
+     */
+    threadId?: number;
+    /**
+     * Limits the number of messages to be retrieved.
+     *
+     * @default  100
+     */
+    limit?: number;
+    /**
+     * Filter the results using some filter (see {@link SearchFilters})
+     *
+     * @default  {@link SearchFilters.Empty} (i.e. will return all messages)
+     */
+    filter?: tl.TypeMessagesFilter;
+    /**
+     * Search only for messages sent by a specific user.
+     *
+     * You can pass their marked ID, username, phone or `"me"` or `"self"`
+     */
+    fromUser?: InputPeerLike;
+}): Promise<ArrayPaginated<Message, SearchMessagesOffset>>;

package/highlevel/methods/messages/send-answer.d.cts

@@ -0,0 +1,12 @@
+import { ITelegramClient } from '../../client.types.js';
+import { Message } from '../../types/messages/message.js';
+import { ParametersSkip2 } from '../../types/utils.js';
+import { sendMediaGroup } from './send-media-group.js';
+import { sendMedia } from './send-media.js';
+import { sendText } from './send-text.js';
+/** Send a text to the same chat (and topic, if applicable) as a given message */
+export declare function answerText(client: ITelegramClient, message: Message, ...params: ParametersSkip2<typeof sendText>): ReturnType<typeof sendText>;
+/** Send a media to the same chat (and topic, if applicable) as a given message */
+export declare function answerMedia(client: ITelegramClient, message: Message, ...params: ParametersSkip2<typeof sendMedia>): ReturnType<typeof sendMedia>;
+/** Send a media group to the same chat (and topic, if applicable) as a given message */
+export declare function answerMediaGroup(client: ITelegramClient, message: Message, ...params: ParametersSkip2<typeof sendMediaGroup>): ReturnType<typeof sendMediaGroup>;

package/highlevel/methods/messages/send-comment.d.cts

@@ -0,0 +1,39 @@
+import { ITelegramClient } from '../../client.types.js';
+import { Message } from '../../types/messages/message.js';
+import { ParametersSkip2 } from '../../types/utils.js';
+import { sendMediaGroup } from './send-media-group.js';
+import { sendMedia } from './send-media.js';
+import { sendText } from './send-text.js';
+/**
+ * Send a text comment to a given message.
+ *
+ * If this is a normal message (not a channel post),
+ * a simple reply will be sent.
+ *
+ * @throws MtArgumentError
+ *     If this is a channel post which does not have comments section.
+ *     To check if a post has comments, use {@link Message#replies}.hasComments
+ */
+export declare function commentText(client: ITelegramClient, message: Message, ...params: ParametersSkip2<typeof sendText>): ReturnType<typeof sendText>;
+/**
+ * Send a text comment to a given message.
+ *
+ * If this is a normal message (not a channel post),
+ * a simple reply will be sent.
+ *
+ * @throws MtArgumentError
+ *     If this is a channel post which does not have comments section.
+ *     To check if a post has comments, use {@link Message#replies}.hasComments
+ */
+export declare function commentMedia(client: ITelegramClient, message: Message, ...params: ParametersSkip2<typeof sendMedia>): ReturnType<typeof sendMedia>;
+/**
+ * Send a text comment to a given message.
+ *
+ * If this is a normal message (not a channel post),
+ * a simple reply will be sent.
+ *
+ * @throws MtArgumentError
+ *     If this is a channel post which does not have comments section.
+ *     To check if a post has comments, use {@link Message#replies}.hasComments
+ */
+export declare function commentMediaGroup(client: ITelegramClient, message: Message, ...params: ParametersSkip2<typeof sendMediaGroup>): ReturnType<typeof sendMediaGroup>;