discord.jselfbot-v13 0.0.1-security → 2.17.2

package/src/managers/MessageManager.js

@@ -0,0 +1,393 @@
+'use strict';
+
+const { Collection } = require('@discordjs/collection');
+const CachedManager = require('./CachedManager');
+const { TypeError, Error } = require('../errors');
+const { Message } = require('../structures/Message');
+const MessagePayload = require('../structures/MessagePayload');
+const Util = require('../util/Util');
+
+/**
+ * Manages API methods for Messages and holds their cache.
+ * @extends {CachedManager}
+ */
+class MessageManager extends CachedManager {
+  constructor(channel, iterable) {
+    super(channel.client, Message, iterable);
+
+    /**
+     * The channel that the messages belong to
+     * @type {TextBasedChannels}
+     */
+    this.channel = channel;
+  }
+
+  /**
+   * The cache of Messages
+   * @type {Collection<Snowflake, Message>}
+   * @name MessageManager#cache
+   */
+
+  _add(data, cache) {
+    return super._add(data, cache);
+  }
+
+  /**
+   * The parameters to pass in when requesting previous messages from a channel. `around`, `before` and
+   * `after` are mutually exclusive. All the parameters are optional.
+   * @typedef {Object} ChannelLogsQueryOptions
+   * @property {number} [limit=50] Number of messages to acquire
+   * @property {Snowflake} [before] The message's id to get the messages that were posted before it
+   * @property {Snowflake} [after] The message's id to get the messages that were posted after it
+   * @property {Snowflake} [around] The message's id to get the messages that were posted around it
+   */
+
+  /**
+   * Gets a message, or messages, from this channel.
+   * <info>The returned Collection does not contain reaction users of the messages if they were not cached.
+   * Those need to be fetched separately in such a case.</info>
+   * @param {Snowflake|ChannelLogsQueryOptions} [message] The id of the message to fetch, or query parameters.
+   * @param {BaseFetchOptions} [options] Additional options for this fetch
+   * @returns {Promise<Message|Collection<Snowflake, Message>>}
+   * @example
+   * // Get message
+   * channel.messages.fetch('99539446449315840')
+   *   .then(message => console.log(message.content))
+   *   .catch(console.error);
+   * @example
+   * // Get messages
+   * channel.messages.fetch({ limit: 10 })
+   *   .then(messages => console.log(`Received ${messages.size} messages`))
+   *   .catch(console.error);
+   * @example
+   * // Get messages and filter by user id
+   * channel.messages.fetch()
+   *   .then(messages => console.log(`${messages.filter(m => m.author.id === '84484653687267328').size} messages`))
+   *   .catch(console.error);
+   */
+  fetch(message, { cache = true, force = false } = {}) {
+    return typeof message === 'string' ? this._fetchId(message, cache, force) : this._fetchMany(message, cache);
+  }
+
+  /**
+   * Fetches the pinned messages of this channel and returns a collection of them.
+   * <info>The returned Collection does not contain any reaction data of the messages.
+   * Those need to be fetched separately.</info>
+   * @param {boolean} [cache=true] Whether to cache the message(s)
+   * @returns {Promise<Collection<Snowflake, Message>>}
+   * @example
+   * // Get pinned messages
+   * channel.messages.fetchPinned()
+   *   .then(messages => console.log(`Received ${messages.size} messages`))
+   *   .catch(console.error);
+   */
+  async fetchPinned(cache = true) {
+    const data = await this.client.api.channels[this.channel.id].pins.get();
+    const messages = new Collection();
+    for (const message of data) messages.set(message.id, this._add(message, cache));
+    return messages;
+  }
+
+  /**
+   * Data that can be resolved to a Message object. This can be:
+   * * A Message
+   * * A Snowflake
+   * @typedef {Message|Snowflake} MessageResolvable
+   */
+
+  /**
+   * Resolves a {@link MessageResolvable} to a {@link Message} object.
+   * @method resolve
+   * @memberof MessageManager
+   * @instance
+   * @param {MessageResolvable} message The message resolvable to resolve
+   * @returns {?Message}
+   */
+
+  /**
+   * Resolves a {@link MessageResolvable} to a {@link Message} id.
+   * @method resolveId
+   * @memberof MessageManager
+   * @instance
+   * @param {MessageResolvable} message The message resolvable to resolve
+   * @returns {?Snowflake}
+   */
+
+  /**
+   * Edits a message, even if it's not cached.
+   * @param {MessageResolvable} message The message to edit
+   * @param {string|MessageEditOptions|MessagePayload} options The options to edit the message
+   * @returns {Promise<Message>}
+   */
+  async edit(message, options) {
+    const messageId = this.resolveId(message);
+    if (!messageId) throw new TypeError('INVALID_TYPE', 'message', 'MessageResolvable');
+
+    let messagePayload;
+    if (options instanceof MessagePayload) {
+      messagePayload = await options.resolveData();
+    } else {
+      messagePayload = await MessagePayload.create(message instanceof Message ? message : this, options).resolveData();
+    }
+    let { data, files } = await messagePayload.resolveFiles();
+
+    if (typeof options == 'object' && typeof options.usingNewAttachmentAPI !== 'boolean') {
+      options.usingNewAttachmentAPI = this.client.options.usingNewAttachmentAPI;
+    }
+
+    if (options?.usingNewAttachmentAPI === true) {
+      const attachments = await Util.getAttachments(this.client, this.channel.id, ...files);
+      const requestPromises = attachments.map(async attachment => {
+        await Util.uploadFile(files[attachment.id].file, attachment.upload_url);
+        return {
+          id: attachment.id,
+          filename: files[attachment.id].name,
+          uploaded_filename: attachment.upload_filename,
+          description: files[attachment.id].description,
+          duration_secs: files[attachment.id].duration_secs,
+          waveform: files[attachment.id].waveform,
+        };
+      });
+      const attachmentsData = await Promise.all(requestPromises);
+      attachmentsData.sort((a, b) => parseInt(a.id) - parseInt(b.id));
+      data.attachments = attachmentsData;
+      files = [];
+    }
+
+    const d = await this.client.api.channels[this.channel.id].messages[messageId].patch({ data, files });
+
+    const existing = this.cache.get(messageId);
+    if (existing) {
+      const clone = existing._clone();
+      clone._patch(d);
+      return clone;
+    }
+    return this._add(d);
+  }
+
+  /**
+   * Publishes a message in an announcement channel to all channels following it, even if it's not cached.
+   * @param {MessageResolvable} message The message to publish
+   * @returns {Promise<Message>}
+   */
+  async crosspost(message) {
+    message = this.resolveId(message);
+    if (!message) throw new TypeError('INVALID_TYPE', 'message', 'MessageResolvable');
+
+    const data = await this.client.api.channels(this.channel.id).messages(message).crosspost.post();
+    return this.cache.get(data.id) ?? this._add(data);
+  }
+
+  /**
+   * Pins a message to the channel's pinned messages, even if it's not cached.
+   * @param {MessageResolvable} message The message to pin
+   * @param {string} [reason] Reason for pinning
+   * @returns {Promise<void>}
+   */
+  async pin(message, reason) {
+    message = this.resolveId(message);
+    if (!message) throw new TypeError('INVALID_TYPE', 'message', 'MessageResolvable');
+
+    await this.client.api.channels(this.channel.id).pins(message).put({ reason });
+  }
+
+  /**
+   * Unpins a message from the channel's pinned messages, even if it's not cached.
+   * @param {MessageResolvable} message The message to unpin
+   * @param {string} [reason] Reason for unpinning
+   * @returns {Promise<void>}
+   */
+  async unpin(message, reason) {
+    message = this.resolveId(message);
+    if (!message) throw new TypeError('INVALID_TYPE', 'message', 'MessageResolvable');
+
+    await this.client.api.channels(this.channel.id).pins(message).delete({ reason });
+  }
+
+  /**
+   * Adds a reaction to a message, even if it's not cached.
+   * @param {MessageResolvable} message The message to react to
+   * @param {EmojiIdentifierResolvable} emoji The emoji to react with
+   * @param {boolean} [burst=false] Super Reactions (Discord Nitro only)
+   * @returns {Promise<void>}
+   */
+  async react(message, emoji, burst = false) {
+    message = this.resolveId(message);
+    if (!message) throw new TypeError('INVALID_TYPE', 'message', 'MessageResolvable');
+
+    emoji = Util.resolvePartialEmoji(emoji);
+    if (!emoji) throw new TypeError('EMOJI_TYPE', 'emoji', 'EmojiIdentifierResolvable');
+
+    const emojiId = emoji.id
+      ? `${emoji.animated ? 'a:' : ''}${emoji.name}:${emoji.id}`
+      : encodeURIComponent(emoji.name);
+
+    // eslint-disable-next-line newline-per-chained-call
+    await this.client.api
+      .channels(this.channel.id)
+      .messages(message)
+      .reactions(emojiId, '@me')
+      .put({
+        query: {
+          type: burst ? 1 : 0,
+        },
+      });
+  }
+
+  /**
+   * Deletes a message, even if it's not cached.
+   * @param {MessageResolvable} message The message to delete
+   * @returns {Promise<void>}
+   */
+  async delete(message) {
+    message = this.resolveId(message);
+    if (!message) throw new TypeError('INVALID_TYPE', 'message', 'MessageResolvable');
+
+    await this.client.api.channels(this.channel.id).messages(message).delete();
+  }
+
+  _fetchId(messageId, cache, force) {
+    if (!force) {
+      const existing = this.cache.get(messageId);
+      if (existing && !existing.partial) return existing;
+    }
+    // https://discord.com/api/v9/channels/:id/messages?limit=50&around=:msgid
+    return new Promise((resolve, reject) => {
+      this._fetchMany({
+        around: messageId,
+        limit: 50,
+      })
+        .then(data_ =>
+          data_.has(messageId) ? resolve(data_.get(messageId)) : reject(new Error('MESSAGE_ID_NOT_FOUND')),
+        )
+        .catch(reject);
+    });
+  }
+
+  async _fetchMany(options = {}, cache) {
+    const data = await this.client.api.channels[this.channel.id].messages.get({ query: options });
+    const messages = new Collection();
+    for (const message of data) messages.set(message.id, this._add(message, cache));
+    return messages;
+  }
+
+  /**
+   * @typedef {object} MessageSearchOptions
+   * @property {Array<UserResolvable>} [authors] An array of author to filter by
+   * @property {Array<UserResolvable>} [mentions] An array of user (mentioned) to filter by
+   * @property {string} [content] A messageContent to filter by
+   * @property {Snowflake} [maxId] The maximum Message ID to filter by
+   * @property {Snowflake} [minId] The minimum Message ID to filter by
+   * @property {Array<TextChannelResolvable>} [channels] An array of channel to filter by
+   * @property {boolean} [pinned] Whether to filter by pinned messages
+   * @property {Array<string>} [has] Message has: `link`, `embed`, `file`, `video`, `image`, or `sound`
+   * @property {boolean} [nsfw=false] Whether to filter by NSFW channels
+   * @property {number} [offset=0] The number of messages to skip (for pagination, 25 results per page)
+   * @property {number} [limit=25] The number of messages to fetch
+   * <info>The maximum limit allowed is 25.</info>
+   * @property {string} [sortBy] The order to sort by (`timestamp` or `relevance`)
+   * @property {string} [sortOrder] The order to return results in (`asc` or `desc`)
+   * <info>The default sort is <code>timestamp</code> in descending order <code>desc</code> (newest first).</info>
+   */
+
+  /**
+   * @typedef {object} MessageSearchResult
+   * @property {Collection<Snowflake, Message>} messages A collection of found messages
+   * @property {number} total The total number of messages that match the search criteria
+   */
+
+  /**
+   * Search Messages in the channel.
+   * @param {MessageSearchOptions} options Performs a search within the channel.
+   * @returns {MessageSearchResult}
+   */
+  async search(options = {}) {
+    // eslint-disable-next-line no-unused-vars
+    let { authors, content, mentions, has, maxId, minId, channels, pinned, nsfw, offset, limit, sortBy, sortOrder } =
+      Object.assign(
+        {
+          authors: [],
+          content: '',
+          mentions: [],
+          has: [],
+          maxId: null,
+          minId: null,
+          channels: [],
+          pinned: false,
+          nsfw: false,
+          offset: 0,
+          limit: 25,
+          sortBy: 'timestamp',
+          sortOrder: 'desc',
+        },
+        options,
+      );
+    // Validate
+    if (authors.length > 0) authors = authors.map(u => this.client.users.resolveId(u));
+    if (mentions.length > 0) mentions = mentions.map(u => this.client.users.resolveId(u));
+    if (channels.length > 0) {
+      channels = channels
+        .map(c => this.client.channels.resolveId(c))
+        .filter(id => {
+          if (this.channel.guildId) {
+            const c = this.channel.guild.channels.cache.get(id);
+            if (!c || !c.messages) return false;
+            const perm = c.permissionsFor(this.client.user);
+            if (!perm.has('READ_MESSAGE_HISTORY') || !perm.has('VIEW_CHANNEL')) return false;
+            return true;
+          } else {
+            return true;
+          }
+        });
+    }
+    if (limit && limit > 25) throw new RangeError('MESSAGE_SEARCH_LIMIT');
+    let stringQuery = [];
+    const result = new Collection();
+    let data;
+    if (authors.length > 0) stringQuery.push(authors.map(id => `author_id=${id}`).join('&'));
+    if (content && content.length) stringQuery.push(`content=${encodeURIComponent(content)}`);
+    if (mentions.length > 0) stringQuery.push(mentions.map(id => `mentions=${id}`).join('&'));
+    has = has.filter(v => ['link', 'embed', 'file', 'video', 'image', 'sound', 'sticker'].includes(v));
+    if (has.length > 0) stringQuery.push(has.map(v => `has=${v}`).join('&'));
+    if (maxId) stringQuery.push(`max_id=${maxId}`);
+    if (minId) stringQuery.push(`min_id=${minId}`);
+    if (nsfw) stringQuery.push('include_nsfw=true');
+    if (offset !== 0) stringQuery.push(`offset=${offset}`);
+    if (limit !== 25) stringQuery.push(`limit=${limit}`);
+    if (['timestamp', 'relevance'].includes(options.sortBy)) {
+      stringQuery.push(`sort_by=${options.sortBy}`);
+    } else {
+      stringQuery.push('sort_by=timestamp');
+    }
+    if (['asc', 'desc'].includes(options.sortOrder)) {
+      stringQuery.push(`sort_order=${options.sortOrder}`);
+    } else {
+      stringQuery.push('sort_order=desc');
+    }
+    if (this.channel.guildId && channels.length > 0) {
+      stringQuery.push(channels.map(id => `channel_id=${id}`).join('&'));
+    }
+    if (typeof pinned == 'boolean') stringQuery.push(`pinned=${pinned}`);
+    // Main
+    if (!stringQuery.length) {
+      return {
+        messages: result,
+        total: 0,
+      };
+    }
+    if (this.channel.guildId) {
+      data = await this.client.api.guilds[this.channel.guildId].messages[`search?${stringQuery.join('&')}`].get();
+    } else {
+      stringQuery = stringQuery.filter(v => !v.startsWith('channel_id') && !v.startsWith('include_nsfw'));
+      data = await this.client.api.channels[this.channel.id].messages[`search?${stringQuery.join('&')}`].get();
+    }
+    console.log(stringQuery);
+    for await (const message of data.messages) result.set(message[0].id, new Message(this.client, message[0]));
+    return {
+      messages: result,
+      total: data.total_results,
+    };
+  }
+}
+
+module.exports = MessageManager;

package/src/managers/PermissionOverwriteManager.js

@@ -0,0 +1,166 @@
+'use strict';
+
+const process = require('node:process');
+const { Collection } = require('@discordjs/collection');
+const CachedManager = require('./CachedManager');
+const { TypeError } = require('../errors');
+const PermissionOverwrites = require('../structures/PermissionOverwrites');
+const { Role } = require('../structures/Role');
+const { OverwriteTypes } = require('../util/Constants');
+
+let cacheWarningEmitted = false;
+
+/**
+ * Manages API methods for guild channel permission overwrites and stores their cache.
+ * @extends {CachedManager}
+ */
+class PermissionOverwriteManager extends CachedManager {
+  constructor(channel, iterable) {
+    super(channel.client, PermissionOverwrites);
+    if (!cacheWarningEmitted && this._cache.constructor.name !== 'Collection') {
+      cacheWarningEmitted = true;
+      process.emitWarning(
+        `Overriding the cache handling for ${this.constructor.name} is unsupported and breaks functionality.`,
+        'UnsupportedCacheOverwriteWarning',
+      );
+    }
+
+    /**
+     * The channel of the permission overwrite this manager belongs to
+     * @type {GuildChannel}
+     */
+    this.channel = channel;
+
+    if (iterable) {
+      for (const item of iterable) {
+        this._add(item);
+      }
+    }
+  }
+
+  /**
+   * The cache of this Manager
+   * @type {Collection<Snowflake, PermissionOverwrites>}
+   * @name PermissionOverwriteManager#cache
+   */
+
+  _add(data, cache) {
+    return super._add(data, cache, { extras: [this.channel] });
+  }
+
+  /**
+   * Replaces the permission overwrites in this channel.
+   * @param {OverwriteResolvable[]|Collection<Snowflake, OverwriteResolvable>} overwrites
+   * Permission overwrites the channel gets updated with
+   * @param {string} [reason] Reason for updating the channel overwrites
+   * @returns {Promise<GuildChannel>}
+   * @example
+   * message.channel.permissionOverwrites.set([
+   *   {
+   *      id: message.author.id,
+   *      deny: [Permissions.FLAGS.VIEW_CHANNEL],
+   *   },
+   * ], 'Needed to change permissions');
+   */
+  set(overwrites, reason) {
+    if (!Array.isArray(overwrites) && !(overwrites instanceof Collection)) {
+      return Promise.reject(
+        new TypeError('INVALID_TYPE', 'overwrites', 'Array or Collection of Permission Overwrites', true),
+      );
+    }
+    return this.channel.edit({ permissionOverwrites: overwrites, reason });
+  }
+
+  /**
+   * Extra information about the overwrite
+   * @typedef {Object} GuildChannelOverwriteOptions
+   * @property {string} [reason] Reason for creating/editing this overwrite
+   * @property {number} [type] The type of overwrite, either `0` for a role or `1` for a member. Use this to bypass
+   * automatic resolution of type that results in an error for uncached structure
+   */
+
+  /**
+   * Creates or edits permission overwrites for a user or role in this channel.
+   * @param {RoleResolvable|UserResolvable} userOrRole The user or role to update
+   * @param {PermissionOverwriteOptions} options The options for the update
+   * @param {GuildChannelOverwriteOptions} [overwriteOptions] The extra information for the update
+   * @param {PermissionOverwrites} [existing] The existing overwrites to merge with this update
+   * @returns {Promise<GuildChannel>}
+   * @private
+   */
+  async upsert(userOrRole, options, overwriteOptions = {}, existing) {
+    const userOrRoleId = this.channel.guild.roles.resolveId(userOrRole) ?? this.client.users.resolveId(userOrRole);
+    let { type, reason } = overwriteOptions;
+    if (typeof type !== 'number') {
+      userOrRole = this.channel.guild.roles.resolve(userOrRole) ?? this.client.users.resolve(userOrRole);
+      if (!userOrRole) throw new TypeError('INVALID_TYPE', 'parameter', 'User nor a Role');
+      type = userOrRole instanceof Role ? OverwriteTypes.role : OverwriteTypes.member;
+    }
+
+    const { allow, deny } = PermissionOverwrites.resolveOverwriteOptions(options, existing);
+
+    await this.client.api
+      .channels(this.channel.id)
+      .permissions(userOrRoleId)
+      .put({
+        data: { id: userOrRoleId, type, allow, deny },
+        reason,
+      });
+    return this.channel;
+  }
+
+  /**
+   * Creates permission overwrites for a user or role in this channel, or replaces them if already present.
+   * @param {RoleResolvable|UserResolvable} userOrRole The user or role to update
+   * @param {PermissionOverwriteOptions} options The options for the update
+   * @param {GuildChannelOverwriteOptions} [overwriteOptions] The extra information for the update
+   * @returns {Promise<GuildChannel>}
+   * @example
+   * // Create or Replace permission overwrites for a message author
+   * message.channel.permissionOverwrites.create(message.author, {
+   *   SEND_MESSAGES: false
+   * })
+   *   .then(channel => console.log(channel.permissionOverwrites.cache.get(message.author.id)))
+   *   .catch(console.error);
+   */
+  create(userOrRole, options, overwriteOptions) {
+    return this.upsert(userOrRole, options, overwriteOptions);
+  }
+
+  /**
+   * Edits permission overwrites for a user or role in this channel, or creates an entry if not already present.
+   * @param {RoleResolvable|UserResolvable} userOrRole The user or role to update
+   * @param {PermissionOverwriteOptions} options The options for the update
+   * @param {GuildChannelOverwriteOptions} [overwriteOptions] The extra information for the update
+   * @returns {Promise<GuildChannel>}
+   * @example
+   * // Edit or Create permission overwrites for a message author
+   * message.channel.permissionOverwrites.edit(message.author, {
+   *   SEND_MESSAGES: false
+   * })
+   *   .then(channel => console.log(channel.permissionOverwrites.cache.get(message.author.id)))
+   *   .catch(console.error);
+   */
+  edit(userOrRole, options, overwriteOptions) {
+    const existing = this.cache.get(
+      this.channel.guild.roles.resolveId(userOrRole) ?? this.client.users.resolveId(userOrRole),
+    );
+    return this.upsert(userOrRole, options, overwriteOptions, existing);
+  }
+
+  /**
+   * Deletes permission overwrites for a user or role in this channel.
+   * @param {UserResolvable|RoleResolvable} userOrRole The user or role to delete
+   * @param {string} [reason] The reason for deleting the overwrite
+   * @returns {Promise<GuildChannel>}
+   */
+  async delete(userOrRole, reason) {
+    const userOrRoleId = this.channel.guild.roles.resolveId(userOrRole) ?? this.client.users.resolveId(userOrRole);
+    if (!userOrRoleId) throw new TypeError('INVALID_TYPE', 'parameter', 'User nor a Role');
+
+    await this.client.api.channels(this.channel.id).permissions(userOrRoleId).delete({ reason });
+    return this.channel;
+  }
+}
+
+module.exports = PermissionOverwriteManager;

package/src/managers/PresenceManager.js

@@ -0,0 +1,58 @@
+'use strict';
+
+const CachedManager = require('./CachedManager');
+const { Presence } = require('../structures/Presence');
+
+/**
+ * Manages API methods for Presences and holds their cache.
+ * @extends {CachedManager}
+ */
+class PresenceManager extends CachedManager {
+  constructor(client, iterable) {
+    super(client, Presence, iterable);
+  }
+
+  /**
+   * The cache of Presences
+   * @type {Collection<Snowflake, Presence>}
+   * @name PresenceManager#cache
+   */
+
+  _add(data, cache) {
+    return super._add(data, cache, { id: data.user.id });
+  }
+
+  /**
+   * Data that can be resolved to a Presence object. This can be:
+   * * A Presence
+   * * A UserResolvable
+   * * A Snowflake
+   * @typedef {Presence|UserResolvable|Snowflake} PresenceResolvable
+   */
+
+  /**
+   * Resolves a {@link PresenceResolvable} to a {@link Presence} object.
+   * @param {PresenceResolvable} presence The presence resolvable to resolve
+   * @returns {?Presence}
+   */
+  resolve(presence) {
+    const presenceResolvable = super.resolve(presence);
+    if (presenceResolvable) return presenceResolvable;
+    const UserResolvable = this.client.users.resolveId(presence);
+    return super.resolve(UserResolvable);
+  }
+
+  /**
+   * Resolves a {@link PresenceResolvable} to a {@link Presence} id.
+   * @param {PresenceResolvable} presence The presence resolvable to resolve
+   * @returns {?Snowflake}
+   */
+  resolveId(presence) {
+    const presenceResolvable = super.resolveId(presence);
+    if (presenceResolvable) return presenceResolvable;
+    const userResolvable = this.client.users.resolveId(presence);
+    return this.cache.has(userResolvable) ? userResolvable : null;
+  }
+}
+
+module.exports = PresenceManager;

package/src/managers/ReactionManager.js

@@ -0,0 +1,67 @@
+'use strict';
+
+const CachedManager = require('./CachedManager');
+const MessageReaction = require('../structures/MessageReaction');
+
+/**
+ * Manages API methods for reactions and holds their cache.
+ * @extends {CachedManager}
+ */
+class ReactionManager extends CachedManager {
+  constructor(message, iterable) {
+    super(message.client, MessageReaction, iterable);
+
+    /**
+     * The message that this manager belongs to
+     * @type {Message}
+     */
+    this.message = message;
+  }
+
+  _add(data, cache) {
+    return super._add(data, cache, { id: data.emoji.id ?? data.emoji.name, extras: [this.message] });
+  }
+
+  /**
+   * The reaction cache of this manager
+   * @type {Collection<string|Snowflake, MessageReaction>}
+   * @name ReactionManager#cache
+   */
+
+  /**
+   * Data that can be resolved to a MessageReaction object. This can be:
+   * * A MessageReaction
+   * * A Snowflake
+   * * The Unicode representation of an emoji
+   * @typedef {MessageReaction|Snowflake} MessageReactionResolvable
+   */
+
+  /**
+   * Resolves a {@link MessageReactionResolvable} to a {@link MessageReaction} object.
+   * @method resolve
+   * @memberof ReactionManager
+   * @instance
+   * @param {MessageReactionResolvable} reaction The MessageReaction to resolve
+   * @returns {?MessageReaction}
+   */
+
+  /**
+   * Resolves a {@link MessageReactionResolvable} to a {@link MessageReaction} id.
+   * @method resolveId
+   * @memberof ReactionManager
+   * @instance
+   * @param {MessageReactionResolvable} reaction The MessageReaction to resolve
+   * @returns {?Snowflake}
+   */
+
+  /**
+   * Removes all reactions from a message.
+   * @returns {Promise<Message>}
+   */
+  async removeAll() {
+    await this.client.api.channels(this.message.channelId).messages(this.message.id).reactions.delete();
+    return this.message;
+  }
+}
+
+module.exports = ReactionManager;