@velliajs/discord 1.0.2 → 1.0.4

package/src/managers/GuildScheduledEventManager.js

@@ -8,66 +8,24 @@ const { DiscordjsTypeError, DiscordjsError, ErrorCodes } = require('../errors');
 const { GuildScheduledEvent } = require('../structures/GuildScheduledEvent');
 const DataResolver = require('../util/DataResolver');
 
-/**
- * Manages API methods for GuildScheduledEvents and stores their cache.
- * @extends {CachedManager}
- */
+
 class GuildScheduledEventManager extends CachedManager {
   constructor(guild, iterable) {
     super(guild.client, GuildScheduledEvent, iterable);
 
-    /**
-     * The guild this manager belongs to
-     * @type {Guild}
-     */
+    
     this.guild = guild;
   }
 
-  /**
-   * The cache of this manager
-   * @type {Collection<Snowflake, GuildScheduledEvent>}
-   * @name GuildScheduledEventManager#cache
-   */
-
-  /**
-   * Data that resolves to give a GuildScheduledEvent object. This can be:
-   * * A Snowflake
-   * * A GuildScheduledEvent object
-   * @typedef {Snowflake|GuildScheduledEvent} GuildScheduledEventResolvable
-   */
-
-  /**
-   * Options used to create a guild scheduled event.
-   * @typedef {Object} GuildScheduledEventCreateOptions
-   * @property {string} name The name of the guild scheduled event
-   * @property {DateResolvable} scheduledStartTime The time to schedule the event at
-   * @property {DateResolvable} [scheduledEndTime] The time to end the event at
-   * <warn>This is required if `entityType` is {@link GuildScheduledEventEntityType.External}</warn>
-   * @property {GuildScheduledEventPrivacyLevel} privacyLevel The privacy level of the guild scheduled event
-   * @property {GuildScheduledEventEntityType} entityType The scheduled entity type of the event
-   * @property {string} [description] The description of the guild scheduled event
-   * @property {GuildVoiceChannelResolvable} [channel] The channel of the guild scheduled event
-   * <warn>This is required if `entityType` is {@link GuildScheduledEventEntityType.StageInstance} or
-   * {@link GuildScheduledEventEntityType.Voice}</warn>
-   * @property {GuildScheduledEventEntityMetadataOptions} [entityMetadata] The entity metadata of the
-   * guild scheduled event
-   * <warn>This is required if `entityType` is {@link GuildScheduledEventEntityType.External}</warn>
-   * @property {?(BufferResolvable|Base64Resolvable)} [image] The cover image of the guild scheduled event
-   * @property {string} [reason] The reason for creating the guild scheduled event
-   */
-
-  /**
-   * Options used to set entity metadata of a guild scheduled event.
-   * @typedef {Object} GuildScheduledEventEntityMetadataOptions
-   * @property {string} [location] The location of the guild scheduled event
-   * <warn>This is required if `entityType` is {@link GuildScheduledEventEntityType.External}</warn>
-   */
-
-  /**
-   * Creates a new guild scheduled event.
-   * @param {GuildScheduledEventCreateOptions} options Options for creating the guild scheduled event
-   * @returns {Promise<GuildScheduledEvent>}
-   */
+  
+
+  
+
+  
+
+  
+
+  
   async create(options) {
     if (typeof options !== 'object') throw new DiscordjsTypeError(ErrorCodes.InvalidType, 'options', 'object', true);
     let {
@@ -111,27 +69,11 @@ class GuildScheduledEventManager extends CachedManager {
     return this._add(data);
   }
 
-  /**
-   * Options used to fetch a single guild scheduled event from a guild.
-   * @typedef {BaseFetchOptions} FetchGuildScheduledEventOptions
-   * @property {GuildScheduledEventResolvable} guildScheduledEvent The guild scheduled event to fetch
-   * @property {boolean} [withUserCount=true] Whether to fetch the number of users subscribed to the scheduled event
-   */
-
-  /**
-   * Options used to fetch multiple guild scheduled events from a guild.
-   * @typedef {Object} FetchGuildScheduledEventsOptions
-   * @property {boolean} [cache] Whether or not to cache the fetched guild scheduled events
-   * @property {boolean} [withUserCount=true] Whether to fetch the number of users subscribed to each scheduled event
-   * should be returned
-   */
-
-  /**
-   * Obtains one or more guild scheduled events from Discord, or the guild cache if it's already available.
-   * @param {GuildScheduledEventResolvable|FetchGuildScheduledEventOptions|FetchGuildScheduledEventsOptions} [options]
-   * The id of the guild scheduled event or options
-   * @returns {Promise<GuildScheduledEvent|Collection<Snowflake, GuildScheduledEvent>>}
-   */
+  
+
+  
+
+  
   async fetch(options = {}) {
     const id = this.resolveId(options.guildScheduledEvent ?? options);
 
@@ -161,31 +103,9 @@ class GuildScheduledEventManager extends CachedManager {
     );
   }
 
-  /**
-   * Options used to edit a guild scheduled event.
-   * @typedef {Object} GuildScheduledEventEditOptions
-   * @property {string} [name] The name of the guild scheduled event
-   * @property {DateResolvable} [scheduledStartTime] The time to schedule the event at
-   * @property {DateResolvable} [scheduledEndTime] The time to end the event at
-   * @property {GuildScheduledEventPrivacyLevel} [privacyLevel] The privacy level of the guild scheduled event
-   * @property {GuildScheduledEventEntityType} [entityType] The scheduled entity type of the event
-   * @property {string} [description] The description of the guild scheduled event
-   * @property {?GuildVoiceChannelResolvable} [channel] The channel of the guild scheduled event
-   * @property {GuildScheduledEventStatus} [status] The status of the guild scheduled event
-   * @property {GuildScheduledEventEntityMetadataOptions} [entityMetadata] The entity metadata of the
-   * guild scheduled event
-   * <warn>This can be modified only if `entityType` of the `GuildScheduledEvent` to be edited is
-   * {@link GuildScheduledEventEntityType.External}</warn>
-   * @property {?(BufferResolvable|Base64Resolvable)} [image] The cover image of the guild scheduled event
-   * @property {string} [reason] The reason for editing the guild scheduled event
-   */
-
-  /**
-   * Edits a guild scheduled event.
-   * @param {GuildScheduledEventResolvable} guildScheduledEvent The guild scheduled event to edit
-   * @param {GuildScheduledEventEditOptions} options Options to edit the guild scheduled event
-   * @returns {Promise<GuildScheduledEvent>}
-   */
+  
+
+  
   async edit(guildScheduledEvent, options) {
     const guildScheduledEventId = this.resolveId(guildScheduledEvent);
     if (!guildScheduledEventId) throw new DiscordjsError(ErrorCodes.GuildScheduledEventResolve);
@@ -231,11 +151,7 @@ class GuildScheduledEventManager extends CachedManager {
     return this._add(data);
   }
 
-  /**
-   * Deletes a guild scheduled event.
-   * @param {GuildScheduledEventResolvable} guildScheduledEvent The guild scheduled event to delete
-   * @returns {Promise<void>}
-   */
+  
   async delete(guildScheduledEvent) {
     const guildScheduledEventId = this.resolveId(guildScheduledEvent);
     if (!guildScheduledEventId) throw new DiscordjsError(ErrorCodes.GuildScheduledEventResolve);
@@ -243,30 +159,11 @@ class GuildScheduledEventManager extends CachedManager {
     await this.client.rest.delete(Routes.guildScheduledEvent(this.guild.id, guildScheduledEventId));
   }
 
-  /**
-   * Options used to fetch subscribers of a guild scheduled event
-   * @typedef {Object} FetchGuildScheduledEventSubscribersOptions
-   * @property {number} [limit] The maximum numbers of users to fetch
-   * @property {boolean} [withMember] Whether to fetch guild member data of the users
-   * @property {Snowflake} [before] Consider only users before this user id
-   * @property {Snowflake} [after] Consider only users after this user id
-   * <warn>If both `before` and `after` are provided, only `before` is respected</warn>
-   */
-
-  /**
-   * Represents a subscriber of a {@link GuildScheduledEvent}
-   * @typedef {Object} GuildScheduledEventUser
-   * @property {Snowflake} guildScheduledEventId The id of the guild scheduled event which the user subscribed to
-   * @property {User} user The user that subscribed to the guild scheduled event
-   * @property {?GuildMember} member The guild member associated with the user, if any
-   */
-
-  /**
-   * Fetches subscribers of a guild scheduled event.
-   * @param {GuildScheduledEventResolvable} guildScheduledEvent The guild scheduled event to fetch subscribers of
-   * @param {FetchGuildScheduledEventSubscribersOptions} [options={}] Options for fetching the subscribers
-   * @returns {Promise<Collection<Snowflake, GuildScheduledEventUser>>}
-   */
+  
+
+  
+
+  
   async fetchSubscribers(guildScheduledEvent, options = {}) {
     const guildScheduledEventId = this.resolveId(guildScheduledEvent);
     if (!guildScheduledEventId) throw new DiscordjsError(ErrorCodes.GuildScheduledEventResolve);

package/src/managers/GuildStickerManager.js

@@ -7,56 +7,24 @@ const { DiscordjsTypeError, ErrorCodes } = require('../errors');
 const MessagePayload = require('../structures/MessagePayload');
 const { Sticker } = require('../structures/Sticker');
 
-/**
- * Manages API methods for Guild Stickers and stores their cache.
- * @extends {CachedManager}
- */
+
 class GuildStickerManager extends CachedManager {
   constructor(guild, iterable) {
     super(guild.client, Sticker, iterable);
 
-    /**
-     * The guild this manager belongs to
-     * @type {Guild}
-     */
+    
     this.guild = guild;
   }
 
-  /**
-   * The cache of Guild Stickers
-   * @type {Collection<Snowflake, Sticker>}
-   * @name GuildStickerManager#cache
-   */
+  
 
   _add(data, cache) {
     return super._add(data, cache, { extras: [this.guild] });
   }
 
-  /**
-   * Options used to create a guild sticker.
-   * @typedef {Object} GuildStickerCreateOptions
-   * @property {AttachmentPayload|BufferResolvable|Stream} file The file for the sticker
-   * @property {string} name The name for the sticker
-   * @property {string} tags The Discord name of a unicode emoji representing the sticker's expression
-   * @property {?string} [description] The description for the sticker
-   * @property {string} [reason] Reason for creating the sticker
-   */
-
-  /**
-   * Creates a new custom sticker in the guild.
-   * @param {GuildStickerCreateOptions} options Options for creating a guild sticker
-   * @returns {Promise<Sticker>} The created sticker
-   * @example
-   * // Create a new sticker from a URL
-   * guild.stickers.create({ file: 'https://i.imgur.com/w3duR07.png', name: 'rip', tags: 'headstone' })
-   *   .then(sticker => console.log(`Created new sticker with name ${sticker.name}!`))
-   *   .catch(console.error);
-   * @example
-   * // Create a new sticker from a file on your computer
-   * guild.stickers.create({ file: './memes/banana.png', name: 'banana', tags: 'banana' })
-   *   .then(sticker => console.log(`Created new sticker with name ${sticker.name}!`))
-   *   .catch(console.error);
-   */
+  
+
+  
   async create({ file, name, tags, description, reason } = {}) {
     const resolvedFile = await MessagePayload.resolveFile(file);
     if (!resolvedFile) throw new DiscordjsTypeError(ErrorCodes.ReqResourceType);
@@ -73,37 +41,13 @@ class GuildStickerManager extends CachedManager {
     return this.client.actions.GuildStickerCreate.handle(this.guild, sticker).sticker;
   }
 
-  /**
-   * Data that resolves to give a Sticker object. This can be:
-   * * A Sticker object
-   * * A Snowflake
-   * @typedef {Sticker|Snowflake} StickerResolvable
-   */
-
-  /**
-   * Resolves a StickerResolvable to a Sticker object.
-   * @method resolve
-   * @memberof GuildStickerManager
-   * @instance
-   * @param {StickerResolvable} sticker The Sticker resolvable to identify
-   * @returns {?Sticker}
-   */
-
-  /**
-   * Resolves a StickerResolvable to a Sticker id string.
-   * @method resolveId
-   * @memberof GuildStickerManager
-   * @instance
-   * @param {StickerResolvable} sticker The Sticker resolvable to identify
-   * @returns {?Snowflake}
-   */
-
-  /**
-   * Edits a sticker.
-   * @param {StickerResolvable} sticker The sticker to edit
-   * @param {GuildStickerEditOptions} [options={}] The new data for the sticker
-   * @returns {Promise<Sticker>}
-   */
+  
+
+  
+
+  
+
+  
   async edit(sticker, options = {}) {
     const stickerId = this.resolveId(sticker);
     if (!stickerId) throw new DiscordjsTypeError(ErrorCodes.InvalidType, 'sticker', 'StickerResolvable');
@@ -122,12 +66,7 @@ class GuildStickerManager extends CachedManager {
     return this._add(d);
   }
 
-  /**
-   * Deletes a sticker.
-   * @param {StickerResolvable} sticker The sticker to delete
-   * @param {string} [reason] Reason for deleting this sticker
-   * @returns {Promise<void>}
-   */
+  
   async delete(sticker, reason) {
     sticker = this.resolveId(sticker);
     if (!sticker) throw new DiscordjsTypeError(ErrorCodes.InvalidType, 'sticker', 'StickerResolvable');
@@ -135,22 +74,7 @@ class GuildStickerManager extends CachedManager {
     await this.client.rest.delete(Routes.guildSticker(this.guild.id, sticker), { reason });
   }
 
-  /**
-   * Obtains one or more stickers from Discord, or the sticker cache if they're already available.
-   * @param {Snowflake} [id] The Sticker's id
-   * @param {BaseFetchOptions} [options] Additional options for this fetch
-   * @returns {Promise<Sticker|Collection<Snowflake, Sticker>>}
-   * @example
-   * // Fetch all stickers from the guild
-   * message.guild.stickers.fetch()
-   *   .then(stickers => console.log(`There are ${stickers.size} stickers.`))
-   *   .catch(console.error);
-   * @example
-   * // Fetch a single sticker
-   * message.guild.stickers.fetch('222078108977594368')
-   *   .then(sticker => console.log(`The sticker name is: ${sticker.name}`))
-   *   .catch(console.error);
-   */
+  
   async fetch(id, { cache = true, force = false } = {}) {
     if (id) {
       if (!force) {
@@ -165,11 +89,7 @@ class GuildStickerManager extends CachedManager {
     return new Collection(data.map(sticker => [sticker.id, this._add(sticker, cache)]));
   }
 
-  /**
-   * Fetches the user who uploaded this sticker, if this is a guild sticker.
-   * @param {StickerResolvable} sticker The sticker to fetch the user for
-   * @returns {Promise<?User>}
-   */
+  
   async fetchUser(sticker) {
     sticker = this.resolve(sticker);
     if (!sticker) throw new DiscordjsTypeError(ErrorCodes.InvalidType, 'sticker', 'StickerResolvable');

package/src/managers/GuildTextThreadManager.js

@@ -4,56 +4,13 @@ const { ChannelType, Routes } = require('discord-api-types/v10');
 const ThreadManager = require('./ThreadManager');
 const { DiscordjsTypeError, ErrorCodes } = require('../errors');
 
-/**
- * Manages API methods for {@link ThreadChannel} objects and stores their cache.
- * @extends {ThreadManager}
- */
+
 class GuildTextThreadManager extends ThreadManager {
-  /**
-   * The channel this Manager belongs to
-   * @name GuildTextThreadManager#channel
-   * @type {TextChannel|NewsChannel}
-   */
+  
 
-  /**
-   * Options for creating a thread. <warn>Only one of `startMessage` or `type` can be defined.</warn>
-   * @typedef {StartThreadOptions} ThreadCreateOptions
-   * @property {MessageResolvable} [startMessage] The message to start a thread from.
-   * <warn>If this is defined, then the `type` of thread gets inferred automatically and cannot be changed.</warn>
-   * @property {ThreadChannelTypes} [type] The type of thread to create.
-   * Defaults to {@link ChannelType.PublicThread} if created in a {@link TextChannel}
-   * <warn>When creating threads in a {@link NewsChannel}, this is ignored and is always
-   * {@link ChannelType.AnnouncementThread}</warn>
-   * @property {boolean} [invitable] Whether non-moderators can add other non-moderators to the thread
-   * <info>Can only be set when type will be {@link ChannelType.PrivateThread}</info>
-   */
+  
 
-  /**
-   * Creates a new thread in the channel.
-   * @param {ThreadCreateOptions} [options] Options to create a new thread
-   * @returns {Promise<ThreadChannel>}
-   * @example
-   * // Create a new public thread
-   * channel.threads
-   *   .create({
-   *     name: 'food-talk',
-   *     autoArchiveDuration: ThreadAutoArchiveDuration.OneHour,
-   *     reason: 'Needed a separate thread for food',
-   *   })
-   *   .then(threadChannel => console.log(threadChannel))
-   *   .catch(console.error);
-   * @example
-   * // Create a new private thread
-   * channel.threads
-   *   .create({
-   *      name: 'mod-talk',
-   *      autoArchiveDuration: ThreadAutoArchiveDuration.OneHour,
-   *      type: ChannelType.PrivateThread,
-   *      reason: 'Needed a separate thread for moderation',
-   *    })
-   *   .then(threadChannel => console.log(threadChannel))
-   *   .catch(console.error);
-   */
+  
   async create({
     name,
     autoArchiveDuration = this.channel.defaultAutoArchiveDuration,

package/src/managers/MessageManager.js

@@ -9,82 +9,28 @@ const { Message } = require('../structures/Message');
 const MessagePayload = require('../structures/MessagePayload');
 const { resolvePartialEmoji } = 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);
   }
 
-  /**
-   * Data that can be resolved to a Message object. This can be:
-   * * A Message
-   * * A Snowflake
-   * @typedef {Message|Snowflake} MessageResolvable
-   */
-
-  /**
-   * Options used to fetch a message.
-   * @typedef {BaseFetchOptions} FetchMessageOptions
-   * @property {MessageResolvable} message The message to fetch
-   */
-
-  /**
-   * Options used to fetch multiple messages.
-   * <info>The `before`, `after`, and `around` parameters are mutually exclusive.</info>
-   * @typedef {Object} FetchMessagesOptions
-   * @property {number} [limit] The maximum number of messages to return
-   * @property {Snowflake} [before] Consider only messages before this id
-   * @property {Snowflake} [after] Consider only messages after this id
-   * @property {Snowflake} [around] Consider only messages around this id
-   * @property {boolean} [cache] Whether to cache the fetched messages
-   */
-
-  /**
-   * Fetches message(s) from a 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 {MessageResolvable|FetchMessageOptions|FetchMessagesOptions} [options] Options for fetching message(s)
-   * @returns {Promise<Message|Collection<Snowflake, Message>>}
-   * @example
-   * // Fetch a message
-   * channel.messages.fetch('99539446449315840')
-   *   .then(message => console.log(message.content))
-   *   .catch(console.error);
-   * @example
-   * // Fetch a maximum of 10 messages without caching
-   * channel.messages.fetch({ limit: 10, cache: false })
-   *   .then(messages => console.log(`Received ${messages.size} messages`))
-   *   .catch(console.error);
-   * @example
-   * // Fetch a maximum of 10 messages without caching around a message id
-   * channel.messages.fetch({ limit: 10, cache: false, around: '99539446449315840' })
-   *   .then(messages => console.log(`Received ${messages.size} messages`))
-   *   .catch(console.error);
-   * @example
-   * // Fetch messages and filter by a user id
-   * channel.messages.fetch()
-   *   .then(messages => console.log(`${messages.filter(m => m.author.id === '84484653687267328').size} messages`))
-   *   .catch(console.error);
-   */
+  
+
+  
+
+  
+
+  
   fetch(options) {
     if (!options) return this._fetchMany();
     const { message, cache, force } = options;
@@ -111,18 +57,7 @@ class MessageManager extends CachedManager {
     return data.reduce((_data, message) => _data.set(message.id, this._add(message, options.cache)), new Collection());
   }
 
-  /**
-   * 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.rest.get(Routes.channelPins(this.channel.id));
     const messages = new Collection();
@@ -130,39 +65,13 @@ class MessageManager extends CachedManager {
     return messages;
   }
 
-  /**
-   * 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}
-   */
-
-  /**
-   * Options that can be passed to edit a message.
-   * @typedef {BaseMessageOptions} MessageEditOptions
-   * @property {AttachmentPayload[]} [attachments] An array of attachments to keep,
-   * all attachments will be kept if omitted
-   * @property {MessageFlags} [flags] Which flags to set for the message
-   * <info>Only the {@link MessageFlags.SuppressEmbeds} flag can be modified.</info>
-   */
-
-  /**
-   * 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 DiscordjsTypeError(ErrorCodes.InvalidType, 'message', 'MessageResolvable');
@@ -184,11 +93,7 @@ class MessageManager extends CachedManager {
     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 DiscordjsTypeError(ErrorCodes.InvalidType, 'message', 'MessageResolvable');
@@ -197,12 +102,7 @@ class MessageManager extends CachedManager {
     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 DiscordjsTypeError(ErrorCodes.InvalidType, 'message', 'MessageResolvable');
@@ -210,12 +110,7 @@ class MessageManager extends CachedManager {
     await this.client.rest.put(Routes.channelPin(this.channel.id, message), { 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 DiscordjsTypeError(ErrorCodes.InvalidType, 'message', 'MessageResolvable');
@@ -223,12 +118,7 @@ class MessageManager extends CachedManager {
     await this.client.rest.delete(Routes.channelPin(this.channel.id, message), { 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
-   * @returns {Promise<void>}
-   */
+  
   async react(message, emoji) {
     message = this.resolveId(message);
     if (!message) throw new DiscordjsTypeError(ErrorCodes.InvalidType, 'message', 'MessageResolvable');
@@ -243,11 +133,7 @@ class MessageManager extends CachedManager {
     await this.client.rest.put(Routes.channelMessageOwnReaction(this.channel.id, message, emojiId));
   }
 
-  /**
-   * 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 DiscordjsTypeError(ErrorCodes.InvalidType, 'message', 'MessageResolvable');