@mtcute/core 0.18.0-rc.5 → 0.19.0

package/highlevel/methods/dialogs/get-chatlist-preview.d.cts

@@ -0,0 +1,8 @@
+import { ITelegramClient } from '../../client.types.js';
+import { ChatlistPreview } from '../../types/index.js';
+/**
+ * Get a preview of a chatlist by its invite link
+ *
+ * @param link  Invite link
+ */
+export declare function getChatlistPreview(client: ITelegramClient, link: string): Promise<ChatlistPreview>;

package/highlevel/methods/dialogs/get-folders.d.cts

@@ -0,0 +1,9 @@
+import { tl } from '@mtcute/tl';
+import { ITelegramClient } from '../../client.types.js';
+import { InputDialogFolder } from '../../types/index.js';
+/**
+ * Get list of folders.
+ */
+export declare function getFolders(client: ITelegramClient): Promise<tl.messages.RawDialogFilters>;
+/** @internal */
+export declare function _normalizeInputFolder(client: ITelegramClient, folder: InputDialogFolder): Promise<tl.TypeDialogFilter>;

package/highlevel/methods/dialogs/get-peer-dialogs.d.cts

@@ -0,0 +1,10 @@
+import { MaybeArray } from '../../../types/utils.js';
+import { ITelegramClient } from '../../client.types.js';
+import { InputPeerLike } from '../../types/peers/index.js';
+import { Dialog } from '../../types/messages/dialog.js';
+/**
+ * Get dialogs with certain peers.
+ *
+ * @param peers  Peers for which to fetch dialogs.
+ */
+export declare function getPeerDialogs(client: ITelegramClient, peers: MaybeArray<InputPeerLike>): Promise<Dialog[]>;

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

@@ -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/dialogs/join-chatlist.d.cts

@@ -0,0 +1,15 @@
+import { tl } from '@mtcute/tl';
+import { MaybeArray } from '../../../types/utils.js';
+import { ITelegramClient } from '../../client.types.js';
+import { InputPeerLike } from '../../types/index.js';
+/**
+ * Join a chatlist by its link
+ *
+ * @param link  Invite link to the chatlist
+ * @param params  Additional parameters
+ * @returns  Folder representing the chatlist
+ */
+export declare function joinChatlist(client: ITelegramClient, link: string, params?: {
+    /** Chats to join from the chatlist (all by default) */
+    peers?: MaybeArray<InputPeerLike>;
+}): Promise<tl.RawDialogFilterChatlist>;

package/highlevel/methods/dialogs/set-folders-order.d.cts

@@ -0,0 +1,7 @@
+import { ITelegramClient } from '../../client.types.js';
+/**
+ * Reorder folders
+ *
+ * @param order  New order of folders (folder IDs, where default = 0)
+ */
+export declare function setFoldersOrder(client: ITelegramClient, order: number[]): Promise<void>;

package/highlevel/methods/files/download-buffer.d.cts

@@ -0,0 +1,11 @@
+import { ITelegramClient } from '../../client.types.js';
+import { FileDownloadLocation, FileDownloadParameters } from '../../types/index.js';
+/**
+ * Download a file and return its contents as a Buffer.
+ *
+ * > **Note**: This method _will_ download the entire file
+ * > into memory at once. This might cause an issue, so use wisely!
+ *
+ * @param params  File download parameters
+ */
+export declare function downloadAsBuffer(client: ITelegramClient, location: FileDownloadLocation, params?: FileDownloadParameters): Promise<Uint8Array>;

package/highlevel/methods/files/download-file.d.cts

@@ -0,0 +1 @@
+export {};

package/highlevel/methods/files/download-iterable.cjs

@@ -22,7 +22,7 @@ async function* downloadAsIterable(client, input, params) {
   let dcId = params?.dcId;
   let fileSize = params?.fileSize;
   const abortSignal = params?.abortSignal;
-  let aborted = false;
+  let ended = false;
   let location;
   if (input instanceof fileLocation.FileLocation) {
     let locationInner = input.location;
@@ -61,7 +61,7 @@ async function* downloadAsIterable(client, input, params) {
   let nextWorkerChunkIdx = 0;
   const nextChunkCv = new utils.ConditionVariable();
   const buffer = {};
-  const isSmall = fileSize && fileSize <= SMALL_FILE_MAX_SIZE;
+  const isSmall = fileSize && fileSize <= SMALL_FILE_MAX_SIZE || location._ === "inputPeerPhotoFileLocation";
   let connectionKind;
   if (isSmall) {
     connectionKind = dcId === primaryDcId ? "main" : "downloadSmall";
@@ -78,7 +78,7 @@ async function* downloadAsIterable(client, input, params) {
   );
   const downloadChunk = async (chunk = nextWorkerChunkIdx++) => {
     let result;
-    if (aborted) {
+    if (ended) {
       return;
     }
     try {
@@ -117,7 +117,7 @@ async function* downloadAsIterable(client, input, params) {
     if (result._ === "upload.fileCdnRedirect") {
       throw new errors.MtUnsupportedError("Received CDN redirect, which is not supported (yet)");
     }
-    if (aborted) {
+    if (ended) {
       return;
     }
     if (result._ === "upload.webFile" && result.size && limitBytes === Infinity) {
@@ -133,10 +133,12 @@ async function* downloadAsIterable(client, input, params) {
     }
   };
   let error;
-  void Promise.all(Array.from({ length: Math.min(poolSize * REQUESTS_PER_CONNECTION, numChunks) }, downloadChunk)).catch((e) => {
+  void Promise.all(Array.from({
+    length: Math.min(poolSize * (isSmall ? 1 : REQUESTS_PER_CONNECTION), numChunks)
+  }, downloadChunk)).catch((e) => {
     client.log.debug("download workers errored: %e", e);
     error = e;
-    aborted = true;
+    ended = true;
     nextChunkCv.notify();
   }).then(() => {
     client.log.debug("download workers finished");
@@ -144,7 +146,7 @@ async function* downloadAsIterable(client, input, params) {
   abortSignal?.addEventListener("abort", () => {
     client.log.debug("download aborted");
     error = abortSignal.reason;
-    aborted = true;
+    ended = true;
     nextChunkCv.notify();
   });
   let position = offset;

package/highlevel/methods/files/download-iterable.d.cts

@@ -0,0 +1,10 @@
+import { ITelegramClient } from '../../client.types.js';
+import { FileDownloadLocation, FileDownloadParameters } from '../../types/index.js';
+/**
+ * Download a file and return it as an iterable, which yields file contents
+ * in chunks of a given size. Order of the chunks is guaranteed to be
+ * consecutive.
+ *
+ * @param params  Download parameters
+ */
+export declare function downloadAsIterable(client: ITelegramClient, input: FileDownloadLocation, params?: FileDownloadParameters): AsyncIterableIterator<Uint8Array>;

package/highlevel/methods/files/download-iterable.js

@@ -15,7 +15,7 @@ async function* downloadAsIterable(client, input, params) {
   let dcId = params?.dcId;
   let fileSize = params?.fileSize;
   const abortSignal = params?.abortSignal;
-  let aborted = false;
+  let ended = false;
   let location;
   if (input instanceof FileLocation$1) {
     let locationInner = input.location;
@@ -54,7 +54,7 @@ async function* downloadAsIterable(client, input, params) {
   let nextWorkerChunkIdx = 0;
   const nextChunkCv = new ConditionVariable();
   const buffer = {};
-  const isSmall = fileSize && fileSize <= SMALL_FILE_MAX_SIZE;
+  const isSmall = fileSize && fileSize <= SMALL_FILE_MAX_SIZE || location._ === "inputPeerPhotoFileLocation";
   let connectionKind;
   if (isSmall) {
     connectionKind = dcId === primaryDcId ? "main" : "downloadSmall";
@@ -71,7 +71,7 @@ async function* downloadAsIterable(client, input, params) {
   );
   const downloadChunk = async (chunk = nextWorkerChunkIdx++) => {
     let result;
-    if (aborted) {
+    if (ended) {
       return;
     }
     try {
@@ -110,7 +110,7 @@ async function* downloadAsIterable(client, input, params) {
     if (result._ === "upload.fileCdnRedirect") {
       throw new MtUnsupportedError("Received CDN redirect, which is not supported (yet)");
     }
-    if (aborted) {
+    if (ended) {
       return;
     }
     if (result._ === "upload.webFile" && result.size && limitBytes === Infinity) {
@@ -126,10 +126,12 @@ async function* downloadAsIterable(client, input, params) {
     }
   };
   let error;
-  void Promise.all(Array.from({ length: Math.min(poolSize * REQUESTS_PER_CONNECTION, numChunks) }, downloadChunk)).catch((e) => {
+  void Promise.all(Array.from({
+    length: Math.min(poolSize * (isSmall ? 1 : REQUESTS_PER_CONNECTION), numChunks)
+  }, downloadChunk)).catch((e) => {
     client.log.debug("download workers errored: %e", e);
     error = e;
-    aborted = true;
+    ended = true;
     nextChunkCv.notify();
   }).then(() => {
     client.log.debug("download workers finished");
@@ -137,7 +139,7 @@ async function* downloadAsIterable(client, input, params) {
   abortSignal?.addEventListener("abort", () => {
     client.log.debug("download aborted");
     error = abortSignal.reason;
-    aborted = true;
+    ended = true;
     nextChunkCv.notify();
   });
   let position = offset;

package/highlevel/methods/files/download-node-stream.d.cts

@@ -0,0 +1 @@
+export {};

package/highlevel/methods/files/download-stream.d.cts

@@ -0,0 +1,9 @@
+import { ITelegramClient } from '../../client.types.js';
+import { FileDownloadLocation, FileDownloadParameters } from '../../types/index.js';
+/**
+ * Download a file and return it as a `@fuman/io` stream,
+ * streaming file contents.
+ *
+ * @param params  File download parameters
+ */
+export declare function downloadAsStream(client: ITelegramClient, location: FileDownloadLocation, params?: FileDownloadParameters): ReadableStream<Uint8Array>;

package/highlevel/methods/files/normalize-file-to-document.d.cts

@@ -0,0 +1,9 @@
+import { ITelegramClient } from '../../client.types.js';
+import { InputFileLike } from '../../types/index.js';
+import { tl } from '@mtcute/tl';
+/**
+ * @internal
+ */
+export declare function _normalizeFileToDocument(client: ITelegramClient, file: InputFileLike | tl.TypeInputDocument, params: {
+    progressCallback?: (uploaded: number, total: number) => void;
+}): Promise<tl.TypeInputDocument>;

package/highlevel/methods/files/normalize-input-file.d.cts

@@ -0,0 +1,13 @@
+import { ITelegramClient } from '../../client.types.js';
+import { InputFileLike } from '../../types/files/index.js';
+import { tl } from '@mtcute/tl';
+/**
+ * Normalize a {@link InputFileLike} to `InputFile`,
+ * uploading it if needed.
+ */
+export declare function _normalizeInputFile(client: ITelegramClient, input: InputFileLike, params: {
+    progressCallback?: (uploaded: number, total: number) => void;
+    fileName?: string;
+    fileSize?: number;
+    fileMime?: string;
+}): Promise<tl.TypeInputFile>;

package/highlevel/methods/files/normalize-input-media.d.cts

@@ -0,0 +1,12 @@
+import { ITelegramClient } from '../../client.types.js';
+import { InputMediaLike } from '../../types/media/input-media/types.js';
+import { tl } from '@mtcute/tl';
+/**
+ * Normalize an {@link InputMediaLike} to `InputMedia`,
+ * uploading the file if needed.
+ */
+export declare function _normalizeInputMedia(client: ITelegramClient, media: InputMediaLike, params?: {
+    progressCallback?: (uploaded: number, total: number) => void;
+    uploadPeer?: tl.TypeInputPeer;
+    businessConnectionId?: string;
+}, uploadMedia?: boolean): Promise<tl.TypeInputMedia>;

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

@@ -0,0 +1,72 @@
+import { ITelegramClient } from '../../client.types.js';
+import { UploadedFile, UploadFileLike } 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;
+    /**
+     * When using `inputMediaUploadedPhoto` (e.g. when sending an uploaded photo) require
+     * the file extension to be known beforehand.
+     *
+     * This will make the library try to guess the file extension from the file mime type,
+     * or throw an error if it cannot be guessed.
+     */
+    requireExtension?: boolean;
+}): Promise<UploadedFile>;

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

@@ -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/create-forum-topic.d.cts

@@ -0,0 +1,36 @@
+import { tl } from '@mtcute/tl';
+import { ITelegramClient } from '../../client.types.js';
+import { InputPeerLike, Message } from '../../types/index.js';
+/**
+ * Create a topic in a forum
+ *
+ * Only admins with `manageTopics` permission can do this.
+ *
+ * @returns  Service message for the created topic
+ */
+export declare function createForumTopic(client: ITelegramClient, params: {
+    /** Chat ID or username */
+    chatId: InputPeerLike;
+    /**
+     * Topic title
+     */
+    title: string;
+    /**
+     * Icon of the topic.
+     *
+     * Can be a number (color in RGB, see {@link ForumTopic} static members for allowed values)
+     * or a custom emoji ID.
+     *
+     * Icon color can't be changed after the topic is created.
+     */
+    icon?: number | tl.Long;
+    /**
+     * Send as a specific channel
+     */
+    sendAs?: InputPeerLike;
+    /**
+     * Whether to dispatch the returned service message (if any)
+     * to the client's update handler.
+     */
+    shouldDispatch?: true;
+}): Promise<Message>;

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

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

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

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

package/highlevel/methods/forums/get-forum-topics.d.cts

@@ -0,0 +1,28 @@
+import { ITelegramClient } from '../../client.types.js';
+import { ArrayPaginated, InputPeerLike, ForumTopic } from '../../types/index.js';
+export interface GetForumTopicsOffset {
+    date: number;
+    id: number;
+    topic: number;
+}
+/**
+ * Get forum topics
+ *
+ * @param chatId  Chat ID or username
+ */
+export declare function getForumTopics(client: ITelegramClient, chatId: InputPeerLike, params?: {
+    /**
+     * Search query
+     */
+    query?: string;
+    /**
+     * Offset for pagination
+     */
+    offset?: GetForumTopicsOffset;
+    /**
+     * Maximum number of topics to return.
+     *
+     * @default  100
+     */
+    limit?: number;
+}): Promise<ArrayPaginated<ForumTopic, GetForumTopicsOffset>>;

package/highlevel/methods/forums/iter-forum-topics.d.cts

@@ -0,0 +1,20 @@
+import { ITelegramClient } from '../../client.types.js';
+import { ForumTopic, InputPeerLike } from '../../types/index.js';
+import { getForumTopics } from './get-forum-topics.js';
+/**
+ * Iterate over forum topics. Wrapper over {@link getForumTopics}.
+ *
+ * @param chatId  Chat ID or username
+ */
+export declare function iterForumTopics(client: ITelegramClient, chatId: InputPeerLike, params?: Parameters<typeof getForumTopics>[2] & {
+    /**
+     * Maximum number of topics to return.
+     *
+     * @default  `Infinity`, i.e. return all topics
+     */
+    limit?: number;
+    /**
+     * Chunk size. Usually you shouldn't care about this.
+     */
+    chunkSize?: number;
+}): AsyncIterableIterator<ForumTopic>;

package/highlevel/methods/forums/reorder-pinned-forum-topics.d.cts

@@ -0,0 +1,19 @@
+import { ITelegramClient } from '../../client.types.js';
+import { ForumTopic, InputPeerLike } from '../../types/index.js';
+/**
+ * Reorder pinned forum topics
+ *
+ * Only admins with `manageTopics` permission can do this.
+ */
+export declare function reorderPinnedForumTopics(client: ITelegramClient, params: {
+    /** Chat ID or username */
+    chatId: InputPeerLike;
+    /**
+     * Order of the pinned topics
+     */
+    order: (number | ForumTopic)[];
+    /**
+     * Whether to un-pin topics not present in the order
+     */
+    force?: boolean;
+}): Promise<void>;

package/highlevel/methods/forums/toggle-forum-topic-closed.d.cts

@@ -0,0 +1,22 @@
+import { ITelegramClient } from '../../client.types.js';
+import { ForumTopic, InputPeerLike, Message } from '../../types/index.js';
+/**
+ * Toggle open/close status of a topic in a forum
+ *
+ * Only admins with `manageTopics` permission can do this.
+ *
+ * @returns  Service message about the modification
+ */
+export declare function toggleForumTopicClosed(client: ITelegramClient, parmas: {
+    /** Chat ID or username */
+    chatId: InputPeerLike;
+    /** ID of the topic (i.e. its top message ID) */
+    topicId: number | ForumTopic;
+    /** Whether the topic should be closed */
+    closed: boolean;
+    /**
+     * Whether to dispatch the returned service message (if any)
+     * to the client's update handler.
+     */
+    shouldDispatch?: true;
+}): Promise<Message>;