@mtcute/core 0.17.1 → 0.18.0

package/highlevel/types/peers/chat.d.ts

@@ -4,18 +4,14 @@ import { EmojiStatus } from '../reactions/emoji-status.js';
 import { ChatColors } from './chat-colors.js';
 import { ChatPermissions } from './chat-permissions.js';
 import { ChatPhoto } from './chat-photo.js';
-import { PeersIndex } from './peers-index.js';
-import { User } from './user.js';
 /**
  * Chat type. Can be:
- *  - `private`: PM with other users or yourself (Saved Messages)
- *  - `bot`: PM with a bot
- *  - `group`: Legacy group
+ *  - `group`: Legacy/basic group
  *  - `supergroup`: Supergroup
  *  - `channel`: Broadcast channel
  *  - `gigagroup`: Gigagroup aka Broadcast group
  */
-export type ChatType = 'private' | 'bot' | 'group' | 'supergroup' | 'channel' | 'gigagroup';
+export type ChatType = 'group' | 'supergroup' | 'channel' | 'gigagroup';
 /**
  * A chat.
  */
@@ -24,8 +20,8 @@ export declare class Chat {
     /**
      * Raw peer object that this {@link Chat} represents.
      */
-    readonly peer: tl.RawUser | tl.RawChat | tl.RawChannel | tl.RawChatForbidden | tl.RawChannelForbidden;
-    constructor(peer: tl.TypeUser | tl.TypeChat);
+    readonly raw: tl.RawChat | tl.RawChannel | tl.RawChatForbidden | tl.RawChannelForbidden;
+    constructor(peer: tl.TypeChat);
     /** Marked ID of this chat */
     get id(): number;
     /**
@@ -44,7 +40,7 @@ export declare class Chat {
      * 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" user information, use one of these methods:
+     * To fetch the "complete" chat information, use one of these methods:
      *  - {@link TelegramClient.getChat}
      *  - {@link TelegramClient.getFullChat}.
      *
@@ -66,8 +62,7 @@ export declare class Chat {
     /** Type of chat */
     get chatType(): ChatType;
     /**
-     * Whether this chat is a group chat
-     * (i.e. not a channel and not PM)
+     * Whether this chat is a group chat (i.e. not a channel)
      */
     get isGroup(): boolean;
     /**
@@ -94,22 +89,35 @@ export declare class Chat {
     get isScam(): boolean;
     /** Whether this chat has been flagged for impersonation */
     get isFake(): boolean;
-    /** Whether this chat is part of the Telegram support team. Users and bots only */
-    get isSupport(): boolean;
-    /** Whether this chat is chat with yourself (i.e. Saved Messages) */
-    get isSelf(): boolean;
-    /** Whether this peer is your contact */
-    get isContact(): boolean;
     /** Whether this peer is a forum supergroup */
     get isForum(): boolean;
-    /** Whether the chat is not available (e.g. because the user was banned from there) */
-    get isUnavailable(): boolean;
+    /**
+     * 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(): boolean;
+    /**
+     * 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(): boolean;
     /**
      * Whether the current user is a member of the chat.
      *
      * For users, this is always `true`.
      */
     get isMember(): boolean;
+    /** Whether this chat has a call/livestrean active */
+    get hasCall(): boolean;
+    /** Whether this chat has a call/livestream, and there's at least one member in it */
+    get hasCallMembers(): boolean;
     /** Whether you have hidden (arhived) this chat's stories */
     get storiesHidden(): boolean;
     get storiesUnavailable(): boolean;
@@ -121,32 +129,20 @@ export declare class Chat {
     get hasContentProtection(): boolean;
     /** Whether this channel has profile signatures (i.e. "Super Channel") */
     get hasProfileSignatures(): boolean;
-    /**
-     * Title, for supergroups, channels and groups
-     */
-    get title(): string | null;
-    /**
-     * Username, for private chats, bots, supergroups and channels if available
-     */
+    /** Whether this channel has author signatures enabled under posts */
+    get hasSignatures(): boolean;
+    /** Chat title */
+    get title(): string;
+    /** Chat username (if available) */
     get username(): string | null;
     /**
-     * Usernames (inclufing collectibles), for private chats, bots, supergroups and channels if available
+     * Usernames (including collectibles), for private chats, bots, supergroups and channels if available
      */
     get usernames(): ReadonlyArray<tl.RawUsername> | null;
-    /**
-     * First name of the other party in a private chat,
-     * for private chats and bots
-     */
-    get firstName(): string | null;
-    /**
-     * Last name of the other party in a private chat, for private chats
-     */
-    get lastName(): string | null;
     /**
      * Get the display name of the chat.
      *
-     * Title for groups and channels,
-     * name (and last name if available) for users
+     * Basically an alias to {@link title}, exists for consistency with {@link User}.
      */
     get displayName(): string;
     /**
@@ -156,16 +152,6 @@ export declare class Chat {
      * If full chat information is available, prefer {@link FullChat#fullPhoto} instead.
      */
     get photo(): ChatPhoto | null;
-    /**
-     * User's or bot's assigned DC (data center).
-     * Available only in case the user has set a public profile photo.
-     *
-     * **Note**: this information is approximate; it is based on where
-     * Telegram stores the current chat photo. It is accurate only in case
-     * the owner has set the chat photo, otherwise it will be the DC assigned
-     * to the administrator who set the current profile photo.
-     */
-    get dcId(): number | null;
     /**
      * The list of reasons why this chat might be unavailable to some users.
      * This field is available only in case {@link isRestricted} is `true`
@@ -180,8 +166,7 @@ export declare class Chat {
      */
     get defaultPermissions(): ChatPermissions | null;
     /**
-     * Admin rights of the current user in this chat.
-     * `null` for PMs and non-administered chats
+     * Admin rights of the current user in this chat, if any.`
      */
     get adminRights(): tl.RawChatAdminRights | null;
     /**
@@ -206,27 +191,37 @@ export declare class Chat {
     /**
      * Color that should be used when rendering the header of
      * the user's profile
-     *
-     * If `null`, a generic header should be used instead
      */
     get profileColors(): ChatColors;
     /** Boosts level this chat has (0 if none or is not a channel) */
     get boostsLevel(): number;
-    /**
-     * Get a {@link User} from this chat.
-     *
-     * Returns `null` if this is not a chat with user
-     */
-    get user(): User | null;
     /**
      * If a subscription to this channel was bought using Telegram Stars,
      * this field will contain the date when the subscription will expire.
      */
     get subscriptionUntilDate(): Date | null;
-    /** @internal */
-    static _parseFromMessage(message: tl.RawMessage | tl.RawMessageService, peers: PeersIndex): Chat;
-    /** @internal */
-    static _parseFromPeer(peer: tl.TypePeer, peers: PeersIndex): Chat;
+    /** Date when the current user joined this chat (if available) */
+    get joinDate(): Date | null;
+    /** Date when the chat was created (if available) */
+    get creationDate(): Date | 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(): Date | null;
+    /** Number of members in this chat (if available) */
+    get membersCount(): number | 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(): tl.TypeInputChannel | 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(): number | null;
     /**
      * Create a mention for the chat.
      *

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;