@mtcute/core 0.16.6 → 0.16.9

package/highlevel/client.types.d.ts

@@ -0,0 +1,58 @@
+import { tl } from '@mtcute/tl';
+import { default as Long } from 'long';
+import { ConnectionKind, RpcCallOptions } from '../network/index.js';
+import { MustEqual, PublicPart } from '../types/utils.js';
+import { Logger } from '../utils/logger.js';
+import { AppConfigManager } from './managers/app-config-manager.js';
+import { TelegramStorageManager } from './storage/storage.js';
+import { RawUpdateHandler } from './updates/types.js';
+import { StringSessionData } from './utils/string-session.js';
+/**
+ * Connection state of the client
+ *
+ * - `offline` - not connected (only emitted when {@link ICorePlatform.onNetworkChanged} callback
+ *   is called with `false`)
+ * - `connecting` - currently connecting. All requests will be queued until the connection is established
+ * - `updating` - connected and is currently updating the state (i.e. downloading missing updates).
+ *   At this point client is already fully operational, but some updates may be missing.
+ *   Is only emitted when updates manager is enabled.
+ * - `connected` - connected and ready to send requests. When updates manager is enabled, this state
+ *   may be emitted before `updating` state
+ */
+export type ConnectionState = 'offline' | 'connecting' | 'updating' | 'connected';
+export type ServerUpdateHandler = (update: tl.TypeUpdates) => void;
+export interface ITelegramClient {
+    readonly log: Logger;
+    readonly storage: PublicPart<TelegramStorageManager>;
+    readonly appConfig: PublicPart<AppConfigManager>;
+    readonly stopSignal: AbortSignal;
+    prepare(): Promise<void>;
+    connect(): Promise<void>;
+    close(): Promise<void>;
+    notifyLoggedIn(auth: tl.auth.TypeAuthorization | tl.RawUser): Promise<tl.RawUser>;
+    notifyLoggedOut(): Promise<void>;
+    notifyChannelOpened(channelId: number, pts?: number): Promise<boolean>;
+    notifyChannelClosed(channelId: number): Promise<boolean>;
+    startUpdatesLoop(): Promise<void>;
+    stopUpdatesLoop(): Promise<void>;
+    call<T extends tl.RpcMethod>(message: MustEqual<T, tl.RpcMethod>, params?: RpcCallOptions): Promise<tl.RpcCallReturn[T['_']]>;
+    importSession(session: string | StringSessionData, force?: boolean): Promise<void>;
+    exportSession(): Promise<string>;
+    onError(handler: (err: unknown) => void): void;
+    emitError(err: unknown): void;
+    handleClientUpdate(updates: tl.TypeUpdates, noDispatch?: boolean): void;
+    onServerUpdate(handler: ServerUpdateHandler): void;
+    getServerUpdateHandler(): ServerUpdateHandler;
+    onUpdate(handler: RawUpdateHandler): void;
+    onConnectionState(handler: (state: ConnectionState) => void): void;
+    getApiCrenetials(): Promise<{
+        id: number;
+        hash: string;
+    }>;
+    getPoolSize(kind: ConnectionKind, dcId?: number): Promise<number>;
+    getPrimaryDcId(): Promise<number>;
+    changePrimaryDc(newDc: number): Promise<void>;
+    computeSrpParams(request: tl.account.RawPassword, password: string): Promise<tl.RawInputCheckPasswordSRP>;
+    computeNewPasswordHash(algo: tl.TypePasswordKdfAlgo, password: string): Promise<Uint8Array>;
+    getMtprotoMessageId(): Promise<Long>;
+}

package/highlevel/methods/bots/answer-callback-query.d.ts

@@ -0,0 +1,41 @@
+import { default as Long } from 'long';
+import { ITelegramClient } from '../../client.types.js';
+import { CallbackQuery } from '../../types/updates/callback-query.js';
+/**
+ * Send an answer to a callback query.
+ *
+ * @param queryId  ID of the callback query, or the query itself
+ * @param params  Parameters of the answer
+ */
+export declare function answerCallbackQuery(client: ITelegramClient, queryId: Long | CallbackQuery, params?: {
+    /**
+     * Maximum amount of time in seconds for which
+     * this result can be cached by the client (not server!).
+     *
+     * @default  0
+     */
+    cacheTime?: number;
+    /**
+     * Text of the notification (0-200 chars).
+     *
+     * If not set, nothing will be displayed
+     */
+    text?: string;
+    /**
+     * Whether to show an alert in the middle of the screen
+     * instead of a notification at the top of the screen.
+     *
+     * @default  false
+     */
+    alert?: boolean;
+    /**
+     * URL that the client should open.
+     *
+     * If this was a button containing a game,
+     * you can provide arbitrary link to your game.
+     * Otherwise, you can only use links in the format
+     * `t.me/your_bot?start=...` that open your bot
+     * with a deep-link parameter.
+     */
+    url?: string;
+}): Promise<void>;

package/highlevel/methods/bots/answer-pre-checkout-query.d.ts

@@ -0,0 +1,12 @@
+import { tl } from '@mtcute/tl';
+import { ITelegramClient } from '../../client.types.js';
+import { PreCheckoutQuery } from '../../types/updates/pre-checkout-query.js';
+/**
+ * Answer a pre-checkout query.
+ *
+ * @param queryId  Pre-checkout query ID
+ */
+export declare function answerPreCheckoutQuery(client: ITelegramClient, queryId: tl.Long | PreCheckoutQuery, params?: {
+    /** If pre-checkout is rejected, error message to show to the user */
+    error?: string;
+}): Promise<void>;

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

@@ -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/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-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/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.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-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/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/set-chat-default-permissions.d.ts

@@ -0,0 +1,16 @@
+import { tl } from '@mtcute/tl';
+import { ITelegramClient } from '../../client.types.js';
+import { InputPeerLike, Chat } from '../../types/index.js';
+/**
+ * Change default chat permissions for all members.
+ *
+ * You must be an administrator in the chat and have appropriate permissions.
+ *
+ * @param chatId  Chat ID or username
+ * @param restrictions
+ *     Restrictions for the chat. Note that unlike Bot API, this object contains
+ *     the restrictions, and not the permissions, i.e.
+ *     passing `sendMessages=true` will disallow the users to send messages,
+ *     and passing `{}` (empty object) will lift any restrictions
+ */
+export declare function setChatDefaultPermissions(client: ITelegramClient, chatId: InputPeerLike, restrictions: Omit<tl.RawChatBannedRights, '_' | 'untilDate'>): Promise<Chat>;

package/highlevel/methods/dialogs/iter-dialogs.d.ts

@@ -0,0 +1,103 @@
+import { tl } from '@mtcute/tl';
+import { ITelegramClient } from '../../client.types.js';
+import { InputDialogFolder, Dialog } from '../../types/index.js';
+/**
+ * Iterate over dialogs.
+ *
+ * Note that due to Telegram API limitations,
+ * ordering here can only be anti-chronological
+ * (i.e. newest - first), and draft update date
+ * is not considered when sorting.
+ *
+ * @param params  Fetch parameters
+ */
+export declare function iterDialogs(client: ITelegramClient, params?: {
+    /**
+     * Offset message date used as an anchor for pagination.
+     */
+    offsetDate?: Date | number;
+    /**
+     * Offset message ID used as an anchor for pagination
+     */
+    offsetId?: number;
+    /**
+     * Offset peer used as an anchor for pagination
+     */
+    offsetPeer?: tl.TypeInputPeer;
+    /**
+     * Limits the number of dialogs to be received.
+     *
+     * @default  `Infinity`, i.e. all dialogs are fetched
+     */
+    limit?: number;
+    /**
+     * Chunk size which will be passed to `messages.getDialogs`.
+     * You shouldn't usually care about this.
+     *
+     * @default  100.
+     */
+    chunkSize?: number;
+    /**
+     * How to handle pinned dialogs?
+     *
+     * Whether to `include` them at the start of the list,
+     * `exclude` them at all, or `only` return pinned dialogs.
+     *
+     * Additionally, for folders you can specify
+     * `keep`, which will return pinned dialogs
+     * ordered by date among other non-pinned dialogs.
+     *
+     * > **Note**: When using `include` mode with folders,
+     * > pinned dialogs will only be fetched if all offset
+     * > parameters are unset.
+     *
+     * @default  `include`.
+     */
+    pinned?: 'include' | 'exclude' | 'only' | 'keep';
+    /**
+     * How to handle archived chats?
+     *
+     * Whether to `keep` them among other dialogs,
+     * `exclude` them from the list, or `only`
+     * return archived dialogs
+     *
+     * Ignored for folders, since folders
+     * themselves contain information about archived chats.
+     *
+     * > **Note**: when `pinned=only`, `archived=keep` will act as `only`
+     * > because of Telegram API limitations.
+     *
+     * @default  `exclude`
+     */
+    archived?: 'keep' | 'exclude' | 'only';
+    /**
+     * Folder from which the dialogs will be fetched.
+     *
+     * You can pass folder object, id or title
+     *
+     * Note that passing anything except object will
+     * cause the list of the folders to be fetched,
+     * and passing a title may fetch from
+     * a wrong folder if you have multiple with the same title.
+     *
+     * Also note that fetching dialogs in a folder is
+     * orders of magnitudes* slower than normal because
+     * of Telegram API limitations - we have to fetch all dialogs
+     * and filter the ones we need manually. If possible,
+     * use {@link Dialog.filterFolder} instead.
+     *
+     * When a folder with given ID or title is not found,
+     * {@link MtArgumentError} is thrown
+     *
+     * @default  <empty> (fetches from "All" folder)
+     */
+    folder?: InputDialogFolder;
+    /**
+     * Additional filtering for the dialogs.
+     *
+     * If `folder` is not provided, this filter is used instead.
+     * If `folder` is provided, fields from this object are used
+     * to override filters inside the folder.
+     */
+    filter?: Partial<Omit<tl.RawDialogFilter, '_' | 'id' | 'title'>>;
+}): AsyncIterableIterator<Dialog>;

package/highlevel/methods/files/upload-file.d.ts

@@ -0,0 +1,64 @@
+import { ITelegramClient } from '../../client.types.js';
+import { UploadFileLike, UploadedFile } from '../../types/index.js';
+/**
+ * Upload a file to Telegram servers, without actually
+ * sending a message anywhere. Useful when an `InputFile` is required.
+ *
+ * This method is quite low-level, and you should use other
+ * methods like {@link sendMedia} that handle this under the hood.
+ *
+ * @param params  Upload parameters
+ */
+export declare function uploadFile(client: ITelegramClient, params: {
+    /**
+     * Upload file source.
+     */
+    file: UploadFileLike;
+    /**
+     * File name for the uploaded file. Is usually inferred from path,
+     * but should be provided for files sent as `Buffer` or stream.
+     *
+     * When file name can't be inferred, it falls back to "unnamed"
+     */
+    fileName?: string;
+    /**
+     * Total file size. Automatically inferred for Buffer, File and local files.
+     */
+    fileSize?: number;
+    /**
+     * If the file size is unknown, you can provide an estimate,
+     * which will be used to determine appropriate part size.
+     */
+    estimatedSize?: number;
+    /**
+     * File MIME type. By default is automatically inferred from magic number
+     * If MIME can't be inferred, it defaults to `application/octet-stream`
+     */
+    fileMime?: string;
+    /**
+     * Upload part size (in KB).
+     *
+     * By default, automatically selected by file size.
+     * Must not be bigger than 512 and must not be a fraction.
+     */
+    partSize?: number;
+    /**
+     * Number of parts to be sent in parallel per connection.
+     */
+    requestsPerConnection?: number;
+    /**
+     * Function that will be called after some part has been uploaded.
+     *
+     * @param uploaded  Number of bytes already uploaded
+     * @param total  Total file size, if known
+     */
+    progressCallback?: (uploaded: number, total: number) => void;
+    /**
+     * When using `inputMediaUploadedPhoto` (e.g. when sending an uploaded photo) require
+     * the file size to be known beforehand.
+     *
+     * In case this is set to `true`, a stream is passed as `file` and the file size is unknown,
+     * the stream will be buffered in memory and the file size will be inferred from the buffer.
+     */
+    requireFileSize?: boolean;
+}): Promise<UploadedFile>;

package/highlevel/methods/files/upload-media.d.ts

@@ -0,0 +1,28 @@
+import { ITelegramClient } from '../../client.types.js';
+import { InputMediaLike, InputPeerLike, MessageMedia, RawDocument, Photo } from '../../types/index.js';
+/**
+ * Upload a media to Telegram servers, without actually
+ * sending a message anywhere. Useful when File ID is needed.
+ *
+ * The difference with {@link uploadFile} is that
+ * the returned object will act like a message media
+ * and contain fields like File ID.
+ *
+ * @param media  Media to upload
+ * @param params  Upload parameters
+ */
+export declare function uploadMedia(client: ITelegramClient, media: InputMediaLike, params?: {
+    /**
+     * Peer to associate this media with.
+     *
+     * @default  `self`
+     */
+    peer?: InputPeerLike;
+    /**
+     * Upload progress callback
+     *
+     * @param uploaded  Number of bytes uploaded
+     * @param total  Total file size
+     */
+    progressCallback?: (uploaded: number, total: number) => void;
+}): Promise<Extract<MessageMedia, Photo | RawDocument>>;

package/highlevel/methods/forums/delete-forum-topic-history.d.ts

@@ -0,0 +1,15 @@
+import { ITelegramClient } from '../../client.types.js';
+import { ForumTopic, InputPeerLike } from '../../types/index.js';
+/**
+ * Delete a forum topic and all its history
+ *
+ * @param chat  Chat or user ID, username, phone number, `"me"` or `"self"`
+ * @param topicId  ID of the topic (i.e. its top message ID)
+ */
+export declare function deleteForumTopicHistory(client: ITelegramClient, chat: InputPeerLike, topicId: number | ForumTopic, params?: {
+    /**
+     * Whether to dispatch updates that will be generated by this call.
+     * Doesn't follow `disableNoDispatch`
+     */
+    shouldDispatch?: true;
+}): Promise<void>;

package/highlevel/methods/forums/edit-forum-topic.d.ts

@@ -0,0 +1,34 @@
+import { tl } from '@mtcute/tl';
+import { ITelegramClient } from '../../client.types.js';
+import { ForumTopic, InputPeerLike, Message } from '../../types/index.js';
+/**
+ * Modify a topic in a forum
+ *
+ * Only admins with `manageTopics` permission can do this.
+ *
+ * @param chatId  Chat ID or username
+ * @param topicId  ID of the topic (i.e. its top message ID)
+ * @returns  Service message about the modification
+ */
+export declare function editForumTopic(client: ITelegramClient, params: {
+    /** Chat ID or username */
+    chatId: InputPeerLike;
+    /** ID of the topic (i.e. its top message ID) */
+    topicId: number | ForumTopic;
+    /**
+     * New topic title
+     */
+    title?: string;
+    /**
+     * New icon of the topic.
+     *
+     * Can be a custom emoji ID, or `null` to remove the icon
+     * and use static color instead
+     */
+    icon?: tl.Long | null;
+    /**
+     * Whether to dispatch the returned service message (if any)
+     * to the client's update handler.
+     */
+    shouldDispatch?: true;
+}): Promise<Message>;

package/highlevel/methods/forums/get-forum-topics-by-id.d.ts

@@ -0,0 +1,9 @@
+import { MaybeArray } from '../../../types/utils.js';
+import { ITelegramClient } from '../../client.types.js';
+import { InputPeerLike, ForumTopic } from '../../types/index.js';
+/**
+ * Get forum topics by their IDs
+ *
+ * @param chatId  Chat ID or username
+ */
+export declare function getForumTopicsById(client: ITelegramClient, chatId: InputPeerLike, ids: MaybeArray<number>): Promise<ForumTopic[]>;