• Home
• net.dv8tion
• JDA
• 5.0.0-alpha.10
• source code
• Message.java

×

Project download

Many resources are needed to download a project. Please understand that we have to compensate our server costs. Thank you in advance.
Project price only 1 $

You can buy this project and download/modify it how often you want.

net.dv8tion.jda.api.entities.Message Maven / Gradle / Ivy

/*
 * Copyright 2015 Austin Keener, Michael Ritter, Florian Spieß, and the JDA contributors
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *    http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
package net.dv8tion.jda.api.entities;

import net.dv8tion.jda.api.JDA;
import net.dv8tion.jda.api.Permission;
import net.dv8tion.jda.api.exceptions.HttpException;
import net.dv8tion.jda.api.exceptions.InsufficientPermissionException;
import net.dv8tion.jda.api.interactions.InteractionType;
import net.dv8tion.jda.api.interactions.components.ActionRow;
import net.dv8tion.jda.api.interactions.components.LayoutComponent;
import net.dv8tion.jda.api.interactions.components.buttons.Button;
import net.dv8tion.jda.api.interactions.components.selections.SelectMenu;
import net.dv8tion.jda.api.requests.RestAction;
import net.dv8tion.jda.api.requests.restaction.AuditableRestAction;
import net.dv8tion.jda.api.requests.restaction.MessageAction;
import net.dv8tion.jda.api.requests.restaction.pagination.ReactionPaginationAction;
import net.dv8tion.jda.api.utils.AttachmentOption;
import net.dv8tion.jda.api.utils.MiscUtil;
import net.dv8tion.jda.internal.JDAImpl;
import net.dv8tion.jda.internal.requests.FunctionalCallback;
import net.dv8tion.jda.internal.requests.Requester;
import net.dv8tion.jda.internal.utils.Checks;
import net.dv8tion.jda.internal.utils.IOUtil;
import okhttp3.OkHttpClient;
import okhttp3.Request;
import org.apache.commons.collections4.Bag;

import javax.annotation.CheckReturnValue;
import javax.annotation.Nonnull;
import javax.annotation.Nullable;
import java.io.*;
import java.time.OffsetDateTime;
import java.util.*;
import java.util.concurrent.CompletableFuture;
import java.util.function.Predicate;
import java.util.regex.Pattern;
import java.util.stream.Collectors;

/**
 * Represents a Text message received from Discord.
 * 
This represents messages received from {@link net.dv8tion.jda.api.entities.MessageChannel MessageChannels}.
 *
 * 
This type is not updated. JDA does not keep track of changes to messages, it is advised to do this via events such
 * as {@link net.dv8tion.jda.api.events.message.MessageUpdateEvent MessageUpdateEvent} and similar.
 *
 * 
Message Differences
 * There are 3 implementations of this interface in JDA.
 * 

 *     
Received Message
 *     
Messages received through events or history query.
 *         These messages hold information of existing messages and
 *         can be modified or deleted.
 *     
System Message
 *     
Specification of Received Messages that are generated by Discord
 *         on certain events. Commonly this is used in groups or to indicate a pin within a MessageChannel.
 *         The different types can be found in the {@link net.dv8tion.jda.api.entities.MessageType MessageType} enum.
 *     
Data Message
 *     
This type is produced by {@link net.dv8tion.jda.api.MessageBuilder MessageBuilder}
 *         and only holds sendable information such as content or nonce. These messages do not allow
 *         any modifications via RestActions or information that is generated when sent such as the id to be used.
 * 
 *
 * 
When a feature is not available it will throw an {@link java.lang.UnsupportedOperationException UnsupportedOperationException}
 * as per interface specifications.
 * 
Specific operations may have specified information available in the {@code throws} javadoc.
 *
 * 
Formattable
 * This interface extends {@link java.util.Formattable Formattable} and can be used with a {@link java.util.Formatter Formatter}
 * such as used by {@link String#format(String, Object...) String.format(String, Object...)}
 * or {@link java.io.PrintStream#printf(String, Object...) PrintStream.printf(String, Object...)}.
 *
 * 
This will use {@link #getContentDisplay()} rather than {@link Object#toString()}!
 * 
Supported Features:
 * 

 *     
Alternative
 *     
   - Using {@link #getContentRaw()}
 *              (Example: {@code %#s} - uses {@link #getContentDisplay()})
 *
 *     
Width/Left-Justification
 *     
   - Ensures the size of a format
 *              (Example: {@code %20s} - uses at minimum 20 chars;
 *              {@code %-10s} - uses left-justified padding)
 *
 *     
Precision
 *     
   - Cuts the content to the specified size
 *              (replacing last 3 chars with {@code ...}; Example: {@code %.20s})
 * 
 *
 * 
More information on formatting syntax can be found in the {@link java.util.Formatter format syntax documentation}!
 *
 * @see net.dv8tion.jda.api.MessageBuilder MessageBuilder
 * @see MessageChannel#sendMessage(Message)
 *
 * @see MessageChannel#getIterableHistory()
 * @see MessageChannel#getHistory()
 * @see MessageChannel#getHistoryAfter(String, int)
 * @see MessageChannel#getHistoryBefore(String, int)
 * @see MessageChannel#getHistoryAround(String, int)
 * @see MessageChannel#getHistoryFromBeginning(int)
 * @see MessageChannel#retrieveMessageById(String)
 *
 * @see MessageChannel#deleteMessageById(String)
 * @see MessageChannel#editMessageById(String, CharSequence)
 */
public interface Message extends ISnowflake, Formattable
{
    /** Template for {@link #getJumpUrl()}.*/
    String JUMP_URL = "https://discord.com/channels/%s/%s/%s";

    /**
     * The maximum sendable file size (8 MiB)
     *
     * @see MessageAction#addFile(java.io.File, net.dv8tion.jda.api.utils.AttachmentOption...) MessageAction.addFile(...)
     */
    int MAX_FILE_SIZE = 8 << 20;

    /**
     * The maximum sendable file size for nitro (50 MiB)
     *
     * @see MessageAction#addFile(java.io.File, net.dv8tion.jda.api.utils.AttachmentOption...) MessageAction.addFile(...)
     */
    int MAX_FILE_SIZE_NITRO = 50 << 20;

    /**
     * The maximum amount of files sendable within a single message ({@value})
     *
     * @see MessageAction#addFile(java.io.File, net.dv8tion.jda.api.utils.AttachmentOption...) MessageAction.addFile(...)
     */
    int MAX_FILE_AMOUNT = 10;

    /**
     * The maximum amount of characters sendable in one message. ({@value})
     * 
This only applies to the raw content and not embeds!
     *
     * @see MessageAction#append(CharSequence) MessageAction.append(...)
     */
    int MAX_CONTENT_LENGTH = 2000;

   /**
    * The maximum amount of reactions that can be added to one message ({@value})
    *
    * @see Message#addReaction(String)
    * @see Message#addReaction(net.dv8tion.jda.api.entities.Emote)
    */
    int MAX_REACTIONS = 20;

    /**
     * The maximum amount of Embeds that can be added to one message ({@value})
     *
     * @see    MessageChannel#sendMessageEmbeds(Collection)
     * @see    MessageAction#setEmbeds(Collection)
     */
    int MAX_EMBED_COUNT = 10;

    /**
     * Pattern used to find instant invites in strings.
     *
     * 
The only named group is at index 1 with the name {@code "code"}.
     *
     * @see #getInvites()
     */
    Pattern INVITE_PATTERN = Pattern.compile(
            "(?:https?://)?" +                     // Scheme
            "(?:\\w+\\.)?" +                       // Subdomain
            "discord(?:(?:app)?\\.com" +           // Discord domain
            "/invite|\\.gg)/(?[a-z0-9-]+)" + // Path
            "(?:\\?\\S*)?(?:#\\S*)?",              // Useless query or URN appendix
            Pattern.CASE_INSENSITIVE);

    /**
     * Pattern used to find {@link #getJumpUrl() Jump URLs} in strings.
     *
     * 
Groups

     * 
     *   
     *   
     *     
     *     
     *     
     *   
     *   
     *     
     *     
     *     
     *   
     *   
     *     
     *     
     *     
     *   
     *   
     *     
     *     
     *     
     *   
     *   
     *     
     *     
     *     
     *   
     * 
Javadoc is stupid, this is not a required tag
Index
Name
Description
0
N/A
The entire link
1
guild
The ID of the target guild
2
channel
The ID of the target channel
3
message
The ID of the target message
     * You can use the names with {@link java.util.regex.Matcher#group(String) Matcher.group(String)}
     * and the index with {@link java.util.regex.Matcher#group(int) Matcher.group(int)}.
     *
     * @see #getJumpUrl()
     */
    Pattern JUMP_URL_PATTERN = Pattern.compile(
            "(?:https?://)?" +                                             // Scheme
            "(?:\\w+\\.)?" +                                               // Subdomain
            "discord(?:app)?\\.com" +                                      // Discord domain
            "/channels/(?\\d+)/(?\\d+)/(?\\d+)" + // Path
            "(?:\\?\\S*)?(?:#\\S*)?",                                      // Useless query or URN appendix
            Pattern.CASE_INSENSITIVE);

    /**
     * Returns the {@link MessageReference} for this Message. This will be null if this Message has no reference.
     *
     * 
You can access all the information about a reference through this object.
     * Additionally, you can retrieve the referenced Message if discord did not load it in time. This can be done with {@link MessageReference#resolve()}.
     *
     * @return The message reference, or null.
     */
    @Nullable
    MessageReference getMessageReference();

    /**
     * Referenced message.
     *
     * 
This will have different meaning depending on the {@link #getType() type} of message.
     * Usually, this is a {@link MessageType#INLINE_REPLY INLINE_REPLY} reference.
     * This can be null even if the type is {@link MessageType#INLINE_REPLY INLINE_REPLY}, when the message it references doesn't exist or discord wasn't able to resolve it in time.
     *
     * 
This differs from a {@link MessageReference}, which contains the raw IDs attached to the reference, and allows you to retrieve the referenced message
     *
     * @return The referenced message, or null
     *
     * @see #getMessageReference()
     */
    @Nullable
    default Message getReferencedMessage()
    {
        return getMessageReference() != null
                ? getMessageReference().getMessage()
                : null;
    }

    /**
     * An immutable list of all mentioned {@link net.dv8tion.jda.api.entities.User Users}.
     * 
If no user was mentioned, this list is empty. Elements are sorted in order of appearance. This only
     * counts direct mentions of the user and not mentions through roles or the everyone tag.
     *
     * @throws java.lang.UnsupportedOperationException
     *         If this is a system message
     *
     * @return immutable list of mentioned users
     */
    @Nonnull
    List getMentionedUsers();

    /**
     * A {@link org.apache.commons.collections4.Bag Bag} of mentioned users.
     * 
This can be used to retrieve the amount of times a user was mentioned in this message. This only
     * counts direct mentions of the user and not mentions through roles or the everyone tag.
     *
     * 
Example
     * 
{@code
     * public void sendCount(Message msg)
     * {
     *     List mentions = msg.getMentionedUsers(); // distinct list, in order of appearance
     *     Bag count = msg.getMentionedUsersBag();
     *     StringBuilder content = new StringBuilder();
     *     for (User user : mentions)
     *     {
     *         content.append(user.getAsTag())
     *                .append(": ")
     *                .append(count.getCount(user))
     *                .append("\n");
     *     }
     *     msg.getChannel().sendMessage(content.toString()).queue();
     * }
     * }
     *
     * @throws java.lang.UnsupportedOperationException
     *         If this is a system message
     *
     * @return {@link org.apache.commons.collections4.Bag Bag} of mentioned users
     *
     * @see    #getMentionedUsers()
     */
    @Nonnull
    Bag getMentionedUsersBag();

    /**
     * A immutable list of all mentioned {@link net.dv8tion.jda.api.entities.TextChannel TextChannels}.
     * 
If none were mentioned, this list is empty. Elements are sorted in order of appearance.
     *
     * 
This may include TextChannels from other {@link net.dv8tion.jda.api.entities.Guild Guilds}
     *
     * @throws java.lang.UnsupportedOperationException
     *         If this is a system message
     *
     * @return immutable list of mentioned TextChannels
     */
    @Nonnull
    List getMentionedChannels();

    /**
     * A {@link org.apache.commons.collections4.Bag Bag} of mentioned channels.
     * 
This can be used to retrieve the amount of times a channel was mentioned in this message.
     *
     * 
Example
     * 
{@code
     * public void sendCount(Message msg)
     * {
     *     List mentions = msg.getMentionedTextChannels(); // distinct list, in order of appearance
     *     Bag count = msg.getMentionedTextChannelsBag();
     *     StringBuilder content = new StringBuilder();
     *     for (TextChannel channel : mentions)
     *     {
     *         content.append("#")
     *                .append(channel.getName())
     *                .append(": ")
     *                .append(count.getCount(channel))
     *                .append("\n");
     *     }
     *     msg.getChannel().sendMessage(content.toString()).queue();
     * }
     * }
     *
     * @throws java.lang.UnsupportedOperationException
     *         If this is a system message
     *
     * @return {@link org.apache.commons.collections4.Bag Bag} of mentioned channels
     *
     * @see    #getMentionedChannels()
     */
    @Nonnull
    Bag getMentionedChannelsBag();

    /**
     * A immutable list of all mentioned {@link net.dv8tion.jda.api.entities.Role Roles}.
     * 
If none were mentioned, this list is empty. Elements are sorted in order of appearance. This only
     * counts direct mentions of the role and not mentions through the everyone tag.
     *
     * 
This may include Roles from other {@link net.dv8tion.jda.api.entities.Guild Guilds}
     *
     * @throws java.lang.UnsupportedOperationException
     *         If this is a system message
     *
     * @return immutable list of mentioned Roles
     */
    @Nonnull
    List getMentionedRoles();

    /**
     * A {@link org.apache.commons.collections4.Bag Bag} of mentioned roles.
     * 
This can be used to retrieve the amount of times a role was mentioned in this message. This only
     * counts direct mentions of the role and not mentions through the everyone tag.
     * If a role is not {@link net.dv8tion.jda.api.entities.Role#isMentionable() mentionable} it will not be included.
     *
     * 
Example
     * 
{@code
     * public void sendCount(Message msg)
     * {
     *     List mentions = msg.getMentionedRoles(); // distinct list, in order of appearance
     *     Bag count = msg.getMentionedRolesBag();
     *     StringBuilder content = new StringBuilder();
     *     for (Role role : mentions)
     *     {
     *         content.append(role.getName())
     *                .append(": ")
     *                .append(count.getCount(role))
     *                .append("\n");
     *     }
     *     msg.getChannel().sendMessage(content.toString()).queue();
     * }
     * }
     *
     * @throws java.lang.UnsupportedOperationException
     *         If this is a system message
     *
     * @return {@link org.apache.commons.collections4.Bag Bag} of mentioned roles
     *
     * @see    #getMentionedRoles()
     */
    @Nonnull
    Bag getMentionedRolesBag();

    /**
     * Creates an immutable list of {@link net.dv8tion.jda.api.entities.Member Members}
     * representing the users of {@link #getMentionedUsers()} in the specified
     * {@link net.dv8tion.jda.api.entities.Guild Guild}.
     * 
This is only a convenience method and will skip all users that are not in the specified
     * Guild.
     *
     * @param  guild
     *         Non-null {@link net.dv8tion.jda.api.entities.Guild Guild}
     *         that will be used to retrieve Members.
     *
     * @throws java.lang.UnsupportedOperationException
     *         If this is a system message
     * @throws java.lang.IllegalArgumentException
     *         If the specified Guild is {@code null}
     *
     * @return Immutable list of mentioned Members
     *
     * @since  3.4.0
     */
    @Nonnull
    List getMentionedMembers(@Nonnull Guild guild);

    /**
     * Creates an immutable list of {@link net.dv8tion.jda.api.entities.Member Members}
     * representing the users of {@link #getMentionedUsers()} in the
     * {@link net.dv8tion.jda.api.entities.Guild Guild} this Message was sent in.
     * 
This is only a convenience method and will skip all users that are not in the specified Guild.
     * 
It will provide the {@link #getGuild()} output Guild to {@link #getMentionedMembers(Guild)}.
     *
     * @throws java.lang.UnsupportedOperationException
     *         If this is a system message
     * @throws java.lang.IllegalStateException
     *         If this message was not sent in a {@link net.dv8tion.jda.api.entities.TextChannel TextChannel}
     *
     * @return Immutable list of mentioned Members
     *
     * @since  3.4.0
     */
    @Nonnull
    List getMentionedMembers();

    /**
     * Combines all instances of {@link net.dv8tion.jda.api.entities.IMentionable IMentionable}
     * filtered by the specified {@link net.dv8tion.jda.api.entities.Message.MentionType MentionType} values.
     * 
This does not include {@link #getMentionedMembers()} to avoid duplicates.
     *
     * 
If no MentionType values are given this will fallback to all types.
     *
     * @param  types
     *         Amount of {@link net.dv8tion.jda.api.entities.Message.MentionType MentionTypes}
     *         to include in the list of mentions
     *
     * @throws java.lang.UnsupportedOperationException
     *         If this is a system message
     * @throws java.lang.IllegalArgumentException
     *         If provided with {@code null}
     *
     * @return Immutable list of filtered {@link net.dv8tion.jda.api.entities.IMentionable IMentionable} instances
     *
     * @since  3.4.0
     */
    @Nonnull
    List getMentions(@Nonnull MentionType... types);

    /**
     * Checks if given {@link net.dv8tion.jda.api.entities.IMentionable IMentionable}
     * was mentioned in this message in any way (@User, @everyone, @here, @Role).
     * 
If no filtering {@link net.dv8tion.jda.api.entities.Message.MentionType MentionTypes} are
     * specified this will fallback to all mention types.
     *
     * 
{@link Message.MentionType#HERE MentionType.HERE} and {@link Message.MentionType#EVERYONE MentionType.EVERYONE}
     * will only be checked, if the given {@link net.dv8tion.jda.api.entities.IMentionable IMentionable} is of type
     * {@link net.dv8tion.jda.api.entities.User User} or {@link net.dv8tion.jda.api.entities.Member Member}.
     * 
Online status of Users/Members is NOT considered when checking {@link Message.MentionType#HERE MentionType.HERE}.
     *
     * @param  mentionable
     *         The mentionable entity to check on.
     * @param  types
     *         The types to include when checking whether this type was mentioned.
     *         This will be used with {@link #getMentions(Message.MentionType...) getMentions(MentionType...)}
     *
     * @throws java.lang.UnsupportedOperationException
     *         If this is a system message
     *
     * @return True, if the given mentionable was mentioned in this message
     */
    boolean isMentioned(@Nonnull IMentionable mentionable, @Nonnull MentionType... types);

    /**
     * Indicates if this Message mentions everyone using @everyone or @here.
     *
     * @throws java.lang.UnsupportedOperationException
     *         If this is a system message
     *
     * @return True, if message is mentioning everyone
     */
    boolean mentionsEveryone();

    /**
     * Returns whether or not this Message has been edited before.
     *
     * @throws java.lang.UnsupportedOperationException
     *         If this is a system message
     *
     * @return True if this message has been edited.
     */
    boolean isEdited();

    /**
     * Provides the {@link java.time.OffsetDateTime OffsetDateTime} defining when this Message was last
     * edited. If this Message has not been edited ({@link #isEdited()} is {@code false}), then this method
     * will return {@code null}.
     *
     * @throws java.lang.UnsupportedOperationException
     *         If this is a system message
     *
     * @return Time of the most recent edit, or {@code null} if the Message has never been edited.
     */
    @Nullable
    OffsetDateTime getTimeEdited();

    /**
     * The author of this Message
     *
     * @throws java.lang.UnsupportedOperationException
     *         If this is a system message
     *
     * @return Message author
     */
    @Nonnull
    User getAuthor();

    /**
     * Returns the author of this Message as a {@link net.dv8tion.jda.api.entities.Member member}.
     * 
This is only valid if the Message was actually sent in a TextChannel. This will return {@code null}
     * if the message was not sent in a TextChannel, or if the message was sent by a Webhook.
     * 
You can check the type of channel this message was sent from using {@link #isFromType(ChannelType)} or {@link #getChannelType()}.
     *
     * 
Discord does not provide a member object for messages returned by {@link RestAction RestActions} of any kind.
     * This will return null if the message was retrieved through {@link MessageChannel#retrieveMessageById(long)} or similar means,
     * unless the member is already cached.
     *
     * @throws java.lang.UnsupportedOperationException
     *         If this is a system message
     *
     * @return Message author, or {@code null} if the message was not sent in a TextChannel, or if the message was sent by a Webhook.
     *
     * @see    #isWebhookMessage()
     */
    @Nullable
    Member getMember();

    /**
     * Returns the jump-to URL for the received message. Clicking this URL in the Discord client will cause the client to
     * jump to the specified message.
     *
     * @throws java.lang.UnsupportedOperationException
     *         If this is a system message
     *
     * @return A String representing the jump-to URL for the message
     */
    @Nonnull
    String getJumpUrl();

    /**
     * The textual content of this message in the format that would be shown to the Discord client. All
     * {@link net.dv8tion.jda.api.entities.IMentionable IMentionable} entities will be resolved to the format
     * shown by the Discord client instead of the {@literal } format.
     *
     * 
This includes resolving:
     * 
{@link net.dv8tion.jda.api.entities.User Users} / {@link net.dv8tion.jda.api.entities.Member Members}
     * to their @Username/@Nickname format,
     * 
{@link net.dv8tion.jda.api.entities.TextChannel TextChannels} to their #ChannelName format,
     * 
{@link net.dv8tion.jda.api.entities.Role Roles} to their @RoleName format
     * 
{@link net.dv8tion.jda.api.entities.Emote Emotes} (not emojis!) to their {@code :name:} format.
     *
     * 
If you want the actual Content (mentions as {@literal <@id>}), use {@link #getContentRaw()} instead
     *
     * @throws java.lang.UnsupportedOperationException
     *         If this is a system message
     *
     * @return The textual content of the message with mentions resolved to be visually like the Discord client.
     */
    @Nonnull
    String getContentDisplay();

    /**
     * The raw textual content of this message. Does not resolve {@link net.dv8tion.jda.api.entities.IMentionable IMentionable}
     * entities like {@link #getContentDisplay()} does. This means that this is the completely raw textual content of the message
     * received from Discord and can contain mentions specified by
     * Discord's Message Formatting.
     *
     * @return The raw textual content of the message, containing unresolved Discord message formatting.
     */
    @Nonnull
    String getContentRaw();

    /**
     * Gets the textual content of this message using {@link #getContentDisplay()} and then strips it of markdown characters
     * like {@literal *, **, __, ~~, ||} that provide text formatting. Any characters that match these but are not being used
     * for formatting are escaped to prevent possible formatting.
     *
     * @throws java.lang.UnsupportedOperationException
     *         If this is a system message
     *
     * @return The textual content from {@link #getContentDisplay()} with all text formatting characters removed or escaped.
     */
    @Nonnull
    String getContentStripped();

    /**
     * Creates an immutable List of {@link net.dv8tion.jda.api.entities.Invite Invite} codes
     * that are included in this Message.
     * 
This will use the {@link java.util.regex.Pattern Pattern} provided
     * under {@link #INVITE_PATTERN} to construct a {@link java.util.regex.Matcher Matcher} that will
     * parse the {@link #getContentRaw()} output and include all codes it finds in a list.
     *
     * 
You can use the codes to retrieve/validate invites via
     * {@link net.dv8tion.jda.api.entities.Invite#resolve(JDA, String) Invite.resolve(JDA, String)}
     *
     * @throws java.lang.UnsupportedOperationException
     *         If this is a system message
     *
     * @return Immutable list of invite codes
     */
    @Nonnull
    List getInvites();

    /**
     * Validation nonce for this Message
     * 
This can be used to validate that a Message was properly sent to the Discord Service.
     * 
To set a nonce before sending you may use {@link net.dv8tion.jda.api.MessageBuilder#setNonce(String) MessageBuilder.setNonce(String)}!
     *
     * @return The validation nonce
     *
     * @since  3.4.0
     *
     * @see    net.dv8tion.jda.api.MessageBuilder#setNonce(String)
     * @see    Cryptographic Nonce - Wikipedia
     */
    @Nullable
    String getNonce();

    /**
     * Used to determine if this Message was received from a {@link net.dv8tion.jda.api.entities.MessageChannel MessageChannel}
     * of the {@link net.dv8tion.jda.api.entities.ChannelType ChannelType} specified.
     * 
This will always be false for {@link net.dv8tion.jda.api.entities.ChannelType#VOICE} as Messages can't be sent to
     * {@link net.dv8tion.jda.api.entities.VoiceChannel VoiceChannels}.
     *
     * 
Useful for restricting functionality to a certain type of channels.
     *
     * @param  type
     *         The {@link net.dv8tion.jda.api.entities.ChannelType ChannelType} to check against.
     *
     * @throws java.lang.UnsupportedOperationException
     *         If this is a system message
     *
     * @return True if the {@link net.dv8tion.jda.api.entities.ChannelType ChannelType} which this message was received
     *         from is the same as the one specified by {@code type}.
     */
    boolean isFromType(@Nonnull ChannelType type);

    /**
     * Whether this message was sent in a {@link net.dv8tion.jda.api.entities.Guild Guild}.
     * 
If this is {@code false} then {@link #getGuild()} will throw an {@link java.lang.IllegalStateException}.
     *
     * @return True, if {@link #getChannelType()}.{@link ChannelType#isGuild() isGuild()} is true.
     */
    default boolean isFromGuild()
    {
        return getChannelType().isGuild();
    }

    /**
     * Gets the {@link net.dv8tion.jda.api.entities.ChannelType ChannelType} that this message was received from.
     * 
This will never be {@link net.dv8tion.jda.api.entities.ChannelType#VOICE} as Messages can't be sent to
     * {@link net.dv8tion.jda.api.entities.VoiceChannel VoiceChannels}.
     *
     * @throws java.lang.UnsupportedOperationException
     *         If this is a system message
     *
     * @return The ChannelType which this message was received from.
     */
    @Nonnull
    ChannelType getChannelType();

    /**
     * Indicates if this Message was sent by a {@link net.dv8tion.jda.api.entities.Webhook Webhook} instead of a
     * {@link net.dv8tion.jda.api.entities.User User}.
     * 
Useful if you want to ignore non-users.
     *
     * @throws java.lang.UnsupportedOperationException
     *         If this is a system message
     *
     * @return True if this message was sent by a {@link net.dv8tion.jda.api.entities.Webhook Webhook}.
     */
    boolean isWebhookMessage();

    /**
     * Returns the {@link net.dv8tion.jda.api.entities.MessageChannel MessageChannel} that this message was sent in.
     *
     * @throws java.lang.UnsupportedOperationException
     *         If this is a system message
     *
     * @return The MessageChannel of this Message
     */
    @Nonnull
    MessageChannel getChannel();

    /**
     * Returns the {@link net.dv8tion.jda.api.entities.GuildMessageChannel GuildMessageChannel} that this message was sent in
     *  if it was sent in a Guild.
     *
     * @throws java.lang.UnsupportedOperationException
     *         If this is a system message
     * @throws java.lang.IllegalStateException
     *         If this was not sent in a {@link net.dv8tion.jda.api.entities.Guild}.
     *
     * @return The MessageChannel of this Message
     */
    @Nonnull
    GuildMessageChannel getGuildChannel();

    /**
     * Returns the {@link net.dv8tion.jda.api.entities.PrivateChannel PrivateChannel} that this message was sent in.
     * 
This is only valid if the Message was actually sent in a PrivateChannel.
     * 
You can check the type of channel this message was sent from using {@link #isFromType(ChannelType)} or {@link #getChannelType()}.
     *
     * 
Use {@link #getChannel()} for an ambiguous {@link net.dv8tion.jda.api.entities.MessageChannel MessageChannel}
     * if you do not need functionality specific to {@link net.dv8tion.jda.api.entities.PrivateChannel PrivateChannel}.
     *
     * @throws java.lang.UnsupportedOperationException
     *         If this is a system message
     * @throws java.lang.IllegalStateException
     *         If this was not sent in a {@link net.dv8tion.jda.api.entities.PrivateChannel}.
     *
     * @return The PrivateChannel this message was sent in
     *
     * @see    #isFromGuild()
     * @see    #isFromType(ChannelType)
     * @see    #getChannelType()
     */
    @Nonnull
    PrivateChannel getPrivateChannel();

    /**
     * Returns the {@link net.dv8tion.jda.api.entities.TextChannel TextChannel} that this message was sent in.
     * 
This is only valid if the Message was actually sent in a TextChannel.
     * 
You can check the type of channel this message was sent from using {@link #isFromType(ChannelType)} or {@link #getChannelType()}.
     *
     * 
Use {@link #getChannel()} for an ambiguous {@link net.dv8tion.jda.api.entities.MessageChannel MessageChannel}
     * if you do not need functionality specific to {@link net.dv8tion.jda.api.entities.TextChannel TextChannel}.
     *
     * @throws java.lang.UnsupportedOperationException
     *         If this is a system message
     * @throws java.lang.IllegalStateException
     *         If this was not sent in a {@link net.dv8tion.jda.api.entities.TextChannel}.
     *
     * @return The TextChannel this message was sent in
     *
     * @see    #isFromGuild()
     * @see    #isFromType(ChannelType)
     * @see    #getChannelType()
     */
    @Nonnull
    TextChannel getTextChannel();

    /**
     * Returns the {@link net.dv8tion.jda.api.entities.NewsChannel NewsChannel} that this message was sent in.
     * 
This is only valid if the Message was actually sent in a NewsChannel.
     * 
You can check the type of channel this message was sent from using {@link #isFromType(ChannelType)} or {@link #getChannelType()}.
     *
     * 
Use {@link #getChannel()} for an ambiguous {@link net.dv8tion.jda.api.entities.MessageChannel MessageChannel}
     * if you do not need functionality specific to {@link net.dv8tion.jda.api.entities.NewsChannel NewsChannel}.
     *
     * @throws java.lang.UnsupportedOperationException
     *         If this is a system message
     * @throws java.lang.IllegalStateException
     *         If this was not sent in a {@link net.dv8tion.jda.api.entities.NewsChannel}.
     *
     * @return The NewsChannel this message was sent in
     *
     * @see    #isFromGuild()
     * @see    #isFromType(ChannelType)
     * @see    #getChannelType()
     */
    @Nonnull
    NewsChannel getNewsChannel();

    /**
     * The {@link net.dv8tion.jda.api.entities.Category Category} this
     * message was sent in. This will always be {@code null} for DMs.
     * 
Equivalent to {@code getTextChannel().getParentCategory()} if this was sent in a {@link net.dv8tion.jda.api.entities.TextChannel}.
     *
     * @throws java.lang.UnsupportedOperationException
     *         If this is a system message
     *
     * @return {@link net.dv8tion.jda.api.entities.Category Category} for this message
     */
    @Nullable
    Category getCategory();

    /**
     * Returns the {@link net.dv8tion.jda.api.entities.Guild Guild} that this message was sent in.
     * 
This is just a shortcut to {@link #getTextChannel()}.{@link net.dv8tion.jda.api.entities.TextChannel#getGuild() getGuild()}.
     * 
This is only valid if the Message was actually sent in a TextChannel.
     * 
You can check the type of channel this message was sent from using {@link #isFromType(ChannelType)} or {@link #getChannelType()}.
     *
     * @throws java.lang.UnsupportedOperationException
     *         If this is a system message
     * @throws java.lang.IllegalStateException
     *         If this was not sent in a {@link net.dv8tion.jda.api.entities.TextChannel}.
     *
     * @return The Guild this message was sent in
     *
     * @see    #isFromGuild()
     * @see    #isFromType(ChannelType)
     * @see    #getChannelType()
     */
    @Nonnull
    Guild getGuild();

    /**
     * An immutable list of {@link net.dv8tion.jda.api.entities.Message.Attachment Attachments} that are attached to this message.
     * 
Most likely this will only ever be 1 {@link net.dv8tion.jda.api.entities.Message.Attachment Attachment} at most.
     *
     * @throws java.lang.UnsupportedOperationException
     *         If this is a system message
     *
     * @return Immutable list of {@link net.dv8tion.jda.api.entities.Message.Attachment Attachments}.
     */
    @Nonnull
    List getAttachments();

    /**
     * An immutable list of {@link net.dv8tion.jda.api.entities.MessageEmbed MessageEmbeds} that are part of this
     * Message.
     *
     * @throws java.lang.UnsupportedOperationException
     *         If this is a system message
     *
     * @return Immutable list of all given MessageEmbeds.
     */
    @Nonnull
    List getEmbeds();

    /**
     * Rows of interactive components such as {@link Button Buttons}.
     * 
You can use {@link MessageAction#setActionRows(ActionRow...)} to update these.
     *
     * @return Immutable {@link List} of {@link ActionRow}
     *
     * @see    #getButtons()
     * @see    #getButtonById(String)
     */
    @Nonnull
    List getActionRows();

    /**
     * All {@link Button Buttons} attached to this message.
     *
     * @return Immutable {@link List} of {@link Button Buttons}
     */
    @Nonnull
    default List getButtons()
    {
        return getActionRows().stream()
                .map(ActionRow::getButtons)
                .flatMap(List::stream)
                .collect(Collectors.toList());
    }

    /**
     * Gets the {@link Button} with the specified ID.
     *
     * @param  id
     *         The id of the button
     *
     * @throws IllegalArgumentException
     *         If the id is null
     *
     * @return The {@link Button} or null of no button with that ID is present on this message
     */
    @Nullable
    default Button getButtonById(@Nonnull String id)
    {
        Checks.notNull(id, "Button ID");
        return getButtons().stream()
                .filter(it -> id.equals(it.getId()))
                .findFirst().orElse(null);
    }

    /**
     * All {@link Button Buttons} with the specified label attached to this message.
     *
     * @param  label
     *         The button label
     * @param  ignoreCase
     *         Whether to use {@link String#equalsIgnoreCase(String)} instead of {@link String#equals(Object)}
     *
     * @throws IllegalArgumentException
     *         If the provided label is null
     *
     * @return Immutable {@link List} of {@link Button Buttons} with the specified label
     */
    @Nonnull
    default List getButtonsByLabel(@Nonnull String label, boolean ignoreCase)
    {
        Checks.notNull(label, "Label");
        Predicate filter;
        if (ignoreCase)
            filter = b -> label.equalsIgnoreCase(b.getLabel());
        else
            filter = b -> label.equals(b.getLabel());
        return getButtons().stream()
                .filter(filter)
                .collect(Collectors.toList());
    }

    /**
     * All {@link net.dv8tion.jda.api.entities.Emote Emotes} used in this Message.
     * 
This only includes Custom Emotes, not unicode Emojis. JDA classifies Emotes as the Custom Emojis uploaded
     * to a Guild and retrievable with {@link net.dv8tion.jda.api.entities.Guild#getEmotes()}. These are not the same
     * as the unicode emojis that Discord also supports. Elements are sorted in order of appearance.
     *
     * 
Unicode emojis are not included as {@link net.dv8tion.jda.api.entities.Emote Emote}!
     *
     * @throws java.lang.UnsupportedOperationException
     *         If this is a system message
     *
     * @return An immutable list of the Emotes used in this message (example match {@literal <:jda:230988580904763393>})
     */
    @Nonnull
    List getEmotes();

    /**
     * A {@link org.apache.commons.collections4.Bag Bag} of emotes used in this message.
     * 
This can be used to retrieve the amount of times an emote was used in this message.
     *
     * 
Example
     * 
{@code
     * public void sendCount(Message msg)
     * {
     *     List emotes = msg.getEmotes(); // distinct list, in order of appearance
     *     Bag count = msg.getEmotesBag();
     *     StringBuilder content = new StringBuilder();
     *     for (Emote emote : emotes)
     *     {
     *         content.append(emote.getName())
     *                .append(": ")
     *                .append(count.getCount(role))
     *                .append("\n");
     *     }
     *     msg.getChannel().sendMessage(content.toString()).queue();
     * }
     * }
     *
     * @throws java.lang.UnsupportedOperationException
     *         If this is a system message
     *
     * @return {@link org.apache.commons.collections4.Bag Bag} of used emotes
     *
     * @see    #getEmotes()
     */
    @Nonnull
    Bag getEmotesBag();

    /**
     * All {@link net.dv8tion.jda.api.entities.MessageReaction MessageReactions} that are on this Message.
     *
     * @throws java.lang.UnsupportedOperationException
     *         If this is a system message
     *
     * @return Immutable list of all MessageReactions on this message.
     *
     * @see    net.dv8tion.jda.api.entities.MessageReaction
     */
    @Nonnull
    List getReactions();

    /**
     * All {@link net.dv8tion.jda.api.entities.MessageSticker MessageStickers} that are in this Message.
     * 
The returned MessageStickers may only contain necessary information such as the sticker id, format type, name, and icon url.
     *
     * @throws java.lang.UnsupportedOperationException
     *         If this is a system message
     *
     * @return Immutable list of all MessageStickers in this message.
     */
    @Nonnull
    List getStickers();

    /**
     * Defines whether or not this Message triggers TTS (Text-To-Speech).
     *
     * @return If this message is TTS.
     */
    boolean isTTS();

    /**
     * A {@link net.dv8tion.jda.api.entities.MessageActivity MessageActivity} that contains its type and party id.
     *
     * @return The activity, or {@code null} if no activity was added to the message.
     */
    @Nullable
    MessageActivity getActivity();

    /**
     * Edits this Message's content to the provided String.
     * 
Messages can only be edited by the account that sent them!.
     *
     * 
This message instance will not be updated by this operation, please use the response message instead.
     *
     * 
The following {@link net.dv8tion.jda.api.requests.ErrorResponse ErrorResponses} are possible:
     * 

     *     
{@link net.dv8tion.jda.api.requests.ErrorResponse#MISSING_ACCESS MISSING_ACCESS}
     *     
The edit was attempted after the account lost access to the {@link net.dv8tion.jda.api.entities.Guild Guild}
     *         typically due to being kicked or removed.
     *
     *     
{@link net.dv8tion.jda.api.requests.ErrorResponse#MISSING_PERMISSIONS MISSING_PERMISSIONS}
     *     
The edit was attempted after the account lost {@link net.dv8tion.jda.api.Permission#MESSAGE_SEND Permission.MESSAGE_SEND} in
     *         the {@link net.dv8tion.jda.api.entities.TextChannel TextChannel}.
     *
     *     
{@link net.dv8tion.jda.api.requests.ErrorResponse#UNKNOWN_MESSAGE UNKNOWN_MESSAGE}
     *     
If the message has already been deleted. This might also be triggered for ephemeral messages.
     * 
     *
     * @param  newContent
     *         the new content of the Message
     *
     * @throws java.lang.UnsupportedOperationException
     *         If this is a system message
     * @throws java.lang.IllegalStateException
     *         If the message attempting to be edited was not created by the currently logged in account, or if
     *         {@code newContent}'s length is 0 or greater than 2000.
     *
     * @return {@link MessageAction MessageAction}
     *         
The {@link net.dv8tion.jda.api.entities.Message Message} with the updated content
     */
    @Nonnull
    @CheckReturnValue
    MessageAction editMessage(@Nonnull CharSequence newContent);

    /**
     * Edits this Message's content to the provided {@link net.dv8tion.jda.api.entities.MessageEmbed MessageEmbeds}.
     * 
Messages can only be edited by the account that sent them!.
     *
     * 
This message instance will not be updated by this operation, please use the response message instead.
     *
     * 
The following {@link net.dv8tion.jda.api.requests.ErrorResponse ErrorResponses} are possible:
     * 

     *     
{@link net.dv8tion.jda.api.requests.ErrorResponse#MISSING_ACCESS MISSING_ACCESS}
     *     
The edit was attempted after the account lost access to the {@link net.dv8tion.jda.api.entities.Guild Guild}
     *         typically due to being kicked or removed.
     *
     *     
{@link net.dv8tion.jda.api.requests.ErrorResponse#MISSING_PERMISSIONS MISSING_PERMISSIONS}
     *     
The edit was attempted after the account lost {@link net.dv8tion.jda.api.Permission#MESSAGE_SEND Permission.MESSAGE_SEND} in
     *         the {@link net.dv8tion.jda.api.entities.TextChannel TextChannel}.
     *
     *     
{@link net.dv8tion.jda.api.requests.ErrorResponse#UNKNOWN_MESSAGE UNKNOWN_MESSAGE}
     *     
If the message has already been deleted. This might also be triggered for ephemeral messages.
     * 
     *
     * @param  embeds
     *         the new embeds of the Message (up to 10)
     *
     * @throws java.lang.UnsupportedOperationException
     *         If this is not a Received Message from {@link net.dv8tion.jda.api.entities.MessageType#DEFAULT MessageType.DEFAULT}
     * @throws java.lang.IllegalStateException
     *         If the message attempting to be edited was not created by the currently logged in account
     * @throws IllegalArgumentException
     *         if any of the passed-in embeds is {@code null} or not {@link net.dv8tion.jda.api.entities.MessageEmbed#isSendable() sendable}.
     *
     * @return {@link MessageAction MessageAction}
     *         
The {@link net.dv8tion.jda.api.entities.Message Message} with the updated content
     */
    @Nonnull
    @CheckReturnValue
    MessageAction editMessageEmbeds(@Nonnull Collection embeds);

    /**
     * Edits this Message's content to the provided {@link net.dv8tion.jda.api.entities.MessageEmbed MessageEmbeds}.
     * 
Messages can only be edited by the account that sent them!.
     *
     * 
This message instance will not be updated by this operation, please use the response message instead.
     *
     * 
The following {@link net.dv8tion.jda.api.requests.ErrorResponse ErrorResponses} are possible:
     * 

     *     
{@link net.dv8tion.jda.api.requests.ErrorResponse#MISSING_ACCESS MISSING_ACCESS}
     *     
The edit was attempted after the account lost access to the {@link net.dv8tion.jda.api.entities.Guild Guild}
     *         typically due to being kicked or removed.
     *
     *     
{@link net.dv8tion.jda.api.requests.ErrorResponse#MISSING_PERMISSIONS MISSING_PERMISSIONS}
     *     
The edit was attempted after the account lost {@link net.dv8tion.jda.api.Permission#MESSAGE_SEND Permission.MESSAGE_SEND} in
     *         the {@link net.dv8tion.jda.api.entities.TextChannel TextChannel}.
     *
     *     
{@link net.dv8tion.jda.api.requests.ErrorResponse#UNKNOWN_MESSAGE UNKNOWN_MESSAGE}
     *     
If the message has already been deleted. This might also be triggered for ephemeral messages.
     * 
     *
     * @param  embeds
     *         the new embeds of the Message (up to 10)
     *
     * @throws java.lang.UnsupportedOperationException
     *         If this is not a Received Message from {@link net.dv8tion.jda.api.entities.MessageType#DEFAULT MessageType.DEFAULT}
     * @throws java.lang.IllegalStateException
     *         If the message attempting to be edited was not created by the currently logged in account
     * @throws IllegalArgumentException
     *         if any of the passed-in embeds is {@code null} or not {@link net.dv8tion.jda.api.entities.MessageEmbed#isSendable() sendable}.
     *
     * @return {@link MessageAction MessageAction}
     *         
The {@link net.dv8tion.jda.api.entities.Message Message} with the updated content
     */
    @Nonnull
    @CheckReturnValue
    default MessageAction editMessageEmbeds(@Nonnull MessageEmbed... embeds)
    {
        Checks.noneNull(embeds, "MessageEmbeds");
        return editMessageEmbeds(Arrays.asList(embeds));
    }

    /**
     * Edits this Message's content to the provided {@link LayoutComponent LayoutComponents}.
     * 
Messages can only be edited by the account that sent them!.
     * 
This will replace all the current {@link net.dv8tion.jda.api.interactions.components.Component Components},
     * such as {@link Button Buttons} or {@link SelectMenu SelectMenus} on this message.
     * The provided parameters are {@link LayoutComponent LayoutComponent} such as {@link ActionRow} which contain a list of components to arrange in the respective layout.
     *
     * 
This message instance will not be updated by this operation, please use the response message instead.
     *
     * 
The following {@link net.dv8tion.jda.api.requests.ErrorResponse ErrorResponses} are possible:
     * 

     *     
{@link net.dv8tion.jda.api.requests.ErrorResponse#INVALID_AUTHOR_EDIT INVALID_AUTHOR_EDIT}
     *     
Attempted to edit a message that was not sent by the currently logged in account.
     *         Discord does not allow editing of other users' Messages!
     *
     *     
{@link net.dv8tion.jda.api.requests.ErrorResponse#MISSING_ACCESS MISSING_ACCESS}
     *     
The request was attempted after the account lost access to the {@link net.dv8tion.jda.api.entities.Guild Guild}
     *         typically due to being kicked or removed, or after {@link net.dv8tion.jda.api.Permission#VIEW_CHANNEL Permission.VIEW_CHANNEL}
     *         was revoked in the {@link net.dv8tion.jda.api.entities.TextChannel TextChannel}
     *
     *     
{@link net.dv8tion.jda.api.requests.ErrorResponse#UNKNOWN_MESSAGE UNKNOWN_MESSAGE}
     *     
If the message has already been deleted. This might also be triggered for ephemeral messages.
     *
     *     
{@link net.dv8tion.jda.api.requests.ErrorResponse#UNKNOWN_CHANNEL UNKNOWN_CHANNEL}
     *     
The request was attempted after the channel was deleted.
     * 
     *
     * 
Example
     * 
{@code
     * List rows = Arrays.asList(
     *   ActionRow.of(Button.success("prompt:accept", "Accept"), Button.danger("prompt:reject", "Reject")), // 1st row below message
     *   ActionRow.of(Button.link(url, "Help")) // 2nd row below message
     * );
     * message.editMessageComponents(rows).queue();
     * }
     *
     * @param  components
     *         Up to 5 new {@link LayoutComponent LayoutComponents} for the edited message, such as {@link ActionRow}
     *
     * @throws java.lang.UnsupportedOperationException
     *         If this is not a Received Message from {@link net.dv8tion.jda.api.entities.MessageType#DEFAULT MessageType.DEFAULT}
     *         or any of the component layouts is a custom implementation that is not supported by this interface
     * @throws IllegalArgumentException
     *         If null is provided, or more than 5 layouts are added
     * @throws java.lang.IllegalStateException
     *         If the message attempting to be edited was not created by the currently logged in account
     *
     * @return {@link MessageAction MessageAction}
     *         
The {@link net.dv8tion.jda.api.entities.Message Message} with the updated components
     */
    @Nonnull
    @CheckReturnValue
    MessageAction editMessageComponents(@Nonnull Collection components);

    /**
     * Edits this Message's content to the provided {@link LayoutComponent LayoutComponents}.
     * 
Messages can only be edited by the account that sent them!.
     * 
This will replace all the current {@link net.dv8tion.jda.api.interactions.components.Component Components},
     * such as {@link Button Buttons} or {@link SelectMenu SelectMenus} on this message.
     * The provided parameters are {@link LayoutComponent LayoutComponent} such as {@link ActionRow} which contain a list of components to arrange in the respective layout.
     *
     * 
This message instance will not be updated by this operation, please use the response message instead.
     *
     * 
The following {@link net.dv8tion.jda.api.requests.ErrorResponse ErrorResponses} are possible:
     * 

     *     
{@link net.dv8tion.jda.api.requests.ErrorResponse#INVALID_AUTHOR_EDIT INVALID_AUTHOR_EDIT}
     *     
Attempted to edit a message that was not sent by the currently logged in account.
     *         Discord does not allow editing of other users' Messages!
     *
     *     
{@link net.dv8tion.jda.api.requests.ErrorResponse#MISSING_ACCESS MISSING_ACCESS}
     *     
The request was attempted after the account lost access to the {@link net.dv8tion.jda.api.entities.Guild Guild}
     *         typically due to being kicked or removed, or after {@link net.dv8tion.jda.api.Permission#VIEW_CHANNEL Permission.VIEW_CHANNEL}
     *         was revoked in the {@link net.dv8tion.jda.api.entities.TextChannel TextChannel}
     *
     *     
{@link net.dv8tion.jda.api.requests.ErrorResponse#UNKNOWN_MESSAGE UNKNOWN_MESSAGE}
     *     
If the message has already been deleted. This might also be triggered for ephemeral messages.
     *
     *     
{@link net.dv8tion.jda.api.requests.ErrorResponse#UNKNOWN_CHANNEL UNKNOWN_CHANNEL}
     *     
The request was attempted after the channel was deleted.
     * 
     *
     * 
Example
     * 
{@code
     * message.editMessageComponents(
     *   ActionRow.of(Button.success("prompt:accept", "Accept"), Button.danger("prompt:reject", "Reject")), // 1st row below message
     *   ActionRow.of(Button.link(url, "Help")) // 2nd row below message
     * ).queue();
     * }
     *
     * @param  components
     *         Up to 5 new {@link LayoutComponent LayoutComponents} for the edited message, such as {@link ActionRow}
     *
     * @throws java.lang.UnsupportedOperationException
     *         If this is not a Received Message from {@link net.dv8tion.jda.api.entities.MessageType#DEFAULT MessageType.DEFAULT}
     *         or any of the component layouts is a custom implementation that is not supported by this interface
     * @throws IllegalArgumentException
     *         If null is provided, or more than 5 layouts are added
     * @throws java.lang.IllegalStateException
     *         If the message attempting to be edited was not created by the currently logged in account
     *
     * @return {@link MessageAction MessageAction}
     *         
The {@link net.dv8tion.jda.api.entities.Message Message} with the updated components
     */
    @Nonnull
    @CheckReturnValue
    default MessageAction editMessageComponents(@Nonnull LayoutComponent... components)
    {
        Checks.noneNull(components, "Components");
        return editMessageComponents(Arrays.asList(components));
    }

    /**
     * Edits this Message's content to the provided format.
     * 
Shortcut for {@link net.dv8tion.jda.api.MessageBuilder#appendFormat(String, Object...)}.
     * 
Messages can only be edited by the account that sent them!.
     *
     * 
This message instance will not be updated by this operation, please use the response message instead.
     *
     * 
The following {@link net.dv8tion.jda.api.requests.ErrorResponse ErrorResponses} are possible:
     * 

     *     
{@link net.dv8tion.jda.api.requests.ErrorResponse#MISSING_ACCESS MISSING_ACCESS}
     *     
The edit was attempted after the account lost access to the {@link net.dv8tion.jda.api.entities.Guild Guild}
     *         typically due to being kicked or removed.
     *
     *     
{@link net.dv8tion.jda.api.requests.ErrorResponse#MISSING_PERMISSIONS MISSING_PERMISSIONS}
     *     
The edit was attempted after the account lost {@link net.dv8tion.jda.api.Permission#MESSAGE_SEND Permission.MESSAGE_SEND} in
     *         the {@link net.dv8tion.jda.api.entities.TextChannel TextChannel}.
     *
     *     
{@link net.dv8tion.jda.api.requests.ErrorResponse#UNKNOWN_MESSAGE UNKNOWN_MESSAGE}
     *     
If the message has already been deleted. This might also be triggered for ephemeral messages.
     * 
     *
     * @param  format
     *         Format String used to generate the Message's content via
     *         {@link net.dv8tion.jda.api.MessageBuilder#appendFormat(String, Object...)} specification
     * @param  args
     *         The arguments to use in order to be converted in the format string
     *
     * @throws java.lang.UnsupportedOperationException
     *         If this is a system message
     * @throws IllegalArgumentException
     *         If the provided format String is {@code null} or blank, or if
     *         the created message exceeds the 2000 character limit
     * @throws java.util.IllegalFormatException
     *         If a format string contains an illegal syntax,
     *         a format specifier that is incompatible with the given arguments,
     *         insufficient arguments given the format string, or other illegal conditions.
     *         For specification of all possible formatting errors,
     *         see the Details
     *         section of the formatter class specification.
     * @throws IllegalStateException
     *         If the message attempting to be edited was not created by the currently logged in account
     *
     * @return {@link MessageAction MessageAction}
     *         
The {@link net.dv8tion.jda.api.entities.Message Message} with the updated content
     */
    @Nonnull
    @CheckReturnValue
    MessageAction editMessageFormat(@Nonnull String format, @Nonnull Object... args);

    /**
     * Edits this Message's content to the provided {@link net.dv8tion.jda.api.entities.Message Message}.
     * 
Messages can only be edited by the account that sent them!.
     *
     * 
This message instance will not be updated by this operation, please use the response message instead.
     *
     * 
The following {@link net.dv8tion.jda.api.requests.ErrorResponse ErrorResponses} are possible:
     * 

     *     
{@link net.dv8tion.jda.api.requests.ErrorResponse#MISSING_ACCESS MISSING_ACCESS}
     *     
The edit was attempted after the account lost access to the {@link net.dv8tion.jda.api.entities.Guild Guild}
     *         typically due to being kicked or removed.
     *
     *     
{@link net.dv8tion.jda.api.requests.ErrorResponse#MISSING_PERMISSIONS MISSING_PERMISSIONS}
     *     
The edit was attempted after the account lost {@link net.dv8tion.jda.api.Permission#MESSAGE_SEND Permission.MESSAGE_SEND} in
     *         the {@link net.dv8tion.jda.api.entities.TextChannel TextChannel}.
     *
     *     
{@link net.dv8tion.jda.api.requests.ErrorResponse#UNKNOWN_MESSAGE UNKNOWN_MESSAGE}
     *     
If the message has already been deleted. This might also be triggered for ephemeral messages.
     * 
     *
     * @param  newContent
     *         the new content of the Message
     *
     * @throws java.lang.UnsupportedOperationException
     *         If this is a system message
     * @throws java.lang.IllegalStateException
     *         

     *             
If the message attempting to be edited was not created by the currently logged in account
     *             
If the message contains a MessageEmbed that is not
     *                 {@link net.dv8tion.jda.api.entities.MessageEmbed#isSendable() sendable}
     *         
     *
     * @return {@link MessageAction MessageAction}
     *         
The {@link net.dv8tion.jda.api.entities.Message Message} with the updated content
     */
    @Nonnull
    @CheckReturnValue
    MessageAction editMessage(@Nonnull Message newContent);

    /**
     * Replies and references this message.
     * 
This is identical to {@code message.getChannel().sendMessage(content).reference(message)}.
     * You can use {@link MessageAction#mentionRepliedUser(boolean) mentionRepliedUser(false)} to not mention the author of the message.
     * 
By default there won't be any error thrown if the referenced message does not exist.
     * This behavior can be changed with {@link MessageAction#failOnInvalidReply(boolean)}.
     *
     * 
For further info, see {@link MessageChannel#sendMessage(CharSequence)} and {@link MessageAction#reference(Message)}.
     *
     * @param  content
     *         The content of the reply message
     *
     * @return {@link MessageAction} Providing the {@link Message} created from this upload.
     *
     * @since  4.2.1
     */
    @Nonnull
    @CheckReturnValue
    default MessageAction reply(@Nonnull CharSequence content)
    {
        return getChannel().sendMessage(content).reference(this);
    }

    /**
     * Replies and references this message.
     * 
This is identical to {@code message.getChannel().sendMessageEmbeds(embeds).reference(message)}.
     * You can use {@link MessageAction#mentionRepliedUser(boolean) mentionRepliedUser(false)} to not mention the author of the message.
     * 
By default there won't be any error thrown if the referenced message does not exist.
     * This behavior can be changed with {@link MessageAction#failOnInvalidReply(boolean)}.
     *
     * 
For further info, see {@link MessageChannel#sendMessageEmbeds(MessageEmbed, MessageEmbed...)} and {@link MessageAction#reference(Message)}.
     *
     * @param  embed
     *         The embed to reply with
     * @param  other
     *         Additional embeds to reply with
     *
     * @throws IllegalArgumentException
     *         If null is provided, any of the embeds are not {@link MessageEmbed#isSendable() sendable}, more than {@value Message#MAX_EMBED_COUNT} embeds are provided,
     *         or the sum of {@link MessageEmbed#getLength()} is greater than {@link MessageEmbed#EMBED_MAX_LENGTH_BOT}
     *
     * @return {@link MessageAction} Providing the {@link Message} created from this upload.
     */
    @Nonnull
    @CheckReturnValue
    default MessageAction replyEmbeds(@Nonnull MessageEmbed embed, @Nonnull MessageEmbed... other)
    {
        Checks.notNull(embed, "MessageEmbeds");
        Checks.noneNull(other, "MessageEmbeds");
        List embeds = new ArrayList<>(1 + other.length);
        embeds.add(embed);
        Collections.addAll(embeds, other);
        return replyEmbeds(embeds);
    }

    /**
     * Replies and references this message.
     * 
This is identical to {@code message.getChannel().sendMessageEmbeds(embeds).reference(message)}.
     * You can use {@link MessageAction#mentionRepliedUser(boolean) mentionRepliedUser(false)} to not mention the author of the message.
     * 
By default there won't be any error thrown if the referenced message does not exist.
     * This behavior can be changed with {@link MessageAction#failOnInvalidReply(boolean)}.
     *
     * 
For further info, see {@link MessageChannel#sendMessageEmbeds(MessageEmbed, MessageEmbed...)} and {@link MessageAction#reference(Message)}.
     *
     * @param  embeds
     *         The embeds to reply with
     *
     * @throws IllegalArgumentException
     *         If null is provided, any of the embeds are not {@link MessageEmbed#isSendable() sendable}, more than {@value Message#MAX_EMBED_COUNT} embeds are provided,
     *         or the sum of {@link MessageEmbed#getLength()} is greater than {@link MessageEmbed#EMBED_MAX_LENGTH_BOT}
     *
     * @return {@link MessageAction} Providing the {@link Message} created from this upload.
     */
    @Nonnull
    @CheckReturnValue
    default MessageAction replyEmbeds(@Nonnull Collection embeds)
    {
        return getChannel().sendMessageEmbeds(embeds).reference(this);
    }

    /**
     * Replies and references this message.
     * 
This is identical to {@code message.getChannel().sendMessage(content).reference(message)}.
     * You can use {@link MessageAction#mentionRepliedUser(boolean) mentionRepliedUser(false)} to not mention the author of the message.
     * 
By default there won't be any error thrown if the referenced message does not exist.
     * This behavior can be changed with {@link MessageAction#failOnInvalidReply(boolean)}.
     *
     * 
For further info, see {@link MessageChannel#sendMessage(Message)} and {@link MessageAction#reference(Message)}.
     *
     * @param  content
     *         The content of the reply message
     *
     * @return {@link MessageAction} Providing the {@link Message} created from this upload.
     *
     * @since  4.2.1
     */
    @Nonnull
    @CheckReturnValue
    default MessageAction reply(@Nonnull Message content)
    {
        return getChannel().sendMessage(content).reference(this);
    }

    /**
     * Replies and references this message.
     * 
This is identical to {@code message.getChannel().sendMessageFormat(content, args).reference(message)}.
     * You can use {@link MessageAction#mentionRepliedUser(boolean) mentionRepliedUser(false)} to not mention the author of the message.
     * 
By default there won't be any error thrown if the referenced message does not exist.
     * This behavior can be changed with {@link MessageAction#failOnInvalidReply(boolean)}.
     *
     * 
For further info, see {@link MessageChannel#sendMessageFormat(String, Object...)} and {@link MessageAction#reference(Message)}.
     *
     * @param  format
     *         The string that should be formatted, if this is null or empty the content of the Message would be empty and cause a builder exception.
     * @param  args
     *         The arguments for your format
     *
     * @return {@link MessageAction} Providing the {@link Message} created from this upload.
     *
     * @since  4.2.1
     */
    @Nonnull
    @CheckReturnValue
    default MessageAction replyFormat(@Nonnull String format, @Nonnull Object... args)
    {
        return getChannel().sendMessageFormat(format, args).reference(this);
    }

    /**
     * Replies and references this message.
     * 
This is identical to {@code message.getChannel().sendFile(file, options).reference(message)}.
     * You can use {@link MessageAction#mentionRepliedUser(boolean) mentionRepliedUser(false)} to not mention the author of the message.
     * 
By default there won't be any error thrown if the referenced message does not exist.
     * This behavior can be changed with {@link MessageAction#failOnInvalidReply(boolean)}.
     *
     * 
For further info, see {@link MessageChannel#sendFile(File, net.dv8tion.jda.api.utils.AttachmentOption...)} and {@link MessageAction#reference(Message)}.
     *
     * @param  file
     *         The file to upload to the channel in the reply
     * @param  options
     *         Possible options to apply to this attachment, such as marking it as spoiler image
     *
     * @return {@link MessageAction} Providing the {@link Message} created from this upload.
     *
     * @since  4.2.1
     */
    @Nonnull
    @CheckReturnValue
    default MessageAction reply(@Nonnull File file, @Nonnull AttachmentOption... options)
    {
        return getChannel().sendFile(file, options).reference(this);
    }

    /**
     * Replies and references this message.
     * 
This is identical to {@code message.getChannel().sendFile(data, name, options).reference(message)}.
     * You can use {@link MessageAction#mentionRepliedUser(boolean) mentionRepliedUser(false)} to not mention the author of the message.
     * 
By default there won't be any error thrown if the referenced message does not exist.
     * This behavior can be changed with {@link MessageAction#failOnInvalidReply(boolean)}.
     *
     * 
For further info, see {@link MessageChannel#sendFile(File, String, net.dv8tion.jda.api.utils.AttachmentOption...)} and {@link MessageAction#reference(Message)}.
     *
     * @param  data
     *         The data to upload to the channel in the reply
     * @param  name
     *         The name that should be sent to discord
     * @param  options
     *         Possible options to apply to this attachment, such as marking it as spoiler image
     *
     * @return {@link MessageAction} Providing the {@link Message} created from this upload.
     *
     * @since  4.2.1
     */
    @Nonnull
    @CheckReturnValue
    default MessageAction reply(@Nonnull File data, @Nonnull String name, @Nonnull AttachmentOption... options)
    {
        return getChannel().sendFile(data, name, options).reference(this);
    }

    /**
     * Replies and references this message.
     * 
This is identical to {@code message.getChannel().sendFile(data, name, options).reference(message)}.
     * You can use {@link MessageAction#mentionRepliedUser(boolean) mentionRepliedUser(false)} to not mention the author of the message.
     * 
By default there won't be any error thrown if the referenced message does not exist.
     * This behavior can be changed with {@link MessageAction#failOnInvalidReply(boolean)}.
     *
     * 
For further info, see {@link MessageChannel#sendFile(InputStream, String, net.dv8tion.jda.api.utils.AttachmentOption...)} and {@link MessageAction#reference(Message)}.
     *
     * @param  data
     *         The data to upload to the channel in the reply
     * @param  name
     *         The name that should be sent to discord
     * @param  options
     *         Possible options to apply to this attachment, such as marking it as spoiler image
     *
     * @return {@link MessageAction} Providing the {@link Message} created from this upload.
     *
     * @since  4.2.1
     */
    @Nonnull
    @CheckReturnValue
    default MessageAction reply(@Nonnull InputStream data, @Nonnull String name, @Nonnull AttachmentOption... options)
    {
        return getChannel().sendFile(data, name, options).reference(this);
    }

    /**
     * Replies and references this message.
     * 
This is identical to {@code message.getChannel().sendFile(data, name, options).reference(message)}.
     * You can use {@link MessageAction#mentionRepliedUser(boolean) mentionRepliedUser(false)} to not mention the author of the message.
     * 
By default there won't be any error thrown if the referenced message does not exist.
     * This behavior can be changed with {@link MessageAction#failOnInvalidReply(boolean)}.
     *
     * 
For further info, see {@link MessageChannel#sendFile(byte[], String, net.dv8tion.jda.api.utils.AttachmentOption...)} and {@link MessageAction#reference(Message)}.
     *
     * @param  data
     *         The data to upload to the channel in the reply
     * @param  name
     *         The name that should be sent to discord
     * @param  options
     *         Possible options to apply to this attachment, such as marking it as spoiler image
     *
     * @return {@link MessageAction} Providing the {@link Message} created from this upload.
     *
     * @since  4.2.1
     */
    @Nonnull
    @CheckReturnValue
    default MessageAction reply(@Nonnull byte[] data, @Nonnull String name, @Nonnull AttachmentOption... options)
    {
        return getChannel().sendFile(data, name, options).reference(this);
    }

    /**
     * Deletes this Message from Discord.
     * 
If this Message was not sent by the currently logged in account, then this will fail unless the Message is from
     * a {@link net.dv8tion.jda.api.entities.TextChannel TextChannel} and the current account has
     * {@link net.dv8tion.jda.api.Permission#MESSAGE_MANAGE Permission.MESSAGE_MANAGE} in the channel.
     *
     * 
To delete many messages at once in a {@link net.dv8tion.jda.api.entities.MessageChannel MessageChannel}
     * you should use {@link net.dv8tion.jda.api.entities.MessageChannel#purgeMessages(List) MessageChannel.purgeMessages(List)} instead.
     *
     * 
The following {@link net.dv8tion.jda.api.requests.ErrorResponse ErrorResponses} are possible:
     * 

     *     
{@link net.dv8tion.jda.api.requests.ErrorResponse#MISSING_ACCESS MISSING_ACCESS}
     *     
The delete was attempted after the account lost access to the {@link net.dv8tion.jda.api.entities.TextChannel TextChannel}
     *         due to {@link net.dv8tion.jda.api.Permission#VIEW_CHANNEL Permission.VIEW_CHANNEL} being revoked, or the
     *         account lost access to the {@link net.dv8tion.jda.api.entities.Guild Guild}
     *         typically due to being kicked or removed.
     *
     *     
{@link net.dv8tion.jda.api.requests.ErrorResponse#MISSING_PERMISSIONS MISSING_PERMISSIONS}
     *     
The delete was attempted after the account lost {@link net.dv8tion.jda.api.Permission#MESSAGE_MANAGE Permission.MESSAGE_MANAGE} in
     *         the {@link net.dv8tion.jda.api.entities.TextChannel TextChannel} when deleting another Member's message
     *         or lost {@link net.dv8tion.jda.api.Permission#MESSAGE_MANAGE}.
     *
     *     
{@link net.dv8tion.jda.api.requests.ErrorResponse#UNKNOWN_MESSAGE UNKNOWN_MESSAGE}
     *     
If the message has already been deleted. This might also be triggered for ephemeral messages.
     * 
     *
     * @throws java.lang.UnsupportedOperationException
     *         If this is a Data Message (output of {@link net.dv8tion.jda.api.MessageBuilder MessageBuilder})
     * @throws net.dv8tion.jda.api.exceptions.InsufficientPermissionException
     *         If this Message was not sent by the currently logged in account, the Message was sent in a
     *         {@link net.dv8tion.jda.api.entities.TextChannel TextChannel}, and the currently logged in account
     *         does not have {@link net.dv8tion.jda.api.Permission#MESSAGE_MANAGE Permission.MESSAGE_MANAGE} in
     *         the channel.
     * @throws java.lang.IllegalStateException
     *         

     *              
If this Message was not sent by the currently logged in account and it was not sent in a
     *              {@link net.dv8tion.jda.api.entities.TextChannel TextChannel}.
     *              
If this Message is ephemeral
     *         
     *
     * @return {@link net.dv8tion.jda.api.requests.restaction.AuditableRestAction AuditableRestAction}
     *
     * @see    net.dv8tion.jda.api.entities.TextChannel#deleteMessages(java.util.Collection) TextChannel.deleteMessages(Collection)
     * @see    net.dv8tion.jda.api.entities.MessageChannel#purgeMessages(java.util.List) MessageChannel.purgeMessages(List)
     */
    @Nonnull
    @CheckReturnValue
    AuditableRestAction delete();

    /**
     * Returns the {@link net.dv8tion.jda.api.JDA JDA} instance related to this Message.
     *
     * @throws java.lang.UnsupportedOperationException
     *         If this is a system message
     *
     * @return  the corresponding JDA instance
     */
    @Nonnull
    JDA getJDA();

    /**
     * Whether or not this Message has been pinned in its parent channel.
     *
     * @throws java.lang.UnsupportedOperationException
     *         If this is a system message
     *
     * @return True - if this message has been pinned.
     */
    boolean isPinned();

    /**
     * Used to add the Message to the {@link #getChannel() MessageChannel's} pinned message list.
     * 
This is a shortcut method to {@link MessageChannel#pinMessageById(String)}.
     *
     * 
The success or failure of this action will not affect the return of {@link #isPinned()}.
     *
     * 
The following {@link net.dv8tion.jda.api.requests.ErrorResponse ErrorResponses} are possible:
     * 

     *     
{@link net.dv8tion.jda.api.requests.ErrorResponse#MISSING_ACCESS MISSING_ACCESS}
     *     
The pin request was attempted after the account lost access to the {@link net.dv8tion.jda.api.entities.TextChannel TextChannel}
     *         due to {@link net.dv8tion.jda.api.Permission#VIEW_CHANNEL Permission.VIEW_CHANNEL} being revoked, or the
     *         account lost access to the {@link net.dv8tion.jda.api.entities.Guild Guild}
     *         typically due to being kicked or removed.
     *
     *     
{@link net.dv8tion.jda.api.requests.ErrorResponse#MISSING_PERMISSIONS MISSING_PERMISSIONS}
     *     
The pin request was attempted after the account lost {@link net.dv8tion.jda.api.Permission#MESSAGE_MANAGE Permission.MESSAGE_MANAGE} in
     *         the {@link net.dv8tion.jda.api.entities.TextChannel TextChannel}.
     *
     *     
{@link net.dv8tion.jda.api.requests.ErrorResponse#UNKNOWN_MESSAGE UNKNOWN_MESSAGE}
     *     
If the message has already been deleted. This might also be triggered for ephemeral messages.
     * 
     *
     * @throws java.lang.UnsupportedOperationException
     *         If this is a system message
     * @throws net.dv8tion.jda.api.exceptions.InsufficientPermissionException
     *         If this Message is from a {@link net.dv8tion.jda.api.entities.TextChannel TextChannel} and:
     *         

     *             
Missing {@link net.dv8tion.jda.api.Permission#VIEW_CHANNEL Permission.VIEW_CHANNEL}.
     *             
The account needs access the the channel to pin a message in it.
     *             
Missing {@link net.dv8tion.jda.api.Permission#MESSAGE_MANAGE Permission.MESSAGE_MANAGE}.
     *             
Required to actually pin the Message.
     *         
     * @throws IllegalStateException
     *         If this Message is ephemeral
     *
     * @return {@link net.dv8tion.jda.api.requests.RestAction RestAction} - Type: {@link java.lang.Void}
     */
    @Nonnull
    @CheckReturnValue
    RestAction pin();

    /**
     * Used to remove the Message from the {@link #getChannel() MessageChannel's} pinned message list.
     * 
This is a shortcut method to {@link MessageChannel#unpinMessageById(String)}.
     *
     * 
The success or failure of this action will not affect the return of {@link #isPinned()}.
     *
     * 
The following {@link net.dv8tion.jda.api.requests.ErrorResponse ErrorResponses} are possible:
     * 

     *     
{@link net.dv8tion.jda.api.requests.ErrorResponse#MISSING_ACCESS MISSING_ACCESS}
     *     
The unpin request was attempted after the account lost access to the {@link net.dv8tion.jda.api.entities.TextChannel TextChannel}
     *         due to {@link net.dv8tion.jda.api.Permission#VIEW_CHANNEL Permission.VIEW_CHANNEL} being revoked, or the
     *         account lost access to the {@link net.dv8tion.jda.api.entities.Guild Guild}
     *         typically due to being kicked or removed.
     *
     *     
{@link net.dv8tion.jda.api.requests.ErrorResponse#MISSING_PERMISSIONS MISSING_PERMISSIONS}
     *     
The unpin request was attempted after the account lost {@link net.dv8tion.jda.api.Permission#MESSAGE_MANAGE Permission.MESSAGE_MANAGE} in
     *         the {@link net.dv8tion.jda.api.entities.TextChannel TextChannel}.
     *
     *     
{@link net.dv8tion.jda.api.requests.ErrorResponse#UNKNOWN_MESSAGE UNKNOWN_MESSAGE}
     *     
If the message has already been deleted. This might also be triggered for ephemeral messages.
     * 
     *
     * @throws java.lang.UnsupportedOperationException
     *         If this is a system message
     * @throws net.dv8tion.jda.api.exceptions.InsufficientPermissionException
     *         If this Message is from a {@link net.dv8tion.jda.api.entities.TextChannel TextChannel} and:
     *         

     *             
Missing {@link net.dv8tion.jda.api.Permission#VIEW_CHANNEL Permission.VIEW_CHANNEL}.
     *             
The account needs access the the channel to pin a message in it.
     *             
Missing {@link net.dv8tion.jda.api.Permission#MESSAGE_MANAGE Permission.MESSAGE_MANAGE}.
     *             
Required to actually pin the Message.
     *         
     * @throws IllegalStateException
     *         If this Message is ephemeral
     *
     * @return {@link net.dv8tion.jda.api.requests.RestAction RestAction} - Type: {@link java.lang.Void}
     */
    @Nonnull
    @CheckReturnValue
    RestAction unpin();

    /**
     * Adds a reaction to this Message using an {@link net.dv8tion.jda.api.entities.Emote Emote}.
     *
     * 
This message instance will not be updated by this operation.
     *
     * 
Reactions are the small emoji/emotes below a message that have a counter beside them
     * showing how many users have reacted with the same emoji/emote.
     *
     * 
Neither success nor failure of this request will affect this Message's {@link #getReactions()} return as Message is immutable.
     *
     * 
Unicode emojis are not included as {@link net.dv8tion.jda.api.entities.Emote Emote}!
     *
     * 
The following {@link net.dv8tion.jda.api.requests.ErrorResponse ErrorResponses} are possible:
     * 

     *     
{@link net.dv8tion.jda.api.requests.ErrorResponse#MISSING_ACCESS MISSING_ACCESS}
     *     
The reaction request was attempted after the account lost access to the {@link net.dv8tion.jda.api.entities.TextChannel TextChannel}
     *         due to {@link net.dv8tion.jda.api.Permission#VIEW_CHANNEL Permission.VIEW_CHANNEL} being revoked
     *     
Also can happen if the account lost the {@link net.dv8tion.jda.api.Permission#MESSAGE_HISTORY Permission.MESSAGE_HISTORY}
     *
     *     
{@link net.dv8tion.jda.api.requests.ErrorResponse#REACTION_BLOCKED REACTION_BLOCKED}
     *     
The user has blocked the currently logged in account and the reaction failed
     *
     *     
{@link net.dv8tion.jda.api.requests.ErrorResponse#TOO_MANY_REACTIONS TOO_MANY_REACTIONS}
     *     
The message already has too many reactions to proceed
     *
     *     
{@link net.dv8tion.jda.api.requests.ErrorResponse#MISSING_PERMISSIONS MISSING_PERMISSIONS}
     *     
The reaction request was attempted after the account lost {@link net.dv8tion.jda.api.Permission#MESSAGE_ADD_REACTION Permission.MESSAGE_ADD_REACTION}
     *         or {@link net.dv8tion.jda.api.Permission#MESSAGE_HISTORY Permission.MESSAGE_HISTORY}
     *         in the {@link net.dv8tion.jda.api.entities.TextChannel TextChannel} when adding the reaction.
     *
     *     
{@link net.dv8tion.jda.api.requests.ErrorResponse#UNKNOWN_EMOJI UNKNOWN_EMOJI}
     *     
The provided emote was deleted, doesn't exist, or is not available to the currently logged-in account in this channel.
     *
     *     
{@link net.dv8tion.jda.api.requests.ErrorResponse#UNKNOWN_MESSAGE UNKNOWN_MESSAGE}
     *     
If the message has already been deleted. This might also be triggered for ephemeral messages.
     * 
     *
     * @param  emote
     *         The {@link net.dv8tion.jda.api.entities.Emote Emote} to add as a reaction to this Message.
     *
     * @throws java.lang.UnsupportedOperationException
     *         If this is a system message
     * @throws net.dv8tion.jda.api.exceptions.InsufficientPermissionException
     *         If the MessageChannel this message was sent in was a {@link net.dv8tion.jda.api.entities.TextChannel TextChannel}
     *         and the logged in account does not have
     *         

     *             
{@link net.dv8tion.jda.api.Permission#MESSAGE_ADD_REACTION Permission.MESSAGE_ADD_REACTION}
     *             
{@link net.dv8tion.jda.api.Permission#MESSAGE_HISTORY Permission.MESSAGE_HISTORY}
     *         
     * @throws java.lang.IllegalArgumentException
     *         

     *             
If the provided {@link net.dv8tion.jda.api.entities.Emote Emote} is null.
     *             
If the provided {@link net.dv8tion.jda.api.entities.Emote Emote} cannot be used in the current channel.
     *                 See {@link Emote#canInteract(User, MessageChannel)} or {@link Emote#canInteract(Member)} for more information.
     *         
     * @throws IllegalStateException
     *         If this message is ephemeral
     *
     * @return {@link net.dv8tion.jda.api.requests.RestAction RestAction} - Type: {@link java.lang.Void}
     */
    @Nonnull
    @CheckReturnValue
    RestAction addReaction(@Nonnull Emote emote);

    /**
     * Adds a reaction to this Message using a unicode emoji.
     * 
A reference of unicode emojis can be found here:
     * Emoji Table.
     *
     * 
This message instance will not be updated by this operation.
     *
     * 
Reactions are the small emoji/emotes below a message that have a counter beside them
     * showing how many users have reacted with the same emoji/emote.
     *
     * 
Neither success nor failure of this request will affect this Message's {@link #getReactions()} return as Message is immutable.
     *
     * 
Examples
     * 
     * // custom

     * message.addReaction("minn:245267426227388416").queue();

     * // unicode escape

     * message.addReaction("\uD83D\uDE02").queue();

     * // codepoint notation

     * message.addReaction("U+1F602").queue();
     * 
     *
     * 
The following {@link net.dv8tion.jda.api.requests.ErrorResponse ErrorResponses} are possible:
     * 

     *     
{@link net.dv8tion.jda.api.requests.ErrorResponse#MISSING_ACCESS MISSING_ACCESS}
     *     
The reaction request was attempted after the account lost access to the {@link net.dv8tion.jda.api.entities.TextChannel TextChannel}
     *         due to {@link net.dv8tion.jda.api.Permission#VIEW_CHANNEL Permission.VIEW_CHANNEL} being revoked
     *     
Also can happen if the account lost the {@link net.dv8tion.jda.api.Permission#MESSAGE_HISTORY Permission.MESSAGE_HISTORY}
     *
     *     
{@link net.dv8tion.jda.api.requests.ErrorResponse#REACTION_BLOCKED REACTION_BLOCKED}
     *     
The user has blocked the currently logged in account and the reaction failed
     *
     *     
{@link net.dv8tion.jda.api.requests.ErrorResponse#TOO_MANY_REACTIONS TOO_MANY_REACTIONS}
     *     
The message already has too many reactions to proceed
     *
     *     
{@link net.dv8tion.jda.api.requests.ErrorResponse#MISSING_PERMISSIONS MISSING_PERMISSIONS}
     *     
The reaction request was attempted after the account lost {@link net.dv8tion.jda.api.Permission#MESSAGE_ADD_REACTION Permission.MESSAGE_ADD_REACTION}
     *         in the {@link net.dv8tion.jda.api.entities.TextChannel TextChannel} when adding the reaction.
     *
     *     
{@link net.dv8tion.jda.api.requests.ErrorResponse#UNKNOWN_EMOJI UNKNOWN_EMOJI}
     *     
The provided unicode character does not refer to a known emoji unicode character.
     *     
Proper unicode characters for emojis can be found here:
     *         Emoji Table
     *
     *     
{@link net.dv8tion.jda.api.requests.ErrorResponse#UNKNOWN_MESSAGE UNKNOWN_MESSAGE}
     *     
If the message has already been deleted. This might also be triggered for ephemeral messages.
     * 
     *
     * @param  unicode
     *         The unicode emoji to add as a reaction to this Message.
     *
     * @throws java.lang.UnsupportedOperationException
     *         If this is a system message
     * @throws net.dv8tion.jda.api.exceptions.InsufficientPermissionException
     *         If the MessageChannel this message was sent in was a {@link net.dv8tion.jda.api.entities.TextChannel TextChannel}
     *         and the logged in account does not have
     *         

     *             
{@link net.dv8tion.jda.api.Permission#MESSAGE_ADD_REACTION Permission.MESSAGE_ADD_REACTION}
     *             
{@link net.dv8tion.jda.api.Permission#MESSAGE_HISTORY Permission.MESSAGE_HISTORY}
     *         
     * @throws java.lang.IllegalArgumentException
     *         If the provided unicode emoji is null or empty.
     * @throws IllegalStateException
     *         If this Message is ephemeral
     *
     * @return {@link net.dv8tion.jda.api.requests.RestAction RestAction} - Type: {@link java.lang.Void}
     */
    @Nonnull
    @CheckReturnValue
    RestAction addReaction(@Nonnull String unicode);

    /**
     * Removes all reactions from this Message.
     * 
This is useful for moderator commands that wish to remove all reactions at once from a specific message.
     *
     * 
Please note that you can't clear reactions if this message was sent in a {@link net.dv8tion.jda.api.entities.PrivateChannel PrivateChannel}!
     *
     * 
Neither success nor failure of this request will affect this Message's {@link #getReactions()} return as Message is immutable.
     *
     * 
The following {@link net.dv8tion.jda.api.requests.ErrorResponse ErrorResponses} are possible:
     * 

     *     
{@link net.dv8tion.jda.api.requests.ErrorResponse#MISSING_ACCESS MISSING_ACCESS}
     *     
The clear-reactions request was attempted after the account lost access to the {@link net.dv8tion.jda.api.entities.TextChannel TextChannel}
     *         due to {@link net.dv8tion.jda.api.Permission#VIEW_CHANNEL Permission.VIEW_CHANNEL} being revoked, or the
     *         account lost access to the {@link net.dv8tion.jda.api.entities.Guild Guild}
     *         typically due to being kicked or removed.
     *
     *     
{@link net.dv8tion.jda.api.requests.ErrorResponse#MISSING_PERMISSIONS MISSING_PERMISSIONS}
     *     
The clear-reactions request was attempted after the account lost {@link net.dv8tion.jda.api.Permission#MESSAGE_MANAGE Permission.MESSAGE_MANAGE}
     *         in the {@link net.dv8tion.jda.api.entities.TextChannel TextChannel} when adding the reaction.
     *
     *     
{@link net.dv8tion.jda.api.requests.ErrorResponse#UNKNOWN_MESSAGE UNKNOWN_MESSAGE}
     *     
If the message has already been deleted. This might also be triggered for ephemeral messages.
     * 
     *
     * @throws java.lang.UnsupportedOperationException
     *         If this is a system message
     * @throws net.dv8tion.jda.api.exceptions.InsufficientPermissionException
     *         If the MessageChannel this message was sent in was a {@link net.dv8tion.jda.api.entities.TextChannel TextChannel}
     *         and the currently logged in account does not have {@link net.dv8tion.jda.api.Permission#MESSAGE_MANAGE Permission.MESSAGE_MANAGE}
     *         in the channel.
     * @throws java.lang.IllegalStateException
     *         

     *             
If this message was not sent in a {@link net.dv8tion.jda.api.entities.Guild Guild}.
     *             
If this message is ephemeral
     *         
     *
     *
     * @return {@link net.dv8tion.jda.api.requests.RestAction RestAction} - Type: {@link java.lang.Void}
     */
    @Nonnull
    @CheckReturnValue
    RestAction clearReactions();

    /**
     * Removes all reactions for the specified emoji.
     *
     * 
Please note that you can't clear reactions if this message was sent in a {@link net.dv8tion.jda.api.entities.PrivateChannel PrivateChannel}!
     *
     * 
Example
     * 

     * // custom
     * message.clearReactions("minn:245267426227388416").queue();
     * // unicode escape
     * message.clearReactions("\uD83D\uDE02").queue();
     * // codepoint notation
     * message.clearReactions("U+1F602").queue();
     * 
     *
     * 
The following {@link net.dv8tion.jda.api.requests.ErrorResponse ErrorResponses} are possible:
     * 

     *     
{@link net.dv8tion.jda.api.requests.ErrorResponse#MISSING_ACCESS MISSING_ACCESS}
     *     
The currently logged in account lost access to the channel by either being removed from the guild
     *         or losing the {@link net.dv8tion.jda.api.Permission#VIEW_CHANNEL VIEW_CHANNEL} permission
     *
     *     
{@link net.dv8tion.jda.api.requests.ErrorResponse#UNKNOWN_EMOJI UNKNOWN_EMOJI}
     *     
The provided unicode character does not refer to a known emoji unicode character.
     *     
Proper unicode characters for emojis can be found here:
     *         Emoji Table
     *
     *     
{@link net.dv8tion.jda.api.requests.ErrorResponse#UNKNOWN_MESSAGE UNKNOWN_MESSAGE}
     *     
If the message has already been deleted. This might also be triggered for ephemeral messages.
     * 
     *
     * @param  unicode
     *         The unicode emoji to remove reactions for
     *
     * @throws java.lang.UnsupportedOperationException
     *         If this is a system message
     * @throws InsufficientPermissionException
     *         If the currently logged in account does not have {@link Permission#MESSAGE_MANAGE} in the channel
     * @throws IllegalArgumentException
     *         If provided with null
     * @throws java.lang.IllegalStateException
     *         

     *             
If this message was not sent in a {@link net.dv8tion.jda.api.entities.Guild Guild}.
     *             
If this message is ephemeral
     *         
     *
     *
     * @return {@link RestAction}
     *
     * @since  4.2.0
     */
    @Nonnull
    @CheckReturnValue
    RestAction clearReactions(@Nonnull String unicode);

    /**
     * Removes all reactions for the specified emote.
     *
     * 
Please note that you can't clear reactions if this message was sent in a {@link net.dv8tion.jda.api.entities.PrivateChannel PrivateChannel}!
     *
     * 
The following {@link net.dv8tion.jda.api.requests.ErrorResponse ErrorResponses} are possible:
     * 

     *     
{@link net.dv8tion.jda.api.requests.ErrorResponse#MISSING_ACCESS MISSING_ACCESS}
     *     
The currently logged in account lost access to the channel by either being removed from the guild
     *         or losing the {@link net.dv8tion.jda.api.Permission#VIEW_CHANNEL VIEW_CHANNEL} permission
     *
     *     
{@link net.dv8tion.jda.api.requests.ErrorResponse#UNKNOWN_EMOJI UNKNOWN_EMOJI}
     *     
The provided emote was deleted, doesn't exist, or is not available to the currently logged-in account in this channel.
     *
     *     
{@link net.dv8tion.jda.api.requests.ErrorResponse#UNKNOWN_MESSAGE UNKNOWN_MESSAGE}
     *     
If the message has already been deleted. This might also be triggered for ephemeral messages.
     * 
     *
     * @param  emote
     *         The {@link Emote} to remove reactions for
     *
     * @throws java.lang.UnsupportedOperationException
     *         If this is a system message
     * @throws InsufficientPermissionException
     *         If the currently logged in account does not have {@link Permission#MESSAGE_MANAGE} in the channel
     * @throws IllegalArgumentException
     *         If provided with null
     * @throws java.lang.IllegalStateException
     *         

     *             
If this message was not sent in a {@link net.dv8tion.jda.api.entities.Guild Guild}.
     *             
If this message is ephemeral
     *         
     *
     * @return {@link RestAction}
     *
     * @since  4.2.0
     */
    @Nonnull
    @CheckReturnValue
    RestAction clearReactions(@Nonnull Emote emote);

    /**
     * Removes a reaction from this Message using an {@link net.dv8tion.jda.api.entities.Emote Emote}.
     *
     * 
This message instance will not be updated by this operation.
     *
     * 
Reactions are the small emoji/emotes below a message that have a counter beside them
     * showing how many users have reacted with the same emoji/emote.
     *
     * 
Neither success nor failure of this request will affect this Message's {@link #getReactions()} return as Message is immutable.
     *
     * 
Unicode emojis are not included as {@link net.dv8tion.jda.api.entities.Emote Emote}!
     *
     * 
The following {@link net.dv8tion.jda.api.requests.ErrorResponse ErrorResponses} are possible:
     * 

     *     
{@link net.dv8tion.jda.api.requests.ErrorResponse#MISSING_ACCESS MISSING_ACCESS}
     *     
The reaction request was attempted after the account lost access to the {@link net.dv8tion.jda.api.entities.TextChannel TextChannel}
     *         due to {@link net.dv8tion.jda.api.Permission#VIEW_CHANNEL Permission.VIEW_CHANNEL} being revoked
     *     
Also can happen if the account lost the {@link net.dv8tion.jda.api.Permission#MESSAGE_HISTORY Permission.MESSAGE_HISTORY}
     *
     *     
{@link net.dv8tion.jda.api.requests.ErrorResponse#UNKNOWN_EMOJI UNKNOWN_EMOJI}
     *     
The provided emote was deleted, doesn't exist, or is not available to the currently logged-in account in this channel.
     *
     *     
{@link net.dv8tion.jda.api.requests.ErrorResponse#UNKNOWN_MESSAGE UNKNOWN_MESSAGE}
     *     
If the message has already been deleted. This might also be triggered for ephemeral messages.
     * 
     *
     * @param  emote
     *         The {@link net.dv8tion.jda.api.entities.Emote Emote} to remove as a reaction from this Message.
     *
     * @throws java.lang.UnsupportedOperationException
     *         If this is a system message
     * @throws net.dv8tion.jda.api.exceptions.InsufficientPermissionException
     *         If the MessageChannel this message was sent in was a {@link net.dv8tion.jda.api.entities.TextChannel TextChannel}
     *         and the logged in account does not have {@link net.dv8tion.jda.api.Permission#MESSAGE_HISTORY Permission.MESSAGE_HISTORY}
     * @throws java.lang.IllegalArgumentException
     *         

     *             
If the provided {@link net.dv8tion.jda.api.entities.Emote Emote} is null.
     *             
If the provided {@link net.dv8tion.jda.api.entities.Emote Emote} cannot be used in the current channel.
     *                 See {@link Emote#canInteract(User, MessageChannel)} or {@link Emote#canInteract(Member)} for more information.
     *         
     * @throws IllegalStateException
     *         If this is an ephemeral message
     *
     * @return {@link net.dv8tion.jda.api.requests.RestAction RestAction} - Type: {@link java.lang.Void}
     *
     * @since  4.1.0
     */
    @Nonnull
    @CheckReturnValue
    RestAction removeReaction(@Nonnull Emote emote);

    /**
     * Removes a {@link net.dv8tion.jda.api.entities.User User's} reaction from this Message using an {@link net.dv8tion.jda.api.entities.Emote Emote}.
     *
     * 
Please note that you can't remove reactions of other users if this message was sent in a {@link net.dv8tion.jda.api.entities.PrivateChannel PrivateChannel}!
     *
     * 
This message instance will not be updated by this operation.
     *
     * 
Reactions are the small emoji/emotes below a message that have a counter beside them
     * showing how many users have reacted with the same emoji/emote.
     *
     * 
Neither success nor failure of this request will affect this Message's {@link #getReactions()} return as Message is immutable.
     *
     * 
Unicode emojis are not included as {@link net.dv8tion.jda.api.entities.Emote Emote}!
     *
     * 
The following {@link net.dv8tion.jda.api.requests.ErrorResponse ErrorResponses} are possible:
     * 

     *     
{@link net.dv8tion.jda.api.requests.ErrorResponse#MISSING_ACCESS MISSING_ACCESS}
     *     
The reaction request was attempted after the account lost access to the {@link net.dv8tion.jda.api.entities.TextChannel TextChannel}
     *         due to {@link net.dv8tion.jda.api.Permission#VIEW_CHANNEL Permission.VIEW_CHANNEL} being revoked
     *     
Also can happen if the account lost the {@link net.dv8tion.jda.api.Permission#MESSAGE_HISTORY Permission.MESSAGE_HISTORY}
     *
     *     
{@link net.dv8tion.jda.api.requests.ErrorResponse#MISSING_PERMISSIONS MISSING_PERMISSIONS}
     *     
The reaction request was attempted after the account lost {@link net.dv8tion.jda.api.Permission#MESSAGE_MANAGE Permission.MESSAGE_MANAGE}
     *         in the {@link net.dv8tion.jda.api.entities.TextChannel TextChannel} when removing the reaction.
     *
     *     
{@link net.dv8tion.jda.api.requests.ErrorResponse#UNKNOWN_EMOJI UNKNOWN_EMOJI}
     *     
The provided emote was deleted, doesn't exist, or is not available to the currently logged-in account in this channel.
     *
     *     
{@link net.dv8tion.jda.api.requests.ErrorResponse#UNKNOWN_MESSAGE UNKNOWN_MESSAGE}
     *     
If the message has already been deleted. This might also be triggered for ephemeral messages.
     * 
     *
     * @param  emote
     *         The {@link net.dv8tion.jda.api.entities.Emote Emote} to remove as a reaction from this Message.
     * @param  user
     *         The {@link net.dv8tion.jda.api.entities.User User} to remove the reaction for.
     *
     * @throws java.lang.UnsupportedOperationException
     *         If this is a system message
     * @throws net.dv8tion.jda.api.exceptions.InsufficientPermissionException
     *         If the MessageChannel this message was sent in was a {@link net.dv8tion.jda.api.entities.TextChannel TextChannel}
     *         and the logged in account does not have {@link net.dv8tion.jda.api.Permission#MESSAGE_HISTORY Permission.MESSAGE_HISTORY}.
     * @throws java.lang.IllegalArgumentException
     *         

     *             
If the provided {@link net.dv8tion.jda.api.entities.Emote Emote} is null.
     *             
If the provided {@link net.dv8tion.jda.api.entities.Emote Emote} cannot be used in the current channel.
     *                 See {@link Emote#canInteract(User, MessageChannel)} or {@link Emote#canInteract(Member)} for more information.
     *             
If the provided user is null
     *         
     * @throws java.lang.IllegalStateException
     * 

     *     
If this message was not sent in a
     *         {@link net.dv8tion.jda.api.entities.Guild Guild}
     *         and the given user is not the {@link net.dv8tion.jda.api.entities.SelfUser SelfUser}.
     *     
If this message is ephemeral
     * 
     *
     *
     * @return {@link net.dv8tion.jda.api.requests.RestAction RestAction} - Type: {@link java.lang.Void}
     *
     * @since  4.1.0
     */
    @Nonnull
    @CheckReturnValue
    RestAction removeReaction(@Nonnull Emote emote, @Nonnull User user);

    /**
     * Removes a reaction from this Message using a unicode emoji.
     * 
A reference of unicode emojis can be found here:
     * Emoji Table.
     *
     * 
This message instance will not be updated by this operation.
     *
     * 
Reactions are the small emoji/emotes below a message that have a counter beside them
     * showing how many users have reacted with the same emoji/unicode.
     *
     * 
Neither success nor failure of this request will affect this Message's {@link #getReactions()} return as Message is immutable.
     *
     * 
Examples
     * 
     * // custom

     * message.removeReaction("minn:245267426227388416").queue();

     * // unicode escape

     * message.removeReaction("\uD83D\uDE02").queue();

     * // codepoint notation

     * message.removeReaction("U+1F602").queue();
     * 
     *
     * 
The following {@link net.dv8tion.jda.api.requests.ErrorResponse ErrorResponses} are possible:
     * 

     *     
{@link net.dv8tion.jda.api.requests.ErrorResponse#MISSING_ACCESS MISSING_ACCESS}
     *     
The reaction request was attempted after the account lost access to the {@link net.dv8tion.jda.api.entities.TextChannel TextChannel}
     *         due to {@link net.dv8tion.jda.api.Permission#VIEW_CHANNEL Permission.VIEW_CHANNEL} being revoked
     *     
Also can happen if the account lost the {@link net.dv8tion.jda.api.Permission#MESSAGE_HISTORY Permission.MESSAGE_HISTORY}
     *
     *     
{@link net.dv8tion.jda.api.requests.ErrorResponse#UNKNOWN_EMOJI UNKNOWN_EMOJI}
     *     
The provided unicode character does not refer to a known emoji unicode character.
     *     
Proper unicode characters for emojis can be found here:
     *         Emoji Table
     *
     *     
{@link net.dv8tion.jda.api.requests.ErrorResponse#UNKNOWN_MESSAGE UNKNOWN_MESSAGE}
     *     
If the message has already been deleted. This might also be triggered for ephemeral messages.
     * 
     *
     * @param  unicode
     *         The unicode emoji to add as a reaction to this Message.
     *
     * @throws java.lang.UnsupportedOperationException
     *         If this is a system message
     * @throws net.dv8tion.jda.api.exceptions.InsufficientPermissionException
     *         If the MessageChannel this message was sent in was a {@link net.dv8tion.jda.api.entities.TextChannel TextChannel}
     *         and the logged in account does not have {@link net.dv8tion.jda.api.Permission#MESSAGE_HISTORY Permission.MESSAGE_HISTORY}
     * @throws java.lang.IllegalArgumentException
     *         If the provided unicode emoji is null or empty.
     * @throws IllegalStateException
     *         If this is an ephemeral message
     *
     * @return {@link net.dv8tion.jda.api.requests.RestAction RestAction} - Type: {@link java.lang.Void}
     *
     * @since  4.1.0
     */
    @Nonnull
    @CheckReturnValue
    RestAction removeReaction(@Nonnull String unicode);

    /**
     * Removes a reaction from this Message using a unicode emoji.
     * 
A reference of unicode emojis can be found here:
     * Emoji Table.
     *
     * 
Please note that you can't remove reactions of other users if this message was sent in a {@link net.dv8tion.jda.api.entities.PrivateChannel PrivateChannel}!
     *
     * 
This message instance will not be updated by this operation.
     *
     * 
Reactions are the small emoji/emotes below a message that have a counter beside them
     * showing how many users have reacted with the same emoji/unicode.
     *
     * 
Neither success nor failure of this request will affect this Message's {@link #getReactions()} return as Message is immutable.
     *
     * 
The following {@link net.dv8tion.jda.api.requests.ErrorResponse ErrorResponses} are possible:
     * 

     *     
{@link net.dv8tion.jda.api.requests.ErrorResponse#MISSING_ACCESS MISSING_ACCESS}
     *     
The reaction request was attempted after the account lost access to the {@link net.dv8tion.jda.api.entities.TextChannel TextChannel}
     *         due to {@link net.dv8tion.jda.api.Permission#VIEW_CHANNEL Permission.VIEW_CHANNEL} being revoked
     *     
Also can happen if the account lost the {@link net.dv8tion.jda.api.Permission#MESSAGE_HISTORY Permission.MESSAGE_HISTORY}
     *
     *     
{@link net.dv8tion.jda.api.requests.ErrorResponse#UNKNOWN_EMOJI UNKNOWN_EMOJI}
     *     
The provided unicode character does not refer to a known emoji unicode character.
     *     
Proper unicode characters for emojis can be found here:
     *         Emoji Table
     *
     *     
{@link net.dv8tion.jda.api.requests.ErrorResponse#MISSING_PERMISSIONS MISSING_PERMISSIONS}
     *     
The reaction request was attempted after the account lost {@link net.dv8tion.jda.api.Permission#MESSAGE_MANAGE Permission.MESSAGE_MANAGE}
     *         in the {@link net.dv8tion.jda.api.entities.TextChannel TextChannel} when removing the reaction.
     *
     *     
{@link net.dv8tion.jda.api.requests.ErrorResponse#UNKNOWN_MESSAGE UNKNOWN_MESSAGE}
     *     
If the message has already been deleted. This might also be triggered for ephemeral messages.
     * 
     *
     * @param  unicode
     *         The unicode emoji to add as a reaction to this Message.
     * @param  user
     *         The {@link net.dv8tion.jda.api.entities.User User} to remove the reaction for.
     *
     * @throws java.lang.UnsupportedOperationException
     *         If this is a system message
     * @throws net.dv8tion.jda.api.exceptions.InsufficientPermissionException
     *         If the MessageChannel this message was sent in was a {@link net.dv8tion.jda.api.entities.TextChannel TextChannel}
     *         and the logged in account does not have
     *         

     *             
{@link net.dv8tion.jda.api.Permission#MESSAGE_HISTORY Permission.MESSAGE_HISTORY}
     *             
{@link net.dv8tion.jda.api.Permission#MESSAGE_MANAGE Permission.MESSAGE_MANAGE}
     *         
     * @throws java.lang.IllegalArgumentException
     *         If the provided unicode emoji is null or empty or if the provided user is null.
     * @throws java.lang.IllegalStateException
     *         If this message:
     *         

     *             
Was not sent in a
     *                 {@link net.dv8tion.jda.api.entities.Guild Guild}
     *                 and the given user is not the {@link net.dv8tion.jda.api.entities.SelfUser SelfUser}.
     *             
Is ephemeral
     *         
     *
     *
     * @return {@link net.dv8tion.jda.api.requests.RestAction RestAction} - Type: {@link java.lang.Void}
     *
     * @since  4.1.0
     */
    @Nonnull
    @CheckReturnValue
    RestAction removeReaction(@Nonnull String unicode, @Nonnull User user);

    /**
     * This obtains the {@link net.dv8tion.jda.api.entities.User users} who reacted using the given {@link net.dv8tion.jda.api.entities.Emote emote}.
     *
     * 
Messages maintain a list of reactions, alongside a list of users who added them.
     *
     * 
Using this data, we can obtain a {@link net.dv8tion.jda.api.requests.restaction.pagination.ReactionPaginationAction ReactionPaginationAction}
     * of the users who've reacted to this message.
     *
     * 
The following {@link net.dv8tion.jda.api.requests.ErrorResponse ErrorResponses} are possible:
     * 

     *     
{@link net.dv8tion.jda.api.requests.ErrorResponse#MISSING_ACCESS MISSING_ACCESS}
     *     
The retrieve request was attempted after the account lost access to the {@link net.dv8tion.jda.api.entities.TextChannel TextChannel}
     *         due to {@link net.dv8tion.jda.api.Permission#VIEW_CHANNEL Permission.VIEW_CHANNEL} being revoked
     *     
Also can happen if the account lost the {@link net.dv8tion.jda.api.Permission#MESSAGE_HISTORY Permission.MESSAGE_HISTORY}
     *
     *     
{@link net.dv8tion.jda.api.requests.ErrorResponse#UNKNOWN_EMOJI UNKNOWN_EMOJI}
     *     
The provided emote was deleted, doesn't exist, or is not available to the currently logged-in account in this channel.
     *
     *     
{@link net.dv8tion.jda.api.requests.ErrorResponse#UNKNOWN_MESSAGE UNKNOWN_MESSAGE}
     *     
If the message has already been deleted. This might also be triggered for ephemeral messages.
     * 
     *
     * @param  emote
     *         The {@link net.dv8tion.jda.api.entities.Emote emote} to retrieve users for.
     *
     * @throws java.lang.UnsupportedOperationException
     *         If this is a system message
     * @throws net.dv8tion.jda.api.exceptions.InsufficientPermissionException
     *         If the MessageChannel this message was sent in was a {@link net.dv8tion.jda.api.entities.TextChannel TextChannel} and the
     *         logged in account does not have {@link net.dv8tion.jda.api.Permission#MESSAGE_HISTORY Permission.MESSAGE_HISTORY} in the channel.
     * @throws java.lang.IllegalArgumentException
     *         If the provided {@link net.dv8tion.jda.api.entities.Emote Emote} is null.
     * @throws IllegalStateException
     *         If this Message is ephemeral
     * @return The {@link net.dv8tion.jda.api.requests.restaction.pagination.ReactionPaginationAction ReactionPaginationAction} of the emote's users.
     *
     * @since  4.1.0
     */
    @Nonnull
    @CheckReturnValue
    ReactionPaginationAction retrieveReactionUsers(@Nonnull Emote emote);

    /**
     * This obtains the {@link net.dv8tion.jda.api.entities.User users} who reacted using the given unicode emoji.
     *
     * 
Messages maintain a list of reactions, alongside a list of users who added them.
     *
     * 
Using this data, we can obtain a {@link net.dv8tion.jda.api.requests.restaction.pagination.ReactionPaginationAction ReactionPaginationAction}
     * of the users who've reacted to this message.
     *
     * 
The following {@link net.dv8tion.jda.api.requests.ErrorResponse ErrorResponses} are possible:
     * 

     *     
{@link net.dv8tion.jda.api.requests.ErrorResponse#MISSING_ACCESS MISSING_ACCESS}
     *     
The retrieve request was attempted after the account lost access to the {@link net.dv8tion.jda.api.entities.TextChannel TextChannel}
     *         due to {@link net.dv8tion.jda.api.Permission#VIEW_CHANNEL Permission.VIEW_CHANNEL} being revoked
     *     
Also can happen if the account lost the {@link net.dv8tion.jda.api.Permission#MESSAGE_HISTORY Permission.MESSAGE_HISTORY}
     *
     *     
{@link net.dv8tion.jda.api.requests.ErrorResponse#UNKNOWN_EMOJI UNKNOWN_EMOJI}
     *     
The provided unicode character does not refer to a known emoji unicode character.
     *     
Proper unicode characters for emojis can be found here:
     *         Emoji Table
     *
     *     
{@link net.dv8tion.jda.api.requests.ErrorResponse#UNKNOWN_MESSAGE UNKNOWN_MESSAGE}
     *     
If the message has already been deleted. This might also be triggered for ephemeral messages.
     * 
     *
     * @param  unicode
     *         The unicode emote to retrieve users for.
     *
     * @throws java.lang.UnsupportedOperationException
     *         If this is a system message
     * @throws net.dv8tion.jda.api.exceptions.InsufficientPermissionException
     *         If the MessageChannel this message was sent in was a {@link net.dv8tion.jda.api.entities.TextChannel TextChannel} and the
     *         logged in account does not have {@link net.dv8tion.jda.api.Permission#MESSAGE_HISTORY Permission.MESSAGE_HISTORY} in the channel.
     * @throws java.lang.IllegalArgumentException
     *         If the provided unicode emoji is null or empty.
     * @throws IllegalStateException
     *         If this Message is ephemeral
     * @return The {@link net.dv8tion.jda.api.requests.restaction.pagination.ReactionPaginationAction ReactionPaginationAction} of the emoji's users.
     *
     * @since  4.1.0
     */
    @Nonnull
    @CheckReturnValue
    ReactionPaginationAction retrieveReactionUsers(@Nonnull String unicode);

    /**
     * This obtains the {@link net.dv8tion.jda.api.entities.MessageReaction MessageReaction} for the given unicode reaction on this message.
     *
     * 
Messages also store reactions using unicode values.
     *
     * 
An instance of the related {@link net.dv8tion.jda.api.entities.MessageReaction MessageReaction} can be
     * obtained through this method by using the emoji's unicode value.
     *
     * @param  unicode
     *         The unicode value of the reaction emoji.
     *
     * @throws java.lang.UnsupportedOperationException
     *         If this is a system message
     * @throws java.lang.IllegalArgumentException
     *         If the provided unicode value is null or empty.
     *
     * @return The {@link net.dv8tion.jda.api.entities.MessageReaction MessageReaction} of this message or null if not present.
     *
     * @see    #getReactionById(long)
     * @see    net.dv8tion.jda.api.entities.MessageReaction
     *
     * @since  4.1.0
     */
    @Nullable
    @CheckReturnValue
    MessageReaction getReactionByUnicode(@Nonnull String unicode);

    /**
     * This obtains the {@link net.dv8tion.jda.api.entities.MessageReaction MessageReaction} for the given reaction id on this message.
     *
     * 
Messages store reactions by keeping a list of reaction names.
     *
     * 
An instance of the related {@link net.dv8tion.jda.api.entities.MessageReaction MessageReaction} can be
     * obtained through this method by using the emote's id.
     *
     * @param  id
     *         The string id of the reaction emote.
     *
     * @throws java.lang.UnsupportedOperationException
     *         If this is a system message
     * @throws java.lang.IllegalArgumentException
     *         If the provided id is not a valid snowflake.
     *
     * @return The {@link net.dv8tion.jda.api.entities.MessageReaction MessageReaction} of this message or null if not present.
     *
     * @see    #getReactionById(long)
     * @see    #getReactionByUnicode(String)
     * @see    net.dv8tion.jda.api.entities.MessageReaction
     *
     * @since  4.1.0
     */
    @Nullable
    @CheckReturnValue
    default MessageReaction getReactionById(@Nonnull String id)
    {
        return getReactionById(MiscUtil.parseSnowflake(id));
    }

    /**
     * This obtains the {@link net.dv8tion.jda.api.entities.MessageReaction MessageReaction} for the given reaction id on this message.
     *
     * 
Messages store reactions by keeping a list of reaction names.
     *
     * 
An instance of the related {@link net.dv8tion.jda.api.entities.MessageReaction MessageReaction} can be
     * obtained through this method by using the emote's id.
     *
     * @param  id
     *         The long id of the reaction emote.
     *
     * @throws java.lang.UnsupportedOperationException
     *         If this is a system message
     *
     * @return The {@link net.dv8tion.jda.api.entities.MessageReaction MessageReaction} of this message or null if not present.
     *
     * @see    #getReactionById(String)
     * @see    #getReactionByUnicode(String)
     * @see    net.dv8tion.jda.api.entities.MessageReaction
     *
     * @since  4.1.0
     */
    @Nullable
    @CheckReturnValue
    MessageReaction getReactionById(long id);

    /**
     * Enables/Disables suppression of Embeds on this Message.
     * 
Suppressing Embeds is equivalent to pressing the {@code X} in the top-right corner of an Embed inside the Discord client.
     *
     * 
The following {@link net.dv8tion.jda.api.requests.ErrorResponse ErrorResponses} are possible:
     * 

     *     
{@link net.dv8tion.jda.api.requests.ErrorResponse#MISSING_ACCESS MISSING_ACCESS}
     *     
The clear-reactions request was attempted after the account lost access to the {@link net.dv8tion.jda.api.entities.TextChannel TextChannel}
     *         due to {@link net.dv8tion.jda.api.Permission#VIEW_CHANNEL Permission.VIEW_CHANNEL} being revoked, or the
     *         account lost access to the {@link net.dv8tion.jda.api.entities.Guild Guild}
     *         typically due to being kicked or removed.
     *
     *     
{@link net.dv8tion.jda.api.requests.ErrorResponse#MISSING_PERMISSIONS MISSING_PERMISSIONS}
     *     
The suppress-embeds request was attempted after the account lost {@link net.dv8tion.jda.api.Permission#MESSAGE_MANAGE Permission.MESSAGE_MANAGE}
     *         in the {@link net.dv8tion.jda.api.entities.TextChannel TextChannel} when adding the reaction.
     *
     *     
{@link net.dv8tion.jda.api.requests.ErrorResponse#UNKNOWN_MESSAGE UNKNOWN_MESSAGE}
     *     
If the message has already been deleted. This might also be triggered for ephemeral messages.
     * 
     *
     * @param  suppressed
     *         Whether or not the embed should be suppressed
     * @throws java.lang.UnsupportedOperationException
     *         If this is a system message
     * @throws net.dv8tion.jda.api.exceptions.InsufficientPermissionException
     *         If the MessageChannel this message was sent in was a {@link net.dv8tion.jda.api.entities.TextChannel TextChannel}
     *         and the currently logged in account does not have
     *         {@link net.dv8tion.jda.api.Permission#MESSAGE_MANAGE Permission.MESSAGE_MANAGE} in the channel.
     * @throws net.dv8tion.jda.api.exceptions.PermissionException
     *         If the MessageChannel this message was sent in was a {@link net.dv8tion.jda.api.entities.PrivateChannel PrivateChannel}
     *         and the message was not sent by the currently logged in account.
     * @throws IllegalStateException
     *         If this Message is ephemeral
     * @return {@link net.dv8tion.jda.api.requests.restaction.AuditableRestAction AuditableRestAction} - Type: {@link java.lang.Void}
     * @see    #isSuppressedEmbeds()
     */
    @Nonnull
    @CheckReturnValue
    AuditableRestAction suppressEmbeds(boolean suppressed);

    /**
     * Attempts to crosspost this message.
     *
     * 
The following {@link net.dv8tion.jda.api.requests.ErrorResponse ErrorResponses} are possible:
     * 

     *     
{@link net.dv8tion.jda.api.requests.ErrorResponse#ALREADY_CROSSPOSTED ALREADY_CROSSPOSTED}
     *     
The target message has already been crossposted.
     *
     *     
{@link net.dv8tion.jda.api.requests.ErrorResponse#MISSING_ACCESS MISSING_ACCESS}
     *     
The request was attempted after the account lost access to the
     *         {@link net.dv8tion.jda.api.entities.Guild Guild}
     *         typically due to being kicked or removed, or after {@link net.dv8tion.jda.api.Permission#VIEW_CHANNEL Permission.VIEW_CHANNEL}
     *         was revoked in the {@link net.dv8tion.jda.api.entities.TextChannel TextChannel}
     *
     *     
{@link net.dv8tion.jda.api.requests.ErrorResponse#MISSING_PERMISSIONS MISSING_PERMISSIONS}
     *     
The request was attempted after the account lost
     *         {@link net.dv8tion.jda.api.Permission#MESSAGE_MANAGE Permission.MESSAGE_MANAGE} in the TextChannel.
     *
     *     
{@link net.dv8tion.jda.api.requests.ErrorResponse#UNKNOWN_MESSAGE UNKNOWN_MESSAGE}
     *     
If the message has already been deleted. This might also be triggered for ephemeral messages.
     *
     *     
{@link net.dv8tion.jda.api.requests.ErrorResponse#UNKNOWN_CHANNEL UNKNOWN_CHANNEL}
     *     
The request was attempted after the channel was deleted.
     * 
     *
     * @throws java.lang.UnsupportedOperationException
     *         If this is a system message
     * @throws IllegalStateException
     *         

     *             
If the channel is not a {@link NewsChannel}.
     *             
If the message is ephemeral.
     *         
     * @throws net.dv8tion.jda.api.exceptions.InsufficientPermissionException
     *         If the currently logged in account does not have
     *         {@link net.dv8tion.jda.api.Permission#VIEW_CHANNEL Permission.VIEW_CHANNEL} in this channel
     *         or if this message is from another user and we don't have {@link Permission#MESSAGE_MANAGE Permission.MESSAGE_MANAGE}.
     *
     * @return {@link net.dv8tion.jda.api.requests.RestAction} - Type: {@link Message}
     *
     * @since  4.2.1
     */
    @Nonnull
    @CheckReturnValue
    RestAction crosspost();

    /**
     * Whether embeds are suppressed for this message.
     * When Embeds are suppressed, they are not displayed on clients nor provided via API until un-suppressed.
     * 
This is a shortcut method for checking if {@link #getFlags() getFlags()} contains
     * {@link net.dv8tion.jda.api.entities.Message.MessageFlag#EMBEDS_SUPPRESSED MessageFlag#EMBEDS_SUPPRESSED}
     *
     * @throws java.lang.UnsupportedOperationException
     *         If this is a system message
     * @return Whether or not Embeds are suppressed for this Message.
     * @see    #suppressEmbeds(boolean)
     */
    boolean isSuppressedEmbeds();

    /**
     * Returns an EnumSet of all {@link Message.MessageFlag MessageFlags} present for this Message.
     *
     * @throws java.lang.UnsupportedOperationException
     *         If this is a system message
     * @return Never-Null EnumSet of present {@link Message.MessageFlag MessageFlags}
     * @see    Message.MessageFlag
     */
    @Nonnull
    EnumSet getFlags();

    /**
     * Returns the raw message flags of this message
     *
     * @throws java.lang.UnsupportedOperationException
     *         If this is a system message
     * @return The raw message flags
     * @see    #getFlags()
     */
    long getFlagsRaw();

    /**
     * Whether this message is ephemeral.
     * 
The message being ephemeral means it is only visible to the bot and the interacting user
     * 
This is a shortcut method for checking if {@link #getFlags()} contains {@link MessageFlag#EPHEMERAL}
     *
     * @throws java.lang.UnsupportedOperationException
     *         If this is a system message
     * @return Whether the message is ephemeral
     */
    boolean isEphemeral();

    /**
     * This specifies the {@link net.dv8tion.jda.api.entities.MessageType MessageType} of this Message.
     *
     * 
Messages can represent more than just simple text sent by Users, they can also be special messages that
     * inform about events that occur. Messages can either be {@link net.dv8tion.jda.api.entities.MessageType#DEFAULT default messages}
     * or special messages like {@link net.dv8tion.jda.api.entities.MessageType#GUILD_MEMBER_JOIN welcome messages}.
     *
     * @throws java.lang.UnsupportedOperationException
     *         If this is a system message
     *
     * @return The {@link net.dv8tion.jda.api.entities.MessageType MessageType} of this message.
     */
    @Nonnull
    MessageType getType();

    /**
     * This is sent on the message object when the message is a response to an {@link net.dv8tion.jda.api.interactions.Interaction Interaction} without an existing message.
     *
     * 
This means responses to Message Components do not include this property, instead including a message reference object as components always exist on preexisting messages.
     *
     * @throws java.lang.UnsupportedOperationException
     *         If this is a system message
     *
     * @return The {@link net.dv8tion.jda.api.entities.Message.Interaction Interaction} of this message.
     */
    @Nullable
    Interaction getInteraction();

    //TODO-v5: Docs
    @CheckReturnValue
    RestAction createThreadChannel(String name);

    /**
     * Mention constants, useful for use with {@link java.util.regex.Pattern Patterns}
     */
    enum MentionType
    {
        /**
         * Represents a mention for a {@link net.dv8tion.jda.api.entities.User User}/{@link net.dv8tion.jda.api.entities.Member Member}
         * 
The first and only group matches the id of the mention.
         */
        USER("<@!?(\\d+)>", "users"),
        /**
         * Represents a mention for a {@link net.dv8tion.jda.api.entities.Role Role}
         * 
The first and only group matches the id of the mention.
         */
        ROLE("<@&(\\d+)>", "roles"),
        /**
         * Represents a mention for a {@link net.dv8tion.jda.api.entities.TextChannel TextChannel}
         * 
The first and only group matches the id of the mention.
         */
        CHANNEL("<#(\\d+)>", null),
        /**
         * Represents a mention for a {@link net.dv8tion.jda.api.entities.Emote Emote}
         * 
The first group matches the name of the emote and the second the id of the mention.
         */
        EMOTE("", null),
        /**
         * Represents a mention for all active users, literal {@code @here}
         */
        HERE("@here", "everyone"),
        /**
         * Represents a mention for all users in a server, literal {@code @everyone}.
         */
        EVERYONE("@everyone", "everyone");

        private final Pattern pattern;
        private final String parseKey;

        MentionType(String regex, String parseKey)
        {
            this.pattern = Pattern.compile(regex);
            this.parseKey = parseKey;
        }

        @Nonnull
        public Pattern getPattern()
        {
            return pattern;
        }

        /**
         * The Key returned by this method is used to determine the group or parsable mention group they are part of.
         * 
It is used internally in methods like {@link net.dv8tion.jda.api.requests.restaction.MessageAction#allowedMentions(Collection) MessageAction#allowedMentions(Collection)}.
         * 

         * Returns {@code null}, when they don't belong to any mention group.
         *
         * @return Nullable group key for mention parsing
         */
        @Nullable
        public String getParseKey()
        {
            return parseKey;
        }
    }

    /**
     * Enum representing the flags on a Message.
     * 

     * Note: The Values defined in this Enum are not considered final and only represent the current State of known Flags.
     */
    enum MessageFlag
    {
        /**
         * The Message has been published to subscribed Channels (via Channel Following)
         */
        CROSSPOSTED(0),
        /**
         * The Message originated from a Message in another Channel (via Channel Following)
         */
        IS_CROSSPOST(1),
        /**
         * Embeds are suppressed on the Message.
         * @see net.dv8tion.jda.api.entities.Message#isSuppressedEmbeds() Message#isSuppressedEmbeds()
         */
        EMBEDS_SUPPRESSED(2),
        /**
         * Indicates, that the source message of this crosspost was deleted.
         * This should only be possible in combination with {@link #IS_CROSSPOST}
         */
        SOURCE_MESSAGE_DELETED(3),
        /**
         * Indicates, that this Message came from the urgent message system
         */
        URGENT(4),
        /**
         * Indicates, that this Message is ephemeral, the Message is only visible to the bot and the interacting user
         * @see Message#isEphemeral
         */
        EPHEMERAL(6),
        /**
         * Indicates, that this Message is an interaction response and the bot is "thinking"
         */
        LOADING(7);

        private final int value;

        MessageFlag(int offset)
        {
            this.value = 1 << offset;
        }

        /**
         * Returns the value of the MessageFlag as represented in the bitfield. It is always a power of 2 (single bit)
         * @return Non-Zero bit value of the field
         */
        public int getValue()
        {
            return value;
        }

        /**
         * Given a bitfield, this function extracts all Enum values according to their bit values and returns
         * an EnumSet containing all matching MessageFlags
         * @param  bitfield
         *         Non-Negative integer representing a bitfield of MessageFlags
         * @return Never-Null EnumSet of MessageFlags being found in the bitfield
         */
        @Nonnull
        public static EnumSet fromBitField(int bitfield)
        {
            Set set = Arrays.stream(MessageFlag.values())
                .filter(e -> (e.value & bitfield) > 0)
                .collect(Collectors.toSet());
            return set.isEmpty() ? EnumSet.noneOf(MessageFlag.class) : EnumSet.copyOf(set);
        }

        /**
         * Converts a Collection of MessageFlags back to the integer representing the bitfield.
         * This is the reverse operation of {@link #fromBitField(int)}.
         * @param  coll
         *         A Non-Null Collection of MessageFlags
         * @throws IllegalArgumentException
         *         If the provided Collection is {@code null}
         * @return Integer value of the bitfield representing the given MessageFlags
         */
        public static int toBitField(@Nonnull Collection coll)
        {
            Checks.notNull(coll, "Collection");
            int flags = 0;
            for (MessageFlag messageFlag : coll)
            {
                flags |= messageFlag.value;
            }
            return flags;
        }
    }

    /**
     * Represents a {@link net.dv8tion.jda.api.entities.Message Message} file attachment.
     */
    class Attachment implements ISnowflake
    {
        private static final Set IMAGE_EXTENSIONS = new HashSet<>(Arrays.asList("jpg",
                "jpeg", "png", "gif", "webp", "tiff", "svg", "apng"));
        private static final Set VIDEO_EXTENSIONS = new HashSet<>(Arrays.asList("webm",
                "flv", "vob", "avi", "mov", "wmv", "amv", "mp4", "mpg", "mpeg", "gifv"));
        private final long id;
        private final String url;
        private final String proxyUrl;
        private final String fileName;
        private final String contentType;
        private final String description;
        private final int size;
        private final int height;
        private final int width;
        private final boolean ephemeral;

        private final JDAImpl jda;

        public Attachment(long id, String url, String proxyUrl, String fileName, String contentType, String description, int size, int height, int width, boolean ephemeral, JDAImpl jda)
        {
            this.id = id;
            this.url = url;
            this.proxyUrl = proxyUrl;
            this.fileName = fileName;
            this.contentType = contentType;
            this.description = description;
            this.size = size;
            this.height = height;
            this.width = width;
            this.ephemeral = ephemeral;
            this.jda = jda;
        }

        /**
         * The corresponding JDA instance for this Attachment
         *
         * @return The corresponding JDA instance for this Attachment
         */
        @Nonnull
        public JDA getJDA()
        {
            return jda;
        }

        @Override
        public long getIdLong()
        {
            return id;
        }

        /**
         * The url of the Attachment, most likely on the Discord servers.
         *
         * @return Non-null String containing the Attachment URL.
         */
        @Nonnull
        public String getUrl()
        {
            return url;
        }

        /**
         * Url to the resource proxied by the Discord CDN.
         *
         * @return Non-null String containing the proxied Attachment url.
         */
        @Nonnull
        public String getProxyUrl()
        {
            return proxyUrl;
        }

        /**
         * The file name of the Attachment when it was first uploaded.
         *
         * @return Non-null String containing the Attachment file name.
         */
        @Nonnull
        public String getFileName()
        {
            return fileName;
        }

        /**
         * The file extension of the Attachment when it was first uploaded.
         * 
Null is returned if no characters follow the last occurrence of the '{@code .}' character
         * (or if the character is not present in {@link #getFileName()}).
         *
         * @return Non-null String containing the Attachment file extension, or null if it can't be determined.
         */
        @Nullable
        public String getFileExtension()
        {
            int index = fileName.lastIndexOf('.') + 1;
            return index == 0 || index == fileName.length() ? null : fileName.substring(index);
        }

        /**
         * The Content-Type of this file.
         * 
This is the  Media type of the file that would be used in an HTTP request or similar.
         *
         * @return The content-type, or null if this isn't provided
         */
        @Nullable
        public String getContentType()
        {
            return contentType;
        }

        /**
         * The description (alt text) of this attachment.
         * 
This description is shown when hovering over the attachment in the client.
         *
         * @return The description, or null if this isn't provided
         */
        @Nullable
        public String getDescription()
        {
            return description;
        }

        /**
         * Enqueues a request to retrieve the contents of this Attachment.
         * 
The receiver is expected to close the retrieved {@link java.io.InputStream}.
         *
         * 
Example
         * 
{@code
         * public void printContents(Message.Attachment attachment)
         * {
         *     attachment.retrieveInputStream().thenAccept(in -> {
         *         StringBuilder builder = new StringBuilder();
         *         byte[] buf = byte[1024];
         *         int count = 0;
         *         while ((count = in.read(buf)) > 0)
         *         {
         *             builder.append(new String(buf, 0, count));
         *         }
         *         in.close();
         *         System.out.println(builder);
         *     }).exceptionally(t -> { // handle failure
         *         t.printStackTrace();
         *         return null;
         *     });
         * }
         * }
         *
         * @return {@link java.util.concurrent.CompletableFuture} - Type: {@link java.io.InputStream}
         */
        @Nonnull
        public CompletableFuture retrieveInputStream() // it is expected that the response is closed by the callback!
        {
            CompletableFuture future = new CompletableFuture<>();
            Request req = getRequest();
            OkHttpClient httpClient = getJDA().getHttpClient();
            httpClient.newCall(req).enqueue(FunctionalCallback
                .onFailure((call, e) -> future.completeExceptionally(new UncheckedIOException(e)))
                .onSuccess((call, response) -> {
                    if (response.isSuccessful())
                    {
                        InputStream body = IOUtil.getBody(response);
                        if (!future.complete(body))
                            IOUtil.silentClose(response);
                    }
                    else
                    {
                        future.completeExceptionally(new HttpException(response.code() + ": " + response.message()));
                        IOUtil.silentClose(response);
                    }
                }).build());
            return future;
        }

        /**
         * Downloads the attachment into the current working directory using the file name provided by {@link #getFileName()}.
         * 
This will download the file using the {@link net.dv8tion.jda.api.JDA#getCallbackPool() callback pool}.
         * Alternatively you can use {@link #retrieveInputStream()} and use a continuation with a different executor.
         *
         * 
Example
         * 
{@code
         * public void saveLocally(Message.Attachment attachment)
         * {
         *     attachment.downloadToFile()
         *         .thenAccept(file -> System.out.println("Saved attachment to " + file.getName()))
         *         .exceptionally(t ->
         *         { // handle failure
         *             t.printStackTrace();
         *             return null;
         *         });
         * }
         * }
         *
         * @return {@link java.util.concurrent.CompletableFuture} - Type: {@link java.io.File}
         */
        @Nonnull
        public CompletableFuture downloadToFile() // using relative path
        {
            return downloadToFile(getFileName());
        }

        /**
         * Downloads the attachment to a file at the specified path (relative or absolute).
         * 
This will download the file using the {@link net.dv8tion.jda.api.JDA#getCallbackPool() callback pool}.
         * Alternatively you can use {@link #retrieveInputStream()} and use a continuation with a different executor.
         *
         * 
Example
         * 
{@code
         * public void saveLocally(Message.Attachment attachment)
         * {
         *     attachment.downloadToFile("/tmp/" + attachment.getFileName())
         *         .thenAccept(file -> System.out.println("Saved attachment to " + file.getName()))
         *         .exceptionally(t ->
         *         { // handle failure
         *             t.printStackTrace();
         *             return null;
         *         });
         * }
         * }
         *
         * @param  path
         *         The path to save the file to
         *
         * @throws java.lang.IllegalArgumentException
         *         If the provided path is null
         *
         * @return {@link java.util.concurrent.CompletableFuture} - Type: {@link java.io.File}
         */
        @Nonnull
        public CompletableFuture downloadToFile(String path)
        {
            Checks.notNull(path, "Path");
            return downloadToFile(new File(path));
        }

        /**
         * Downloads the attachment to a file at the specified path (relative or absolute).
         * 
This will download the file using the {@link net.dv8tion.jda.api.JDA#getCallbackPool() callback pool}.
         * Alternatively you can use {@link #retrieveInputStream()} and use a continuation with a different executor.
         *
         * 
Example
         * 
{@code
         * public void saveLocally(Message.Attachment attachment)
         * {
         *     attachment.downloadToFile(new File("/tmp/" + attachment.getFileName()))
         *         .thenAccept(file -> System.out.println("Saved attachment to " + file.getName()))
         *         .exceptionally(t ->
         *         { // handle failure
         *             t.printStackTrace();
         *             return null;
         *         });
         * }
         * }
         *
         * @param  file
         *         The file to write to
         *
         * @throws java.lang.IllegalArgumentException
         *         If the provided file is null or cannot be written to
         *
         * @return {@link java.util.concurrent.CompletableFuture} - Type: {@link java.io.File}
         */
        @SuppressWarnings("ResultOfMethodCallIgnored")
        @Nonnull
        public CompletableFuture downloadToFile(File file)
        {
            Checks.notNull(file, "File");
            try
            {
                if (!file.exists())
                    file.createNewFile();
                else
                    Checks.check(file.canWrite(), "Cannot write to file %s", file.getName());
            }
            catch (IOException e)
            {
                throw new IllegalArgumentException("Cannot create file", e);
            }

            return retrieveInputStream().thenApplyAsync((stream) -> {
                try (FileOutputStream out = new FileOutputStream(file))
                {
                    byte[] buf = new byte[1024];
                    int count;
                    while ((count = stream.read(buf)) > 0)
                    {
                        out.write(buf, 0, count);
                    }
                    return file;
                }
                catch (IOException e)
                {
                    throw new UncheckedIOException(e);
                }
                finally
                {
                    IOUtil.silentClose(stream);
                }
            }, getJDA().getCallbackPool());
        }

        /**
         * Retrieves the image of this attachment and provides an {@link net.dv8tion.jda.api.entities.Icon} equivalent.
         * 
Useful with {@link net.dv8tion.jda.api.managers.AccountManager#setAvatar(Icon)}.
         * 
This will download the file using the {@link net.dv8tion.jda.api.JDA#getCallbackPool() callback pool}.
         * Alternatively you can use {@link #retrieveInputStream()} and use a continuation with a different executor.
         *
         * 
Example
         * 
{@code
         * public void changeAvatar(Message.Attachment attachment)
         * {
         *     attachment.retrieveAsIcon().thenCompose(icon -> {
         *         SelfUser self = attachment.getJDA().getSelfUser();
         *         AccountManager manager = self.getManager();
         *         return manager.setAvatar(icon).submit();
         *     }).exceptionally(t -> {
         *         t.printStackTrace();
         *         return null;
         *     });
         * }
         * }
         *
         * @throws java.lang.IllegalStateException
         *         If this is not an image ({@link #isImage()})
         *
         * @return {@link java.util.concurrent.CompletableFuture} - Type: {@link net.dv8tion.jda.api.entities.Icon}
         */
        @Nonnull
        public CompletableFuture retrieveAsIcon()
        {
            if (!isImage())
                throw new IllegalStateException("Cannot create an Icon out of this attachment. This is not an image.");
            return retrieveInputStream().thenApplyAsync((stream) ->
            {
                try
                {
                    return Icon.from(stream);
                }
                catch (IOException e)
                {
                    throw new UncheckedIOException(e);
                }
                finally
                {
                    IOUtil.silentClose(stream);
                }
            }, getJDA().getCallbackPool());
        }

        protected Request getRequest()
        {
            return new Request.Builder()
                .url(getUrl())
                .addHeader("user-agent", Requester.USER_AGENT)
                .addHeader("accept-encoding", "gzip, deflate")
                .build();
        }

        /**
         * The size of the attachment in bytes.
         * 
Example: if {@code getSize()} returns 1024, then the attachment is 1024 bytes, or 1KiB, in size.
         *
         * @return Positive int containing the size of the Attachment.
         */
        public int getSize()
        {
            return size;
        }

        /**
         * The height of the Attachment if this Attachment is an image/video.
         * 
If this Attachment is neither an image, nor a video, this returns -1.
         *
         * @return int containing image/video Attachment height, or -1 if attachment is neither image nor video.
         */
        public int getHeight()
        {
            return height;
        }

        /**
         * The width of the Attachment if this Attachment is an image/video.
         * 
If this Attachment is neither an image, nor a video, this returns -1.
         *
         * @return int containing image/video Attachment width, or -1 if attachment is neither image nor video.
         */
        public int getWidth()
        {
            return width;
        }

        /**
         * Whether or not this attachment is from an ephemeral Message.
         * 
If this Attachment is ephemeral, it will automatically be removed after 2 weeks. The attachment is guaranteed to be available as long as the message itself exists.
         *
         * @return True if this attachment is from an ephemeral message
         */
        public boolean isEphemeral()
        {
            return ephemeral;
        }

        /**
         * Whether or not this attachment is an Image,
         * based on {@link #getWidth()}, {@link #getHeight()}, and {@link #getFileExtension()}.
         *
         * @return True if this attachment is an image
         */
        public boolean isImage()
        {
            if (width < 0) return false; //if width is -1, so is height
            String extension = getFileExtension();
            return extension != null && IMAGE_EXTENSIONS.contains(extension.toLowerCase());
        }

        /**
         * Whether or not this attachment is a video,
         * based on {@link #getWidth()}, {@link #getHeight()}, and {@link #getFileExtension()}.
         *
         * @return True if this attachment is a video
         */
        public boolean isVideo()
        {
            if (width < 0) return false; //if width is -1, so is height
            String extension = getFileExtension();
            return extension != null && VIDEO_EXTENSIONS.contains(extension.toLowerCase());
        }

        /**
         * Whether or not this attachment is marked as spoiler,
         * based on {@link #getFileName()}.
         *
         * @return True if this attachment is marked as spoiler
         *
         * @since  4.2.1
         */
        public boolean isSpoiler()
        {
            return getFileName().startsWith("SPOILER_");
        }

    }

    /**
     * Represents an {@link net.dv8tion.jda.api.interactions.Interaction Interaction} provided with a {@link net.dv8tion.jda.api.entities.Message Message}.
     */
    class Interaction implements ISnowflake
    {
        private final long id;
        private final int type;
        private final String name;
        private final User user;
        private final Member member;

        public Interaction(long id, int type, String name, User user, Member member)
        {
            this.id = id;
            this.type = type;
            this.name = name;
            this.user = user;
            this.member = member;
        }

        @Override
        public long getIdLong()
        {
            return id;
        }

        /**
         * The raw interaction type.
         * 
It is recommended to use {@link #getType()} instead.
         *
         * @return The raw interaction type
         */
        public int getTypeRaw()
        {
            return type;
        }

        /**
         * The {@link net.dv8tion.jda.api.interactions.InteractionType} for this interaction.
         *
         * @return The {@link net.dv8tion.jda.api.interactions.InteractionType} or {@link net.dv8tion.jda.api.interactions.InteractionType#UNKNOWN}
         */
        @Nonnull
        public InteractionType getType()
        {
            return InteractionType.fromKey(getTypeRaw());
        }

        /**
         * The command name.
         *
         * @return The command name
         */
        @Nonnull
        public String getName()
        {
            return name;
        }

        /**
         * The {@link User} who caused this interaction.
         *
         * @return The {@link User}
         */
        @Nonnull
        public User getUser()
        {
            return user;
        }

        /**
         * The {@link Member} who caused this interaction.
         * 
This is null if the interaction is not from a guild.
         *
         * @return The {@link Member}
         */
        @Nullable
        public Member getMember()
        {
            return member;
        }
    }
}