Preview environment

class MessageManager

abstract
export abstract class MessageManager<InGuild extends boolean = boolean> extends CachedManager<Snowflake, Message<InGuild>, MessageResolvable>

Manages API methods for Messages and holds their cache.

Constructors

constructor(
channel: TextBasedChannel
iterable?: Iterable<RawMessageData>
)

Constructs a new instance of the MessageManager class

Type Parameters

optional
InGuild? extends boolean = boolean

readonly
cache : Collection<Key, Holds>

The cache of items for this manager.

Inherited from: DataManager

channel : TextBasedChannel

The channel that the messages belong to

readonly
client : Client

The client that instantiated this Manager

Inherited from: BaseManager

readonly
holds : Constructable<Holds>

The data structure belonging to this manager.

Inherited from: DataManager

crosspost(
message: MessageResolvable
) : Promise<Message>

Publishes a message in an announcement channel to all channels following it, even if it's not cached.

delete(
message: MessageResolvable
) : Promise<void>

Deletes a message, even if it's not cached.

edit(
message: MessageResolvable
options: string | MessagePayload | MessageEditOptions
) : Promise<Message<InGuild>>

Edits a message, even if it's not cached.

endPoll(
messageId: Snowflake
) : Promise<Message>

Ends a poll.

fetch(
options: MessageResolvable | FetchMessageOptions
) : Promise<Message<InGuild>>

Fetches message(s) from a channel. 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.

Examples:
// Fetch a message
channel.messages.fetch('99539446449315840')
  .then(message => console.log(message.content))
  .catch(console.error);
// 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);
// 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);
// Fetch messages and filter by a user id
channel.messages.fetch()
  .then(messages => console.log(`${messages.filter(message =>
         message.author.id === '84484653687267328').size} messages`))
  .catch(console.error);

fetchPinned(
cache?: boolean
) : Promise<Collection<Snowflake, Message<InGuild>>>

Fetches the pinned messages of this channel and returns a collection of them. The returned Collection does not contain any reaction data of the messages. Those need to be fetched separately.

Examples:
// Get pinned messages
channel.messages.fetchPinned()
  .then(messages => console.log(`Received ${messages.size} messages`))
  .catch(console.error);

fetchPollAnswerVoters(
options: FetchPollAnswerVotersOptions
) : Promise<Collection<Snowflake, User>>

Fetches the users that voted for a poll answer.

pin(
message: MessageResolvable
reason?: string
) : Promise<void>

Pins a message to the channel's pinned messages, even if it's not cached.

react(
message: MessageResolvable
emoji: EmojiIdentifierResolvable
) : Promise<void>

Adds a reaction to a message, even if it's not cached.

resolve(
message: MessageResolvable
) : Message | null

Resolves a MessageResolvable to a Message object.

resolveId(
message: MessageResolvable
) : Snowflake | null

Resolves a MessageResolvable to a Message id.

unpin(
message: MessageResolvable
reason?: string
) : Promise<void>

Unpins a message from the channel's pinned messages, even if it's not cached.

valueOf() : Collection<Key, Holds>

Inherited from: DataManager