@mtcute/dispatcher 0.17.2 → 0.18.0

package/context/callback-query.cjs

@@ -0,0 +1,92 @@
+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 core = require("@mtcute/core");
+class CallbackQueryContext extends core.CallbackQuery {
+  constructor(client, query) {
+    super(query.raw, query._peers);
+    this.client = client;
+  }
+  _name = "callback_query";
+  /** Answer to this callback query */
+  answer(params) {
+    return this.client.answerCallbackQuery(this.id, params);
+  }
+  /**
+   * Get the message containing the callback button being clicked.
+   *
+   * Note that the message may have been deleted, in which case
+   * `null` will be returned.
+   */
+  async getMessage() {
+    return this.client.getCallbackQueryMessage(this);
+  }
+  /**
+   * Edit the message that contained the callback button that was clicked.
+   */
+  async editMessage(params) {
+    return this.client.editMessage({
+      chatId: this.raw.peer,
+      message: this.raw.msgId,
+      ...params
+    });
+  }
+  /**
+   * Shortcut for getting the message and editing it.
+   */
+  async editMessageWith(handler) {
+    const msg = await this.getMessage();
+    if (!msg) return;
+    const res = await handler(msg);
+    if (!res) return;
+    return this.editMessage(res);
+  }
+}
+class InlineCallbackQueryContext extends core.InlineCallbackQuery {
+  constructor(client, query) {
+    super(query.raw, query._peers);
+    this.client = client;
+  }
+  _name = "inline_callback_query";
+  /** Answer to this callback query */
+  answer(params) {
+    return this.client.answerCallbackQuery(this.id, params);
+  }
+  /**
+   * Edit the message that contained the callback button that was clicked.
+   */
+  async editMessage(params) {
+    return this.client.editInlineMessage({
+      messageId: this.raw.msgId,
+      ...params
+    });
+  }
+}
+class BusinessCallbackQueryContext extends core.BusinessCallbackQuery {
+  constructor(client, query) {
+    super(query.raw, query._peers);
+    this.client = client;
+  }
+  _name = "business_callback_query";
+  /** Answer to this callback query */
+  answer(params) {
+    return this.client.answerCallbackQuery(this.id, params);
+  }
+  /**
+   * Edit the message that contained the callback button that was clicked.
+   */
+  async editMessage(params) {
+    return this.client.editMessage({
+      message: this.message,
+      businessConnectionId: this.connectionId,
+      ...params
+    });
+  }
+}
+exports.BusinessCallbackQueryContext = BusinessCallbackQueryContext;
+exports.CallbackQueryContext = CallbackQueryContext;
+exports.InlineCallbackQueryContext = InlineCallbackQueryContext;

package/context/callback-query.d.cts

@@ -0,0 +1,62 @@
+import { MaybePromise, Message, BusinessCallbackQuery, CallbackQuery, InlineCallbackQuery } from '@mtcute/core';
+import { TelegramClient } from '@mtcute/core/client.js';
+import { UpdateContext } from './base.js';
+/**
+ * Context of a callback query update.
+ *
+ * This is a subclass of {@link CallbackQuery}, so all its fields are also available.
+ */
+export declare class CallbackQueryContext extends CallbackQuery implements UpdateContext<CallbackQuery> {
+    readonly client: TelegramClient;
+    readonly _name: "callback_query";
+    constructor(client: TelegramClient, query: CallbackQuery);
+    /** Answer to this callback query */
+    answer(params: Parameters<TelegramClient['answerCallbackQuery']>[1]): Promise<void>;
+    /**
+     * Get the message containing the callback button being clicked.
+     *
+     * Note that the message may have been deleted, in which case
+     * `null` will be returned.
+     */
+    getMessage(): Promise<Message | null>;
+    /**
+     * Edit the message that contained the callback button that was clicked.
+     */
+    editMessage(params: Omit<Parameters<TelegramClient['editInlineMessage']>[0], 'messageId'>): Promise<Message>;
+    /**
+     * Shortcut for getting the message and editing it.
+     */
+    editMessageWith(handler: (msg: Message) => MaybePromise<Parameters<CallbackQueryContext['editMessage']>[0]>): Promise<Message | undefined>;
+}
+/**
+ * Context of an inline-originated callback query update.
+ *
+ * This is a subclass of {@link InlineCallbackQuery}, so all its fields are also available.
+ */
+export declare class InlineCallbackQueryContext extends InlineCallbackQuery implements UpdateContext<InlineCallbackQuery> {
+    readonly client: TelegramClient;
+    readonly _name: "inline_callback_query";
+    constructor(client: TelegramClient, query: InlineCallbackQuery);
+    /** Answer to this callback query */
+    answer(params: Parameters<TelegramClient['answerCallbackQuery']>[1]): Promise<void>;
+    /**
+     * Edit the message that contained the callback button that was clicked.
+     */
+    editMessage(params: Omit<Parameters<TelegramClient['editInlineMessage']>[0], 'messageId'>): Promise<void>;
+}
+/**
+ * Context of an callback query update originated from a business connection message
+ *
+ * This is a subclass of {@link BusinessCallbackQuery}, so all its fields are also available.
+ */
+export declare class BusinessCallbackQueryContext extends BusinessCallbackQuery implements UpdateContext<BusinessCallbackQuery> {
+    readonly client: TelegramClient;
+    readonly _name: "business_callback_query";
+    constructor(client: TelegramClient, query: BusinessCallbackQuery);
+    /** Answer to this callback query */
+    answer(params: Parameters<TelegramClient['answerCallbackQuery']>[1]): Promise<void>;
+    /**
+     * Edit the message that contained the callback button that was clicked.
+     */
+    editMessage(params: Omit<Parameters<TelegramClient['editInlineMessage']>[0], 'messageId'>): Promise<Message>;
+}

package/context/callback-query.js

@@ -0,0 +1,87 @@
+import { CallbackQuery, InlineCallbackQuery, BusinessCallbackQuery } from "@mtcute/core";
+class CallbackQueryContext extends CallbackQuery {
+  constructor(client, query) {
+    super(query.raw, query._peers);
+    this.client = client;
+  }
+  _name = "callback_query";
+  /** Answer to this callback query */
+  answer(params) {
+    return this.client.answerCallbackQuery(this.id, params);
+  }
+  /**
+   * Get the message containing the callback button being clicked.
+   *
+   * Note that the message may have been deleted, in which case
+   * `null` will be returned.
+   */
+  async getMessage() {
+    return this.client.getCallbackQueryMessage(this);
+  }
+  /**
+   * Edit the message that contained the callback button that was clicked.
+   */
+  async editMessage(params) {
+    return this.client.editMessage({
+      chatId: this.raw.peer,
+      message: this.raw.msgId,
+      ...params
+    });
+  }
+  /**
+   * Shortcut for getting the message and editing it.
+   */
+  async editMessageWith(handler) {
+    const msg = await this.getMessage();
+    if (!msg) return;
+    const res = await handler(msg);
+    if (!res) return;
+    return this.editMessage(res);
+  }
+}
+class InlineCallbackQueryContext extends InlineCallbackQuery {
+  constructor(client, query) {
+    super(query.raw, query._peers);
+    this.client = client;
+  }
+  _name = "inline_callback_query";
+  /** Answer to this callback query */
+  answer(params) {
+    return this.client.answerCallbackQuery(this.id, params);
+  }
+  /**
+   * Edit the message that contained the callback button that was clicked.
+   */
+  async editMessage(params) {
+    return this.client.editInlineMessage({
+      messageId: this.raw.msgId,
+      ...params
+    });
+  }
+}
+class BusinessCallbackQueryContext extends BusinessCallbackQuery {
+  constructor(client, query) {
+    super(query.raw, query._peers);
+    this.client = client;
+  }
+  _name = "business_callback_query";
+  /** Answer to this callback query */
+  answer(params) {
+    return this.client.answerCallbackQuery(this.id, params);
+  }
+  /**
+   * Edit the message that contained the callback button that was clicked.
+   */
+  async editMessage(params) {
+    return this.client.editMessage({
+      message: this.message,
+      businessConnectionId: this.connectionId,
+      ...params
+    });
+  }
+}
+export {
+  BusinessCallbackQueryContext,
+  CallbackQueryContext,
+  InlineCallbackQueryContext
+};

package/context/chat-join-request.cjs

@@ -0,0 +1,32 @@
+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 core = require("@mtcute/core");
+class ChatJoinRequestUpdateContext extends core.BotChatJoinRequestUpdate {
+  constructor(client, update) {
+    super(update.raw, update._peers);
+    this.client = client;
+  }
+  _name = "bot_chat_join_request";
+  /** Approve the request */
+  approve() {
+    return this.client.hideJoinRequest({
+      action: "approve",
+      user: this.user.inputPeer,
+      chatId: this.chat.inputPeer
+    });
+  }
+  /** Decline the request */
+  decline() {
+    return this.client.hideJoinRequest({
+      action: "decline",
+      user: this.user.inputPeer,
+      chatId: this.chat.inputPeer
+    });
+  }
+}
+exports.ChatJoinRequestUpdateContext = ChatJoinRequestUpdateContext;

package/context/chat-join-request.d.cts

@@ -0,0 +1,17 @@
+import { TelegramClient } from '@mtcute/core/client.js';
+import { UpdateContext } from './base.js';
+import { BotChatJoinRequestUpdate } from '@mtcute/core';
+/**
+ * Context of a chat join request update (for bots).
+ *
+ * This is a subclass of {@link BotChatJoinRequestUpdate}, so all its fields are also available.
+ */
+export declare class ChatJoinRequestUpdateContext extends BotChatJoinRequestUpdate implements UpdateContext<BotChatJoinRequestUpdate> {
+    readonly client: TelegramClient;
+    readonly _name: "bot_chat_join_request";
+    constructor(client: TelegramClient, update: BotChatJoinRequestUpdate);
+    /** Approve the request */
+    approve(): Promise<void>;
+    /** Decline the request */
+    decline(): Promise<void>;
+}

package/context/chat-join-request.d.ts

@@ -1,6 +1,6 @@
-import { BotChatJoinRequestUpdate } from '@mtcute/core';
 import { TelegramClient } from '@mtcute/core/client.js';
 import { UpdateContext } from './base.js';
+import { BotChatJoinRequestUpdate } from '@mtcute/core';
 /**
  * Context of a chat join request update (for bots).
  *

package/context/chat-join-request.js

@@ -0,0 +1,27 @@
+import { BotChatJoinRequestUpdate } from "@mtcute/core";
+class ChatJoinRequestUpdateContext extends BotChatJoinRequestUpdate {
+  constructor(client, update) {
+    super(update.raw, update._peers);
+    this.client = client;
+  }
+  _name = "bot_chat_join_request";
+  /** Approve the request */
+  approve() {
+    return this.client.hideJoinRequest({
+      action: "approve",
+      user: this.user.inputPeer,
+      chatId: this.chat.inputPeer
+    });
+  }
+  /** Decline the request */
+  decline() {
+    return this.client.hideJoinRequest({
+      action: "decline",
+      user: this.user.inputPeer,
+      chatId: this.chat.inputPeer
+    });
+  }
+}
+export {
+  ChatJoinRequestUpdateContext
+};

package/context/chosen-inline-result.cjs

@@ -0,0 +1,30 @@
+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 core = require("@mtcute/core");
+class ChosenInlineResultContext extends core.ChosenInlineResult {
+  constructor(client, result) {
+    super(result.raw, result._peers);
+    this.client = client;
+  }
+  _name = "chosen_inline_result";
+  /**
+   * Edit the message that was sent when this inline result that was chosen.
+   *
+   * > **Note**: This method can only be used if the message contained a reply markup
+   */
+  async editMessage(params) {
+    if (!this.raw.msgId) {
+      throw new core.MtArgumentError("No message ID, make sure you have included reply markup!");
+    }
+    return this.client.editInlineMessage({
+      ...params,
+      messageId: this.raw.msgId
+    });
+  }
+}
+exports.ChosenInlineResultContext = ChosenInlineResultContext;

package/context/chosen-inline-result.d.cts

@@ -0,0 +1,22 @@
+import { TelegramClient } from '@mtcute/core/client.js';
+import { UpdateContext } from './base.js';
+import { ChosenInlineResult } from '@mtcute/core';
+/**
+ * Context of a chosen inline result update.
+ *
+ * This is a subclass of {@link ChosenInlineResult}, so all its fields are also available.
+ *
+ * > **Note**: To receive these updates, you must enable
+ * > Inline feedback in [@BotFather](//t.me/botfather)
+ */
+export declare class ChosenInlineResultContext extends ChosenInlineResult implements UpdateContext<ChosenInlineResult> {
+    readonly client: TelegramClient;
+    readonly _name: "chosen_inline_result";
+    constructor(client: TelegramClient, result: ChosenInlineResult);
+    /**
+     * Edit the message that was sent when this inline result that was chosen.
+     *
+     * > **Note**: This method can only be used if the message contained a reply markup
+     */
+    editMessage(params: Parameters<TelegramClient['editInlineMessage']>[0]): Promise<void>;
+}

package/context/chosen-inline-result.d.ts

@@ -1,6 +1,6 @@
-import { ChosenInlineResult } from '@mtcute/core';
 import { TelegramClient } from '@mtcute/core/client.js';
 import { UpdateContext } from './base.js';
+import { ChosenInlineResult } from '@mtcute/core';
 /**
  * Context of a chosen inline result update.
  *

package/context/chosen-inline-result.js

@@ -0,0 +1,25 @@
+import { ChosenInlineResult, MtArgumentError } from "@mtcute/core";
+class ChosenInlineResultContext extends ChosenInlineResult {
+  constructor(client, result) {
+    super(result.raw, result._peers);
+    this.client = client;
+  }
+  _name = "chosen_inline_result";
+  /**
+   * Edit the message that was sent when this inline result that was chosen.
+   *
+   * > **Note**: This method can only be used if the message contained a reply markup
+   */
+  async editMessage(params) {
+    if (!this.raw.msgId) {
+      throw new MtArgumentError("No message ID, make sure you have included reply markup!");
+    }
+    return this.client.editInlineMessage({
+      ...params,
+      messageId: this.raw.msgId
+    });
+  }
+}
+export {
+  ChosenInlineResultContext
+};

package/context/index.d.cts

@@ -0,0 +1,9 @@
+export * from './base.js';
+export * from './business-message.js';
+export * from './callback-query.js';
+export * from './chat-join-request.js';
+export * from './chosen-inline-result.js';
+export * from './inline-query.js';
+export * from './message.js';
+export type { UpdateContextType } from './parse.js';
+export * from './pre-checkout-query.js';

package/context/inline-query.cjs

@@ -0,0 +1,20 @@
+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 core = require("@mtcute/core");
+class InlineQueryContext extends core.InlineQuery {
+  constructor(client, query) {
+    super(query.raw, query._peers);
+    this.client = client;
+  }
+  _name = "inline_query";
+  /** Answer to this inline query */
+  answer(...params) {
+    return this.client.answerInlineQuery(this.id, ...params);
+  }
+}
+exports.InlineQueryContext = InlineQueryContext;

package/context/inline-query.d.cts

@@ -0,0 +1,15 @@
+import { ParametersSkip1, InlineQuery } from '@mtcute/core';
+import { TelegramClient } from '@mtcute/core/client.js';
+import { UpdateContext } from './base.js';
+/**
+ * Context of an inline query update.
+ *
+ * This is a subclass of {@link InlineQuery}, so all its fields are also available.
+ */
+export declare class InlineQueryContext extends InlineQuery implements UpdateContext<InlineQuery> {
+    readonly client: TelegramClient;
+    readonly _name: "inline_query";
+    constructor(client: TelegramClient, query: InlineQuery);
+    /** Answer to this inline query */
+    answer(...params: ParametersSkip1<TelegramClient['answerInlineQuery']>): Promise<void>;
+}

package/context/inline-query.js

@@ -0,0 +1,15 @@
+import { InlineQuery } from "@mtcute/core";
+class InlineQueryContext extends InlineQuery {
+  constructor(client, query) {
+    super(query.raw, query._peers);
+    this.client = client;
+  }
+  _name = "inline_query";
+  /** Answer to this inline query */
+  answer(...params) {
+    return this.client.answerInlineQuery(this.id, ...params);
+  }
+}
+export {
+  InlineQueryContext
+};

package/context/message.cjs

@@ -0,0 +1,182 @@
+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 core = require("@mtcute/core");
+class MessageContext extends core.Message {
+  constructor(client, message) {
+    const msg = Array.isArray(message) ? message[message.length - 1] : message;
+    super(msg.raw, msg._peers, msg.isScheduled);
+    this.client = client;
+    this.messages = Array.isArray(message) ? message.map((it) => new MessageContext(client, it)) : [this];
+    this.isMessageGroup = Array.isArray(message);
+  }
+  // this is primarily for proper types in filters, so don't bother much with actual value
+  _name = "new_message";
+  /**
+   * List of messages in the message group.
+   *
+   * For other updates, this is a list with a single element (`this`).
+   */
+  messages;
+  /** Whether this update is about a message group */
+  isMessageGroup;
+  /**
+   * Get complete information about {@link sender}
+   *
+   * Learn more: [Incomplete peers](https://mtcute.dev/guide/topics/peers.html#incomplete-peers)
+   */
+  async getCompleteSender() {
+    if (!this.sender.isMin) return this.sender;
+    let res;
+    if (this.sender.type === "user") {
+      res = await this.client.getUser(this.sender);
+    } else {
+      res = await this.client.getChat(this.sender);
+    }
+    if (!res) throw new core.MtPeerNotFoundError("Failed to fetch sender");
+    Object.defineProperty(this, "sender", { value: res });
+    return res;
+  }
+  /**
+   * Get complete information about {@link chat}
+   *
+   * Learn more: [Incomplete peers](https://mtcute.dev/guide/topics/peers.html#incomplete-peers)
+   */
+  async getCompleteChat() {
+    if (!this.chat.isMin) return this.chat;
+    let res;
+    if (this.chat.type === "user") {
+      res = await this.client.getUser(this.chat);
+    } else {
+      res = await this.client.getChat(this.chat);
+    }
+    if (!res) throw new core.MtPeerNotFoundError("Failed to fetch chat");
+    Object.defineProperty(this, "chat", { value: res });
+    return res;
+  }
+  /** Get a message that this message is a reply to */
+  getReplyTo() {
+    return this.client.getReplyTo(this);
+  }
+  /** If this is a channel post, get its automatic forward in the discussion group */
+  getDiscussionMessage() {
+    return this.client.getDiscussionMessage({ chatId: this.chat.inputPeer, message: this.id });
+  }
+  /** Get all custom emojis contained in this message (message group), if any */
+  getCustomEmojis() {
+    return this.client.getCustomEmojisFromMessages(this.messages);
+  }
+  /** Send a text message to the same chat (and topic, if applicable) as a given message */
+  answerText(...params) {
+    return this.client.answerText(this, ...params);
+  }
+  /** Send a media to the same chat (and topic, if applicable) as a given message */
+  answerMedia(...params) {
+    return this.client.answerMedia(this, ...params);
+  }
+  /** Send a media group to the same chat (and topic, if applicable) as a given message */
+  answerMediaGroup(...params) {
+    return this.client.answerMediaGroup(this, ...params);
+  }
+  /** Send a text message in reply to this message */
+  replyText(...params) {
+    return this.client.replyText(this, ...params);
+  }
+  /** Send a media in reply to this message */
+  replyMedia(...params) {
+    return this.client.replyMedia(this, ...params);
+  }
+  /** Send a media group in reply to this message */
+  replyMediaGroup(...params) {
+    return this.client.replyMediaGroup(this, ...params);
+  }
+  /** Send a text message in reply to this message */
+  quoteWithText(params) {
+    return this.client.quoteWithText(this, params);
+  }
+  /** Send a media in reply to this message */
+  quoteWithMedia(params) {
+    return this.client.quoteWithMedia(this, params);
+  }
+  /** Send a media group in reply to this message */
+  quoteWithMediaGroup(params) {
+    return this.client.quoteWithMediaGroup(this, params);
+  }
+  /** Send a text as a comment to this message */
+  commentText(...params) {
+    return this.client.commentText(this, ...params);
+  }
+  /** Send a media as a comment to this message */
+  commentMedia(...params) {
+    return this.client.commentMedia(this, ...params);
+  }
+  /** Send a media group as a comment to this message */
+  commentMediaGroup(...params) {
+    return this.client.commentMediaGroup(this, ...params);
+  }
+  /** Delete this message (message group) */
+  delete(params) {
+    return this.client.deleteMessagesById(
+      this.chat.inputPeer,
+      this.messages.map((it) => it.id),
+      params
+    );
+  }
+  /** Pin this message */
+  pin(params) {
+    return this.client.pinMessage({
+      chatId: this.chat.inputPeer,
+      message: this.id,
+      ...params
+    });
+  }
+  /** Unpin this message */
+  unpin() {
+    return this.client.unpinMessage({
+      chatId: this.chat.inputPeer,
+      message: this.id
+    });
+  }
+  /** Edit this message */
+  edit(params) {
+    return this.client.editMessage({
+      chatId: this.chat.inputPeer,
+      message: this.id,
+      ...params
+    });
+  }
+  /** Forward this message (message group) */
+  forwardTo(params) {
+    return this.client.forwardMessagesById({
+      fromChatId: this.chat.inputPeer,
+      messages: this.messages.map((it) => it.id),
+      ...params
+    });
+  }
+  /** Send a copy of this message (message group) */
+  copy(params) {
+    if (this.isMessageGroup) {
+      return this.client.sendCopyGroup({
+        messages: this.messages,
+        ...params
+      });
+    }
+    return this.client.sendCopy({
+      message: this,
+      ...params
+    });
+  }
+  /** React to this message */
+  react(params) {
+    return this.client.sendReaction({
+      chatId: this.chat.inputPeer,
+      message: this.id,
+      ...params
+    });
+  }
+}
+exports.MessageContext = MessageContext;