@mtcute/core 0.17.1 → 0.18.0

package/highlevel/methods/files/upload-file.js

@@ -0,0 +1,220 @@
+import { Bytes, webReadableToFuman, read } from "@fuman/io";
+import { AsyncLock } from "@fuman/utils";
+import { MtArgumentError } from "../../../types/errors.js";
+import { randomLong } from "../../../utils/long-utils.js";
+import { guessFileMime, MIME_TO_EXTENSION } from "../../utils/file-type.js";
+import { determinePartSize, isProbablyPlainText } from "../../utils/file-utils.js";
+const OVERRIDE_MIME = {
+  // tg doesn't interpret `audio/opus` files as voice messages for some reason
+  "audio/opus": "audio/ogg"
+};
+const SMALL_FILE_MAX_SIZE = 131072;
+const BIG_FILE_MIN_SIZE = 10485760;
+const DEFAULT_FILE_NAME = "unnamed";
+const REQUESTS_PER_CONNECTION = 3;
+const MAX_PART_COUNT = 4e3;
+const MAX_PART_COUNT_PREMIUM = 8e3;
+const HAS_FILE = typeof File !== "undefined";
+const HAS_RESPONSE = typeof Response !== "undefined";
+const HAS_URL = typeof URL !== "undefined";
+const HAS_BLOB = typeof Blob !== "undefined";
+async function uploadFile(client, params) {
+  let file = params.file;
+  let fileSize = -1;
+  let fileName = params.fileName;
+  let fileMime = params.fileMime;
+  if (client.platform.normalizeFile) {
+    const res = await client.platform.normalizeFile(file);
+    if (res?.file) {
+      file = res.file;
+      if (res.fileSize) fileSize = res.fileSize;
+      if (res.fileName) fileName = res.fileName;
+    }
+  }
+  if (ArrayBuffer.isView(file)) {
+    fileSize = file.length;
+    file = Bytes.from(file);
+  }
+  if (HAS_FILE && file instanceof File) {
+    fileName = file.name;
+    fileSize = file.size;
+    fileMime = file.type;
+    file = file.stream();
+  }
+  if (HAS_URL && file instanceof URL) {
+    file = await fetch(file);
+  }
+  if (HAS_BLOB && file instanceof Blob) {
+    fileSize = file.size;
+    file = file.stream();
+  }
+  if (HAS_RESPONSE && file instanceof Response) {
+    const length = Number.parseInt(file.headers.get("content-length") || "0");
+    if (!Number.isNaN(length) && length) fileSize = length;
+    fileMime = file.headers.get("content-type")?.split(";")[0];
+    const disposition = file.headers.get("content-disposition");
+    if (disposition) {
+      const idx2 = disposition.indexOf("filename=");
+      if (idx2 > -1) {
+        const raw = disposition.slice(idx2 + 9).split(";")[0];
+        fileName = JSON.parse(raw);
+      }
+    }
+    if (fileName === DEFAULT_FILE_NAME) {
+      const url = new URL(file.url);
+      const name = url.pathname.split("/").pop();
+      if (name && name.includes(".")) {
+        fileName = name;
+      }
+    }
+    if (!file.body) {
+      throw new MtArgumentError("Fetch response contains `null` body");
+    }
+    file = file.body;
+  }
+  if (file instanceof ReadableStream) {
+    file = webReadableToFuman(file);
+  } else if (!(typeof file === "object" && "read" in file)) {
+    throw new MtArgumentError("Could not convert input `file` to stream!");
+  }
+  let readable = file;
+  if (fileSize === -1 && params.fileSize) fileSize = params.fileSize;
+  if (fileSize === -1 && params.requireFileSize) {
+    const buffer = await read.async.untilEnd(readable);
+    fileSize = buffer.length;
+    readable = Bytes.from(buffer);
+  }
+  let partSizeKb = params.partSize;
+  if (!partSizeKb) {
+    if (fileSize === -1) {
+      partSizeKb = params.estimatedSize ? determinePartSize(params.estimatedSize) : 64;
+    } else {
+      partSizeKb = determinePartSize(fileSize);
+    }
+  }
+  if (partSizeKb > 512) {
+    throw new MtArgumentError(`Invalid part size: ${partSizeKb}KB`);
+  }
+  const partSize = partSizeKb * 1024;
+  let partCount = fileSize === -1 ? -1 : ~~((fileSize + partSize - 1) / partSize);
+  const maxPartCount = client.storage.self.getCached()?.isPremium ? MAX_PART_COUNT_PREMIUM : MAX_PART_COUNT;
+  if (partCount > maxPartCount) {
+    throw new MtArgumentError(`File is too large (max ${maxPartCount} parts, got ${partCount})`);
+  }
+  const isBig = fileSize === -1 || fileSize > BIG_FILE_MIN_SIZE;
+  const isSmall = fileSize !== -1 && fileSize < SMALL_FILE_MAX_SIZE;
+  const connectionKind = isSmall ? "main" : "upload";
+  const connectionPoolSize = Math.min(await client.getPoolSize(connectionKind), partCount);
+  const requestsPerConnection = params.requestsPerConnection ?? REQUESTS_PER_CONNECTION;
+  client.log.debug(
+    "uploading %d bytes file in %d chunks, each %d bytes in %s connection pool of size %d",
+    fileSize,
+    partCount,
+    partSize,
+    connectionKind,
+    connectionPoolSize
+  );
+  const fileId = randomLong();
+  const lock = new AsyncLock();
+  let pos = 0;
+  let idx = 0;
+  let readableEnded = false;
+  const uploadNextPart = async () => {
+    const thisIdx = idx++;
+    await lock.acquire();
+    if (readableEnded) {
+      lock.release();
+      return;
+    }
+    let part;
+    try {
+      part = await read.async.exactly(readable, partSize, "truncate");
+    } finally {
+      lock.release();
+    }
+    const ended = part.length < partSize;
+    if (ended) {
+      readableEnded = true;
+      if (fileSize === -1) {
+        fileSize = pos + part.length;
+        partCount = ~~((fileSize + partSize - 1) / partSize);
+      } else if (thisIdx !== partCount - 1) {
+        throw new MtArgumentError(`Unexpected EOS (there were only ${idx} parts, but expected ${partCount})`);
+      }
+      client.log.debug("readable ended, file size = %d, part count = %d", fileSize, partCount);
+    }
+    if (thisIdx === 0 && fileMime === void 0) {
+      const mime = guessFileMime(part);
+      if (mime) {
+        fileMime = mime;
+      } else {
+        const isPlainText = isProbablyPlainText(part.slice(0, 8));
+        fileMime = isPlainText ? "text/plain" : "application/octet-stream";
+      }
+    }
+    const request = isBig ? {
+      _: "upload.saveBigFilePart",
+      fileId,
+      filePart: thisIdx,
+      fileTotalParts: partCount,
+      bytes: part
+    } : {
+      _: "upload.saveFilePart",
+      fileId,
+      filePart: thisIdx,
+      bytes: part
+    };
+    const result = await client.call(request, { kind: connectionKind });
+    if (!result) throw new Error(`Failed to upload part ${idx}`);
+    pos += part.length;
+    params.progressCallback?.(pos, fileSize);
+    if (idx === partCount) return;
+    return uploadNextPart();
+  };
+  let poolSize = partCount === -1 ? 1 : connectionPoolSize * requestsPerConnection;
+  if (partCount !== -1 && poolSize > partCount) poolSize = partCount;
+  await Promise.all(Array.from({ length: poolSize }, uploadNextPart));
+  if (fileName === void 0) {
+    const ext = MIME_TO_EXTENSION[fileMime];
+    fileName = ext ? `${DEFAULT_FILE_NAME}.${ext}` : DEFAULT_FILE_NAME;
+  } else if (params.requireExtension) {
+    const extFromMime = MIME_TO_EXTENSION[fileMime];
+    const idx2 = fileName.lastIndexOf(".");
+    const extFromName = idx2 === -1 ? void 0 : fileName.slice(idx2 + 1);
+    if (!extFromName) {
+      if (!extFromMime) {
+        throw new MtArgumentError(`File name does not have an extension, and we cannot guess it from the mime type (${fileMime})`);
+      }
+      fileName = `${fileName}.${extFromMime}`;
+    } else if (extFromMime && extFromName !== extFromMime) {
+      throw new MtArgumentError(`File name has ${extFromName} extension (${fileName}), but the mime type (${fileMime}) expects it to be ${extFromMime}`);
+    }
+  }
+  let inputFile;
+  if (isBig) {
+    inputFile = {
+      _: "inputFileBig",
+      id: fileId,
+      parts: partCount,
+      name: fileName
+    };
+  } else {
+    inputFile = {
+      _: "inputFile",
+      id: fileId,
+      parts: partCount,
+      name: fileName,
+      md5Checksum: ""
+      // tdlib doesn't do this, why should we?
+    };
+  }
+  if (fileMime in OVERRIDE_MIME) fileMime = OVERRIDE_MIME[fileMime];
+  return {
+    inputFile,
+    size: fileSize,
+    mime: fileMime
+  };
+}
+export {
+  uploadFile
+};

package/highlevel/methods/files/upload-media.cjs

@@ -0,0 +1,58 @@
+if (typeof globalThis !== "undefined" && !globalThis._MTCUTE_CJS_DEPRECATION_WARNED) {
+  globalThis._MTCUTE_CJS_DEPRECATION_WARNED = true;
+  console.warn("[mtcute-workspace] CommonJS support is deprecated and will be removed in 0.20.0. Please consider switching to ESM, it's " + (/* @__PURE__ */ new Date()).getFullYear() + " already.");
+  console.warn("[mtcute-workspace] Learn more about switching to ESM: https://gist.github.com/sindresorhus/a39789f98801d908bbc7ff3ecc99d99c");
+}
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const errors = require("../../../types/errors.cjs");
+const utils = require("../../../types/utils.cjs");
+const typeAssertions = require("../../../utils/type-assertions.cjs");
+const documentUtils = require("../../types/media/document-utils.cjs");
+const resolvePeer = require("../users/resolve-peer.cjs");
+const normalizeInputMedia = require("./normalize-input-media.cjs");
+const photo = require("../../types/media/photo.cjs");
+async function uploadMedia(client, media, params = {}) {
+  const normMedia = await normalizeInputMedia._normalizeInputMedia(client, media, params, false);
+  switch (normMedia._) {
+    case "inputMediaEmpty":
+    case "inputMediaGeoPoint":
+    case "inputMediaGeoLive":
+    case "inputMediaContact":
+    case "inputMediaVenue":
+    case "inputMediaGame":
+    case "inputMediaInvoice":
+    case "inputMediaPoll":
+    case "inputMediaDice":
+    case "inputMediaPaidMedia":
+      throw new errors.MtArgumentError("This media can't be uploaded");
+  }
+  const res = await client.call({
+    _: "messages.uploadMedia",
+    peer: params.peer ? await resolvePeer.resolvePeer(client, params.peer) : {
+      _: "inputPeerSelf"
+    },
+    media: normMedia
+  });
+  typeAssertions.assertTypeIsNot("uploadMedia", res, "messageMediaEmpty");
+  switch (normMedia._) {
+    case "inputMediaUploadedPhoto":
+    case "inputMediaPhoto":
+    case "inputMediaPhotoExternal":
+      typeAssertions.assertTypeIs("uploadMedia", res, "messageMediaPhoto");
+      typeAssertions.assertTypeIs("uploadMedia", res.photo, "photo");
+      return new photo.Photo(res.photo);
+    case "inputMediaUploadedDocument":
+    case "inputMediaDocument":
+    case "inputMediaDocumentExternal":
+      typeAssertions.assertTypeIs("uploadMedia", res, "messageMediaDocument");
+      typeAssertions.assertTypeIs("uploadMedia", res.document, "document");
+      return documentUtils.parseDocument(res.document, res);
+    case "inputMediaStory":
+    case "inputMediaWebPage":
+      throw new errors.MtArgumentError(`This media (${normMedia._}) can't be uploaded`);
+    default:
+      utils.assertNever();
+  }
+}
+exports.uploadMedia = uploadMedia;

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/files/upload-media.js

@@ -0,0 +1,53 @@
+import { MtArgumentError } from "../../../types/errors.js";
+import { assertNever } from "../../../types/utils.js";
+import { assertTypeIsNot, assertTypeIs } from "../../../utils/type-assertions.js";
+import { parseDocument } from "../../types/media/document-utils.js";
+import { resolvePeer } from "../users/resolve-peer.js";
+import { _normalizeInputMedia } from "./normalize-input-media.js";
+import { Photo as Photo$2 } from "../../types/media/photo.js";
+async function uploadMedia(client, media, params = {}) {
+  const normMedia = await _normalizeInputMedia(client, media, params, false);
+  switch (normMedia._) {
+    case "inputMediaEmpty":
+    case "inputMediaGeoPoint":
+    case "inputMediaGeoLive":
+    case "inputMediaContact":
+    case "inputMediaVenue":
+    case "inputMediaGame":
+    case "inputMediaInvoice":
+    case "inputMediaPoll":
+    case "inputMediaDice":
+    case "inputMediaPaidMedia":
+      throw new MtArgumentError("This media can't be uploaded");
+  }
+  const res = await client.call({
+    _: "messages.uploadMedia",
+    peer: params.peer ? await resolvePeer(client, params.peer) : {
+      _: "inputPeerSelf"
+    },
+    media: normMedia
+  });
+  assertTypeIsNot("uploadMedia", res, "messageMediaEmpty");
+  switch (normMedia._) {
+    case "inputMediaUploadedPhoto":
+    case "inputMediaPhoto":
+    case "inputMediaPhotoExternal":
+      assertTypeIs("uploadMedia", res, "messageMediaPhoto");
+      assertTypeIs("uploadMedia", res.photo, "photo");
+      return new Photo$2(res.photo);
+    case "inputMediaUploadedDocument":
+    case "inputMediaDocument":
+    case "inputMediaDocumentExternal":
+      assertTypeIs("uploadMedia", res, "messageMediaDocument");
+      assertTypeIs("uploadMedia", res.document, "document");
+      return parseDocument(res.document, res);
+    case "inputMediaStory":
+    case "inputMediaWebPage":
+      throw new MtArgumentError(`This media (${normMedia._}) can't be uploaded`);
+    default:
+      assertNever();
+  }
+}
+export {
+  uploadMedia
+};

package/highlevel/methods/forums/create-forum-topic.cjs

@@ -0,0 +1,24 @@
+if (typeof globalThis !== "undefined" && !globalThis._MTCUTE_CJS_DEPRECATION_WARNED) {
+  globalThis._MTCUTE_CJS_DEPRECATION_WARNED = true;
+  console.warn("[mtcute-workspace] CommonJS support is deprecated and will be removed in 0.20.0. Please consider switching to ESM, it's " + (/* @__PURE__ */ new Date()).getFullYear() + " already.");
+  console.warn("[mtcute-workspace] Learn more about switching to ESM: https://gist.github.com/sindresorhus/a39789f98801d908bbc7ff3ecc99d99c");
+}
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const longUtils = require("../../../utils/long-utils.cjs");
+const findInUpdate = require("../messages/find-in-update.cjs");
+const resolvePeer = require("../users/resolve-peer.cjs");
+async function createForumTopic(client, params) {
+  const { chatId, title, icon, sendAs, shouldDispatch } = params;
+  const res = await client.call({
+    _: "channels.createForumTopic",
+    channel: await resolvePeer.resolveChannel(client, chatId),
+    title,
+    iconColor: typeof icon === "number" ? icon : void 0,
+    iconEmojiId: typeof icon !== "number" ? icon : void 0,
+    sendAs: sendAs ? await resolvePeer.resolvePeer(client, sendAs) : void 0,
+    randomId: longUtils.randomLong()
+  });
+  return findInUpdate._findMessageInUpdate(client, res, false, !shouldDispatch);
+}
+exports.createForumTopic = createForumTopic;

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/create-forum-topic.js

@@ -0,0 +1,19 @@
+import { randomLong } from "../../../utils/long-utils.js";
+import { _findMessageInUpdate } from "../messages/find-in-update.js";
+import { resolvePeer, resolveChannel } from "../users/resolve-peer.js";
+async function createForumTopic(client, params) {
+  const { chatId, title, icon, sendAs, shouldDispatch } = params;
+  const res = await client.call({
+    _: "channels.createForumTopic",
+    channel: await resolveChannel(client, chatId),
+    title,
+    iconColor: typeof icon === "number" ? icon : void 0,
+    iconEmojiId: typeof icon !== "number" ? icon : void 0,
+    sendAs: sendAs ? await resolvePeer(client, sendAs) : void 0,
+    randomId: randomLong()
+  });
+  return _findMessageInUpdate(client, res, false, !shouldDispatch);
+}
+export {
+  createForumTopic
+};

package/highlevel/methods/forums/delete-forum-topic-history.cjs

@@ -0,0 +1,24 @@
+if (typeof globalThis !== "undefined" && !globalThis._MTCUTE_CJS_DEPRECATION_WARNED) {
+  globalThis._MTCUTE_CJS_DEPRECATION_WARNED = true;
+  console.warn("[mtcute-workspace] CommonJS support is deprecated and will be removed in 0.20.0. Please consider switching to ESM, it's " + (/* @__PURE__ */ new Date()).getFullYear() + " already.");
+  console.warn("[mtcute-workspace] Learn more about switching to ESM: https://gist.github.com/sindresorhus/a39789f98801d908bbc7ff3ecc99d99c");
+}
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const typeAssertions = require("../../../utils/type-assertions.cjs");
+const utils = require("../../updates/utils.cjs");
+const resolvePeer = require("../users/resolve-peer.cjs");
+async function deleteForumTopicHistory(client, chat, topicId, params) {
+  const { shouldDispatch } = params ?? {};
+  const channel = await resolvePeer.resolveChannel(client, chat);
+  typeAssertions.assertTypeIsNot("deleteForumTopicHistory", channel, "inputChannelEmpty");
+  const res = await client.call({
+    _: "channels.deleteTopicHistory",
+    channel,
+    topMsgId: typeof topicId === "number" ? topicId : topicId.id
+  });
+  if (!shouldDispatch) {
+    client.handleClientUpdate(utils.createDummyUpdate(res.pts, res.ptsCount, channel.channelId));
+  }
+}
+exports.deleteForumTopicHistory = deleteForumTopicHistory;

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/delete-forum-topic-history.js

@@ -0,0 +1,19 @@
+import { assertTypeIsNot } from "../../../utils/type-assertions.js";
+import { createDummyUpdate } from "../../updates/utils.js";
+import { resolveChannel } from "../users/resolve-peer.js";
+async function deleteForumTopicHistory(client, chat, topicId, params) {
+  const { shouldDispatch } = params ?? {};
+  const channel = await resolveChannel(client, chat);
+  assertTypeIsNot("deleteForumTopicHistory", channel, "inputChannelEmpty");
+  const res = await client.call({
+    _: "channels.deleteTopicHistory",
+    channel,
+    topMsgId: typeof topicId === "number" ? topicId : topicId.id
+  });
+  if (!shouldDispatch) {
+    client.handleClientUpdate(createDummyUpdate(res.pts, res.ptsCount, channel.channelId));
+  }
+}
+export {
+  deleteForumTopicHistory
+};

package/highlevel/methods/forums/edit-forum-topic.cjs

@@ -0,0 +1,22 @@
+if (typeof globalThis !== "undefined" && !globalThis._MTCUTE_CJS_DEPRECATION_WARNED) {
+  globalThis._MTCUTE_CJS_DEPRECATION_WARNED = true;
+  console.warn("[mtcute-workspace] CommonJS support is deprecated and will be removed in 0.20.0. Please consider switching to ESM, it's " + (/* @__PURE__ */ new Date()).getFullYear() + " already.");
+  console.warn("[mtcute-workspace] Learn more about switching to ESM: https://gist.github.com/sindresorhus/a39789f98801d908bbc7ff3ecc99d99c");
+}
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const Long = require("long");
+const findInUpdate = require("../messages/find-in-update.cjs");
+const resolvePeer = require("../users/resolve-peer.cjs");
+async function editForumTopic(client, params) {
+  const { chatId, topicId, title, icon, shouldDispatch } = params;
+  const res = await client.call({
+    _: "channels.editForumTopic",
+    channel: await resolvePeer.resolveChannel(client, chatId),
+    topicId: typeof topicId === "number" ? topicId : topicId.id,
+    title,
+    iconEmojiId: icon ? icon ?? Long.ZERO : void 0
+  });
+  return findInUpdate._findMessageInUpdate(client, res, false, shouldDispatch);
+}
+exports.editForumTopic = editForumTopic;

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/edit-forum-topic.js

@@ -0,0 +1,17 @@
+import Long from "long";
+import { _findMessageInUpdate } from "../messages/find-in-update.js";
+import { resolveChannel } from "../users/resolve-peer.js";
+async function editForumTopic(client, params) {
+  const { chatId, topicId, title, icon, shouldDispatch } = params;
+  const res = await client.call({
+    _: "channels.editForumTopic",
+    channel: await resolveChannel(client, chatId),
+    topicId: typeof topicId === "number" ? topicId : topicId.id,
+    title,
+    iconEmojiId: icon ? icon ?? Long.ZERO : void 0
+  });
+  return _findMessageInUpdate(client, res, false, shouldDispatch);
+}
+export {
+  editForumTopic
+};

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

@@ -0,0 +1,19 @@
+if (typeof globalThis !== "undefined" && !globalThis._MTCUTE_CJS_DEPRECATION_WARNED) {
+  globalThis._MTCUTE_CJS_DEPRECATION_WARNED = true;
+  console.warn("[mtcute-workspace] CommonJS support is deprecated and will be removed in 0.20.0. Please consider switching to ESM, it's " + (/* @__PURE__ */ new Date()).getFullYear() + " already.");
+  console.warn("[mtcute-workspace] Learn more about switching to ESM: https://gist.github.com/sindresorhus/a39789f98801d908bbc7ff3ecc99d99c");
+}
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const resolvePeer = require("../users/resolve-peer.cjs");
+const forumTopic = require("../../types/peers/forum-topic.cjs");
+async function getForumTopicsById(client, chatId, ids) {
+  if (!Array.isArray(ids)) ids = [ids];
+  const res = await client.call({
+    _: "channels.getForumTopicsByID",
+    channel: await resolvePeer.resolveChannel(client, chatId),
+    topics: ids
+  });
+  return forumTopic.ForumTopic.parseTlForumTopics(res);
+}
+exports.getForumTopicsById = getForumTopicsById;

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-by-id.js

@@ -0,0 +1,14 @@
+import { resolveChannel } from "../users/resolve-peer.js";
+import { ForumTopic as ForumTopic$2 } from "../../types/peers/forum-topic.js";
+async function getForumTopicsById(client, chatId, ids) {
+  if (!Array.isArray(ids)) ids = [ids];
+  const res = await client.call({
+    _: "channels.getForumTopicsByID",
+    channel: await resolveChannel(client, chatId),
+    topics: ids
+  });
+  return ForumTopic$2.parseTlForumTopics(res);
+}
+export {
+  getForumTopicsById
+};

package/highlevel/methods/forums/get-forum-topics.cjs

@@ -0,0 +1,41 @@
+if (typeof globalThis !== "undefined" && !globalThis._MTCUTE_CJS_DEPRECATION_WARNED) {
+  globalThis._MTCUTE_CJS_DEPRECATION_WARNED = true;
+  console.warn("[mtcute-workspace] CommonJS support is deprecated and will be removed in 0.20.0. Please consider switching to ESM, it's " + (/* @__PURE__ */ new Date()).getFullYear() + " already.");
+  console.warn("[mtcute-workspace] Learn more about switching to ESM: https://gist.github.com/sindresorhus/a39789f98801d908bbc7ff3ecc99d99c");
+}
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const resolvePeer = require("../users/resolve-peer.cjs");
+const miscUtils = require("../../utils/misc-utils.cjs");
+const forumTopic = require("../../types/peers/forum-topic.cjs");
+const defaultOffset = {
+  date: 0,
+  id: 0,
+  topic: 0
+};
+async function getForumTopics(client, chatId, params) {
+  if (!params) params = {};
+  const {
+    query,
+    offset: { date: offsetDate, id: offsetId, topic: offsetTopic } = defaultOffset,
+    limit = 100
+  } = params;
+  const res = await client.call({
+    _: "channels.getForumTopics",
+    channel: await resolvePeer.resolveChannel(client, chatId),
+    q: query,
+    offsetDate,
+    offsetId,
+    offsetTopic,
+    limit
+  });
+  const topics = forumTopic.ForumTopic.parseTlForumTopics(res);
+  const last = topics[topics.length - 1];
+  const next = last ? {
+    date: res.orderByCreateDate ? last.raw.date : last.lastMessage.raw.date,
+    id: last.raw.topMessage,
+    topic: last.raw.id
+  } : void 0;
+  return miscUtils.makeArrayPaginated(topics, res.count, next);
+}
+exports.getForumTopics = getForumTopics;