djs-selfbot-v13 3.1.7 → 3.2.2

package/src/structures/Message.js

@@ -4,19 +4,17 @@ const process = require('node:process');
 const { Collection } = require('@discordjs/collection');
 const Base = require('./Base');
 const BaseMessageComponent = require('./BaseMessageComponent');
-const ClientApplication = require('./ClientApplication');
-const InteractionCollector = require('./InteractionCollector');
 const MessageAttachment = require('./MessageAttachment');
-const MessageButton = require('./MessageButton');
 const Embed = require('./MessageEmbed');
 const Mentions = require('./MessageMentions');
 const MessagePayload = require('./MessagePayload');
-const MessageSelectMenu = require('./MessageSelectMenu');
+const MessagePoll = require('./MessagePoll');
 const ReactionCollector = require('./ReactionCollector');
 const { Sticker } = require('./Sticker');
+const Application = require('./interfaces/Application');
 const { Error } = require('../errors');
 const ReactionManager = require('../managers/ReactionManager');
-const { InteractionTypes, MessageTypes, SystemMessageTypes, MaxBulkDeletableMessageAge } = require('../util/Constants');
+const { InteractionTypes, MessageTypes, SystemMessageTypes, MessageComponentTypes } = require('../util/Constants');
 const MessageFlags = require('../util/MessageFlags');
 const Permissions = require('../util/Permissions');
 const SnowflakeUtil = require('../util/SnowflakeUtil');
@@ -253,12 +251,22 @@ class Message extends Base {
       this.webhookId ??= null;
     }
 
+    /**
+     * A poll!
+     * @type {?MessagePoll}
+     */
+    if ('poll' in data) {
+      this.poll = new MessagePoll(data.poll, this.client);
+    } else {
+      this.poll = null;
+    }
+
     if ('application' in data) {
       /**
        * Supplemental application information for group activities
-       * @type {?ClientApplication}
+       * @type {?Application}
        */
-      this.groupActivityApplication = new ClientApplication(this.client, data.application);
+      this.groupActivityApplication = new Application(this.client, data.application);
     } else {
       this.groupActivityApplication ??= null;
     }
@@ -533,65 +541,6 @@ class Message extends Base {
     });
   }
 
-  /**
-   * @typedef {CollectorOptions} MessageComponentCollectorOptions
-   * @property {MessageComponentType} [componentType] The type of component to listen for
-   * @property {number} [max] The maximum total amount of interactions to collect
-   * @property {number} [maxComponents] The maximum number of components to collect
-   * @property {number} [maxUsers] The maximum number of users to interact
-   */
-
-  /**
-   * Creates a message component interaction collector.
-   * @param {MessageComponentCollectorOptions} [options={}] Options to send to the collector
-   * @returns {InteractionCollector}
-   * @example
-   * // Create a message component interaction collector
-   * const filter = (interaction) => interaction.customId === 'button' && interaction.user.id === 'someId';
-   * const collector = message.createMessageComponentCollector({ filter, time: 15_000 });
-   * collector.on('collect', i => console.log(`Collected ${i.customId}`));
-   * collector.on('end', collected => console.log(`Collected ${collected.size} items`));
-   */
-  createMessageComponentCollector(options = {}) {
-    return new InteractionCollector(this.client, {
-      ...options,
-      interactionType: InteractionTypes.MESSAGE_COMPONENT,
-      message: this,
-    });
-  }
-
-  /**
-   * An object containing the same properties as CollectorOptions, but a few more:
-   * @typedef {Object} AwaitMessageComponentOptions
-   * @property {CollectorFilter} [filter] The filter applied to this collector
-   * @property {number} [time] Time to wait for an interaction before rejecting
-   * @property {MessageComponentType} [componentType] The type of component interaction to collect
-   */
-
-  /**
-   * Collects a single component interaction that passes the filter.
-   * The Promise will reject if the time expires.
-   * @param {AwaitMessageComponentOptions} [options={}] Options to pass to the internal collector
-   * @returns {Promise<MessageComponentInteraction>}
-   * @example
-   * // Collect a message component interaction
-   * const filter = (interaction) => interaction.customId === 'button' && interaction.user.id === 'someId';
-   * message.awaitMessageComponent({ filter, time: 15_000 })
-   *   .then(interaction => console.log(`${interaction.customId} was clicked!`))
-   *   .catch(console.error);
-   */
-  awaitMessageComponent(options = {}) {
-    const _options = { ...options, max: 1 };
-    return new Promise((resolve, reject) => {
-      const collector = this.createMessageComponentCollector(_options);
-      collector.once('end', (interactions, reason) => {
-        const interaction = interactions.first();
-        if (interaction) resolve(interaction);
-        else reject(new Error('INTERACTION_COLLECTOR_ERROR', reason));
-      });
-    });
-  }
-
   /**
    * Whether the message is editable by the client user
    * @type {boolean}
@@ -653,14 +602,7 @@ class Message extends Base {
    * channel.bulkDelete(messages.filter(message => message.bulkDeletable));
    */
   get bulkDeletable() {
-    return (
-      (this.inGuild() &&
-        this.client.user.bot &&
-        Date.now() - this.createdTimestamp < MaxBulkDeletableMessageAge &&
-        this.deletable &&
-        this.channel?.permissionsFor(this.client.user).has(Permissions.FLAGS.MANAGE_MESSAGES, false)) ??
-      false
-    );
+    return false;
   }
 
   /**
@@ -722,7 +664,7 @@ class Message extends Base {
    * @property {MessageAttachment[]} [attachments] An array of attachments to keep,
    * all attachments will be kept if omitted
    * @property {FileOptions[]|BufferResolvable[]|MessageAttachment[]} [files] Files to add to the message
-   * @property {Array<(MessageActionRow|MessageActionRowOptions)>} [components]
+   * @property {MessageActionRow[]|MessageActionRowOptions[]} [components]
    * Action rows containing interactive components for the message (buttons, select menus)
    */
 
@@ -792,7 +734,7 @@ class Message extends Base {
   /**
    * Adds a reaction to the message.
    * @param {EmojiIdentifierResolvable} emoji The emoji to react with
-   * @param {boolean} [burst=false] Super Reactions (Discord Nitro only)
+   * @param {boolean} [burst=false] Super Reactions
    * @returns {Promise<MessageReaction>}
    * @example
    * // React to a message with a unicode emoji
@@ -811,9 +753,9 @@ class Message extends Base {
 
     return this.client.actions.MessageReactionAdd.handle(
       {
-        user: this.client.user,
-        channel: this.channel,
-        message: this,
+        [this.client.actions.injectedUser]: this.client.user,
+        [this.client.actions.injectedChannel]: this.channel,
+        [this.client.actions.injectedMessage]: this,
         emoji: Util.resolvePartialEmoji(emoji),
         me_burst: burst,
       },
@@ -908,6 +850,55 @@ class Message extends Base {
     return this.channel.threads.create({ ...options, startMessage: this });
   }
 
+  /**
+   * Submits a poll vote for the current user. Returns a 204 empty response on success.
+   * @param  {...number[]} ids ID of the answer
+   * @returns {Promise<void>}
+   * @example
+   * // Vote multi choices
+   * message.vote(1,2);
+   * // Remove vote
+   * message.vote();
+   */
+  vote(...ids) {
+    return this.client.api
+      .channels(this.channel.id)
+      .polls(this.id)
+      .answers['@me'].put({
+        data: {
+          answer_ids: ids.flat(1).map(value => value.toString()),
+        },
+      });
+  }
+
+  /**
+   * Immediately ends the poll. You cannot end polls from other users.
+   * @returns {Promise<RawMessage>}
+   */
+  endPoll() {
+    return this.client.api.channels(this.channel.id).polls(this.id).expire.post();
+  }
+
+  /**
+   * Get a list of users that voted for this specific answer.
+   * @param {number} answerId Answer Id
+   * @param {Snowflake} [afterUserId] Get users after this user ID
+   * @param {number} [limit=25] Max number of users to return (1-100, default 25)
+   * @returns {Promise<{ users: Partial<RawUser> }>}
+   */
+  getAnswerVoter(answerId, afterUserId, limit = 25) {
+    return this.client.api
+      .channels(this.channel.id)
+      .polls(this.id)
+      .answers(answerId)
+      .get({
+        query: {
+          after: afterUserId,
+          limit,
+        },
+      });
+  }
+
   /**
    * Fetch this message.
    * @param {boolean} [force=true] Whether to skip the cache check and request the API
@@ -1024,157 +1015,182 @@ class Message extends Base {
       reactions: false,
     });
   }
-  // Added
-  /**
-   * Marks the message as unread.
-   * @returns {Promise<boolean>}
-   */
-  async markUnread() {
-    await this.client.api.channels[this.channelId].messages[this.id].ack.post({
-      data: {
-        manual: true,
-        mention_count: 1,
-      },
-    });
-    return true;
-  }
 
+  // TypeScript
   /**
-   * Marks the message as read.
-   * @returns {Promise<boolean>}
+   * Check data
+   * @type {boolean}
+   * @readonly
    */
-  async markRead() {
-    await this.client.api.channels[this.channelId].messages[this.id].ack.post({
-      data: {
-        token: null,
-      },
-    });
+  get isMessage() {
     return true;
   }
 
   /**
+   * Click specific button with X and Y
    * @typedef {Object} MessageButtonLocation
-   * @property {number} row Index of the row
-   * @property {number} col Index of the column
+   * @property {number} X Index of the row
+   * @property {number} Y Index of the column
    */
 
   /**
    * Click specific button or automatically click first button if no button is specified.
-   * @param {MessageButton|MessageButtonLocation|string} button Button ID
-   * @returns {Promise<InteractionResponse>}
+   * @param {MessageButtonLocation|string|undefined} button button
+   * @returns {Promise<Message|Modal>}
    * @example
-   * client.on('messageCreate', async message => {
-   *  if (message.components.length) {
-   *    // Find first button and click it
-   *    await message.clickButton();
-   *    // Click with button ID
-   *    await message.clickButton('button-id');
-   *    // Click with button location
-   *    await message.clickButton({ row: 0, col: 0 });
-   *    // Click with class MessageButton
-   *    const button = message.components[0].components[0];
-   *    await message.clickButton(button);
-   *    // Click with class MessageButton (2)
-   *    button.click(message);
-   *  }
+   * // Demo msg
+   * Some content
+   *  ――――――――――――――――――――――――――――――――> X from 0
+   *  │ [button1] [button2] [button3]
+   *  │ [button4] [button5] [button6]
+   *  ↓
+   *  Y from 0
+   * // Click button6 with X and Y
+   * [0,0] [1,0] [2,0]
+   * [0,1] [1,1] [2,1]
+   * // Code
+   * message.clickButton({
+   *  X: 2, Y: 1,
    * });
+   * // Click button with customId (Ex button 5)
+   * message.clickButton('button5');
+   * // Click button 1
+   * message.clickButton();
    */
   clickButton(button) {
-    if (!button) {
-      button = this.components.flatMap(row => row.components).find(b => b.type === 'BUTTON')?.customId;
-    } else if (button instanceof MessageButton) {
-      button = button.customId;
-    } else if (typeof button === 'object') {
-      if (!('row' in button) || !('col' in button)) throw new TypeError('INVALID_BUTTON_LOCATION');
-      button = this.components[button.row]?.components[button.col]?.customId;
+    if (typeof button == 'undefined') {
+      button = this.components
+        .flatMap(row => row.components)
+        .find(b => b.type === 'BUTTON' && b.customId && !b.disabled);
+    } else if (typeof button == 'string') {
+      button = this.components.flatMap(row => row.components).find(b => b.type === 'BUTTON' && b.customId == button);
+    } else {
+      button = this.components[button.Y]?.components[button.X];
     }
     if (!button) throw new TypeError('BUTTON_NOT_FOUND');
-    button = this.components.flatMap(row => row.components).find(b => b.customId === button && b.type === 'BUTTON');
-    return button ? button.click(this) : Promise.reject(new TypeError('BUTTON_NOT_FOUND'));
+    button = button.toJSON();
+    if (!button.custom_id || button.disabled) throw new TypeError('BUTTON_CANNOT_CLICK');
+    const nonce = SnowflakeUtil.generate();
+    const data = {
+      type: InteractionTypes.MESSAGE_COMPONENT,
+      nonce,
+      guild_id: this.guildId,
+      channel_id: this.channelId,
+      message_id: this.id,
+      application_id: this.applicationId ?? this.author.id,
+      session_id: this.client.sessionId,
+      message_flags: this.flags.bitfield,
+      data: {
+        component_type: MessageComponentTypes.BUTTON,
+        custom_id: button.custom_id,
+      },
+    };
+    this.client.api.interactions.post({
+      data,
+    });
+    return Util.createPromiseInteraction(this.client, nonce, 5_000, true, this);
   }
+
   /**
-   * Select specific menu or First Menu
-   * @param {MessageSelectMenu|string|number|Array<any>} menuID MenuId / MessageSelectMenu / Row of Menu / Array of Values (first menu)
-   * @param {Array<any>} options Array of Values
-   * @returns {Promise<InteractionResponse>}
-   * @example
-   * client.on('messageCreate', async message => {
-   *  if (message.components.length) {
-   *    // Row
-   *    await message.selectMenu(1, [message.channel]); // row 1, type: Channel, multi: false
-   *    // Id
-   *    await message.selectMenu('menu-id', ['uid1', client.user, message.member]); // MenuId, type: User, multi: true
-   *    // First Menu
-   *    await message.selectMenu(['role-id']); // First Menu, type: role, multi: false
-   *    // class MessageSelectMenu
-   *    const menu = message.components[0].components[0];
-   *    await message.selectMenu(menu, ['option1', 'option2']);
-   *    // MessageSelectMenu (2)
-   *    menu.select(message, ['option1', 'option2']);
-   *  }
-   * });
+   * Select specific menu
+   * @param {number|string} menu Target
+   * @param {Array<UserResolvable | RoleResolvable | ChannelResolvable | string>} values Any value
+   * @returns {Promise<Message|Modal>}
    */
-  selectMenu(menuID, options = []) {
-    if (!this.components[0]) throw new TypeError('MESSAGE_NO_COMPONENTS');
-    if (menuID instanceof MessageSelectMenu) {
-      //
-    } else if (/[0-4]/.test(menuID)) {
-      menuID = this.components[menuID]?.components[0];
-    } else {
-      const menuAll = this.components
+  selectMenu(menu, values = []) {
+    let selectMenu = menu;
+    if (/[0-4]/.test(menu)) {
+      selectMenu = this.components[menu]?.components[0];
+    } else if (typeof menu == 'string') {
+      selectMenu = this.components
         .flatMap(row => row.components)
-        .filter(b =>
-          [
-            'STRING_SELECT',
-            'USER_SELECT',
-            'ROLE_SELECT',
-            'MENTIONABLE_SELECT',
-            'CHANNEL_SELECT',
-            'SELECT_MENU',
-          ].includes(b.type),
+        .find(
+          b =>
+            ['STRING_SELECT', 'USER_SELECT', 'ROLE_SELECT', 'MENTIONABLE_SELECT', 'CHANNEL_SELECT'].includes(b.type) &&
+            b.customId == menu &&
+            !b.disabled,
         );
-      if (menuAll.length == 0) throw new TypeError('MENU_NOT_FOUND');
-      if (menuID) {
-        menuID = menuAll.find(b => b.customId === menuID);
-      } else {
-        menuID = menuAll[0];
-      }
     }
-    if (!menuID.type.includes('SELECT')) throw new TypeError('MENU_NOT_FOUND');
-    return menuID.select(this, Array.isArray(menuID) ? menuID : options);
+    if (values.length < selectMenu.minValues) {
+      throw new RangeError(`[SELECT_MENU_MIN_VALUES] The minimum number of values is ${selectMenu.minValues}`);
+    }
+    if (values.length > selectMenu?.maxValues) {
+      throw new RangeError(`[SELECT_MENU_MAX_VALUES] The maximum number of values is ${selectMenu.maxValues}`);
+    }
+    values = values.map(value => {
+      switch (selectMenu.type) {
+        case 'STRING_SELECT': {
+          return selectMenu.options.find(obj => obj.value === value || obj.label === value).value;
+        }
+        case 'USER_SELECT': {
+          return this.client.users.resolveId(value);
+        }
+        case 'ROLE_SELECT': {
+          return this.guild.roles.resolveId(value);
+        }
+        case 'MENTIONABLE_SELECT': {
+          return this.client.users.resolveId(value) || this.guild.roles.resolveId(value);
+        }
+        case 'CHANNEL_SELECT': {
+          return this.client.channels.resolveId(value);
+        }
+        default: {
+          return value;
+        }
+      }
+    });
+    const nonce = SnowflakeUtil.generate();
+    const data = {
+      type: InteractionTypes.MESSAGE_COMPONENT,
+      guild_id: this.guildId,
+      channel_id: this.channelId,
+      message_id: this.id,
+      application_id: this.applicationId ?? this.author.id,
+      session_id: this.client.sessionId,
+      message_flags: this.flags.bitfield,
+      data: {
+        component_type: MessageComponentTypes[selectMenu.type],
+        custom_id: selectMenu.customId,
+        type: MessageComponentTypes[selectMenu.type],
+        values,
+      },
+      nonce,
+    };
+    this.client.api.interactions.post({
+      data,
+    });
+    return Util.createPromiseInteraction(this.client, nonce, 5_000, true, this);
   }
-  //
+
   /**
-   * Send context Menu v2
-   * @param {Snowflake} botId Bot id
-   * @param {string} commandName Command name in Context Menu
-   * @returns {Promise<InteractionResponse>}
+   * Marks the message as unread.
+   * @returns {Promise<void>}
    */
-  async contextMenu(botId, commandName) {
-    if (!botId) throw new Error('Bot ID is required');
-    const user = await this.client.users.fetch(botId).catch(() => {});
-    if (!user || !user.bot || !user.application) {
-      throw new Error('BotID is not a bot or does not have an application slash command');
-    }
-    if (!commandName || typeof commandName !== 'string') {
-      throw new Error('Command name is required');
-    }
-    let contextCMD;
-    const data = await this.channel.searchInteraction(botId, 'MESSAGE');
-    for (const command of data.application_commands) {
-      user.application?.commands?._add(command, true);
-    }
-    contextCMD = user.application?.commands?.cache.find(c => c.name == commandName && c.type === 'MESSAGE');
-    if (!contextCMD) {
-      throw new Error(
-        'INTERACTION_SEND_FAILURE',
-        `Command ${commandName} is not found (with search)\nList command avalible: ${user.application?.commands?.cache
-          .filter(a => a.type == 'MESSAGE')
-          .map(a => a.name)
-          .join(', ')}`,
-      );
-    }
-    return contextCMD.sendContextMenu(this, true);
+  markUnread() {
+    return this.client.api.channels[this.channelId].messages[this.id].ack.post({
+      data: {
+        manual: true,
+        mention_count:
+          this.mentions.everyone ||
+          this.mentions.repliedUser?.id === this.client.user.id ||
+          this.mentions.users.has(this.client.user.id) ||
+          (this.guildId && this.mentions.roles.some(r => this.guild.members.me._roles?.includes(r.id)))
+            ? 1
+            : 1,
+      },
+    });
+  }
+
+  /**
+   * Marks the message as read.
+   * @returns {Promise<void>}
+   */
+  markRead() {
+    return this.client.api.channels[this.channelId].messages[this.id].ack.post({
+      data: {
+        token: null,
+      },
+    });
   }
 
   /**
@@ -1183,6 +1199,7 @@ class Message extends Base {
    * @param {Object} [elements={}] Metadata
    * @returns {Promise<{ report_id: Snowflake }>}
    * @example
+   * // GET https://discord.com/api/v9/reporting/menu/message?variant=4
    * // Report Category
    * // - <hidden>MESSAGE_WELCOME (3)</hidden>
    * // - Something else (28)

package/src/structures/MessageAttachment.js

@@ -1,5 +1,6 @@
 'use strict';
 
+const AttachmentFlags = require('../util/AttachmentFlags');
 const Util = require('../util/Util');
 
 /**
@@ -169,6 +170,16 @@ class MessageAttachment {
     } else {
       this.waveform ??= null;
     }
+
+    if ('flags' in data) {
+      /**
+       * The flags of this attachment
+       * @type {Readonly<AttachmentFlags>}
+       */
+      this.flags = new AttachmentFlags(data.flags).freeze();
+    } else {
+      this.flags ??= new AttachmentFlags().freeze();
+    }
   }
 
   /**

package/src/structures/MessageButton.js

@@ -1,13 +1,9 @@
 'use strict';
 
-const { setTimeout } = require('node:timers');
 const BaseMessageComponent = require('./BaseMessageComponent');
 const { RangeError } = require('../errors');
-const { MessageButtonStyles, MessageComponentTypes, InteractionTypes } = require('../util/Constants');
-const SnowflakeUtil = require('../util/SnowflakeUtil');
+const { MessageButtonStyles, MessageComponentTypes } = require('../util/Constants');
 const Util = require('../util/Util');
-const { lazy } = require('../util/Util');
-const Message = lazy(() => require('../structures/Message').Message);
 
 /**
  * Represents a button message component.
@@ -164,68 +160,6 @@ class MessageButton extends BaseMessageComponent {
   static resolveStyle(style) {
     return typeof style === 'string' ? style : MessageButtonStyles[style];
   }
-  // Patch Click
-  /**
-   * Click the button
-   * @param {Message} message Discord Message
-   * @returns {Promise<InteractionResponse>}
-   */
-  async click(message) {
-    const nonce = SnowflakeUtil.generate();
-    if (!(message instanceof Message())) throw new Error('[UNKNOWN_MESSAGE] Please pass a valid Message');
-    if (!this.customId || this.style == MessageButtonStyles.LINK || this.disabled) return false;
-    const data = {
-      type: InteractionTypes.MESSAGE_COMPONENT,
-      nonce,
-      guild_id: message.guild?.id ?? null,
-      channel_id: message.channel.id,
-      message_id: message.id,
-      application_id: message.applicationId ?? message.author.id,
-      session_id: message.client.session_id,
-      message_flags: message.flags.bitfield,
-      data: {
-        component_type: MessageComponentTypes.BUTTON,
-        custom_id: this.customId,
-      },
-    };
-    await message.client.api.interactions.post({
-      data,
-    });
-    message.client._interactionCache.set(nonce, {
-      channelId: message.channelId,
-      guildId: message.guildId,
-      metadata: data,
-    });
-    return new Promise((resolve, reject) => {
-      const handler = data => {
-        timeout.refresh();
-        if (data.metadata?.nonce !== nonce) return;
-        clearTimeout(timeout);
-        message.client.removeListener('interactionResponse', handler);
-        message.client.decrementMaxListeners();
-        if (data.status) {
-          resolve(data.metadata);
-        } else {
-          reject(
-            new Error('INTERACTION_ERROR', {
-              cause: data,
-            }),
-          );
-        }
-      };
-      const timeout = setTimeout(() => {
-        message.client.removeListener('interactionResponse', handler);
-        message.client.decrementMaxListeners();
-        reject(
-          new Error('INTERACTION_TIMEOUT', {
-            cause: data,
-          }),
-        );
-      }, message.client.options.interactionTimeout).unref();
-      message.client.incrementMaxListeners();
-      message.client.on('interactionResponse', handler);
-    });
-  }
 }
 
 module.exports = MessageButton;

package/src/structures/MessageEmbed.js

@@ -8,7 +8,7 @@ let deprecationEmittedForSetAuthor = false;
 let deprecationEmittedForSetFooter = false;
 let deprecationEmittedForAddField = false;
 
-// TODO: Remove the deprecated code for `setAuthor()`, `setFooter()` and `addField()`.
+// TODO: Remove the deprecated code for `setAuthor()` and `setFooter()`.
 
 /**
  * Represents an embed in a message (image/video preview, rich embed, etc.)

package/src/structures/MessageMentions.js

@@ -211,12 +211,13 @@ class MessageMentions {
    */
   has(data, { ignoreDirect = false, ignoreRoles = false, ignoreRepliedUser = false, ignoreEveryone = false } = {}) {
     const user = this.client.users.resolve(data);
+
     if (!ignoreEveryone && user && this.everyone) return true;
 
     const userWasRepliedTo = user && this.repliedUser?.id === user.id;
 
     if (!ignoreRepliedUser && userWasRepliedTo && this.users.has(user.id)) return true;
-    if (!ignoreRepliedUser && this.users.has(this.repliedUser?.id) && this.repliedUser?.id === user?.id) return true;
+
     if (!ignoreDirect) {
       if (user && (!ignoreRepliedUser || this.parsedUsers.has(user.id)) && this.users.has(user.id)) return true;
 
@@ -226,7 +227,7 @@ class MessageMentions {
       const channel = this.client.channels.resolve(data);
       if (channel && this.channels.has(channel.id)) return true;
     }
-    if (user && !ignoreEveryone && this.everyone) return true;
+
     if (!ignoreRoles) {
       const member = this.guild?.members.resolve(data);
       if (member) {