.gitignore

@@ -3,4 +3,6 @@
 
 # Ignore Gradle build output directory
 build
-.vscode
+.vscode
+lib/bin
+wrapper/javacord/bin

lib/src/main/java/net/tomatentum/marinara/interaction/annotation/Button.java

@@ -0,0 +1,12 @@
+package net.tomatentum.marinara.interaction.annotation;
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+@Target({ElementType.METHOD})
+@Retention(RetentionPolicy.RUNTIME)
+public @interface Button {
+    public String value(); //aka customId
+}

lib/src/main/java/net/tomatentum/marinara/interaction/methods/ButtonInteractionMethod.java

@@ -0,0 +1,40 @@
+package net.tomatentum.marinara.interaction.methods;
+
+import java.lang.reflect.Method;
+
+import net.tomatentum.marinara.interaction.InteractionHandler;
+import net.tomatentum.marinara.interaction.InteractionType;
+import net.tomatentum.marinara.interaction.annotation.Button;
+import net.tomatentum.marinara.wrapper.LibraryWrapper;
+
+public class ButtonInteractionMethod extends InteractionMethod {
+
+    private String customId;
+
+    ButtonInteractionMethod(Method method, InteractionHandler handler, LibraryWrapper wrapper) {
+        super(method, handler, wrapper);
+        parseMethod();
+    }
+
+    @Override
+    public Object getParameter(Object parameter, int index) {
+        Class<?> type = getMethod().getParameterTypes()[index+1];
+        return wrapper.getComponentContextObject(parameter, type);
+    }
+
+    @Override
+    public boolean canRun(Object context) {
+        return wrapper.getButtonId(context).equals(customId);
+    }
+
+    @Override
+    public InteractionType getType() {
+        return InteractionType.BUTTON;
+    }
+
+    private void parseMethod() {
+        Button button = getMethod().getAnnotation(Button.class);
+        this.customId = button.value();
+    }
+    
+}

lib/src/main/java/net/tomatentum/marinara/interaction/methods/InteractionMethod.java

@@ -9,6 +9,7 @@ import java.util.List;
 
 import net.tomatentum.marinara.interaction.InteractionHandler;
 import net.tomatentum.marinara.interaction.InteractionType;
+import net.tomatentum.marinara.interaction.annotation.Button;
 import net.tomatentum.marinara.interaction.commands.annotation.SlashCommand;
 import net.tomatentum.marinara.interaction.commands.annotation.SubCommand;
 import net.tomatentum.marinara.wrapper.LibraryWrapper;
@@ -18,7 +19,8 @@ public abstract class InteractionMethod {
     public static InteractionMethod create(Method method, InteractionHandler handler, LibraryWrapper wrapper) {
         if (method.isAnnotationPresent(SlashCommand.class) || method.isAnnotationPresent(SubCommand.class))
             return new SlashCommandInteractionMethod(method, handler, wrapper);
-        
+        if (method.isAnnotationPresent(Button.class))
+            return new ButtonInteractionMethod(method, handler, wrapper);
         return null;
     }
 

lib/src/main/java/net/tomatentum/marinara/wrapper/LibraryWrapper.java

@@ -17,7 +17,6 @@ public abstract class LibraryWrapper {
         interactionSubscriber = new ArrayList<>();
     }
 
-    public abstract void registerSlashCommands(SlashCommandDefinition[] defs); 
 
     public void handleInteraction(Object context) {
         interactionSubscriber.forEach((o) -> o.accept(context));
@@ -31,6 +30,11 @@ public abstract class LibraryWrapper {
     }
 
     public abstract InteractionType getInteractionType(Class<?> clazz);
+
+    public abstract void registerSlashCommands(SlashCommandDefinition[] defs); 
     public abstract Object convertCommandOption(Object context, SlashCommandOptionType type, String optionName);
     public abstract ExecutableSlashCommandDefinition getCommandDefinition(Object context);
+
+    public abstract String getButtonId(Object context);
+    public abstract Object getComponentContextObject(Object context, Class<?> type);
 }

wrapper/javacord/src/main/java/net/tomatentum/marinare/wrapper/javacord/JavacordWrapper.java

@@ -10,6 +10,7 @@ import java.util.Set;
 
 import org.javacord.api.DiscordApi;
 import org.javacord.api.interaction.ApplicationCommandInteraction;
+import org.javacord.api.interaction.ButtonInteraction;
 import org.javacord.api.interaction.SlashCommandBuilder;
 import org.javacord.api.interaction.SlashCommandInteraction;
 import org.javacord.api.interaction.SlashCommandInteractionOption;
@@ -35,6 +36,16 @@ public class JavacordWrapper extends LibraryWrapper {
         api.addInteractionCreateListener((e) -> handleInteraction(e.getInteraction()));
     }
 
+    @Override
+    public InteractionType getInteractionType(Class<?> clazz) {
+        if (ApplicationCommandInteraction.class.isAssignableFrom(clazz))
+            return InteractionType.COMMAND;
+        if (ButtonInteraction.class.isAssignableFrom(clazz))
+            return InteractionType.BUTTON;
+
+        return null;
+    }
+
     @Override
     public void registerSlashCommands(SlashCommandDefinition[] defs) {
         HashMap<Long, Set<SlashCommandBuilder>> serverCommands = new HashMap<>();
@@ -56,14 +67,6 @@ public class JavacordWrapper extends LibraryWrapper {
         api.bulkOverwriteGlobalApplicationCommands(globalCommands);
     }
 
-    @Override
-    public InteractionType getInteractionType(Class<?> clazz) {
-        if (ApplicationCommandInteraction.class.isAssignableFrom(clazz))
-            return InteractionType.COMMAND;
-
-        return null;
-    }
-
     @Override
     public Object convertCommandOption(Object context, SlashCommandOptionType type, String optionName) {
         if (!(context instanceof SlashCommandInteraction))
@@ -156,4 +159,28 @@ public class JavacordWrapper extends LibraryWrapper {
                 return null;
         }
     }
+
+    @Override
+    public String getButtonId(Object context) {
+        ButtonInteraction button = (ButtonInteraction) context;
+        return button.getCustomId();
+    }
+
+    @Override
+    public Object getComponentContextObject(Object context, Class<?> type) {
+        ButtonInteraction button = (ButtonInteraction) context;
+        switch (type.getName()) {
+            case "org.javacord.api.entity.channel.TextChannel":
+                return button.getChannel().orElse(null);
+            case "org.javacord.api.entity.message.Message":
+                return button.getMessage();
+            case "org.javacord.api.entity.server.Server":
+                return button.getServer().orElse(null);
+            case "org.javacord.api.entity.user.User":
+                return button.getUser();
+        }
+        return null;
+    }
+
+    
 }

wrapper/javacord/src/test/java/net/tomatentum/marinara/test/ButtonTest.java

@@ -0,0 +1,27 @@
+package net.tomatentum.marinara.test;
+
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.TestInstance;
+import org.junit.jupiter.api.TestInstance.Lifecycle;
+
+import net.tomatentum.marinara.Marinara;
+import net.tomatentum.marinara.test.mocks.ButtonInteractionMock;
+import net.tomatentum.marinara.test.mocks.DiscordApiMock;
+import net.tomatentum.marinara.wrapper.LibraryWrapper;
+import net.tomatentum.marinare.wrapper.javacord.JavacordWrapper;
+
+@TestInstance(Lifecycle.PER_CLASS)
+public class ButtonTest {
+
+    @Test
+    public void testButtonExecution() {
+        LibraryWrapper wrapper = new JavacordWrapper(new DiscordApiMock()); //null okay as we don't use the discord API in this test.
+        Marinara marinara = Marinara.load(wrapper);
+        marinara.getRegistry().addInteractions(new TestButton());
+        wrapper.handleInteraction(new ButtonInteractionMock());
+        assertTrue(TestButton.didRun);
+    }
+    
+}

wrapper/javacord/src/test/java/net/tomatentum/marinara/test/TestButton.java

@@ -0,0 +1,29 @@
+package net.tomatentum.marinara.test;
+
+import static org.junit.jupiter.api.Assertions.assertNotNull;
+
+import org.javacord.api.entity.channel.TextChannel;
+import org.javacord.api.entity.message.Message;
+import org.javacord.api.entity.server.Server;
+import org.javacord.api.entity.user.User;
+import org.javacord.api.interaction.ButtonInteraction;
+
+import net.tomatentum.marinara.interaction.InteractionHandler;
+import net.tomatentum.marinara.interaction.annotation.Button;
+
+public class TestButton implements InteractionHandler {
+
+
+    public static boolean didRun = false;
+    @Button("test")
+    public void exec(ButtonInteraction interaction, TextChannel channel, Message message, User member, Server server) {
+        assertNotNull(interaction);
+        assertNotNull(channel);
+        assertNotNull(message);
+        assertNotNull(member);
+        assertNotNull(server);
+        didRun = true;
+        System.out.println("Success!");
+    }
+    
+}

wrapper/javacord/src/test/java/net/tomatentum/marinara/test/mocks/ButtonInteractionMock.java

@@ -0,0 +1,137 @@
+package net.tomatentum.marinara.test.mocks;
+
+import java.util.EnumSet;
+import java.util.List;
+import java.util.Optional;
+import java.util.concurrent.CompletableFuture;
+
+import org.javacord.api.DiscordApi;
+import org.javacord.api.entity.channel.TextChannel;
+import org.javacord.api.entity.message.Message;
+import org.javacord.api.entity.message.component.ComponentType;
+import org.javacord.api.entity.message.component.HighLevelComponent;
+import org.javacord.api.entity.permission.PermissionType;
+import org.javacord.api.entity.server.Server;
+import org.javacord.api.entity.user.User;
+import org.javacord.api.interaction.ButtonInteraction;
+import org.javacord.api.interaction.DiscordLocale;
+import org.javacord.api.interaction.InteractionType;
+import org.javacord.api.interaction.callback.ComponentInteractionOriginalMessageUpdater;
+import org.javacord.api.interaction.callback.InteractionFollowupMessageBuilder;
+import org.javacord.api.interaction.callback.InteractionImmediateResponseBuilder;
+import org.javacord.api.interaction.callback.InteractionOriginalResponseUpdater;
+
+public class ButtonInteractionMock implements ButtonInteraction {
+
+    @Override
+    public Message getMessage() {
+        return new MessageMock();
+    }
+
+    @Override
+    public String getCustomId() {
+        return "test";
+    }
+
+    @Override
+    public ComponentType getComponentType() {
+        return ComponentType.BUTTON;
+    }
+
+    @Override
+    public CompletableFuture<Void> acknowledge() {
+        throw new UnsupportedOperationException("Unimplemented method 'acknowledge'");
+    }
+
+    @Override
+    public ComponentInteractionOriginalMessageUpdater createOriginalMessageUpdater() {
+        throw new UnsupportedOperationException("Unimplemented method 'createOriginalMessageUpdater'");
+    }
+
+    @Override
+    public long getApplicationId() {
+        throw new UnsupportedOperationException("Unimplemented method 'getApplicationId'");
+    }
+
+    @Override
+    public InteractionType getType() {
+        return InteractionType.MESSAGE_COMPONENT;
+    }
+
+    @Override
+    public InteractionImmediateResponseBuilder createImmediateResponder() {
+        throw new UnsupportedOperationException("Unimplemented method 'createImmediateResponder'");
+    }
+
+    @Override
+    public CompletableFuture<InteractionOriginalResponseUpdater> respondLater() {
+        throw new UnsupportedOperationException("Unimplemented method 'respondLater'");
+    }
+
+    @Override
+    public CompletableFuture<InteractionOriginalResponseUpdater> respondLater(boolean ephemeral) {
+        throw new UnsupportedOperationException("Unimplemented method 'respondLater'");
+    }
+
+    @Override
+    public CompletableFuture<Void> respondWithModal(String customId, String title,
+            List<HighLevelComponent> components) {
+        throw new UnsupportedOperationException("Unimplemented method 'respondWithModal'");
+    }
+
+    @Override
+    public InteractionFollowupMessageBuilder createFollowupMessageBuilder() {
+        throw new UnsupportedOperationException("Unimplemented method 'createFollowupMessageBuilder'");
+    }
+
+    @Override
+    public Optional<Server> getServer() {
+        return Optional.of(new ServerMock());
+    }
+
+    @Override
+    public Optional<TextChannel> getChannel() {
+        return Optional.of(new ChannelMock());
+    }
+
+    @Override
+    public User getUser() {
+        return new UserMock();
+    }
+
+    @Override
+    public String getToken() {
+        throw new UnsupportedOperationException("Unimplemented method 'getToken'");
+    }
+
+    @Override
+    public int getVersion() {
+        throw new UnsupportedOperationException("Unimplemented method 'getVersion'");
+    }
+
+    @Override
+    public DiscordLocale getLocale() {
+        throw new UnsupportedOperationException("Unimplemented method 'getLocale'");
+    }
+
+    @Override
+    public Optional<DiscordLocale> getServerLocale() {
+        throw new UnsupportedOperationException("Unimplemented method 'getServerLocale'");
+    }
+
+    @Override
+    public Optional<EnumSet<PermissionType>> getBotPermissions() {
+        throw new UnsupportedOperationException("Unimplemented method 'getBotPermissions'");
+    }
+
+    @Override
+    public DiscordApi getApi() {
+        throw new UnsupportedOperationException("Unimplemented method 'getApi'");
+    }
+
+    @Override
+    public long getId() {
+        throw new UnsupportedOperationException("Unimplemented method 'getId'");
+    }
+     
+}

wrapper/javacord/src/test/java/net/tomatentum/marinara/test/mocks/ChannelMock.java

@@ -0,0 +1,824 @@
+package net.tomatentum.marinara.test.mocks;
+
+import java.util.Collection;
+import java.util.List;
+import java.util.Map;
+import java.util.concurrent.CompletableFuture;
+import java.util.function.Predicate;
+import java.util.stream.Stream;
+
+import org.javacord.api.DiscordApi;
+import org.javacord.api.entity.channel.ChannelType;
+import org.javacord.api.entity.channel.TextChannel;
+import org.javacord.api.entity.message.Message;
+import org.javacord.api.entity.message.MessageSet;
+import org.javacord.api.entity.user.User;
+import org.javacord.api.entity.webhook.IncomingWebhook;
+import org.javacord.api.entity.webhook.Webhook;
+import org.javacord.api.listener.ObjectAttachableListener;
+import org.javacord.api.listener.channel.ChannelAttachableListener;
+import org.javacord.api.listener.channel.ServerThreadChannelAttachableListener;
+import org.javacord.api.listener.channel.TextChannelAttachableListener;
+import org.javacord.api.listener.channel.server.thread.ServerThreadChannelCreateListener;
+import org.javacord.api.listener.channel.server.thread.ServerThreadChannelDeleteListener;
+import org.javacord.api.listener.channel.server.thread.ServerThreadChannelMembersUpdateListener;
+import org.javacord.api.listener.channel.server.thread.ServerThreadChannelUpdateListener;
+import org.javacord.api.listener.interaction.AutocompleteCreateListener;
+import org.javacord.api.listener.interaction.ButtonClickListener;
+import org.javacord.api.listener.interaction.InteractionCreateListener;
+import org.javacord.api.listener.interaction.MessageComponentCreateListener;
+import org.javacord.api.listener.interaction.MessageContextMenuCommandListener;
+import org.javacord.api.listener.interaction.ModalSubmitListener;
+import org.javacord.api.listener.interaction.SelectMenuChooseListener;
+import org.javacord.api.listener.interaction.SlashCommandCreateListener;
+import org.javacord.api.listener.interaction.UserContextMenuCommandListener;
+import org.javacord.api.listener.message.CachedMessagePinListener;
+import org.javacord.api.listener.message.CachedMessageUnpinListener;
+import org.javacord.api.listener.message.ChannelPinsUpdateListener;
+import org.javacord.api.listener.message.MessageCreateListener;
+import org.javacord.api.listener.message.MessageDeleteListener;
+import org.javacord.api.listener.message.MessageEditListener;
+import org.javacord.api.listener.message.MessageReplyListener;
+import org.javacord.api.listener.message.reaction.ReactionAddListener;
+import org.javacord.api.listener.message.reaction.ReactionRemoveAllListener;
+import org.javacord.api.listener.message.reaction.ReactionRemoveListener;
+import org.javacord.api.listener.server.thread.ServerPrivateThreadJoinListener;
+import org.javacord.api.listener.server.thread.ServerThreadChannelChangeArchiveTimestampListener;
+import org.javacord.api.listener.server.thread.ServerThreadChannelChangeArchivedListener;
+import org.javacord.api.listener.server.thread.ServerThreadChannelChangeAutoArchiveDurationListener;
+import org.javacord.api.listener.server.thread.ServerThreadChannelChangeInvitableListener;
+import org.javacord.api.listener.server.thread.ServerThreadChannelChangeLastMessageIdListener;
+import org.javacord.api.listener.server.thread.ServerThreadChannelChangeLockedListener;
+import org.javacord.api.listener.server.thread.ServerThreadChannelChangeMemberCountListener;
+import org.javacord.api.listener.server.thread.ServerThreadChannelChangeMessageCountListener;
+import org.javacord.api.listener.server.thread.ServerThreadChannelChangeRateLimitPerUserListener;
+import org.javacord.api.listener.server.thread.ServerThreadChannelChangeTotalMessageSentListener;
+import org.javacord.api.listener.user.UserStartTypingListener;
+import org.javacord.api.util.cache.MessageCache;
+import org.javacord.api.util.event.ListenerManager;
+
+public class ChannelMock implements TextChannel {
+
+    @Override
+    public ChannelType getType() {
+        
+        throw new UnsupportedOperationException("Unimplemented method 'getType'");
+    }
+
+    @Override
+    public DiscordApi getApi() {
+        
+        throw new UnsupportedOperationException("Unimplemented method 'getApi'");
+    }
+
+    @Override
+    public long getId() {
+        
+        throw new UnsupportedOperationException("Unimplemented method 'getId'");
+    }
+
+    @Override
+    public <T extends ChannelAttachableListener & ObjectAttachableListener> Collection<ListenerManager<T>> addChannelAttachableListener(
+            T listener) {
+        
+        throw new UnsupportedOperationException("Unimplemented method 'addChannelAttachableListener'");
+    }
+
+    @Override
+    public <T extends ChannelAttachableListener & ObjectAttachableListener> void removeChannelAttachableListener(
+            T listener) {
+        
+        throw new UnsupportedOperationException("Unimplemented method 'removeChannelAttachableListener'");
+    }
+
+    @Override
+    public <T extends ChannelAttachableListener & ObjectAttachableListener> Map<T, List<Class<T>>> getChannelAttachableListeners() {
+        
+        throw new UnsupportedOperationException("Unimplemented method 'getChannelAttachableListeners'");
+    }
+
+    @Override
+    public <T extends ChannelAttachableListener & ObjectAttachableListener> void removeListener(Class<T> listenerClass,
+            T listener) {
+        
+        throw new UnsupportedOperationException("Unimplemented method 'removeListener'");
+    }
+
+    @Override
+    public ListenerManager<InteractionCreateListener> addInteractionCreateListener(InteractionCreateListener listener) {
+        
+        throw new UnsupportedOperationException("Unimplemented method 'addInteractionCreateListener'");
+    }
+
+    @Override
+    public List<InteractionCreateListener> getInteractionCreateListeners() {
+        
+        throw new UnsupportedOperationException("Unimplemented method 'getInteractionCreateListeners'");
+    }
+
+    @Override
+    public ListenerManager<SlashCommandCreateListener> addSlashCommandCreateListener(
+            SlashCommandCreateListener listener) {
+        
+        throw new UnsupportedOperationException("Unimplemented method 'addSlashCommandCreateListener'");
+    }
+
+    @Override
+    public List<SlashCommandCreateListener> getSlashCommandCreateListeners() {
+        
+        throw new UnsupportedOperationException("Unimplemented method 'getSlashCommandCreateListeners'");
+    }
+
+    @Override
+    public ListenerManager<AutocompleteCreateListener> addAutocompleteCreateListener(
+            AutocompleteCreateListener listener) {
+        
+        throw new UnsupportedOperationException("Unimplemented method 'addAutocompleteCreateListener'");
+    }
+
+    @Override
+    public List<AutocompleteCreateListener> getAutocompleteCreateListeners() {
+        
+        throw new UnsupportedOperationException("Unimplemented method 'getAutocompleteCreateListeners'");
+    }
+
+    @Override
+    public ListenerManager<ModalSubmitListener> addModalSubmitListener(ModalSubmitListener listener) {
+        
+        throw new UnsupportedOperationException("Unimplemented method 'addModalSubmitListener'");
+    }
+
+    @Override
+    public List<ModalSubmitListener> getModalSubmitListeners() {
+        
+        throw new UnsupportedOperationException("Unimplemented method 'getModalSubmitListeners'");
+    }
+
+    @Override
+    public ListenerManager<MessageContextMenuCommandListener> addMessageContextMenuCommandListener(
+            MessageContextMenuCommandListener listener) {
+        
+        throw new UnsupportedOperationException("Unimplemented method 'addMessageContextMenuCommandListener'");
+    }
+
+    @Override
+    public List<MessageContextMenuCommandListener> getMessageContextMenuCommandListeners() {
+        
+        throw new UnsupportedOperationException("Unimplemented method 'getMessageContextMenuCommandListeners'");
+    }
+
+    @Override
+    public ListenerManager<MessageComponentCreateListener> addMessageComponentCreateListener(
+            MessageComponentCreateListener listener) {
+        
+        throw new UnsupportedOperationException("Unimplemented method 'addMessageComponentCreateListener'");
+    }
+
+    @Override
+    public List<MessageComponentCreateListener> getMessageComponentCreateListeners() {
+        
+        throw new UnsupportedOperationException("Unimplemented method 'getMessageComponentCreateListeners'");
+    }
+
+    @Override
+    public ListenerManager<UserContextMenuCommandListener> addUserContextMenuCommandListener(
+            UserContextMenuCommandListener listener) {
+        
+        throw new UnsupportedOperationException("Unimplemented method 'addUserContextMenuCommandListener'");
+    }
+
+    @Override
+    public List<UserContextMenuCommandListener> getUserContextMenuCommandListeners() {
+        
+        throw new UnsupportedOperationException("Unimplemented method 'getUserContextMenuCommandListeners'");
+    }
+
+    @Override
+    public ListenerManager<SelectMenuChooseListener> addSelectMenuChooseListener(SelectMenuChooseListener listener) {
+        
+        throw new UnsupportedOperationException("Unimplemented method 'addSelectMenuChooseListener'");
+    }
+
+    @Override
+    public List<SelectMenuChooseListener> getSelectMenuChooseListeners() {
+        
+        throw new UnsupportedOperationException("Unimplemented method 'getSelectMenuChooseListeners'");
+    }
+
+    @Override
+    public ListenerManager<ButtonClickListener> addButtonClickListener(ButtonClickListener listener) {
+        
+        throw new UnsupportedOperationException("Unimplemented method 'addButtonClickListener'");
+    }
+
+    @Override
+    public List<ButtonClickListener> getButtonClickListeners() {
+        
+        throw new UnsupportedOperationException("Unimplemented method 'getButtonClickListeners'");
+    }
+
+    @Override
+    public ListenerManager<UserStartTypingListener> addUserStartTypingListener(UserStartTypingListener listener) {
+        
+        throw new UnsupportedOperationException("Unimplemented method 'addUserStartTypingListener'");
+    }
+
+    @Override
+    public List<UserStartTypingListener> getUserStartTypingListeners() {
+        
+        throw new UnsupportedOperationException("Unimplemented method 'getUserStartTypingListeners'");
+    }
+
+    @Override
+    public ListenerManager<MessageEditListener> addMessageEditListener(MessageEditListener listener) {
+        
+        throw new UnsupportedOperationException("Unimplemented method 'addMessageEditListener'");
+    }
+
+    @Override
+    public List<MessageEditListener> getMessageEditListeners() {
+        
+        throw new UnsupportedOperationException("Unimplemented method 'getMessageEditListeners'");
+    }
+
+    @Override
+    public ListenerManager<ChannelPinsUpdateListener> addChannelPinsUpdateListener(ChannelPinsUpdateListener listener) {
+        
+        throw new UnsupportedOperationException("Unimplemented method 'addChannelPinsUpdateListener'");
+    }
+
+    @Override
+    public List<ChannelPinsUpdateListener> getChannelPinsUpdateListeners() {
+        
+        throw new UnsupportedOperationException("Unimplemented method 'getChannelPinsUpdateListeners'");
+    }
+
+    @Override
+    public ListenerManager<ReactionRemoveListener> addReactionRemoveListener(ReactionRemoveListener listener) {
+        
+        throw new UnsupportedOperationException("Unimplemented method 'addReactionRemoveListener'");
+    }
+
+    @Override
+    public List<ReactionRemoveListener> getReactionRemoveListeners() {
+        
+        throw new UnsupportedOperationException("Unimplemented method 'getReactionRemoveListeners'");
+    }
+
+    @Override
+    public ListenerManager<ReactionAddListener> addReactionAddListener(ReactionAddListener listener) {
+        
+        throw new UnsupportedOperationException("Unimplemented method 'addReactionAddListener'");
+    }
+
+    @Override
+    public List<ReactionAddListener> getReactionAddListeners() {
+        
+        throw new UnsupportedOperationException("Unimplemented method 'getReactionAddListeners'");
+    }
+
+    @Override
+    public ListenerManager<ReactionRemoveAllListener> addReactionRemoveAllListener(ReactionRemoveAllListener listener) {
+        
+        throw new UnsupportedOperationException("Unimplemented method 'addReactionRemoveAllListener'");
+    }
+
+    @Override
+    public List<ReactionRemoveAllListener> getReactionRemoveAllListeners() {
+        
+        throw new UnsupportedOperationException("Unimplemented method 'getReactionRemoveAllListeners'");
+    }
+
+    @Override
+    public ListenerManager<MessageCreateListener> addMessageCreateListener(MessageCreateListener listener) {
+        
+        throw new UnsupportedOperationException("Unimplemented method 'addMessageCreateListener'");
+    }
+
+    @Override
+    public List<MessageCreateListener> getMessageCreateListeners() {
+        
+        throw new UnsupportedOperationException("Unimplemented method 'getMessageCreateListeners'");
+    }
+
+    @Override
+    public ListenerManager<CachedMessageUnpinListener> addCachedMessageUnpinListener(
+            CachedMessageUnpinListener listener) {
+        
+        throw new UnsupportedOperationException("Unimplemented method 'addCachedMessageUnpinListener'");
+    }
+
+    @Override
+    public List<CachedMessageUnpinListener> getCachedMessageUnpinListeners() {
+        
+        throw new UnsupportedOperationException("Unimplemented method 'getCachedMessageUnpinListeners'");
+    }
+
+    @Override
+    public ListenerManager<CachedMessagePinListener> addCachedMessagePinListener(CachedMessagePinListener listener) {
+        
+        throw new UnsupportedOperationException("Unimplemented method 'addCachedMessagePinListener'");
+    }
+
+    @Override
+    public List<CachedMessagePinListener> getCachedMessagePinListeners() {
+        
+        throw new UnsupportedOperationException("Unimplemented method 'getCachedMessagePinListeners'");
+    }
+
+    @Override
+    public ListenerManager<MessageReplyListener> addMessageReplyListener(MessageReplyListener listener) {
+        
+        throw new UnsupportedOperationException("Unimplemented method 'addMessageReplyListener'");
+    }
+
+    @Override
+    public List<MessageReplyListener> getMessageReplyListeners() {
+        
+        throw new UnsupportedOperationException("Unimplemented method 'getMessageReplyListeners'");
+    }
+
+    @Override
+    public ListenerManager<MessageDeleteListener> addMessageDeleteListener(MessageDeleteListener listener) {
+        
+        throw new UnsupportedOperationException("Unimplemented method 'addMessageDeleteListener'");
+    }
+
+    @Override
+    public List<MessageDeleteListener> getMessageDeleteListeners() {
+        
+        throw new UnsupportedOperationException("Unimplemented method 'getMessageDeleteListeners'");
+    }
+
+    @Override
+    public <T extends TextChannelAttachableListener & ObjectAttachableListener> Collection<ListenerManager<? extends TextChannelAttachableListener>> addTextChannelAttachableListener(
+            T listener) {
+        
+        throw new UnsupportedOperationException("Unimplemented method 'addTextChannelAttachableListener'");
+    }
+
+    @Override
+    public <T extends TextChannelAttachableListener & ObjectAttachableListener> void removeTextChannelAttachableListener(
+            T listener) {
+        
+        throw new UnsupportedOperationException("Unimplemented method 'removeTextChannelAttachableListener'");
+    }
+
+    @Override
+    public <T extends TextChannelAttachableListener & ObjectAttachableListener> Map<T, List<Class<T>>> getTextChannelAttachableListeners() {
+        
+        throw new UnsupportedOperationException("Unimplemented method 'getTextChannelAttachableListeners'");
+    }
+
+    @Override
+    public <T extends TextChannelAttachableListener & ObjectAttachableListener> void removeListener(
+            Class<T> listenerClass, T listener) {
+        
+        throw new UnsupportedOperationException("Unimplemented method 'removeListener'");
+    }
+
+    @Override
+    public ListenerManager<ServerThreadChannelChangeLastMessageIdListener> addServerThreadChannelChangeLastMessageIdListener(
+            ServerThreadChannelChangeLastMessageIdListener listener) {
+        
+        throw new UnsupportedOperationException("Unimplemented method 'addServerThreadChannelChangeLastMessageIdListener'");
+    }
+
+    @Override
+    public List<ServerThreadChannelChangeLastMessageIdListener> getServerThreadChannelChangeLastMessageIdListeners() {
+        
+        throw new UnsupportedOperationException("Unimplemented method 'getServerThreadChannelChangeLastMessageIdListeners'");
+    }
+
+    @Override
+    public ListenerManager<ServerThreadChannelChangeArchivedListener> addServerThreadChannelChangeArchivedListener(
+            ServerThreadChannelChangeArchivedListener listener) {
+        
+        throw new UnsupportedOperationException("Unimplemented method 'addServerThreadChannelChangeArchivedListener'");
+    }
+
+    @Override
+    public List<ServerThreadChannelChangeArchivedListener> getServerThreadChannelChangeArchivedListeners() {
+        
+        throw new UnsupportedOperationException("Unimplemented method 'getServerThreadChannelChangeArchivedListeners'");
+    }
+
+    @Override
+    public ListenerManager<ServerThreadChannelChangeMemberCountListener> addServerThreadChannelChangeMemberCountListener(
+            ServerThreadChannelChangeMemberCountListener listener) {
+        
+        throw new UnsupportedOperationException("Unimplemented method 'addServerThreadChannelChangeMemberCountListener'");
+    }
+
+    @Override
+    public List<ServerThreadChannelChangeMemberCountListener> getServerThreadChannelChangeMemberCountListeners() {
+        
+        throw new UnsupportedOperationException("Unimplemented method 'getServerThreadChannelChangeMemberCountListeners'");
+    }
+
+    @Override
+    public ListenerManager<ServerPrivateThreadJoinListener> addServerPrivateThreadJoinListener(
+            ServerPrivateThreadJoinListener listener) {
+        
+        throw new UnsupportedOperationException("Unimplemented method 'addServerPrivateThreadJoinListener'");
+    }
+
+    @Override
+    public List<ServerPrivateThreadJoinListener> getServerPrivateThreadJoinListeners() {
+        
+        throw new UnsupportedOperationException("Unimplemented method 'getServerPrivateThreadJoinListeners'");
+    }
+
+    @Override
+    public ListenerManager<ServerThreadChannelChangeInvitableListener> addServerThreadChannelChangeInvitableListener(
+            ServerThreadChannelChangeInvitableListener listener) {
+        
+        throw new UnsupportedOperationException("Unimplemented method 'addServerThreadChannelChangeInvitableListener'");
+    }
+
+    @Override
+    public List<ServerThreadChannelChangeInvitableListener> getServerThreadChannelChangeInvitableListeners() {
+        
+        throw new UnsupportedOperationException("Unimplemented method 'getServerThreadChannelChangeInvitableListeners'");
+    }
+
+    @Override
+    public ListenerManager<ServerThreadChannelChangeAutoArchiveDurationListener> addServerThreadChannelChangeAutoArchiveDurationListener(
+            ServerThreadChannelChangeAutoArchiveDurationListener listener) {
+        
+        throw new UnsupportedOperationException("Unimplemented method 'addServerThreadChannelChangeAutoArchiveDurationListener'");
+    }
+
+    @Override
+    public List<ServerThreadChannelChangeAutoArchiveDurationListener> getServerThreadChannelChangeAutoArchiveDurationListeners() {
+        
+        throw new UnsupportedOperationException("Unimplemented method 'getServerThreadChannelChangeAutoArchiveDurationListeners'");
+    }
+
+    @Override
+    public ListenerManager<ServerThreadChannelChangeRateLimitPerUserListener> addServerThreadChannelChangeRateLimitPerUserListener(
+            ServerThreadChannelChangeRateLimitPerUserListener listener) {
+        
+        throw new UnsupportedOperationException("Unimplemented method 'addServerThreadChannelChangeRateLimitPerUserListener'");
+    }
+
+    @Override
+    public List<ServerThreadChannelChangeRateLimitPerUserListener> getServerThreadChannelChangeRateLimitPerUserListeners() {
+        
+        throw new UnsupportedOperationException("Unimplemented method 'getServerThreadChannelChangeRateLimitPerUserListeners'");
+    }
+
+    @Override
+    public ListenerManager<ServerThreadChannelChangeLockedListener> addServerThreadChannelChangeLockedListener(
+            ServerThreadChannelChangeLockedListener listener) {
+        
+        throw new UnsupportedOperationException("Unimplemented method 'addServerThreadChannelChangeLockedListener'");
+    }
+
+    @Override
+    public List<ServerThreadChannelChangeLockedListener> getServerThreadChannelChangeLockedListeners() {
+        
+        throw new UnsupportedOperationException("Unimplemented method 'getServerThreadChannelChangeLockedListeners'");
+    }
+
+    @Override
+    public ListenerManager<ServerThreadChannelChangeArchiveTimestampListener> addServerThreadChannelChangeArchiveTimestampListener(
+            ServerThreadChannelChangeArchiveTimestampListener listener) {
+        
+        throw new UnsupportedOperationException("Unimplemented method 'addServerThreadChannelChangeArchiveTimestampListener'");
+    }
+
+    @Override
+    public List<ServerThreadChannelChangeArchiveTimestampListener> getServerThreadChannelChangeArchiveTimestampListeners() {
+        
+        throw new UnsupportedOperationException("Unimplemented method 'getServerThreadChannelChangeArchiveTimestampListeners'");
+    }
+
+    @Override
+    public ListenerManager<ServerThreadChannelChangeTotalMessageSentListener> addServerThreadChannelChangeTotalMessageSentListener(
+            ServerThreadChannelChangeTotalMessageSentListener listener) {
+        
+        throw new UnsupportedOperationException("Unimplemented method 'addServerThreadChannelChangeTotalMessageSentListener'");
+    }
+
+    @Override
+    public List<ServerThreadChannelChangeTotalMessageSentListener> getServerThreadChannelChangeTotalMessageSentListeners() {
+        
+        throw new UnsupportedOperationException("Unimplemented method 'getServerThreadChannelChangeTotalMessageSentListeners'");
+    }
+
+    @Override
+    public ListenerManager<ServerThreadChannelChangeMessageCountListener> addServerThreadChannelChangeMessageCountListener(
+            ServerThreadChannelChangeMessageCountListener listener) {
+        
+        throw new UnsupportedOperationException("Unimplemented method 'addServerThreadChannelChangeMessageCountListener'");
+    }
+
+    @Override
+    public List<ServerThreadChannelChangeMessageCountListener> getServerThreadChannelChangeMessageCountListeners() {
+        
+        throw new UnsupportedOperationException("Unimplemented method 'getServerThreadChannelChangeMessageCountListeners'");
+    }
+
+    @Override
+    public ListenerManager<ServerThreadChannelUpdateListener> addServerThreadChannelUpdateListener(
+            ServerThreadChannelUpdateListener listener) {
+        
+        throw new UnsupportedOperationException("Unimplemented method 'addServerThreadChannelUpdateListener'");
+    }
+
+    @Override
+    public List<ServerThreadChannelUpdateListener> getServerThreadChannelUpdateListeners() {
+        
+        throw new UnsupportedOperationException("Unimplemented method 'getServerThreadChannelUpdateListeners'");
+    }
+
+    @Override
+    public ListenerManager<ServerThreadChannelMembersUpdateListener> addServerThreadChannelMembersUpdateListener(
+            ServerThreadChannelMembersUpdateListener listener) {
+        
+        throw new UnsupportedOperationException("Unimplemented method 'addServerThreadChannelMembersUpdateListener'");
+    }
+
+    @Override
+    public List<ServerThreadChannelMembersUpdateListener> getServerThreadChannelMembersUpdateListeners() {
+        
+        throw new UnsupportedOperationException("Unimplemented method 'getServerThreadChannelMembersUpdateListeners'");
+    }
+
+    @Override
+    public ListenerManager<ServerThreadChannelCreateListener> addServerThreadChannelCreateListener(
+            ServerThreadChannelCreateListener listener) {
+        
+        throw new UnsupportedOperationException("Unimplemented method 'addServerThreadChannelCreateListener'");
+    }
+
+    @Override
+    public List<ServerThreadChannelCreateListener> getServerThreadChannelCreateListeners() {
+        
+        throw new UnsupportedOperationException("Unimplemented method 'getServerThreadChannelCreateListeners'");
+    }
+
+    @Override
+    public ListenerManager<ServerThreadChannelDeleteListener> addServerThreadChannelDeleteListener(
+            ServerThreadChannelDeleteListener listener) {
+        
+        throw new UnsupportedOperationException("Unimplemented method 'addServerThreadChannelDeleteListener'");
+    }
+
+    @Override
+    public List<ServerThreadChannelDeleteListener> getServerThreadChannelDeleteListeners() {
+        
+        throw new UnsupportedOperationException("Unimplemented method 'getServerThreadChannelDeleteListeners'");
+    }
+
+    @Override
+    public <T extends ServerThreadChannelAttachableListener & ObjectAttachableListener> Collection<ListenerManager<T>> addServerThreadChannelAttachableListener(
+            T listener) {
+        
+        throw new UnsupportedOperationException("Unimplemented method 'addServerThreadChannelAttachableListener'");
+    }
+
+    @Override
+    public <T extends ServerThreadChannelAttachableListener & ObjectAttachableListener> void removeServerThreadChannelAttachableListener(
+            T listener) {
+        
+        throw new UnsupportedOperationException("Unimplemented method 'removeServerThreadChannelAttachableListener'");
+    }
+
+    @Override
+    public <T extends ServerThreadChannelAttachableListener & ObjectAttachableListener> Map<T, List<Class<T>>> getServerThreadChannelAttachableListeners() {
+        
+        throw new UnsupportedOperationException("Unimplemented method 'getServerThreadChannelAttachableListeners'");
+    }
+
+    @Override
+    public <T extends ServerThreadChannelAttachableListener & ObjectAttachableListener> void removeListener(
+            Class<T> listenerClass, T listener) {
+        
+        throw new UnsupportedOperationException("Unimplemented method 'removeListener'");
+    }
+
+    @Override
+    public CompletableFuture<Void> type() {
+        
+        throw new UnsupportedOperationException("Unimplemented method 'type'");
+    }
+
+    @Override
+    public CompletableFuture<Void> bulkDelete(long... messageIds) {
+        
+        throw new UnsupportedOperationException("Unimplemented method 'bulkDelete'");
+    }
+
+    @Override
+    public CompletableFuture<Message> getMessageById(long id) {
+        
+        throw new UnsupportedOperationException("Unimplemented method 'getMessageById'");
+    }
+
+    @Override
+    public CompletableFuture<MessageSet> getPins() {
+        
+        throw new UnsupportedOperationException("Unimplemented method 'getPins'");
+    }
+
+    @Override
+    public CompletableFuture<MessageSet> getMessages(int limit) {
+        
+        throw new UnsupportedOperationException("Unimplemented method 'getMessages'");
+    }
+
+    @Override
+    public CompletableFuture<MessageSet> getMessagesUntil(Predicate<Message> condition) {
+        
+        throw new UnsupportedOperationException("Unimplemented method 'getMessagesUntil'");
+    }
+
+    @Override
+    public CompletableFuture<MessageSet> getMessagesWhile(Predicate<Message> condition) {
+        
+        throw new UnsupportedOperationException("Unimplemented method 'getMessagesWhile'");
+    }
+
+    @Override
+    public Stream<Message> getMessagesAsStream() {
+        
+        throw new UnsupportedOperationException("Unimplemented method 'getMessagesAsStream'");
+    }
+
+    @Override
+    public CompletableFuture<MessageSet> getMessagesBefore(int limit, long before) {
+        
+        throw new UnsupportedOperationException("Unimplemented method 'getMessagesBefore'");
+    }
+
+    @Override
+    public CompletableFuture<MessageSet> getMessagesBeforeUntil(Predicate<Message> condition, long before) {
+        
+        throw new UnsupportedOperationException("Unimplemented method 'getMessagesBeforeUntil'");
+    }
+
+    @Override
+    public CompletableFuture<MessageSet> getMessagesBeforeWhile(Predicate<Message> condition, long before) {
+        
+        throw new UnsupportedOperationException("Unimplemented method 'getMessagesBeforeWhile'");
+    }
+
+    @Override
+    public Stream<Message> getMessagesBeforeAsStream(long before) {
+        
+        throw new UnsupportedOperationException("Unimplemented method 'getMessagesBeforeAsStream'");
+    }
+
+    @Override
+    public CompletableFuture<MessageSet> getMessagesAfter(int limit, long after) {
+        
+        throw new UnsupportedOperationException("Unimplemented method 'getMessagesAfter'");
+    }
+
+    @Override
+    public CompletableFuture<MessageSet> getMessagesAfterUntil(Predicate<Message> condition, long after) {
+        
+        throw new UnsupportedOperationException("Unimplemented method 'getMessagesAfterUntil'");
+    }
+
+    @Override
+    public CompletableFuture<MessageSet> getMessagesAfterWhile(Predicate<Message> condition, long after) {
+        
+        throw new UnsupportedOperationException("Unimplemented method 'getMessagesAfterWhile'");
+    }
+
+    @Override
+    public Stream<Message> getMessagesAfterAsStream(long after) {
+        
+        throw new UnsupportedOperationException("Unimplemented method 'getMessagesAfterAsStream'");
+    }
+
+    @Override
+    public CompletableFuture<MessageSet> getMessagesAround(int limit, long around) {
+        
+        throw new UnsupportedOperationException("Unimplemented method 'getMessagesAround'");
+    }
+
+    @Override
+    public CompletableFuture<MessageSet> getMessagesAroundUntil(Predicate<Message> condition, long around) {
+        
+        throw new UnsupportedOperationException("Unimplemented method 'getMessagesAroundUntil'");
+    }
+
+    @Override
+    public CompletableFuture<MessageSet> getMessagesAroundWhile(Predicate<Message> condition, long around) {
+        
+        throw new UnsupportedOperationException("Unimplemented method 'getMessagesAroundWhile'");
+    }
+
+    @Override
+    public Stream<Message> getMessagesAroundAsStream(long around) {
+        
+        throw new UnsupportedOperationException("Unimplemented method 'getMessagesAroundAsStream'");
+    }
+
+    @Override
+    public CompletableFuture<MessageSet> getMessagesBetween(long from, long to) {
+        
+        throw new UnsupportedOperationException("Unimplemented method 'getMessagesBetween'");
+    }
+
+    @Override
+    public CompletableFuture<MessageSet> getMessagesBetweenUntil(Predicate<Message> condition, long from, long to) {
+        
+        throw new UnsupportedOperationException("Unimplemented method 'getMessagesBetweenUntil'");
+    }
+
+    @Override
+    public CompletableFuture<MessageSet> getMessagesBetweenWhile(Predicate<Message> condition, long from, long to) {
+        
+        throw new UnsupportedOperationException("Unimplemented method 'getMessagesBetweenWhile'");
+    }
+
+    @Override
+    public Stream<Message> getMessagesBetweenAsStream(long from, long to) {
+        
+        throw new UnsupportedOperationException("Unimplemented method 'getMessagesBetweenAsStream'");
+    }
+
+    @Override
+    public MessageCache getMessageCache() {
+        
+        throw new UnsupportedOperationException("Unimplemented method 'getMessageCache'");
+    }
+
+    @Override
+    public CompletableFuture<List<Webhook>> getWebhooks() {
+        
+        throw new UnsupportedOperationException("Unimplemented method 'getWebhooks'");
+    }
+
+    @Override
+    public CompletableFuture<List<Webhook>> getAllIncomingWebhooks() {
+        
+        throw new UnsupportedOperationException("Unimplemented method 'getAllIncomingWebhooks'");
+    }
+
+    @Override
+    public CompletableFuture<List<IncomingWebhook>> getIncomingWebhooks() {
+        
+        throw new UnsupportedOperationException("Unimplemented method 'getIncomingWebhooks'");
+    }
+
+    @Override
+    public boolean canWrite(User user) {
+        
+        throw new UnsupportedOperationException("Unimplemented method 'canWrite'");
+    }
+
+    @Override
+    public boolean canUseExternalEmojis(User user) {
+        
+        throw new UnsupportedOperationException("Unimplemented method 'canUseExternalEmojis'");
+    }
+
+    @Override
+    public boolean canEmbedLinks(User user) {
+        
+        throw new UnsupportedOperationException("Unimplemented method 'canEmbedLinks'");
+    }
+
+    @Override
+    public boolean canReadMessageHistory(User user) {
+        
+        throw new UnsupportedOperationException("Unimplemented method 'canReadMessageHistory'");
+    }
+
+    @Override
+    public boolean canUseTts(User user) {
+        
+        throw new UnsupportedOperationException("Unimplemented method 'canUseTts'");
+    }
+
+    @Override
+    public boolean canAttachFiles(User user) {
+        
+        throw new UnsupportedOperationException("Unimplemented method 'canAttachFiles'");
+    }
+
+    @Override
+    public boolean canAddNewReactions(User user) {
+        
+        throw new UnsupportedOperationException("Unimplemented method 'canAddNewReactions'");
+    }
+
+    @Override
+    public boolean canManageMessages(User user) {
+        
+        throw new UnsupportedOperationException("Unimplemented method 'canManageMessages'");
+    }
+
+    @Override
+    public boolean canMentionEveryone(User user) {
+        
+        throw new UnsupportedOperationException("Unimplemented method 'canMentionEveryone'");
+    }
+    
+}

wrapper/javacord/src/test/java/net/tomatentum/marinara/test/mocks/DiscordApiMock.java

@@ -0,0 +1,605 @@
+package net.tomatentum.marinara.test.mocks;
+
+import java.time.Duration;
+import java.util.Collection;
+import java.util.List;
+import java.util.Map;
+import java.util.Optional;
+import java.util.Set;
+import java.util.concurrent.CompletableFuture;
+import java.util.function.Function;
+
+import org.javacord.api.DiscordApi;
+import org.javacord.api.entity.ApplicationInfo;
+import org.javacord.api.entity.activity.Activity;
+import org.javacord.api.entity.activity.ActivityType;
+import org.javacord.api.entity.channel.Channel;
+import org.javacord.api.entity.channel.ChannelCategory;
+import org.javacord.api.entity.channel.PrivateChannel;
+import org.javacord.api.entity.channel.RegularServerChannel;
+import org.javacord.api.entity.channel.ServerChannel;
+import org.javacord.api.entity.channel.ServerForumChannel;
+import org.javacord.api.entity.channel.ServerStageVoiceChannel;
+import org.javacord.api.entity.channel.ServerTextChannel;
+import org.javacord.api.entity.channel.ServerThreadChannel;
+import org.javacord.api.entity.channel.ServerVoiceChannel;
+import org.javacord.api.entity.channel.TextChannel;
+import org.javacord.api.entity.channel.VoiceChannel;
+import org.javacord.api.entity.emoji.CustomEmoji;
+import org.javacord.api.entity.emoji.KnownCustomEmoji;
+import org.javacord.api.entity.intent.Intent;
+import org.javacord.api.entity.message.Message;
+import org.javacord.api.entity.message.MessageSet;
+import org.javacord.api.entity.message.UncachedMessageUtil;
+import org.javacord.api.entity.server.Server;
+import org.javacord.api.entity.server.invite.Invite;
+import org.javacord.api.entity.sticker.Sticker;
+import org.javacord.api.entity.sticker.StickerPack;
+import org.javacord.api.entity.user.User;
+import org.javacord.api.entity.user.UserStatus;
+import org.javacord.api.entity.webhook.IncomingWebhook;
+import org.javacord.api.entity.webhook.Webhook;
+import org.javacord.api.interaction.ApplicationCommand;
+import org.javacord.api.interaction.ApplicationCommandBuilder;
+import org.javacord.api.interaction.MessageContextMenu;
+import org.javacord.api.interaction.ServerApplicationCommandPermissions;
+import org.javacord.api.interaction.SlashCommand;
+import org.javacord.api.interaction.UserContextMenu;
+import org.javacord.api.listener.GloballyAttachableListener;
+import org.javacord.api.util.concurrent.ThreadPool;
+import org.javacord.api.util.event.ListenerManager;
+import org.javacord.api.util.ratelimit.Ratelimiter;
+
+public class DiscordApiMock implements DiscordApi{
+
+    @Override
+    public <T extends GloballyAttachableListener> ListenerManager<T> addListener(Class<T> listenerClass, T listener) {
+        return null;
+    }
+
+    @Override
+    public Collection<ListenerManager<? extends GloballyAttachableListener>> addListener(
+            GloballyAttachableListener listener) {
+        return null;
+    }
+
+    @Override
+    public void removeListener(GloballyAttachableListener listener) {
+        
+        throw new UnsupportedOperationException("Unimplemented method 'removeListener'");
+    }
+
+    @Override
+    public <T extends GloballyAttachableListener> void removeListener(Class<T> listenerClass, T listener) {
+        
+        throw new UnsupportedOperationException("Unimplemented method 'removeListener'");
+    }
+
+    @Override
+    public <T extends GloballyAttachableListener> Map<T, List<Class<T>>> getListeners() {
+        
+        throw new UnsupportedOperationException("Unimplemented method 'getListeners'");
+    }
+
+    @Override
+    public <T extends GloballyAttachableListener> List<T> getListeners(Class<T> listenerClass) {
+        
+        throw new UnsupportedOperationException("Unimplemented method 'getListeners'");
+    }
+
+    @Override
+    public String getToken() {
+        
+        throw new UnsupportedOperationException("Unimplemented method 'getToken'");
+    }
+
+    @Override
+    public String getPrefixedToken() {
+        
+        throw new UnsupportedOperationException("Unimplemented method 'getPrefixedToken'");
+    }
+
+    @Override
+    public Set<Intent> getIntents() {
+        
+        throw new UnsupportedOperationException("Unimplemented method 'getIntents'");
+    }
+
+    @Override
+    public ThreadPool getThreadPool() {
+        
+        throw new UnsupportedOperationException("Unimplemented method 'getThreadPool'");
+    }
+
+    @Override
+    public void setEventsDispatchable(boolean dispatchEvents) {
+        
+        throw new UnsupportedOperationException("Unimplemented method 'setEventsDispatchable'");
+    }
+
+    @Override
+    public boolean canDispatchEvents() {
+        
+        throw new UnsupportedOperationException("Unimplemented method 'canDispatchEvents'");
+    }
+
+    @Override
+    public CompletableFuture<Set<ApplicationCommand>> getGlobalApplicationCommands() {
+        
+        throw new UnsupportedOperationException("Unimplemented method 'getGlobalApplicationCommands'");
+    }
+
+    @Override
+    public CompletableFuture<ApplicationCommand> getGlobalApplicationCommandById(long applicationCommandId) {
+        
+        throw new UnsupportedOperationException("Unimplemented method 'getGlobalApplicationCommandById'");
+    }
+
+    @Override
+    public CompletableFuture<Set<ApplicationCommand>> getServerApplicationCommands(Server server) {
+        
+        throw new UnsupportedOperationException("Unimplemented method 'getServerApplicationCommands'");
+    }
+
+    @Override
+    public CompletableFuture<ApplicationCommand> getServerApplicationCommandById(Server server,
+            long applicationCommandId) {
+        
+        throw new UnsupportedOperationException("Unimplemented method 'getServerApplicationCommandById'");
+    }
+
+    @Override
+    public CompletableFuture<Set<SlashCommand>> getGlobalSlashCommands() {
+        
+        throw new UnsupportedOperationException("Unimplemented method 'getGlobalSlashCommands'");
+    }
+
+    @Override
+    public CompletableFuture<SlashCommand> getGlobalSlashCommandById(long commandId) {
+        
+        throw new UnsupportedOperationException("Unimplemented method 'getGlobalSlashCommandById'");
+    }
+
+    @Override
+    public CompletableFuture<Set<SlashCommand>> getServerSlashCommands(Server server) {
+        
+        throw new UnsupportedOperationException("Unimplemented method 'getServerSlashCommands'");
+    }
+
+    @Override
+    public CompletableFuture<SlashCommand> getServerSlashCommandById(Server server, long commandId) {
+        
+        throw new UnsupportedOperationException("Unimplemented method 'getServerSlashCommandById'");
+    }
+
+    @Override
+    public CompletableFuture<Set<UserContextMenu>> getGlobalUserContextMenus() {
+        
+        throw new UnsupportedOperationException("Unimplemented method 'getGlobalUserContextMenus'");
+    }
+
+    @Override
+    public CompletableFuture<UserContextMenu> getGlobalUserContextMenuById(long commandId) {
+        
+        throw new UnsupportedOperationException("Unimplemented method 'getGlobalUserContextMenuById'");
+    }
+
+    @Override
+    public CompletableFuture<Set<UserContextMenu>> getServerUserContextMenus(Server server) {
+        
+        throw new UnsupportedOperationException("Unimplemented method 'getServerUserContextMenus'");
+    }
+
+    @Override
+    public CompletableFuture<UserContextMenu> getServerUserContextMenuById(Server server, long commandId) {
+        
+        throw new UnsupportedOperationException("Unimplemented method 'getServerUserContextMenuById'");
+    }
+
+    @Override
+    public CompletableFuture<Set<MessageContextMenu>> getGlobalMessageContextMenus() {
+        
+        throw new UnsupportedOperationException("Unimplemented method 'getGlobalMessageContextMenus'");
+    }
+
+    @Override
+    public CompletableFuture<MessageContextMenu> getGlobalMessageContextMenuById(long commandId) {
+        
+        throw new UnsupportedOperationException("Unimplemented method 'getGlobalMessageContextMenuById'");
+    }
+
+    @Override
+    public CompletableFuture<Set<MessageContextMenu>> getServerMessageContextMenus(Server server) {
+        
+        throw new UnsupportedOperationException("Unimplemented method 'getServerMessageContextMenus'");
+    }
+
+    @Override
+    public CompletableFuture<MessageContextMenu> getServerMessageContextMenuById(Server server, long commandId) {
+        
+        throw new UnsupportedOperationException("Unimplemented method 'getServerMessageContextMenuById'");
+    }
+
+    @Override
+    public CompletableFuture<Set<ServerApplicationCommandPermissions>> getServerApplicationCommandPermissions(
+            Server server) {
+        
+        throw new UnsupportedOperationException("Unimplemented method 'getServerApplicationCommandPermissions'");
+    }
+
+    @Override
+    public CompletableFuture<ServerApplicationCommandPermissions> getServerApplicationCommandPermissionsById(
+            Server server, long commandId) {
+        
+        throw new UnsupportedOperationException("Unimplemented method 'getServerApplicationCommandPermissionsById'");
+    }
+
+    @Override
+    public CompletableFuture<Set<ApplicationCommand>> bulkOverwriteGlobalApplicationCommands(
+            Set<? extends ApplicationCommandBuilder<?, ?, ?>> applicationCommandBuilderList) {
+        
+        throw new UnsupportedOperationException("Unimplemented method 'bulkOverwriteGlobalApplicationCommands'");
+    }
+
+    @Override
+    public CompletableFuture<Set<ApplicationCommand>> bulkOverwriteServerApplicationCommands(long server,
+            Set<? extends ApplicationCommandBuilder<?, ?, ?>> applicationCommandBuilderList) {
+        
+        throw new UnsupportedOperationException("Unimplemented method 'bulkOverwriteServerApplicationCommands'");
+    }
+
+    @Override
+    public UncachedMessageUtil getUncachedMessageUtil() {
+        
+        throw new UnsupportedOperationException("Unimplemented method 'getUncachedMessageUtil'");
+    }
+
+    @Override
+    public Optional<Ratelimiter> getGlobalRatelimiter() {
+        
+        throw new UnsupportedOperationException("Unimplemented method 'getGlobalRatelimiter'");
+    }
+
+    @Override
+    public Ratelimiter getGatewayIdentifyRatelimiter() {
+        
+        throw new UnsupportedOperationException("Unimplemented method 'getGatewayIdentifyRatelimiter'");
+    }
+
+    @Override
+    public Duration getLatestGatewayLatency() {
+        
+        throw new UnsupportedOperationException("Unimplemented method 'getLatestGatewayLatency'");
+    }
+
+    @Override
+    public CompletableFuture<Duration> measureRestLatency() {
+        
+        throw new UnsupportedOperationException("Unimplemented method 'measureRestLatency'");
+    }
+
+    @Override
+    public void setMessageCacheSize(int capacity, int storageTimeInSeconds) {
+        
+        throw new UnsupportedOperationException("Unimplemented method 'setMessageCacheSize'");
+    }
+
+    @Override
+    public int getDefaultMessageCacheCapacity() {
+        
+        throw new UnsupportedOperationException("Unimplemented method 'getDefaultMessageCacheCapacity'");
+    }
+
+    @Override
+    public int getDefaultMessageCacheStorageTimeInSeconds() {
+        
+        throw new UnsupportedOperationException("Unimplemented method 'getDefaultMessageCacheStorageTimeInSeconds'");
+    }
+
+    @Override
+    public void setAutomaticMessageCacheCleanupEnabled(boolean automaticMessageCacheCleanupEnabled) {
+        
+        throw new UnsupportedOperationException("Unimplemented method 'setAutomaticMessageCacheCleanupEnabled'");
+    }
+
+    @Override
+    public boolean isDefaultAutomaticMessageCacheCleanupEnabled() {
+        
+        throw new UnsupportedOperationException("Unimplemented method 'isDefaultAutomaticMessageCacheCleanupEnabled'");
+    }
+
+    @Override
+    public int getCurrentShard() {
+        
+        throw new UnsupportedOperationException("Unimplemented method 'getCurrentShard'");
+    }
+
+    @Override
+    public int getTotalShards() {
+        
+        throw new UnsupportedOperationException("Unimplemented method 'getTotalShards'");
+    }
+
+    @Override
+    public boolean isWaitingForServersOnStartup() {
+        
+        throw new UnsupportedOperationException("Unimplemented method 'isWaitingForServersOnStartup'");
+    }
+
+    @Override
+    public boolean isWaitingForUsersOnStartup() {
+        
+        throw new UnsupportedOperationException("Unimplemented method 'isWaitingForUsersOnStartup'");
+    }
+
+    @Override
+    public void updateStatus(UserStatus status) {
+        
+        throw new UnsupportedOperationException("Unimplemented method 'updateStatus'");
+    }
+
+    @Override
+    public UserStatus getStatus() {
+        
+        throw new UnsupportedOperationException("Unimplemented method 'getStatus'");
+    }
+
+    @Override
+    public void updateActivity(String name) {
+        
+        throw new UnsupportedOperationException("Unimplemented method 'updateActivity'");
+    }
+
+    @Override
+    public void updateActivity(ActivityType type, String name) {
+        
+        throw new UnsupportedOperationException("Unimplemented method 'updateActivity'");
+    }
+
+    @Override
+    public void updateActivity(String name, String streamingUrl) {
+        
+        throw new UnsupportedOperationException("Unimplemented method 'updateActivity'");
+    }
+
+    @Override
+    public void unsetActivity() {
+        
+        throw new UnsupportedOperationException("Unimplemented method 'unsetActivity'");
+    }
+
+    @Override
+    public Optional<Activity> getActivity() {
+        
+        throw new UnsupportedOperationException("Unimplemented method 'getActivity'");
+    }
+
+    @Override
+    public User getYourself() {
+        
+        throw new UnsupportedOperationException("Unimplemented method 'getYourself'");
+    }
+
+    @Override
+    public CompletableFuture<Void> disconnect() {
+        
+        throw new UnsupportedOperationException("Unimplemented method 'disconnect'");
+    }
+
+    @Override
+    public void setReconnectDelay(Function<Integer, Integer> reconnectDelayProvider) {
+        
+        throw new UnsupportedOperationException("Unimplemented method 'setReconnectDelay'");
+    }
+
+    @Override
+    public int getReconnectDelay(int attempt) {
+        
+        throw new UnsupportedOperationException("Unimplemented method 'getReconnectDelay'");
+    }
+
+    @Override
+    public ApplicationInfo getCachedApplicationInfo() {
+        
+        throw new UnsupportedOperationException("Unimplemented method 'getCachedApplicationInfo'");
+    }
+
+    @Override
+    public CompletableFuture<ApplicationInfo> requestApplicationInfo() {
+        
+        throw new UnsupportedOperationException("Unimplemented method 'requestApplicationInfo'");
+    }
+
+    @Override
+    public CompletableFuture<Webhook> getWebhookById(long id) {
+        
+        throw new UnsupportedOperationException("Unimplemented method 'getWebhookById'");
+    }
+
+    @Override
+    public CompletableFuture<IncomingWebhook> getIncomingWebhookByIdAndToken(String id, String token) {
+        
+        throw new UnsupportedOperationException("Unimplemented method 'getIncomingWebhookByIdAndToken'");
+    }
+
+    @Override
+    public Set<Long> getUnavailableServers() {
+        
+        throw new UnsupportedOperationException("Unimplemented method 'getUnavailableServers'");
+    }
+
+    @Override
+    public CompletableFuture<Invite> getInviteByCode(String code) {
+        
+        throw new UnsupportedOperationException("Unimplemented method 'getInviteByCode'");
+    }
+
+    @Override
+    public CompletableFuture<Invite> getInviteWithMemberCountsByCode(String code) {
+        
+        throw new UnsupportedOperationException("Unimplemented method 'getInviteWithMemberCountsByCode'");
+    }
+
+    @Override
+    public boolean isUserCacheEnabled() {
+        
+        throw new UnsupportedOperationException("Unimplemented method 'isUserCacheEnabled'");
+    }
+
+    @Override
+    public Set<User> getCachedUsers() {
+        
+        throw new UnsupportedOperationException("Unimplemented method 'getCachedUsers'");
+    }
+
+    @Override
+    public Optional<User> getCachedUserById(long id) {
+        
+        throw new UnsupportedOperationException("Unimplemented method 'getCachedUserById'");
+    }
+
+    @Override
+    public CompletableFuture<User> getUserById(long id) {
+        
+        throw new UnsupportedOperationException("Unimplemented method 'getUserById'");
+    }
+
+    @Override
+    public MessageSet getCachedMessages() {
+        
+        throw new UnsupportedOperationException("Unimplemented method 'getCachedMessages'");
+    }
+
+    @Override
+    public Optional<Message> getCachedMessageById(long id) {
+        
+        throw new UnsupportedOperationException("Unimplemented method 'getCachedMessageById'");
+    }
+
+    @Override
+    public Set<Server> getServers() {
+        
+        throw new UnsupportedOperationException("Unimplemented method 'getServers'");
+    }
+
+    @Override
+    public Set<KnownCustomEmoji> getCustomEmojis() {
+        
+        throw new UnsupportedOperationException("Unimplemented method 'getCustomEmojis'");
+    }
+
+    @Override
+    public CustomEmoji getKnownCustomEmojiOrCreateCustomEmoji(long id, String name, boolean animated) {
+        
+        throw new UnsupportedOperationException("Unimplemented method 'getKnownCustomEmojiOrCreateCustomEmoji'");
+    }
+
+    @Override
+    public CompletableFuture<Set<StickerPack>> getNitroStickerPacks() {
+        
+        throw new UnsupportedOperationException("Unimplemented method 'getNitroStickerPacks'");
+    }
+
+    @Override
+    public Optional<Sticker> getStickerById(long id) {
+        
+        throw new UnsupportedOperationException("Unimplemented method 'getStickerById'");
+    }
+
+    @Override
+    public CompletableFuture<Sticker> requestStickerById(long id) {
+        
+        throw new UnsupportedOperationException("Unimplemented method 'requestStickerById'");
+    }
+
+    @Override
+    public Set<Channel> getChannels() {
+        
+        throw new UnsupportedOperationException("Unimplemented method 'getChannels'");
+    }
+
+    @Override
+    public Set<PrivateChannel> getPrivateChannels() {
+        
+        throw new UnsupportedOperationException("Unimplemented method 'getPrivateChannels'");
+    }
+
+    @Override
+    public Set<ServerChannel> getServerChannels() {
+        
+        throw new UnsupportedOperationException("Unimplemented method 'getServerChannels'");
+    }
+
+    @Override
+    public Set<RegularServerChannel> getRegularServerChannels() {
+        
+        throw new UnsupportedOperationException("Unimplemented method 'getRegularServerChannels'");
+    }
+
+    @Override
+    public Set<ChannelCategory> getChannelCategories() {
+        
+        throw new UnsupportedOperationException("Unimplemented method 'getChannelCategories'");
+    }
+
+    @Override
+    public Set<ServerTextChannel> getServerTextChannels() {
+        
+        throw new UnsupportedOperationException("Unimplemented method 'getServerTextChannels'");
+    }
+
+    @Override
+    public Set<ServerForumChannel> getServerForumChannels() {
+        
+        throw new UnsupportedOperationException("Unimplemented method 'getServerForumChannels'");
+    }
+
+    @Override
+    public Set<ServerThreadChannel> getServerThreadChannels() {
+        
+        throw new UnsupportedOperationException("Unimplemented method 'getServerThreadChannels'");
+    }
+
+    @Override
+    public Set<ServerThreadChannel> getPrivateServerThreadChannels() {
+        
+        throw new UnsupportedOperationException("Unimplemented method 'getPrivateServerThreadChannels'");
+    }
+
+    @Override
+    public Set<ServerThreadChannel> getPublicServerThreadChannels() {
+        
+        throw new UnsupportedOperationException("Unimplemented method 'getPublicServerThreadChannels'");
+    }
+
+    @Override
+    public Set<ServerVoiceChannel> getServerVoiceChannels() {
+        
+        throw new UnsupportedOperationException("Unimplemented method 'getServerVoiceChannels'");
+    }
+
+    @Override
+    public Set<ServerStageVoiceChannel> getServerStageVoiceChannels() {
+        
+        throw new UnsupportedOperationException("Unimplemented method 'getServerStageVoiceChannels'");
+    }
+
+    @Override
+    public Set<TextChannel> getTextChannels() {
+        
+        throw new UnsupportedOperationException("Unimplemented method 'getTextChannels'");
+    }
+
+    @Override
+    public Set<VoiceChannel> getVoiceChannels() {
+        
+        throw new UnsupportedOperationException("Unimplemented method 'getVoiceChannels'");
+    }
+
+    @Override
+    public Optional<Channel> getChannelById(long id) {
+        
+        throw new UnsupportedOperationException("Unimplemented method 'getChannelById'");
+    }
+    
+}

wrapper/javacord/src/test/java/net/tomatentum/marinara/test/mocks/MessageMock.java

@@ -0,0 +1,443 @@
+package net.tomatentum.marinara.test.mocks;
+
+import java.time.Instant;
+import java.util.Collection;
+import java.util.EnumSet;
+import java.util.List;
+import java.util.Map;
+import java.util.Optional;
+import java.util.Set;
+import java.util.concurrent.CompletableFuture;
+
+import org.javacord.api.DiscordApi;
+import org.javacord.api.entity.channel.TextChannel;
+import org.javacord.api.entity.emoji.CustomEmoji;
+import org.javacord.api.entity.message.Message;
+import org.javacord.api.entity.message.MessageActivity;
+import org.javacord.api.entity.message.MessageAttachment;
+import org.javacord.api.entity.message.MessageAuthor;
+import org.javacord.api.entity.message.MessageFlag;
+import org.javacord.api.entity.message.MessageReference;
+import org.javacord.api.entity.message.MessageType;
+import org.javacord.api.entity.message.Reaction;
+import org.javacord.api.entity.message.component.HighLevelComponent;
+import org.javacord.api.entity.message.embed.Embed;
+import org.javacord.api.entity.permission.Role;
+import org.javacord.api.entity.sticker.StickerItem;
+import org.javacord.api.entity.user.User;
+import org.javacord.api.interaction.MessageInteraction;
+import org.javacord.api.listener.ObjectAttachableListener;
+import org.javacord.api.listener.interaction.ButtonClickListener;
+import org.javacord.api.listener.interaction.MessageComponentCreateListener;
+import org.javacord.api.listener.interaction.MessageContextMenuCommandListener;
+import org.javacord.api.listener.interaction.SelectMenuChooseListener;
+import org.javacord.api.listener.message.CachedMessagePinListener;
+import org.javacord.api.listener.message.CachedMessageUnpinListener;
+import org.javacord.api.listener.message.MessageAttachableListener;
+import org.javacord.api.listener.message.MessageDeleteListener;
+import org.javacord.api.listener.message.MessageEditListener;
+import org.javacord.api.listener.message.MessageReplyListener;
+import org.javacord.api.listener.message.reaction.ReactionAddListener;
+import org.javacord.api.listener.message.reaction.ReactionRemoveAllListener;
+import org.javacord.api.listener.message.reaction.ReactionRemoveListener;
+import org.javacord.api.util.event.ListenerManager;
+
+public class MessageMock implements Message{
+
+    @Override
+    public DiscordApi getApi() {
+        
+        throw new UnsupportedOperationException("Unimplemented method 'getApi'");
+    }
+
+    @Override
+    public long getId() {
+        
+        throw new UnsupportedOperationException("Unimplemented method 'getId'");
+    }
+
+    @Override
+    public int compareTo(Message arg0) {
+        
+        throw new UnsupportedOperationException("Unimplemented method 'compareTo'");
+    }
+
+    @Override
+    public ListenerManager<MessageContextMenuCommandListener> addMessageContextMenuCommandListener(
+            MessageContextMenuCommandListener listener) {
+        
+        throw new UnsupportedOperationException("Unimplemented method 'addMessageContextMenuCommandListener'");
+    }
+
+    @Override
+    public List<MessageContextMenuCommandListener> getMessageContextMenuCommandListeners() {
+        
+        throw new UnsupportedOperationException("Unimplemented method 'getMessageContextMenuCommandListeners'");
+    }
+
+    @Override
+    public ListenerManager<MessageComponentCreateListener> addMessageComponentCreateListener(
+            MessageComponentCreateListener listener) {
+        
+        throw new UnsupportedOperationException("Unimplemented method 'addMessageComponentCreateListener'");
+    }
+
+    @Override
+    public List<MessageComponentCreateListener> getMessageComponentCreateListeners() {
+        
+        throw new UnsupportedOperationException("Unimplemented method 'getMessageComponentCreateListeners'");
+    }
+
+    @Override
+    public ListenerManager<SelectMenuChooseListener> addSelectMenuChooseListener(SelectMenuChooseListener listener) {
+        
+        throw new UnsupportedOperationException("Unimplemented method 'addSelectMenuChooseListener'");
+    }
+
+    @Override
+    public List<SelectMenuChooseListener> getSelectMenuChooseListeners() {
+        
+        throw new UnsupportedOperationException("Unimplemented method 'getSelectMenuChooseListeners'");
+    }
+
+    @Override
+    public ListenerManager<ButtonClickListener> addButtonClickListener(ButtonClickListener listener) {
+        
+        throw new UnsupportedOperationException("Unimplemented method 'addButtonClickListener'");
+    }
+
+    @Override
+    public List<ButtonClickListener> getButtonClickListeners() {
+        
+        throw new UnsupportedOperationException("Unimplemented method 'getButtonClickListeners'");
+    }
+
+    @Override
+    public ListenerManager<MessageEditListener> addMessageEditListener(MessageEditListener listener) {
+        
+        throw new UnsupportedOperationException("Unimplemented method 'addMessageEditListener'");
+    }
+
+    @Override
+    public List<MessageEditListener> getMessageEditListeners() {
+        
+        throw new UnsupportedOperationException("Unimplemented method 'getMessageEditListeners'");
+    }
+
+    @Override
+    public ListenerManager<ReactionRemoveListener> addReactionRemoveListener(ReactionRemoveListener listener) {
+        
+        throw new UnsupportedOperationException("Unimplemented method 'addReactionRemoveListener'");
+    }
+
+    @Override
+    public List<ReactionRemoveListener> getReactionRemoveListeners() {
+        
+        throw new UnsupportedOperationException("Unimplemented method 'getReactionRemoveListeners'");
+    }
+
+    @Override
+    public ListenerManager<ReactionAddListener> addReactionAddListener(ReactionAddListener listener) {
+        
+        throw new UnsupportedOperationException("Unimplemented method 'addReactionAddListener'");
+    }
+
+    @Override
+    public List<ReactionAddListener> getReactionAddListeners() {
+        
+        throw new UnsupportedOperationException("Unimplemented method 'getReactionAddListeners'");
+    }
+
+    @Override
+    public ListenerManager<ReactionRemoveAllListener> addReactionRemoveAllListener(ReactionRemoveAllListener listener) {
+        
+        throw new UnsupportedOperationException("Unimplemented method 'addReactionRemoveAllListener'");
+    }
+
+    @Override
+    public List<ReactionRemoveAllListener> getReactionRemoveAllListeners() {
+        
+        throw new UnsupportedOperationException("Unimplemented method 'getReactionRemoveAllListeners'");
+    }
+
+    @Override
+    public ListenerManager<CachedMessageUnpinListener> addCachedMessageUnpinListener(
+            CachedMessageUnpinListener listener) {
+        
+        throw new UnsupportedOperationException("Unimplemented method 'addCachedMessageUnpinListener'");
+    }
+
+    @Override
+    public List<CachedMessageUnpinListener> getCachedMessageUnpinListeners() {
+        
+        throw new UnsupportedOperationException("Unimplemented method 'getCachedMessageUnpinListeners'");
+    }
+
+    @Override
+    public ListenerManager<CachedMessagePinListener> addCachedMessagePinListener(CachedMessagePinListener listener) {
+        
+        throw new UnsupportedOperationException("Unimplemented method 'addCachedMessagePinListener'");
+    }
+
+    @Override
+    public List<CachedMessagePinListener> getCachedMessagePinListeners() {
+        
+        throw new UnsupportedOperationException("Unimplemented method 'getCachedMessagePinListeners'");
+    }
+
+    @Override
+    public ListenerManager<MessageReplyListener> addMessageReplyListener(MessageReplyListener listener) {
+        
+        throw new UnsupportedOperationException("Unimplemented method 'addMessageReplyListener'");
+    }
+
+    @Override
+    public List<MessageReplyListener> getMessageReplyListeners() {
+        
+        throw new UnsupportedOperationException("Unimplemented method 'getMessageReplyListeners'");
+    }
+
+    @Override
+    public ListenerManager<MessageDeleteListener> addMessageDeleteListener(MessageDeleteListener listener) {
+        
+        throw new UnsupportedOperationException("Unimplemented method 'addMessageDeleteListener'");
+    }
+
+    @Override
+    public List<MessageDeleteListener> getMessageDeleteListeners() {
+        
+        throw new UnsupportedOperationException("Unimplemented method 'getMessageDeleteListeners'");
+    }
+
+    @Override
+    public <T extends MessageAttachableListener & ObjectAttachableListener> Collection<ListenerManager<T>> addMessageAttachableListener(
+            T listener) {
+        
+        throw new UnsupportedOperationException("Unimplemented method 'addMessageAttachableListener'");
+    }
+
+    @Override
+    public <T extends MessageAttachableListener & ObjectAttachableListener> void removeMessageAttachableListener(
+            T listener) {
+        
+        throw new UnsupportedOperationException("Unimplemented method 'removeMessageAttachableListener'");
+    }
+
+    @Override
+    public <T extends MessageAttachableListener & ObjectAttachableListener> Map<T, List<Class<T>>> getMessageAttachableListeners() {
+        
+        throw new UnsupportedOperationException("Unimplemented method 'getMessageAttachableListeners'");
+    }
+
+    @Override
+    public <T extends MessageAttachableListener & ObjectAttachableListener> void removeListener(Class<T> listenerClass,
+            T listener) {
+        
+        throw new UnsupportedOperationException("Unimplemented method 'removeListener'");
+    }
+
+    @Override
+    public boolean canYouReadContent() {
+        
+        throw new UnsupportedOperationException("Unimplemented method 'canYouReadContent'");
+    }
+
+    @Override
+    public String getContent() {
+        
+        throw new UnsupportedOperationException("Unimplemented method 'getContent'");
+    }
+
+    @Override
+    public Optional<Instant> getLastEditTimestamp() {
+        
+        throw new UnsupportedOperationException("Unimplemented method 'getLastEditTimestamp'");
+    }
+
+    @Override
+    public List<MessageAttachment> getAttachments() {
+        
+        throw new UnsupportedOperationException("Unimplemented method 'getAttachments'");
+    }
+
+    @Override
+    public List<CustomEmoji> getCustomEmojis() {
+        
+        throw new UnsupportedOperationException("Unimplemented method 'getCustomEmojis'");
+    }
+
+    @Override
+    public MessageType getType() {
+        
+        throw new UnsupportedOperationException("Unimplemented method 'getType'");
+    }
+
+    @Override
+    public TextChannel getChannel() {
+        
+        throw new UnsupportedOperationException("Unimplemented method 'getChannel'");
+    }
+
+    @Override
+    public Optional<MessageActivity> getActivity() {
+        
+        throw new UnsupportedOperationException("Unimplemented method 'getActivity'");
+    }
+
+    @Override
+    public EnumSet<MessageFlag> getFlags() {
+        
+        throw new UnsupportedOperationException("Unimplemented method 'getFlags'");
+    }
+
+    @Override
+    public boolean isPinned() {
+        
+        throw new UnsupportedOperationException("Unimplemented method 'isPinned'");
+    }
+
+    @Override
+    public boolean isTts() {
+        
+        throw new UnsupportedOperationException("Unimplemented method 'isTts'");
+    }
+
+    @Override
+    public boolean mentionsEveryone() {
+        
+        throw new UnsupportedOperationException("Unimplemented method 'mentionsEveryone'");
+    }
+
+    @Override
+    public List<Embed> getEmbeds() {
+        
+        throw new UnsupportedOperationException("Unimplemented method 'getEmbeds'");
+    }
+
+    @Override
+    public Optional<User> getUserAuthor() {
+        
+        throw new UnsupportedOperationException("Unimplemented method 'getUserAuthor'");
+    }
+
+    @Override
+    public MessageAuthor getAuthor() {
+        
+        throw new UnsupportedOperationException("Unimplemented method 'getAuthor'");
+    }
+
+    @Override
+    public Optional<MessageReference> getMessageReference() {
+        
+        throw new UnsupportedOperationException("Unimplemented method 'getMessageReference'");
+    }
+
+    @Override
+    public Optional<Message> getReferencedMessage() {
+        
+        throw new UnsupportedOperationException("Unimplemented method 'getReferencedMessage'");
+    }
+
+    @Override
+    public boolean isCachedForever() {
+        
+        throw new UnsupportedOperationException("Unimplemented method 'isCachedForever'");
+    }
+
+    @Override
+    public void setCachedForever(boolean cachedForever) {
+        
+        throw new UnsupportedOperationException("Unimplemented method 'setCachedForever'");
+    }
+
+    @Override
+    public List<Reaction> getReactions() {
+        
+        throw new UnsupportedOperationException("Unimplemented method 'getReactions'");
+    }
+
+    @Override
+    public Optional<MessageInteraction> getMessageInteraction() {
+        
+        throw new UnsupportedOperationException("Unimplemented method 'getMessageInteraction'");
+    }
+
+    @Override
+    public List<HighLevelComponent> getComponents() {
+        
+        throw new UnsupportedOperationException("Unimplemented method 'getComponents'");
+    }
+
+    @Override
+    public List<User> getMentionedUsers() {
+        
+        throw new UnsupportedOperationException("Unimplemented method 'getMentionedUsers'");
+    }
+
+    @Override
+    public List<Role> getMentionedRoles() {
+        
+        throw new UnsupportedOperationException("Unimplemented method 'getMentionedRoles'");
+    }
+
+    @Override
+    public Optional<String> getNonce() {
+        
+        throw new UnsupportedOperationException("Unimplemented method 'getNonce'");
+    }
+
+    @Override
+    public Set<StickerItem> getStickerItems() {
+        
+        throw new UnsupportedOperationException("Unimplemented method 'getStickerItems'");
+    }
+
+    @Override
+    public Optional<Integer> getPosition() {
+        
+        throw new UnsupportedOperationException("Unimplemented method 'getPosition'");
+    }
+
+    @Override
+    public CompletableFuture<Void> addReactions(String... unicodeEmojis) {
+        
+        throw new UnsupportedOperationException("Unimplemented method 'addReactions'");
+    }
+
+    @Override
+    public CompletableFuture<Void> removeReactionByEmoji(User user, String unicodeEmoji) {
+        
+        throw new UnsupportedOperationException("Unimplemented method 'removeReactionByEmoji'");
+    }
+
+    @Override
+    public CompletableFuture<Void> removeReactionByEmoji(String unicodeEmoji) {
+        
+        throw new UnsupportedOperationException("Unimplemented method 'removeReactionByEmoji'");
+    }
+
+    @Override
+    public CompletableFuture<Void> removeReactionsByEmoji(User user, String... unicodeEmojis) {
+        
+        throw new UnsupportedOperationException("Unimplemented method 'removeReactionsByEmoji'");
+    }
+
+    @Override
+    public CompletableFuture<Void> removeReactionsByEmoji(String... unicodeEmojis) {
+        
+        throw new UnsupportedOperationException("Unimplemented method 'removeReactionsByEmoji'");
+    }
+
+    @Override
+    public CompletableFuture<Void> removeOwnReactionByEmoji(String unicodeEmoji) {
+        
+        throw new UnsupportedOperationException("Unimplemented method 'removeOwnReactionByEmoji'");
+    }
+
+    @Override
+    public CompletableFuture<Void> removeOwnReactionsByEmoji(String... unicodeEmojis) {
+        
+        throw new UnsupportedOperationException("Unimplemented method 'removeOwnReactionsByEmoji'");
+    }
+    
+}

wrapper/javacord/src/test/java/net/tomatentum/marinara/test/mocks/SlashCommandInteractionMock.java

@@ -1,7 +1,6 @@
 package net.tomatentum.marinara.test.mocks;
 
 import java.util.Arrays;
-import java.util.Collections;
 import java.util.EnumSet;
 import java.util.List;
 import java.util.Optional;

wrapper/javacord/src/test/java/net/tomatentum/marinara/test/mocks/UserMock.java

@@ -0,0 +1,752 @@
+package net.tomatentum.marinara.test.mocks;
+
+import java.awt.Color;
+import java.time.Instant;
+import java.util.Collection;
+import java.util.EnumSet;
+import java.util.List;
+import java.util.Map;
+import java.util.Optional;
+import java.util.Set;
+import java.util.concurrent.CompletableFuture;
+
+import org.javacord.api.DiscordApi;
+import org.javacord.api.entity.DiscordClient;
+import org.javacord.api.entity.Icon;
+import org.javacord.api.entity.activity.Activity;
+import org.javacord.api.entity.channel.PrivateChannel;
+import org.javacord.api.entity.permission.Role;
+import org.javacord.api.entity.server.Server;
+import org.javacord.api.entity.user.User;
+import org.javacord.api.entity.user.UserFlag;
+import org.javacord.api.entity.user.UserStatus;
+import org.javacord.api.listener.ObjectAttachableListener;
+import org.javacord.api.listener.channel.server.ServerChannelChangeOverwrittenPermissionsListener;
+import org.javacord.api.listener.channel.server.voice.ServerVoiceChannelMemberJoinListener;
+import org.javacord.api.listener.channel.server.voice.ServerVoiceChannelMemberLeaveListener;
+import org.javacord.api.listener.channel.user.PrivateChannelCreateListener;
+import org.javacord.api.listener.channel.user.PrivateChannelDeleteListener;
+import org.javacord.api.listener.interaction.AutocompleteCreateListener;
+import org.javacord.api.listener.interaction.ButtonClickListener;
+import org.javacord.api.listener.interaction.InteractionCreateListener;
+import org.javacord.api.listener.interaction.MessageComponentCreateListener;
+import org.javacord.api.listener.interaction.MessageContextMenuCommandListener;
+import org.javacord.api.listener.interaction.ModalSubmitListener;
+import org.javacord.api.listener.interaction.SelectMenuChooseListener;
+import org.javacord.api.listener.interaction.SlashCommandCreateListener;
+import org.javacord.api.listener.interaction.UserContextMenuCommandListener;
+import org.javacord.api.listener.message.MessageCreateListener;
+import org.javacord.api.listener.message.MessageReplyListener;
+import org.javacord.api.listener.message.reaction.ReactionAddListener;
+import org.javacord.api.listener.message.reaction.ReactionRemoveListener;
+import org.javacord.api.listener.server.member.ServerMemberBanListener;
+import org.javacord.api.listener.server.member.ServerMemberJoinListener;
+import org.javacord.api.listener.server.member.ServerMemberLeaveListener;
+import org.javacord.api.listener.server.member.ServerMemberUnbanListener;
+import org.javacord.api.listener.server.role.UserRoleAddListener;
+import org.javacord.api.listener.server.role.UserRoleRemoveListener;
+import org.javacord.api.listener.user.UserAttachableListener;
+import org.javacord.api.listener.user.UserChangeActivityListener;
+import org.javacord.api.listener.user.UserChangeAvatarListener;
+import org.javacord.api.listener.user.UserChangeDeafenedListener;
+import org.javacord.api.listener.user.UserChangeDiscriminatorListener;
+import org.javacord.api.listener.user.UserChangeMutedListener;
+import org.javacord.api.listener.user.UserChangeNameListener;
+import org.javacord.api.listener.user.UserChangeNicknameListener;
+import org.javacord.api.listener.user.UserChangePendingListener;
+import org.javacord.api.listener.user.UserChangeSelfDeafenedListener;
+import org.javacord.api.listener.user.UserChangeSelfMutedListener;
+import org.javacord.api.listener.user.UserChangeServerAvatarListener;
+import org.javacord.api.listener.user.UserChangeStatusListener;
+import org.javacord.api.listener.user.UserChangeTimeoutListener;
+import org.javacord.api.listener.user.UserStartTypingListener;
+import org.javacord.api.util.event.ListenerManager;
+
+public class UserMock implements User {
+
+    @Override
+    public DiscordApi getApi() {
+        
+        throw new UnsupportedOperationException("Unimplemented method 'getApi'");
+    }
+
+    @Override
+    public long getId() {
+        
+        throw new UnsupportedOperationException("Unimplemented method 'getId'");
+    }
+
+    @Override
+    public String getName() {
+        
+        throw new UnsupportedOperationException("Unimplemented method 'getName'");
+    }
+
+    @Override
+    public ListenerManager<InteractionCreateListener> addInteractionCreateListener(InteractionCreateListener listener) {
+        
+        throw new UnsupportedOperationException("Unimplemented method 'addInteractionCreateListener'");
+    }
+
+    @Override
+    public List<InteractionCreateListener> getInteractionCreateListeners() {
+        
+        throw new UnsupportedOperationException("Unimplemented method 'getInteractionCreateListeners'");
+    }
+
+    @Override
+    public ListenerManager<SlashCommandCreateListener> addSlashCommandCreateListener(
+            SlashCommandCreateListener listener) {
+        
+        throw new UnsupportedOperationException("Unimplemented method 'addSlashCommandCreateListener'");
+    }
+
+    @Override
+    public List<SlashCommandCreateListener> getSlashCommandCreateListeners() {
+        
+        throw new UnsupportedOperationException("Unimplemented method 'getSlashCommandCreateListeners'");
+    }
+
+    @Override
+    public ListenerManager<AutocompleteCreateListener> addAutocompleteCreateListener(
+            AutocompleteCreateListener listener) {
+        
+        throw new UnsupportedOperationException("Unimplemented method 'addAutocompleteCreateListener'");
+    }
+
+    @Override
+    public List<AutocompleteCreateListener> getAutocompleteCreateListeners() {
+        
+        throw new UnsupportedOperationException("Unimplemented method 'getAutocompleteCreateListeners'");
+    }
+
+    @Override
+    public ListenerManager<ModalSubmitListener> addModalSubmitListener(ModalSubmitListener listener) {
+        
+        throw new UnsupportedOperationException("Unimplemented method 'addModalSubmitListener'");
+    }
+
+    @Override
+    public List<ModalSubmitListener> getModalSubmitListeners() {
+        
+        throw new UnsupportedOperationException("Unimplemented method 'getModalSubmitListeners'");
+    }
+
+    @Override
+    public ListenerManager<MessageContextMenuCommandListener> addMessageContextMenuCommandListener(
+            MessageContextMenuCommandListener listener) {
+        
+        throw new UnsupportedOperationException("Unimplemented method 'addMessageContextMenuCommandListener'");
+    }
+
+    @Override
+    public List<MessageContextMenuCommandListener> getMessageContextMenuCommandListeners() {
+        
+        throw new UnsupportedOperationException("Unimplemented method 'getMessageContextMenuCommandListeners'");
+    }
+
+    @Override
+    public ListenerManager<MessageComponentCreateListener> addMessageComponentCreateListener(
+            MessageComponentCreateListener listener) {
+        
+        throw new UnsupportedOperationException("Unimplemented method 'addMessageComponentCreateListener'");
+    }
+
+    @Override
+    public List<MessageComponentCreateListener> getMessageComponentCreateListeners() {
+        
+        throw new UnsupportedOperationException("Unimplemented method 'getMessageComponentCreateListeners'");
+    }
+
+    @Override
+    public ListenerManager<UserContextMenuCommandListener> addUserContextMenuCommandListener(
+            UserContextMenuCommandListener listener) {
+        
+        throw new UnsupportedOperationException("Unimplemented method 'addUserContextMenuCommandListener'");
+    }
+
+    @Override
+    public List<UserContextMenuCommandListener> getUserContextMenuCommandListeners() {
+        
+        throw new UnsupportedOperationException("Unimplemented method 'getUserContextMenuCommandListeners'");
+    }
+
+    @Override
+    public ListenerManager<SelectMenuChooseListener> addSelectMenuChooseListener(SelectMenuChooseListener listener) {
+        
+        throw new UnsupportedOperationException("Unimplemented method 'addSelectMenuChooseListener'");
+    }
+
+    @Override
+    public List<SelectMenuChooseListener> getSelectMenuChooseListeners() {
+        
+        throw new UnsupportedOperationException("Unimplemented method 'getSelectMenuChooseListeners'");
+    }
+
+    @Override
+    public ListenerManager<ButtonClickListener> addButtonClickListener(ButtonClickListener listener) {
+        
+        throw new UnsupportedOperationException("Unimplemented method 'addButtonClickListener'");
+    }
+
+    @Override
+    public List<ButtonClickListener> getButtonClickListeners() {
+        
+        throw new UnsupportedOperationException("Unimplemented method 'getButtonClickListeners'");
+    }
+
+    @Override
+    public ListenerManager<ServerMemberJoinListener> addServerMemberJoinListener(ServerMemberJoinListener listener) {
+        
+        throw new UnsupportedOperationException("Unimplemented method 'addServerMemberJoinListener'");
+    }
+
+    @Override
+    public List<ServerMemberJoinListener> getServerMemberJoinListeners() {
+        
+        throw new UnsupportedOperationException("Unimplemented method 'getServerMemberJoinListeners'");
+    }
+
+    @Override
+    public ListenerManager<ServerMemberLeaveListener> addServerMemberLeaveListener(ServerMemberLeaveListener listener) {
+        
+        throw new UnsupportedOperationException("Unimplemented method 'addServerMemberLeaveListener'");
+    }
+
+    @Override
+    public List<ServerMemberLeaveListener> getServerMemberLeaveListeners() {
+        
+        throw new UnsupportedOperationException("Unimplemented method 'getServerMemberLeaveListeners'");
+    }
+
+    @Override
+    public ListenerManager<ServerMemberBanListener> addServerMemberBanListener(ServerMemberBanListener listener) {
+        
+        throw new UnsupportedOperationException("Unimplemented method 'addServerMemberBanListener'");
+    }
+
+    @Override
+    public List<ServerMemberBanListener> getServerMemberBanListeners() {
+        
+        throw new UnsupportedOperationException("Unimplemented method 'getServerMemberBanListeners'");
+    }
+
+    @Override
+    public ListenerManager<ServerMemberUnbanListener> addServerMemberUnbanListener(ServerMemberUnbanListener listener) {
+        
+        throw new UnsupportedOperationException("Unimplemented method 'addServerMemberUnbanListener'");
+    }
+
+    @Override
+    public List<ServerMemberUnbanListener> getServerMemberUnbanListeners() {
+        
+        throw new UnsupportedOperationException("Unimplemented method 'getServerMemberUnbanListeners'");
+    }
+
+    @Override
+    public ListenerManager<UserRoleRemoveListener> addUserRoleRemoveListener(UserRoleRemoveListener listener) {
+        
+        throw new UnsupportedOperationException("Unimplemented method 'addUserRoleRemoveListener'");
+    }
+
+    @Override
+    public List<UserRoleRemoveListener> getUserRoleRemoveListeners() {
+        
+        throw new UnsupportedOperationException("Unimplemented method 'getUserRoleRemoveListeners'");
+    }
+
+    @Override
+    public ListenerManager<UserRoleAddListener> addUserRoleAddListener(UserRoleAddListener listener) {
+        
+        throw new UnsupportedOperationException("Unimplemented method 'addUserRoleAddListener'");
+    }
+
+    @Override
+    public List<UserRoleAddListener> getUserRoleAddListeners() {
+        
+        throw new UnsupportedOperationException("Unimplemented method 'getUserRoleAddListeners'");
+    }
+
+    @Override
+    public ListenerManager<ServerChannelChangeOverwrittenPermissionsListener> addServerChannelChangeOverwrittenPermissionsListener(
+            ServerChannelChangeOverwrittenPermissionsListener listener) {
+        
+        throw new UnsupportedOperationException("Unimplemented method 'addServerChannelChangeOverwrittenPermissionsListener'");
+    }
+
+    @Override
+    public List<ServerChannelChangeOverwrittenPermissionsListener> getServerChannelChangeOverwrittenPermissionsListeners() {
+        
+        throw new UnsupportedOperationException("Unimplemented method 'getServerChannelChangeOverwrittenPermissionsListeners'");
+    }
+
+    @Override
+    public ListenerManager<ServerVoiceChannelMemberLeaveListener> addServerVoiceChannelMemberLeaveListener(
+            ServerVoiceChannelMemberLeaveListener listener) {
+        
+        throw new UnsupportedOperationException("Unimplemented method 'addServerVoiceChannelMemberLeaveListener'");
+    }
+
+    @Override
+    public List<ServerVoiceChannelMemberLeaveListener> getServerVoiceChannelMemberLeaveListeners() {
+        
+        throw new UnsupportedOperationException("Unimplemented method 'getServerVoiceChannelMemberLeaveListeners'");
+    }
+
+    @Override
+    public ListenerManager<ServerVoiceChannelMemberJoinListener> addServerVoiceChannelMemberJoinListener(
+            ServerVoiceChannelMemberJoinListener listener) {
+        
+        throw new UnsupportedOperationException("Unimplemented method 'addServerVoiceChannelMemberJoinListener'");
+    }
+
+    @Override
+    public List<ServerVoiceChannelMemberJoinListener> getServerVoiceChannelMemberJoinListeners() {
+        
+        throw new UnsupportedOperationException("Unimplemented method 'getServerVoiceChannelMemberJoinListeners'");
+    }
+
+    @Override
+    public ListenerManager<PrivateChannelDeleteListener> addPrivateChannelDeleteListener(
+            PrivateChannelDeleteListener listener) {
+        
+        throw new UnsupportedOperationException("Unimplemented method 'addPrivateChannelDeleteListener'");
+    }
+
+    @Override
+    public List<PrivateChannelDeleteListener> getPrivateChannelDeleteListeners() {
+        
+        throw new UnsupportedOperationException("Unimplemented method 'getPrivateChannelDeleteListeners'");
+    }
+
+    @Override
+    public ListenerManager<PrivateChannelCreateListener> addPrivateChannelCreateListener(
+            PrivateChannelCreateListener listener) {
+        
+        throw new UnsupportedOperationException("Unimplemented method 'addPrivateChannelCreateListener'");
+    }
+
+    @Override
+    public List<PrivateChannelCreateListener> getPrivateChannelCreateListeners() {
+        
+        throw new UnsupportedOperationException("Unimplemented method 'getPrivateChannelCreateListeners'");
+    }
+
+    @Override
+    public ListenerManager<UserChangeDeafenedListener> addUserChangeDeafenedListener(
+            UserChangeDeafenedListener listener) {
+        
+        throw new UnsupportedOperationException("Unimplemented method 'addUserChangeDeafenedListener'");
+    }
+
+    @Override
+    public List<UserChangeDeafenedListener> getUserChangeDeafenedListeners() {
+        
+        throw new UnsupportedOperationException("Unimplemented method 'getUserChangeDeafenedListeners'");
+    }
+
+    @Override
+    public ListenerManager<UserChangeNicknameListener> addUserChangeNicknameListener(
+            UserChangeNicknameListener listener) {
+        
+        throw new UnsupportedOperationException("Unimplemented method 'addUserChangeNicknameListener'");
+    }
+
+    @Override
+    public List<UserChangeNicknameListener> getUserChangeNicknameListeners() {
+        
+        throw new UnsupportedOperationException("Unimplemented method 'getUserChangeNicknameListeners'");
+    }
+
+    @Override
+    public ListenerManager<UserChangePendingListener> addUserChangePendingListener(UserChangePendingListener listener) {
+        
+        throw new UnsupportedOperationException("Unimplemented method 'addUserChangePendingListener'");
+    }
+
+    @Override
+    public List<UserChangePendingListener> getUserChangePendingListeners() {
+        
+        throw new UnsupportedOperationException("Unimplemented method 'getUserChangePendingListeners'");
+    }
+
+    @Override
+    public ListenerManager<UserStartTypingListener> addUserStartTypingListener(UserStartTypingListener listener) {
+        
+        throw new UnsupportedOperationException("Unimplemented method 'addUserStartTypingListener'");
+    }
+
+    @Override
+    public List<UserStartTypingListener> getUserStartTypingListeners() {
+        
+        throw new UnsupportedOperationException("Unimplemented method 'getUserStartTypingListeners'");
+    }
+
+    @Override
+    public ListenerManager<UserChangeDiscriminatorListener> addUserChangeDiscriminatorListener(
+            UserChangeDiscriminatorListener listener) {
+        
+        throw new UnsupportedOperationException("Unimplemented method 'addUserChangeDiscriminatorListener'");
+    }
+
+    @Override
+    public List<UserChangeDiscriminatorListener> getUserChangeDiscriminatorListeners() {
+        
+        throw new UnsupportedOperationException("Unimplemented method 'getUserChangeDiscriminatorListeners'");
+    }
+
+    @Override
+    public ListenerManager<UserChangeStatusListener> addUserChangeStatusListener(UserChangeStatusListener listener) {
+        
+        throw new UnsupportedOperationException("Unimplemented method 'addUserChangeStatusListener'");
+    }
+
+    @Override
+    public List<UserChangeStatusListener> getUserChangeStatusListeners() {
+        
+        throw new UnsupportedOperationException("Unimplemented method 'getUserChangeStatusListeners'");
+    }
+
+    @Override
+    public ListenerManager<UserChangeServerAvatarListener> addUserChangeServerAvatarListener(
+            UserChangeServerAvatarListener listener) {
+        
+        throw new UnsupportedOperationException("Unimplemented method 'addUserChangeServerAvatarListener'");
+    }
+
+    @Override
+    public List<UserChangeServerAvatarListener> getUserChangeServerAvatarListeners() {
+        
+        throw new UnsupportedOperationException("Unimplemented method 'getUserChangeServerAvatarListeners'");
+    }
+
+    @Override
+    public ListenerManager<UserChangeSelfMutedListener> addUserChangeSelfMutedListener(
+            UserChangeSelfMutedListener listener) {
+        
+        throw new UnsupportedOperationException("Unimplemented method 'addUserChangeSelfMutedListener'");
+    }
+
+    @Override
+    public List<UserChangeSelfMutedListener> getUserChangeSelfMutedListeners() {
+        
+        throw new UnsupportedOperationException("Unimplemented method 'getUserChangeSelfMutedListeners'");
+    }
+
+    @Override
+    public ListenerManager<UserChangeNameListener> addUserChangeNameListener(UserChangeNameListener listener) {
+        
+        throw new UnsupportedOperationException("Unimplemented method 'addUserChangeNameListener'");
+    }
+
+    @Override
+    public List<UserChangeNameListener> getUserChangeNameListeners() {
+        
+        throw new UnsupportedOperationException("Unimplemented method 'getUserChangeNameListeners'");
+    }
+
+    @Override
+    public ListenerManager<UserChangeTimeoutListener> addUserChangeTimeoutListener(UserChangeTimeoutListener listener) {
+        
+        throw new UnsupportedOperationException("Unimplemented method 'addUserChangeTimeoutListener'");
+    }
+
+    @Override
+    public List<UserChangeTimeoutListener> getUserChangeTimeoutListeners() {
+        
+        throw new UnsupportedOperationException("Unimplemented method 'getUserChangeTimeoutListeners'");
+    }
+
+    @Override
+    public ListenerManager<UserChangeAvatarListener> addUserChangeAvatarListener(UserChangeAvatarListener listener) {
+        
+        throw new UnsupportedOperationException("Unimplemented method 'addUserChangeAvatarListener'");
+    }
+
+    @Override
+    public List<UserChangeAvatarListener> getUserChangeAvatarListeners() {
+        
+        throw new UnsupportedOperationException("Unimplemented method 'getUserChangeAvatarListeners'");
+    }
+
+    @Override
+    public ListenerManager<UserChangeSelfDeafenedListener> addUserChangeSelfDeafenedListener(
+            UserChangeSelfDeafenedListener listener) {
+        
+        throw new UnsupportedOperationException("Unimplemented method 'addUserChangeSelfDeafenedListener'");
+    }
+
+    @Override
+    public List<UserChangeSelfDeafenedListener> getUserChangeSelfDeafenedListeners() {
+        
+        throw new UnsupportedOperationException("Unimplemented method 'getUserChangeSelfDeafenedListeners'");
+    }
+
+    @Override
+    public ListenerManager<UserChangeMutedListener> addUserChangeMutedListener(UserChangeMutedListener listener) {
+        
+        throw new UnsupportedOperationException("Unimplemented method 'addUserChangeMutedListener'");
+    }
+
+    @Override
+    public List<UserChangeMutedListener> getUserChangeMutedListeners() {
+        
+        throw new UnsupportedOperationException("Unimplemented method 'getUserChangeMutedListeners'");
+    }
+
+    @Override
+    public ListenerManager<UserChangeActivityListener> addUserChangeActivityListener(
+            UserChangeActivityListener listener) {
+        
+        throw new UnsupportedOperationException("Unimplemented method 'addUserChangeActivityListener'");
+    }
+
+    @Override
+    public List<UserChangeActivityListener> getUserChangeActivityListeners() {
+        
+        throw new UnsupportedOperationException("Unimplemented method 'getUserChangeActivityListeners'");
+    }
+
+    @Override
+    public ListenerManager<ReactionRemoveListener> addReactionRemoveListener(ReactionRemoveListener listener) {
+        
+        throw new UnsupportedOperationException("Unimplemented method 'addReactionRemoveListener'");
+    }
+
+    @Override
+    public List<ReactionRemoveListener> getReactionRemoveListeners() {
+        
+        throw new UnsupportedOperationException("Unimplemented method 'getReactionRemoveListeners'");
+    }
+
+    @Override
+    public ListenerManager<ReactionAddListener> addReactionAddListener(ReactionAddListener listener) {
+        
+        throw new UnsupportedOperationException("Unimplemented method 'addReactionAddListener'");
+    }
+
+    @Override
+    public List<ReactionAddListener> getReactionAddListeners() {
+        
+        throw new UnsupportedOperationException("Unimplemented method 'getReactionAddListeners'");
+    }
+
+    @Override
+    public ListenerManager<MessageCreateListener> addMessageCreateListener(MessageCreateListener listener) {
+        
+        throw new UnsupportedOperationException("Unimplemented method 'addMessageCreateListener'");
+    }
+
+    @Override
+    public List<MessageCreateListener> getMessageCreateListeners() {
+        
+        throw new UnsupportedOperationException("Unimplemented method 'getMessageCreateListeners'");
+    }
+
+    @Override
+    public ListenerManager<MessageReplyListener> addMessageReplyListener(MessageReplyListener listener) {
+        
+        throw new UnsupportedOperationException("Unimplemented method 'addMessageReplyListener'");
+    }
+
+    @Override
+    public List<MessageReplyListener> getMessageReplyListeners() {
+        
+        throw new UnsupportedOperationException("Unimplemented method 'getMessageReplyListeners'");
+    }
+
+    @Override
+    public <T extends UserAttachableListener & ObjectAttachableListener> Collection<ListenerManager<T>> addUserAttachableListener(
+            T listener) {
+        
+        throw new UnsupportedOperationException("Unimplemented method 'addUserAttachableListener'");
+    }
+
+    @Override
+    public <T extends UserAttachableListener & ObjectAttachableListener> void removeUserAttachableListener(T listener) {
+        
+        throw new UnsupportedOperationException("Unimplemented method 'removeUserAttachableListener'");
+    }
+
+    @Override
+    public <T extends UserAttachableListener & ObjectAttachableListener> Map<T, List<Class<T>>> getUserAttachableListeners() {
+        
+        throw new UnsupportedOperationException("Unimplemented method 'getUserAttachableListeners'");
+    }
+
+    @Override
+    public <T extends UserAttachableListener & ObjectAttachableListener> void removeListener(Class<T> listenerClass,
+            T listener) {
+        
+        throw new UnsupportedOperationException("Unimplemented method 'removeListener'");
+    }
+
+    @Override
+    public String getDiscriminator() {
+        
+        throw new UnsupportedOperationException("Unimplemented method 'getDiscriminator'");
+    }
+
+    @Override
+    public boolean isBot() {
+        
+        throw new UnsupportedOperationException("Unimplemented method 'isBot'");
+    }
+
+    @Override
+    public Set<Activity> getActivities() {
+        
+        throw new UnsupportedOperationException("Unimplemented method 'getActivities'");
+    }
+
+    @Override
+    public UserStatus getStatus() {
+        
+        throw new UnsupportedOperationException("Unimplemented method 'getStatus'");
+    }
+
+    @Override
+    public UserStatus getStatusOnClient(DiscordClient client) {
+        
+        throw new UnsupportedOperationException("Unimplemented method 'getStatusOnClient'");
+    }
+
+    @Override
+    public EnumSet<UserFlag> getUserFlags() {
+        
+        throw new UnsupportedOperationException("Unimplemented method 'getUserFlags'");
+    }
+
+    @Override
+    public Optional<String> getAvatarHash() {
+        
+        throw new UnsupportedOperationException("Unimplemented method 'getAvatarHash'");
+    }
+
+    @Override
+    public Icon getAvatar() {
+        
+        throw new UnsupportedOperationException("Unimplemented method 'getAvatar'");
+    }
+
+    @Override
+    public Icon getAvatar(int size) {
+        
+        throw new UnsupportedOperationException("Unimplemented method 'getAvatar'");
+    }
+
+    @Override
+    public Optional<String> getServerAvatarHash(Server server) {
+        
+        throw new UnsupportedOperationException("Unimplemented method 'getServerAvatarHash'");
+    }
+
+    @Override
+    public Optional<Icon> getServerAvatar(Server server) {
+        
+        throw new UnsupportedOperationException("Unimplemented method 'getServerAvatar'");
+    }
+
+    @Override
+    public Optional<Icon> getServerAvatar(Server server, int size) {
+        
+        throw new UnsupportedOperationException("Unimplemented method 'getServerAvatar'");
+    }
+
+    @Override
+    public Icon getEffectiveAvatar(Server server) {
+        
+        throw new UnsupportedOperationException("Unimplemented method 'getEffectiveAvatar'");
+    }
+
+    @Override
+    public Icon getEffectiveAvatar(Server server, int size) {
+        
+        throw new UnsupportedOperationException("Unimplemented method 'getEffectiveAvatar'");
+    }
+
+    @Override
+    public boolean hasDefaultAvatar() {
+        
+        throw new UnsupportedOperationException("Unimplemented method 'hasDefaultAvatar'");
+    }
+
+    @Override
+    public Set<Server> getMutualServers() {
+        
+        throw new UnsupportedOperationException("Unimplemented method 'getMutualServers'");
+    }
+
+    @Override
+    public String getDisplayName(Server server) {
+        
+        throw new UnsupportedOperationException("Unimplemented method 'getDisplayName'");
+    }
+
+    @Override
+    public Optional<String> getNickname(Server server) {
+        
+        throw new UnsupportedOperationException("Unimplemented method 'getNickname'");
+    }
+
+    @Override
+    public Optional<Instant> getServerBoostingSinceTimestamp(Server server) {
+        
+        throw new UnsupportedOperationException("Unimplemented method 'getServerBoostingSinceTimestamp'");
+    }
+
+    @Override
+    public Optional<Instant> getTimeout(Server server) {
+        
+        throw new UnsupportedOperationException("Unimplemented method 'getTimeout'");
+    }
+
+    @Override
+    public boolean isPending(Server server) {
+        
+        throw new UnsupportedOperationException("Unimplemented method 'isPending'");
+    }
+
+    @Override
+    public boolean isSelfMuted(Server server) {
+        
+        throw new UnsupportedOperationException("Unimplemented method 'isSelfMuted'");
+    }
+
+    @Override
+    public boolean isSelfDeafened(Server server) {
+        
+        throw new UnsupportedOperationException("Unimplemented method 'isSelfDeafened'");
+    }
+
+    @Override
+    public Optional<Instant> getJoinedAtTimestamp(Server server) {
+        
+        throw new UnsupportedOperationException("Unimplemented method 'getJoinedAtTimestamp'");
+    }
+
+    @Override
+    public List<Role> getRoles(Server server) {
+        
+        throw new UnsupportedOperationException("Unimplemented method 'getRoles'");
+    }
+
+    @Override
+    public Optional<Color> getRoleColor(Server server) {
+        
+        throw new UnsupportedOperationException("Unimplemented method 'getRoleColor'");
+    }
+
+    @Override
+    public Optional<PrivateChannel> getPrivateChannel() {
+        
+        throw new UnsupportedOperationException("Unimplemented method 'getPrivateChannel'");
+    }
+
+    @Override
+    public CompletableFuture<PrivateChannel> openPrivateChannel() {
+        
+        throw new UnsupportedOperationException("Unimplemented method 'openPrivateChannel'");
+    }
+    
+}