@mtcute/core 0.17.1 → 0.18.0-rc.5

package/highlevel/types/peers/chat.js

@@ -0,0 +1,439 @@
+import { MtTypeAssertionError, MtArgumentError } from "../../../types/errors.js";
+import { getMarkedPeerId } from "../../../utils/peer-utils.js";
+import { memoizeGetters } from "../../utils/memoize.js";
+import { MessageEntity as MessageEntity$2 } from "../messages/message-entity.js";
+import { EmojiStatus as EmojiStatus$1 } from "../reactions/emoji-status.js";
+import { ChatColors as ChatColors$1 } from "./chat-colors.js";
+import { ChatPermissions as ChatPermissions$1 } from "./chat-permissions.js";
+import { ChatPhoto as ChatPhoto$2 } from "./chat-photo.js";
+import { makeInspectable } from "../../utils/inspectable.js";
+class Chat {
+  type = "chat";
+  /**
+   * Raw peer object that this {@link Chat} represents.
+   */
+  raw;
+  constructor(peer) {
+    switch (peer._) {
+      case "chat":
+      case "channel":
+      case "chatForbidden":
+      case "channelForbidden":
+        break;
+      default:
+        throw new MtTypeAssertionError("peer", "user | chat | channel", peer._);
+    }
+    this.raw = peer;
+  }
+  /** Marked ID of this chat */
+  get id() {
+    return getMarkedPeerId(this.inputPeer);
+  }
+  /**
+   * Whether this chat's information is incomplete.
+   *
+   * This usually only happens in large chats, where
+   * the server sometimes sends only a part of the chat's
+   * information. Basic info like name and profile photo
+   * are always available, but other fields may be omitted
+   * despite being available.
+   *
+   * For a rough list of fields that may be missing, see the
+   * official docs for [channel](https://core.telegram.org/constructor/channel)
+   * and [user](https://core.telegram.org/constructor/user).
+   *
+   * This currently only ever happens for non-bot users, so if you are building
+   * a normal bot, you can safely ignore this field.
+   *
+   * To fetch the "complete" chat information, use one of these methods:
+   *  - {@link TelegramClient.getChat}
+   *  - {@link TelegramClient.getFullChat}.
+   *
+   * Learn more: [Incomplete peers](https://mtcute.dev/guide/topics/peers.html#incomplete-peers)
+   */
+  get isMin() {
+    return Boolean(this.raw.min);
+  }
+  /**
+   * Chat's input peer for advanced use-cases.
+   *
+   * > **Note**: for {@link min} chats, this method will return
+   * > `mtcute.dummyInputPeerMin*`, which are actually not a valid input peer,
+   * > These are used to indicate that the user is incomplete, and a message
+   * > reference is needed to resolve the peer.
+   * >
+   * > Such objects are handled by {@link TelegramClient.resolvePeer} method,
+   * so prefer using it whenever you need an input peer.
+   */
+  get inputPeer() {
+    switch (this.raw._) {
+      case "chat":
+      case "chatForbidden":
+        return {
+          _: "inputPeerChat",
+          chatId: this.raw.id
+        };
+      case "channel":
+      case "channelForbidden":
+        if (this.raw.min) {
+          return {
+            _: "mtcute.dummyInputPeerMinChannel",
+            channelId: this.raw.id
+          };
+        }
+        if (!this.raw.accessHash) {
+          throw new MtArgumentError("Peer's access hash is not available!");
+        }
+        return {
+          _: "inputPeerChannel",
+          channelId: this.raw.id,
+          accessHash: this.raw.accessHash
+        };
+    }
+  }
+  /** Type of chat */
+  get chatType() {
+    switch (this.raw._) {
+      case "chat":
+      case "chatForbidden":
+        return "group";
+      case "channel":
+      case "channelForbidden":
+        if (this.raw._ === "channel" && this.raw.gigagroup) {
+          return "gigagroup";
+        } else if (this.raw.broadcast) {
+          return "channel";
+        } else if (this.raw.megagroup) {
+          return "supergroup";
+        }
+        throw new MtArgumentError("Unknown chat type");
+    }
+  }
+  /**
+   * Whether this chat is a group chat (i.e. not a channel)
+   */
+  get isGroup() {
+    return this.chatType !== "channel";
+  }
+  /**
+   * Whether this chat has been verified by Telegram.
+   * Supergroups, channels and groups only
+   */
+  get isVerified() {
+    return "verified" in this.raw ? this.raw.verified : false;
+  }
+  /**
+   * Whether this chat has been restricted.
+   * See {@link restrictions} for details
+   */
+  get isRestricted() {
+    return "restricted" in this.raw ? this.raw.restricted : false;
+  }
+  /**
+   * Whether this chat is owned by the current user.
+   * Supergroups, channels and groups only
+   */
+  get isCreator() {
+    return "creator" in this.raw ? this.raw.creator : false;
+  }
+  /**
+   * Whether current user has admin rights in this chat.
+   * Supergroups, channels and groups only.
+   */
+  get isAdmin() {
+    return "adminRights" in this.raw && Boolean(this.raw.adminRights);
+  }
+  /** Whether this chat has been flagged for scam */
+  get isScam() {
+    return "scam" in this.raw ? this.raw.scam : false;
+  }
+  /** Whether this chat has been flagged for impersonation */
+  get isFake() {
+    return "fake" in this.raw ? this.raw.fake : false;
+  }
+  /** Whether this peer is a forum supergroup */
+  get isForum() {
+    return this.raw._ === "channel" && this.raw.forum;
+  }
+  /**
+   * Whether the chat is not available (e.g. because the user was banned from there).
+   *
+   * **Note**: This method checks if the underlying peer is [`chatForbidden`](https://core.telegram.org/constructor/chatForbidden)
+   * or [`channelForbidden`](https://core.telegram.org/constructor/channelForbidden).
+   * In some cases this field might be `false` *even if* the user is not a member of the chat,
+   * and calling `.getChat()` will throw `CHANNEL_PRIVATE`.
+   * In particular, this seems to be the case for `.forward.sender` of {@link Message} objects.
+   *
+   * Consider also checking for {@link isLikelyUnavailable}.
+   */
+  get isBanned() {
+    return this.raw._ === "chatForbidden" || this.raw._ === "channelForbidden";
+  }
+  /**
+   * Whether the chat is likely not available (e.g. because the user was banned from there),
+   * or the channel is private and the user is not a member of it.
+   */
+  get isLikelyUnavailable() {
+    switch (this.raw._) {
+      case "chatForbidden":
+      case "channelForbidden":
+        return true;
+      case "chat":
+        return this.raw.left || this.raw.deactivated;
+      case "channel":
+        return this.raw.left && this.raw.username === void 0 && this.raw.usernames === void 0 && (this.raw.broadcast || this.raw.megagroup && !this.raw.hasLink);
+    }
+  }
+  /**
+   * Whether the current user is a member of the chat.
+   *
+   * For users, this is always `true`.
+   */
+  get isMember() {
+    switch (this.raw._) {
+      case "channel":
+      case "chat":
+        return !this.raw.left;
+      default:
+        return false;
+    }
+  }
+  /** Whether this chat has a call/livestrean active */
+  get hasCall() {
+    return "callActive" in this.raw ? this.raw.callActive : false;
+  }
+  /** Whether this chat has a call/livestream, and there's at least one member in it */
+  get hasCallMembers() {
+    return "callNotEmpty" in this.raw ? this.raw.callNotEmpty : false;
+  }
+  /** Whether you have hidden (arhived) this chat's stories */
+  get storiesHidden() {
+    return "storiesHidden" in this.raw ? this.raw.storiesHidden : false;
+  }
+  get storiesUnavailable() {
+    return "storiesUnavailable" in this.raw ? this.raw.storiesUnavailable : false;
+  }
+  /** Whether this group is a channel/supergroup with join requests enabled */
+  get hasJoinRequests() {
+    return this.raw._ === "channel" && this.raw.joinRequest;
+  }
+  /** Whether this group is a supergroup with join-to-send rule enabled */
+  get hasJoinToSend() {
+    return this.raw._ === "channel" && this.raw.joinToSend;
+  }
+  /** Whether this group has content protection (i.e. disabled forwards) */
+  get hasContentProtection() {
+    return (this.raw._ === "channel" || this.raw._ === "chat") && this.raw.noforwards;
+  }
+  /** Whether this channel has profile signatures (i.e. "Super Channel") */
+  get hasProfileSignatures() {
+    return this.raw._ === "channel" && this.raw.signatureProfiles;
+  }
+  /** Whether this channel has author signatures enabled under posts */
+  get hasSignatures() {
+    return this.raw._ === "channel" && this.raw.signatures;
+  }
+  /** Chat title */
+  get title() {
+    return this.raw.title;
+  }
+  /** Chat username (if available) */
+  get username() {
+    if (!("username" in this.raw)) return null;
+    return this.raw.username ?? this.raw.usernames?.[0].username ?? null;
+  }
+  /**
+   * Usernames (including collectibles), for private chats, bots, supergroups and channels if available
+   */
+  get usernames() {
+    if (!("usernames" in this.raw)) return null;
+    return this.raw.usernames ?? (this.raw.username ? [{ _: "username", username: this.raw.username, active: true }] : null);
+  }
+  /**
+   * Get the display name of the chat.
+   *
+   * Basically an alias to {@link title}, exists for consistency with {@link User}.
+   */
+  get displayName() {
+    return this.raw.title;
+  }
+  /**
+   * Chat photo, if any.
+   * Suitable for downloads only.
+   *
+   * If full chat information is available, prefer {@link FullChat#fullPhoto} instead.
+   */
+  get photo() {
+    if (!("photo" in this.raw) || this.raw.photo?._ !== "chatPhoto") {
+      return null;
+    }
+    return new ChatPhoto$2(this.inputPeer, this.raw.photo);
+  }
+  /**
+   * The list of reasons why this chat might be unavailable to some users.
+   * This field is available only in case {@link isRestricted} is `true`
+   */
+  get restrictions() {
+    return "restrictionReason" in this.raw ? this.raw.restrictionReason ?? null : null;
+  }
+  /**
+   * Current user's permissions, for supergroups.
+   */
+  get permissions() {
+    if (!("bannedRights" in this.raw && this.raw.bannedRights)) {
+      return null;
+    }
+    return new ChatPermissions$1(this.raw.bannedRights);
+  }
+  /**
+   * Default chat member permissions, for groups and supergroups.
+   */
+  get defaultPermissions() {
+    if (!("defaultBannedRights" in this.raw) || !this.raw.defaultBannedRights) {
+      return null;
+    }
+    return new ChatPermissions$1(this.raw.defaultBannedRights);
+  }
+  /**
+   * Admin rights of the current user in this chat, if any.`
+   */
+  get adminRights() {
+    return "adminRights" in this.raw ? this.raw.adminRights ?? null : null;
+  }
+  /**
+   * Distance in meters of this group chat from your location
+   * Returned only in {@link TelegramClient.getNearbyChats}
+   */
+  distance;
+  /**
+   * Maximum ID of stories this chat has (or 0 if none)
+   */
+  get storiesMaxId() {
+    return this.raw._ === "channel" ? this.raw.storiesMaxId ?? 0 : 0;
+  }
+  /**
+   * Color that should be used when rendering replies to
+   * the messages and web previews sent by this chat,
+   * as well as to render the chat title
+   */
+  get color() {
+    return new ChatColors$1(this.raw.id, this.raw._ === "channel" ? this.raw.color : void 0);
+  }
+  /**
+   * Chat's emoji status, if any.
+   */
+  get emojiStatus() {
+    if (this.raw._ !== "channel") return null;
+    if (!this.raw.emojiStatus || this.raw.emojiStatus._ === "emojiStatusEmpty") return null;
+    return new EmojiStatus$1(this.raw.emojiStatus);
+  }
+  /**
+   * Color that should be used when rendering the header of
+   * the user's profile
+   */
+  get profileColors() {
+    return new ChatColors$1(this.raw.id, this.raw._ === "channel" ? this.raw.profileColor : void 0);
+  }
+  /** Boosts level this chat has (0 if none or is not a channel) */
+  get boostsLevel() {
+    return this.raw._ === "channel" ? this.raw.level ?? 0 : 0;
+  }
+  /**
+   * If a subscription to this channel was bought using Telegram Stars,
+   * this field will contain the date when the subscription will expire.
+   */
+  get subscriptionUntilDate() {
+    if (this.raw._ !== "channel" || !this.raw.subscriptionUntilDate) return null;
+    return new Date(this.raw.subscriptionUntilDate * 1e3);
+  }
+  /** Date when the current user joined this chat (if available) */
+  get joinDate() {
+    return this.isMember && "date" in this.raw ? new Date(this.raw.date * 1e3) : null;
+  }
+  /** Date when the chat was created (if available) */
+  get creationDate() {
+    return !this.isMember && "date" in this.raw ? new Date(this.raw.date * 1e3) : null;
+  }
+  /**
+   * Date when the current user will be unbanned (if available)
+   *
+   * Returns `null` if the user is not banned, or if the ban is permanent
+   */
+  get bannedUntilDate() {
+    if (this.raw._ !== "channelForbidden" || !this.raw.untilDate) return null;
+    return new Date(this.raw.untilDate * 1e3);
+  }
+  /** Number of members in this chat (if available) */
+  get membersCount() {
+    return "participantsCount" in this.raw ? this.raw.participantsCount ?? null : null;
+  }
+  /**
+   * If this chat is a basic group that has been migrated to a supergroup,
+   * this field will contain the input peer of that supergroup.
+   */
+  get migratedTo() {
+    return this.raw._ === "chat" ? this.raw.migratedTo ?? null : null;
+  }
+  /**
+   * If this chat is a basic group that has been migrated to a supergroup,
+   * this field will contain the marked ID of that supergroup.
+   */
+  get migratedToId() {
+    if (this.raw._ !== "chat") return null;
+    if (!this.raw.migratedTo) return null;
+    return getMarkedPeerId(this.raw.migratedTo);
+  }
+  /**
+   * Create a mention for the chat.
+   *
+   * If this is a user, works just like {@link User.mention}.
+   * Otherwise, if the chat has a username, a `@username` is created
+   * (or text link, if `text` is passed). If it does not, chat title is
+   * simply returned without additional formatting.
+   *
+   * When available and `text` is omitted, this method will return `@username`.
+   * Otherwise, text mention is created for the given (or default) parse mode
+   *
+   * Use `null` as `text` (first parameter) to force create a text
+   * mention with display name, even if there is a username.
+   *
+   * > **Note**: This method doesn't format anything on its own.
+   * > Instead, it returns a {@link MessageEntity} that can later
+   * > be used with `html` or `md` template tags, or `unparse` method directly.
+   *
+   * @param text  Text of the mention.
+   * @example
+   * ```typescript
+   * msg.replyText(html`Hello, ${msg.chat.mention()`)
+   * ```
+   */
+  mention(text) {
+    if (text === void 0 && this.username) {
+      return `@${this.username}`;
+    }
+    if (!text) text = this.displayName;
+    if (!this.username) return text;
+    return new MessageEntity$2(
+      {
+        _: "messageEntityTextUrl",
+        offset: 0,
+        length: text.length,
+        url: `https://t.me/${this.username}`
+      },
+      text
+    );
+  }
+}
+const Chat$1 = /* @__PURE__ */ memoizeGetters(Chat, [
+  "inputPeer",
+  "chatType",
+  "usernames",
+  "photo",
+  "permissions",
+  "defaultPermissions",
+  "color"
+]);
+const Chat$2 = /* @__PURE__ */ makeInspectable(Chat$1, []);
+export {
+  Chat$2 as Chat
+};

package/highlevel/types/peers/chatlist-preview.cjs

@@ -0,0 +1,47 @@
+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 inspectable = require("../../utils/inspectable.cjs");
+const memoize = require("../../utils/memoize.cjs");
+const peer = require("./peer.cjs");
+const peersIndex = require("./peers-index.cjs");
+class ChatlistPreview {
+  constructor(raw) {
+    this.raw = raw;
+    this.peers = peersIndex.PeersIndex.from(raw);
+  }
+  peers;
+  /** Whether the current user has already joined this chatlist */
+  get isJoined() {
+    return this.raw._ === "chatlists.chatlistInviteAlready";
+  }
+  /** If we joined the chatlist, ID of the folder representing it */
+  get folderId() {
+    return this.raw._ === "chatlists.chatlistInviteAlready" ? this.raw.filterId : null;
+  }
+  /** Title of the chatlist (only available for non-joined chatlists) */
+  get title() {
+    return this.raw._ === "chatlists.chatlistInvite" ? this.raw.title : "";
+  }
+  /** Emoji representing an icon of the chatlist (may only be available for non-joined chatlists) */
+  get emoji() {
+    return this.raw._ === "chatlists.chatlistInvite" ? this.raw.emoticon ?? null : null;
+  }
+  /** List of all chats contained in the chatlist */
+  get chats() {
+    let peers;
+    if (this.raw._ === "chatlists.chatlistInvite") {
+      peers = this.raw.peers;
+    } else {
+      peers = [...this.raw.alreadyPeers, ...this.raw.missingPeers];
+    }
+    return peers.map((peer$1) => peer.parsePeer(peer$1, this.peers));
+  }
+}
+const ChatlistPreview$1 = /* @__PURE__ */ memoize.memoizeGetters(ChatlistPreview, ["chats"]);
+const ChatlistPreview$2 = /* @__PURE__ */ inspectable.makeInspectable(ChatlistPreview$1);
+exports.ChatlistPreview = ChatlistPreview$2;

package/highlevel/types/peers/chatlist-preview.d.ts

@@ -1,5 +1,5 @@
 import { tl } from '@mtcute/tl';
-import { Chat } from './chat.js';
+import { Peer } from './peer.js';
 import { PeersIndex } from './peers-index.js';
 /**
  * Information about a chatlist
@@ -17,5 +17,5 @@ export declare class ChatlistPreview {
     /** Emoji representing an icon of the chatlist (may only be available for non-joined chatlists) */
     get emoji(): string | null;
     /** List of all chats contained in the chatlist */
-    get chats(): Chat[];
+    get chats(): Peer[];
 }

package/highlevel/types/peers/chatlist-preview.js

@@ -0,0 +1,42 @@
+import { makeInspectable } from "../../utils/inspectable.js";
+import { memoizeGetters } from "../../utils/memoize.js";
+import { parsePeer } from "./peer.js";
+import { PeersIndex } from "./peers-index.js";
+class ChatlistPreview {
+  constructor(raw) {
+    this.raw = raw;
+    this.peers = PeersIndex.from(raw);
+  }
+  peers;
+  /** Whether the current user has already joined this chatlist */
+  get isJoined() {
+    return this.raw._ === "chatlists.chatlistInviteAlready";
+  }
+  /** If we joined the chatlist, ID of the folder representing it */
+  get folderId() {
+    return this.raw._ === "chatlists.chatlistInviteAlready" ? this.raw.filterId : null;
+  }
+  /** Title of the chatlist (only available for non-joined chatlists) */
+  get title() {
+    return this.raw._ === "chatlists.chatlistInvite" ? this.raw.title : "";
+  }
+  /** Emoji representing an icon of the chatlist (may only be available for non-joined chatlists) */
+  get emoji() {
+    return this.raw._ === "chatlists.chatlistInvite" ? this.raw.emoticon ?? null : null;
+  }
+  /** List of all chats contained in the chatlist */
+  get chats() {
+    let peers;
+    if (this.raw._ === "chatlists.chatlistInvite") {
+      peers = this.raw.peers;
+    } else {
+      peers = [...this.raw.alreadyPeers, ...this.raw.missingPeers];
+    }
+    return peers.map((peer) => parsePeer(peer, this.peers));
+  }
+}
+const ChatlistPreview$1 = /* @__PURE__ */ memoizeGetters(ChatlistPreview, ["chats"]);
+const ChatlistPreview$2 = /* @__PURE__ */ makeInspectable(ChatlistPreview$1);
+export {
+  ChatlistPreview$2 as ChatlistPreview
+};

package/highlevel/types/peers/forum-topic.cjs

@@ -0,0 +1,160 @@
+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 memoize = require("../../utils/memoize.cjs");
+const errors = require("../errors.cjs");
+const peer = require("./peer.cjs");
+const peersIndex = require("./peers-index.cjs");
+const message = require("../messages/message.cjs");
+const draftMessage = require("../messages/draft-message.cjs");
+const inspectable = require("../../utils/inspectable.cjs");
+class ForumTopic {
+  constructor(raw, _peers, _messages) {
+    this.raw = raw;
+    this._peers = _peers;
+    this._messages = _messages;
+  }
+  static COLOR_BLUE = 7322096;
+  static COLOR_YELLOW = 16766590;
+  static COLOR_PURPLE = 13338331;
+  static COLOR_GREEN = 9367192;
+  static COLOR_PINK = 16749490;
+  static COLOR_RED = 16478047;
+  static parseTlForumTopics(topics) {
+    const peers = peersIndex.PeersIndex.from(topics);
+    const messages = /* @__PURE__ */ new Map();
+    topics.messages.forEach((msg) => {
+      if (!msg.peerId) return;
+      messages.set(msg.id, msg);
+    });
+    return topics.topics.filter(typeAssertions.hasValueAtKey("_", "forumTopic")).map((it) => new ForumTopic(it, peers, messages));
+  }
+  /**
+   * Whether the topic was created by the current user
+   */
+  get isMy() {
+    return this.raw.my;
+  }
+  /**
+   * Whether the topic is closed
+   */
+  get isClosed() {
+    return this.raw.closed;
+  }
+  /**
+   * Whether the topic is pinned
+   */
+  get isPinned() {
+    return this.raw.pinned;
+  }
+  /**
+   * Whether this constructor is a reduced version of the full topic information.
+   *
+   * If `true`, only {@link isMy}, {@link isClosed}, {@link id}, {@link date},
+   * {@link title}, {@link iconColor}, {@link iconCustomEmoji} and {@link creator}
+   * parameters will contain valid information.
+   */
+  get isShort() {
+    return this.raw.short;
+  }
+  /**
+   * ID of the topic
+   */
+  get id() {
+    return this.raw.id;
+  }
+  /**
+   * Date when the topic was created
+   */
+  get date() {
+    return new Date(this.raw.date * 1e3);
+  }
+  /**
+   * Title of the topic
+   */
+  get title() {
+    return this.raw.title;
+  }
+  /**
+   * Color of the topic's icon, used as a fallback
+   * in case {@link iconEmoji} is not set.
+   *
+   * One of the static `COLOR_*` fields.
+   */
+  get iconColor() {
+    return this.raw.iconColor ?? null;
+  }
+  /**
+   * Emoji used as the topic's icon.
+   */
+  get iconCustomEmoji() {
+    return this.raw.iconEmojiId ?? null;
+  }
+  /**
+   * Creator of the topic
+   */
+  get creator() {
+    return peer.parsePeer(this.raw.fromId, this._peers);
+  }
+  /**
+   * The latest message sent in this topic
+   */
+  get lastMessage() {
+    const id = this.raw.topMessage;
+    if (this._messages?.has(id)) {
+      return new message.Message(this._messages.get(id), this._peers);
+    }
+    throw new errors.MtMessageNotFoundError(0, id);
+  }
+  /**
+   * ID of the last read outgoing message in this topic
+   */
+  get lastReadIngoing() {
+    return this.raw.readInboxMaxId;
+  }
+  /**
+   * ID of the last read ingoing message in this topic
+   */
+  get lastReadOutgoing() {
+    return this.raw.readOutboxMaxId;
+  }
+  /**
+   * ID of the last read message in this topic
+   */
+  get lastRead() {
+    return Math.max(this.raw.readOutboxMaxId, this.raw.readInboxMaxId);
+  }
+  /**
+   * Number of unread messages in the topic
+   */
+  get unreadCount() {
+    return this.raw.unreadCount;
+  }
+  /**
+   * Number of unread mentions in the topic
+   */
+  get unreadMentionsCount() {
+    return this.raw.unreadMentionsCount;
+  }
+  /**
+   * Number of unread reactions in the topic
+   */
+  get unreadReactionsCount() {
+    return this.raw.unreadReactionsCount;
+  }
+  /**
+   * Draft message in the topic
+   */
+  get draftMessage() {
+    if (!this.raw.draft || this.raw.draft._ === "draftMessageEmpty") return null;
+    return new draftMessage.DraftMessage(this.raw.draft);
+  }
+}
+const ForumTopic$1 = /* @__PURE__ */ memoize.memoizeGetters(ForumTopic, ["creator", "lastMessage", "draftMessage"]);
+const ForumTopic$2 = /* @__PURE__ */ inspectable.makeInspectable(ForumTopic$1);
+exports.ForumTopic = ForumTopic$2;