Merge pull request 'add package publishing and CI/CD using Gitea actions' (#5) from feat/ci-cd into master

Reviewed-on: #5

.gitea/workflows/github-mirror.yaml

@@ -0,0 +1,17 @@
+name: github-mirror
+on: push
+jobs:
+  push-github:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v4
+        with:
+          fetch-depth: 0
+      - name: Push to GitHub
+        uses: pixta-dev/repository-mirroring-action@v1
+        with:
+          target_repo_url:
+            git@github.com:EkiciLP/Marinara.git
+          ssh_private_key:
+            ${{ secrets.MIRROR_SSH_PRIVATE_KEY }}

.gitea/workflows/gradle-build.yaml

@@ -0,0 +1,47 @@
+name: Build
+
+on:
+  push:
+
+jobs:
+  Gradle-Build:
+
+    runs-on: ubuntu-latest
+
+    steps:
+    - name: Checkout code
+      uses: actions/checkout@v4
+
+    - name: Set up JDK
+      uses: actions/setup-java@v4
+      with:
+        java-version: '23'
+        check-latest: true
+        distribution: 'zulu'
+
+    - name: Setup Gradle
+      uses: gradle/actions/setup-gradle@v4
+      with:
+        add-job-summary: always
+        cache-cleanup: on-success
+
+    - name: Cache Gradle dependencies
+      uses: actions/cache@v4
+      with:
+        path: | 
+          ~/.gradle/caches
+        key: ${{ runner.os }}-gradle-${{ hashFiles('**/*.gradle*', '**/gradle-wrapper.properties') }}
+        restore-keys: |
+          ${{ runner.os }}-gradle-
+
+    - name: Build
+      run: chmod +x gradlew; ./gradlew assemble
+
+    - name: Move artifacts
+      run: mkdir artifacts; mv lib/build/libs/*.jar artifacts; mv wrapper/javacord/build/libs/*.jar artifacts;
+
+    - name: Upload artifact
+      uses: christopherhx/gitea-upload-artifact@v4
+      with:
+        name: artifacts
+        path: artifacts

.gitea/workflows/gradle-publish.yaml

@@ -0,0 +1,40 @@
+name: Test
+
+on:
+  push:
+    branches: [master]
+
+jobs:
+  Gradle-Test:
+    runs-on: ubuntu-latest
+
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v4
+
+      - name: Set up JDK
+        uses: actions/setup-java@v4
+        with:
+          java-version: '23'
+          check-latest: true
+          distribution: 'zulu'
+
+      - name: Setup Gradle
+        uses: gradle/actions/setup-gradle@v4
+        with:
+          add-job-summary: always
+          cache-cleanup: on-success
+
+      - name: Cache Gradle dependencies
+        uses: actions/cache@v4
+        with:
+          path: | 
+            ~/.gradle/caches
+          key: ${{ runner.os }}-gradle-${{ hashFiles('**/*.gradle*', '**/gradle-wrapper.properties') }}
+          restore-keys: |
+            ${{ runner.os }}-gradle-
+
+      - name: Publish
+        env:
+          GITEA_TOKEN: ${{ secrets.PUBLISH_PACKAGE_TOKEN }}
+        run: chmod +x gradlew; ./gradlew publishAllPublicationsToGiteaRepository

.gitea/workflows/gradle-test.yaml

@@ -0,0 +1,53 @@
+name: Test
+
+on:
+  push:
+
+jobs:
+  Gradle-Test:
+    runs-on: ubuntu-latest
+
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v4
+
+      - name: Set up JDK
+        uses: actions/setup-java@v4
+        with:
+          java-version: '23'
+          check-latest: true
+          distribution: 'zulu'
+
+      - name: Setup Gradle
+        uses: gradle/actions/setup-gradle@v4
+        with:
+          add-job-summary: always
+          cache-cleanup: on-success
+
+      - name: Cache Gradle dependencies
+        uses: actions/cache@v4
+        with:
+          path: | 
+            ~/.gradle/caches
+          key: ${{ runner.os }}-gradle-${{ hashFiles('**/*.gradle*', '**/gradle-wrapper.properties') }}
+          restore-keys: |
+            ${{ runner.os }}-gradle-
+
+      - name: Test
+        env:
+          DISCORD_TEST_TOKEN: ${{ secrets.DISCORD_TOKEN }}
+        run: chmod +x gradlew; ./gradlew test
+
+      - name: Move Test Results
+        if: always()
+        run: |
+          mkdir test-results/;
+          [ -d lib/build/test-results/test/ ] && mv lib/build/test-results/test/*.xml test-results/;
+          [ -d wrapper/javacord/build/test-results/test/ ] && mv wrapper/javacord/build/test-results/test/*.xml test-results/;
+
+      - name: Upload Test Result
+        uses: christopherhx/gitea-upload-artifact@v4
+        if: always()
+        with:
+          name: test-results
+          path: test-results/

.gitignore

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

build.gradle.kts

@@ -0,0 +1,50 @@
+import java.io.ByteArrayOutputStream
+
+plugins {
+    `maven-publish`
+}
+
+allprojects {
+    group = "net.tomatentum.Marinara"
+    version = "1.0.0-RC1" + (if (!project.hasProperty("release")) ("-" + getGitHash()) else "")
+    description = "A simple but powerful, library-agnostic Discord Interaction Wrapper."
+}
+
+subprojects {
+    apply(plugin = "maven-publish")
+    apply(plugin = "java-library")
+
+    plugins.withType<MavenPublishPlugin> {
+        publishing {
+            publications {
+                create<MavenPublication>("maven") {
+                    from(components["java"])
+                }
+            }
+
+            repositories {
+                maven {
+                    name = "Gitea"
+                    url = uri("https://git.tomatentum.net/api/packages/tueem/maven/")
+
+                    credentials(HttpHeaderCredentials::class) {
+                        name = "Authorization"
+                        value = "token " + System.getenv("GITEA_TOKEN")
+                    }
+                    authentication {
+                        create<HttpHeaderAuthentication>("header")
+                    }
+                }
+            }
+        }
+    }
+}
+
+fun getGitHash(): String {
+    val output = ByteArrayOutputStream()
+    project.exec {
+        commandLine("git", "rev-parse", "--short", "HEAD")
+        standardOutput = output
+    }
+    return output.toString().trim()
+}

gradle.properties

@@ -0,0 +1 @@
+org.gradle.caching=true

gradle/libs.versions.toml

@@ -2,13 +2,13 @@
 # https://docs.gradle.org/current/userguide/platforms.html#sub::toml-dependencies-format
 
 [versions]
-commons-math3 = "3.6.1"
-guava = "33.0.0-jre"
 junit-jupiter = "5.10.2"
 log4j = "2.24.1"
+javacord = "3.8.0"
+geantyref = "2.0.0"
 
 [libraries]
-commons-math3 = { module = "org.apache.commons:commons-math3", version.ref = "commons-math3" }
-guava = { module = "com.google.guava:guava", version.ref = "guava" }
 junit-jupiter = { module = "org.junit.jupiter:junit-jupiter", version.ref = "junit-jupiter" }
 log4j = { module = "org.apache.logging.log4j:log4j-core", version.ref = "log4j"}
+javacord = { module = "org.javacord:javacord", version.ref = "javacord"}
+geantyref = { module = "io.leangen.geantyref:geantyref", version.ref = "geantyref"}

gradle/wrapper/gradle-wrapper.properties

@@ -1,6 +1,6 @@
 distributionBase=GRADLE_USER_HOME
 distributionPath=wrapper/dists
-distributionUrl=https\://services.gradle.org/distributions/gradle-8.8-bin.zip
+distributionUrl=https\://services.gradle.org/distributions/gradle-8.11-bin.zip
 networkTimeout=10000
 validateDistributionUrl=true
 zipStoreBase=GRADLE_USER_HOME

lib/build.gradle.kts

@@ -20,12 +20,6 @@ dependencies {
     testImplementation(libs.junit.jupiter)
 
     testRuntimeOnly("org.junit.platform:junit-platform-launcher")
-
-    // This dependency is exported to consumers, that is to say found on their compile classpath.
-    api(libs.commons.math3)
-
-    // This dependency is used internally, and not exposed to consumers on their own compile classpath.
-    implementation(libs.guava)
     implementation(libs.log4j)
 
 }

lib/src/main/java/net/tomatentum/marinara/Marinara.java

@@ -5,7 +5,7 @@ import net.tomatentum.marinara.wrapper.LibraryWrapper;
 
 public class Marinara {
     
-    public static Marinara load(LibraryWrapper wrapper) {
+    public static <T extends LibraryWrapper> Marinara load(LibraryWrapper wrapper) {
         InteractionRegistry registry = new InteractionRegistry(wrapper);
         return new Marinara(registry);
     }

lib/src/main/java/net/tomatentum/marinara/handler/InteractionHandler.java

@@ -1,4 +0,0 @@
-package net.tomatentum.marinara.handler;
-
-public interface InteractionHandler {
-}

lib/src/main/java/net/tomatentum/marinara/interaction/InteractionHandler.java

@@ -0,0 +1,4 @@
+package net.tomatentum.marinara.interaction;
+
+public interface InteractionHandler {
+}

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/commands/ApplicationCommandDefinition.java

@@ -1,56 +0,0 @@
-package net.tomatentum.marinara.interaction.commands;
-
-import java.util.ArrayList;
-import java.util.List;
-
-import net.tomatentum.marinara.interaction.commands.annotation.ApplicationCommand;
-
-public class ApplicationCommandDefinition {
-    private List<ExecutableCommandDefinition> executableDefinitons;
-    private ApplicationCommand applicationCommand;
-    private int subCommandGroupCount = -1;
-    private boolean isRootCommand = false;
-
-    public ApplicationCommandDefinition(ApplicationCommand applicationCommand) {
-        this.executableDefinitons = new ArrayList<>();
-        this.applicationCommand = applicationCommand;
-    }
-
-    public ApplicationCommandDefinition addExecutableCommand(ExecutableCommandDefinition def) {
-        if (this.subCommandGroupCount == -1)
-            this.subCommandGroupCount = def.subCommandGroups().length;
-        if (def.subCommandGroups().length != subCommandGroupCount)
-            throw new IllegalArgumentException(def + ": has a non matching amount of subcommand groups. All subcommands must have the same amount of subcommand groups!");
-        if (def.applicationCommand() != null) {
-            if (applicationCommand == null)
-                this.applicationCommand = def.applicationCommand();
-            if (!this.applicationCommand.equals(def.applicationCommand()))
-                throw new IllegalArgumentException(def + ": has a non matching Application Command description. Please edit it to equal all other descriptions or remove it to use other definitions descriptions");
-        }
-        if (isRootCommand) {
-            if (!def.isRootCommand())
-                throw new IllegalArgumentException(def + ": cannot have subcommands and rootcommand definitions together");
-            long subCommandAmount = executableDefinitons.stream()
-                .filter((x) -> !x.isRootCommand())
-                .count();
-            if (subCommandAmount > 0)
-                throw new IllegalArgumentException(def + ": cannot have subcommands and rootcommand definitions together");
-        }
-        
-        executableDefinitons.add(def);
-        return this;
-    }
-
-    public ApplicationCommand getApplicationCommand() {
-        return applicationCommand;
-    }
-
-    public List<ExecutableCommandDefinition> getExecutableDefinitons() {
-        return executableDefinitons;
-    }
-
-    public int getSubCommandGroupCount() {
-        return subCommandGroupCount;
-    }
-
-}

lib/src/main/java/net/tomatentum/marinara/interaction/commands/ExecutableCommandDefinition.java

@@ -1,73 +0,0 @@
-package net.tomatentum.marinara.interaction.commands;
-
-import net.tomatentum.marinara.interaction.commands.annotation.ApplicationCommand;
-import net.tomatentum.marinara.interaction.commands.annotation.CommandOption;
-import net.tomatentum.marinara.interaction.commands.annotation.SubCommand;
-
-public record ExecutableCommandDefinition(
-    ApplicationCommand applicationCommand,
-    SubCommand subCommand,
-    String[] subCommandGroups, 
-    CommandOption[] options) {
-
-    @Override
-    public final boolean equals(Object o) {
-        if (!(o instanceof ExecutableCommandDefinition))
-            return false;
-        ExecutableCommandDefinition other = (ExecutableCommandDefinition) o;
-        return other.applicationCommand.equals(this.applicationCommand) && 
-            other.subCommandGroups.equals(this.subCommandGroups) &&
-            other.subCommand.equals(this.subCommand);
-    }
-
-    @Override
-    public final String toString() {
-        return applicationCommand.name() + subCommand.name() != null ? "::" + subCommand.name() : "";
-    }
-
-    public boolean isRootCommand() {
-        return subCommand == null;    
-    }
-
-    public static class Builder {
-        private ApplicationCommand applicationCommand;
-        private SubCommand subCommand;
-        private String[] subCommandGroupNames;
-
-        public Builder() {
-            this.subCommandGroupNames = new String[0];
-        }
-
-        public ExecutableCommandDefinition build() {
-            if (applicationCommand == null)
-                throw new IllegalArgumentException("applicationCommandName cant be null");
-
-            return new ExecutableCommandDefinition(applicationCommand, subCommand, subCommandGroupNames, subCommand != null ? subCommand.options() : applicationCommand.options());
-        }
-
-        public void setApplicationCommand(ApplicationCommand applicationCommand) {
-            this.applicationCommand = applicationCommand;
-        }
-
-        public void setSubCommand(SubCommand subCommand) {
-            this.subCommand = subCommand;
-        }
-
-        public void setSubCommandGroupNames(String[] subCommandGroupNames) {
-            this.subCommandGroupNames = subCommandGroupNames;
-        }
-
-        public ApplicationCommand getApplicationCommand() {
-            return applicationCommand;
-        }
-
-        public SubCommand getSubCommand() {
-            return subCommand;
-        }
-
-        public String[] getSubCommandGroupNames() {
-            return subCommandGroupNames;
-        }
-
-    }
-}

lib/src/main/java/net/tomatentum/marinara/interaction/commands/ExecutableSlashCommandDefinition.java

@@ -0,0 +1,70 @@
+package net.tomatentum.marinara.interaction.commands;
+
+import net.tomatentum.marinara.interaction.commands.annotation.SlashCommand;
+import net.tomatentum.marinara.interaction.commands.annotation.SlashCommandOption;
+import net.tomatentum.marinara.interaction.commands.annotation.SubCommand;
+import net.tomatentum.marinara.interaction.commands.annotation.SubCommandGroup;
+
+public record ExecutableSlashCommandDefinition(
+    SlashCommand applicationCommand,
+    SubCommand subCommand,
+    SubCommandGroup subCommandGroup, 
+    SlashCommandOption[] options) {
+
+    @Override
+    public final boolean equals(Object o) {
+        if (!(o instanceof ExecutableSlashCommandDefinition))
+            return false;
+        ExecutableSlashCommandDefinition other = (ExecutableSlashCommandDefinition) o;
+        return other.applicationCommand.name().equals(this.applicationCommand.name()) && 
+            other.subCommandGroup.name().equals(this.subCommandGroup.name()) &&
+            other.subCommand.name().equals(this.subCommand.name());
+    }
+
+    @Override
+    public final String toString() {
+        return applicationCommand.name() + subCommand.name() != null ? "::" + subCommand.name() : "";
+    }
+
+    public boolean isRootCommand() {
+        return subCommand == null;    
+    }
+
+    public static class Builder {
+        private SlashCommand applicationCommand;
+        private SubCommand subCommand;
+        private SubCommandGroup subCommandGroup;
+
+        public ExecutableSlashCommandDefinition build() {
+            if (applicationCommand == null)
+                throw new IllegalArgumentException("applicationCommandName cant be null");
+
+            return new ExecutableSlashCommandDefinition(applicationCommand, subCommand, subCommandGroup, subCommand != null ? subCommand.options() : applicationCommand.options());
+        }
+
+        public void setApplicationCommand(SlashCommand applicationCommand) {
+            this.applicationCommand = applicationCommand;
+        }
+
+        public void setSubCommand(SubCommand subCommand) {
+            this.subCommand = subCommand;
+        }
+
+        public void setSubCommandGroup(SubCommandGroup subCommandGroup) {
+            this.subCommandGroup = subCommandGroup;
+        }
+
+        public SlashCommand getApplicationCommand() {
+            return applicationCommand;
+        }
+
+        public SubCommand getSubCommand() {
+            return subCommand;
+        }
+
+        public SubCommandGroup getSubCommandGroup() {
+            return subCommandGroup;
+        }
+
+    }
+}

lib/src/main/java/net/tomatentum/marinara/interaction/commands/SlashCommandDefinition.java

@@ -0,0 +1,102 @@
+package net.tomatentum.marinara.interaction.commands;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.HashMap;
+import java.util.List;
+
+import net.tomatentum.marinara.interaction.commands.annotation.SlashCommand;
+import net.tomatentum.marinara.interaction.commands.annotation.SubCommand;
+import net.tomatentum.marinara.interaction.commands.annotation.SubCommandGroup;
+
+public class SlashCommandDefinition {
+    private List<ExecutableSlashCommandDefinition> executableDefinitons;
+    private SlashCommand slashCommand;
+    private boolean isRootCommand;
+
+    public SlashCommandDefinition(SlashCommand applicationCommand) {
+        this.executableDefinitons = new ArrayList<>();
+        this.slashCommand = applicationCommand;
+    }
+
+    public SlashCommandDefinition addExecutableCommand(ExecutableSlashCommandDefinition def) {
+        if (def.applicationCommand() != null) {
+            if (slashCommand == null)
+                this.slashCommand = def.applicationCommand();
+            if (!this.slashCommand.name().equals(def.applicationCommand().name()))
+                throw new IllegalArgumentException(def + ": has a non matching Application Command description. Please edit it to equal all other descriptions or remove it to use other definitions descriptions");
+        }
+
+        if (executableDefinitons.isEmpty())
+            this.isRootCommand = def.isRootCommand();
+
+        if ((isRootCommand && !def.isRootCommand()) || (!isRootCommand && def.isRootCommand())) {
+            throw new IllegalArgumentException(def + ": cannot have subcommands and rootcommand definitions together");
+        }
+        
+        executableDefinitons.add(def);
+        return this;
+    }
+
+    public SubCommandGroup[] getSubCommandGroups() {
+        List<SubCommandGroup> subCommandGroups = Arrays.stream(getExecutableDefinitons())
+            .filter((x) -> x.subCommandGroup() != null)
+            .map((x) -> x.subCommandGroup())
+            .toList();
+
+        HashMap<String, SubCommandGroup> subCommandGroupMap = new HashMap<>();
+        subCommandGroups.forEach((x) -> {
+            SubCommandGroup current = subCommandGroupMap.get(x.name());
+            if (current == null || (current.description().isBlank() && !x.description().isBlank()))
+                subCommandGroupMap.put(x.name(), x);
+        });
+
+        return subCommandGroupMap.values().toArray(new SubCommandGroup[0]);
+    }
+
+    public SubCommand[] getSubCommands(String groupName) {
+        List<SubCommand> subCommands;
+        if (groupName == null)
+            subCommands = Arrays.stream(getExecutableDefinitons())
+            .filter((x) -> x.subCommandGroup() == null && x.subCommand() != null)
+            .map((x) -> x.subCommand())
+            .toList();
+        else 
+            subCommands = Arrays.stream(getExecutableDefinitons())
+            .filter((x) -> x.subCommandGroup().name().equals(groupName) && x.subCommand() != null)
+            .map((x) -> x.subCommand())
+            .toList();
+        
+        HashMap<String, SubCommand> subCommandMap = new HashMap<>();
+        subCommands.forEach((x) -> {
+            SubCommand current = subCommandMap.get(x.name());
+            if (current == null || (current.description().isBlank() && !x.description().isBlank()))
+                subCommandMap.put(x.name(), x);
+        });
+
+        return subCommandMap.values().toArray(new SubCommand[0]);
+    }
+
+    public SlashCommand getFullSlashCommand() {
+        if (isRootCommand())
+            return getSlashCommand();
+        for (ExecutableSlashCommandDefinition executableSlashCommandDefinition : executableDefinitons) {
+            if (executableSlashCommandDefinition.options().length > 0)
+                return executableSlashCommandDefinition.applicationCommand();
+        }
+
+        return null;
+    }
+
+    public SlashCommand getSlashCommand() {
+        return slashCommand;
+    }
+
+    public ExecutableSlashCommandDefinition[] getExecutableDefinitons() {
+        return executableDefinitons.toArray(new ExecutableSlashCommandDefinition[0]);
+    }
+
+    public boolean isRootCommand() {
+        return isRootCommand;
+    }
+}

lib/src/main/java/net/tomatentum/marinara/interaction/commands/annotation/SlashCommand.java

@@ -7,9 +7,9 @@ import java.lang.annotation.Target;
 
 @Target({ElementType.METHOD, ElementType.TYPE})
 @Retention(RetentionPolicy.RUNTIME)
-public @interface ApplicationCommand {
+public @interface SlashCommand {
     public String name();
     public String description() default "";
-    public String[] aliases() default {};
-    public CommandOption[] options() default {};
+    public SlashCommandOption[] options() default {};
+    public long[] serverIds() default {};
 }

lib/src/main/java/net/tomatentum/marinara/interaction/commands/annotation/SlashCommandOption.java

@@ -5,13 +5,13 @@ import java.lang.annotation.Retention;
 import java.lang.annotation.RetentionPolicy;
 import java.lang.annotation.Target;
 
-import net.tomatentum.marinara.interaction.commands.option.OptionType;
+import net.tomatentum.marinara.interaction.commands.option.SlashCommandOptionType;
 
 @Target({ElementType.ANNOTATION_TYPE})
 @Retention(RetentionPolicy.RUNTIME)
-public @interface CommandOption {
+public @interface SlashCommandOption {
     public String name();
     public String description() default "";
-    public OptionType type() default OptionType.STRING;
+    public SlashCommandOptionType type() default SlashCommandOptionType.STRING;
     public boolean required() default false;
 }

lib/src/main/java/net/tomatentum/marinara/interaction/commands/annotation/SubCommand.java

@@ -10,5 +10,5 @@ import java.lang.annotation.Target;
 public @interface SubCommand {
     public String name();
     public String description() default "";
-    public CommandOption[] options() default {};
+    public SlashCommandOption[] options() default {};
 }

lib/src/main/java/net/tomatentum/marinara/interaction/commands/option/SlashCommandOptionType.java

@@ -1,6 +1,6 @@
 package net.tomatentum.marinara.interaction.commands.option;
 
-public enum OptionType {
+public enum SlashCommandOptionType {
     ATTACHMENT,
     BOOLEAN,
     CHANNEL,

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

@@ -1,23 +1,26 @@
 package net.tomatentum.marinara.interaction.methods;
 
+import java.lang.reflect.InvocationTargetException;
 import java.lang.reflect.Method;
 import java.security.InvalidParameterException;
 import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.List;
 
-import net.tomatentum.marinara.handler.InteractionHandler;
+import net.tomatentum.marinara.interaction.InteractionHandler;
 import net.tomatentum.marinara.interaction.InteractionType;
-import net.tomatentum.marinara.interaction.commands.annotation.ApplicationCommand;
+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;
 
 public abstract class InteractionMethod {
 
     public static InteractionMethod create(Method method, InteractionHandler handler, LibraryWrapper wrapper) {
-        if (method.isAnnotationPresent(ApplicationCommand.class) || method.isAnnotationPresent(SubCommand.class))
-            return new CommandInteractionMethod(method, handler, 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;
     }
 
@@ -52,8 +55,8 @@ public abstract class InteractionMethod {
         }
         method.setAccessible(true);
         try {
-            method.invoke(handler, parameters);
-        }catch (Exception ex) {
+            method.invoke(handler, parameters.toArray());
+        }catch (IllegalAccessException | InvocationTargetException ex) {
             throw new RuntimeException(ex);
         }
     }

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

@@ -2,20 +2,20 @@ 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.commands.ExecutableCommandDefinition;
-import net.tomatentum.marinara.interaction.commands.annotation.ApplicationCommand;
+import net.tomatentum.marinara.interaction.commands.ExecutableSlashCommandDefinition;
+import net.tomatentum.marinara.interaction.commands.annotation.SlashCommand;
 import net.tomatentum.marinara.interaction.commands.annotation.SubCommand;
 import net.tomatentum.marinara.interaction.commands.annotation.SubCommandGroup;
 import net.tomatentum.marinara.util.ReflectionUtil;
-import net.tomatentum.marinara.handler.InteractionHandler;
 import net.tomatentum.marinara.wrapper.LibraryWrapper;
 
-public class CommandInteractionMethod extends InteractionMethod {
+public class SlashCommandInteractionMethod extends InteractionMethod {
 
-    private ExecutableCommandDefinition commandDefinition;
+    private ExecutableSlashCommandDefinition commandDefinition;
 
-    CommandInteractionMethod(Method method, InteractionHandler handler, LibraryWrapper wrapper) {
+    SlashCommandInteractionMethod(Method method, InteractionHandler handler, LibraryWrapper wrapper) {
         super(method, handler, wrapper);
         parseMethod();
     }
@@ -27,7 +27,7 @@ public class CommandInteractionMethod extends InteractionMethod {
 
     @Override
     public boolean canRun(Object context) {
-        ExecutableCommandDefinition other = wrapper.getCommandDefinition(context);
+        ExecutableSlashCommandDefinition other = wrapper.getCommandDefinition(context);
         return commandDefinition.equals(other);
     }
 
@@ -36,20 +36,20 @@ public class CommandInteractionMethod extends InteractionMethod {
         return InteractionType.COMMAND;
     }
 
-    public ExecutableCommandDefinition getCommandDefinition() {
+    public ExecutableSlashCommandDefinition getCommandDefinition() {
         return commandDefinition;
     }
 
     private void parseMethod() {
         ReflectionUtil.checkValidCommandMethod(method);
 
-        ApplicationCommand cmd = ReflectionUtil.getAnnotation(method, ApplicationCommand.class);
-        ExecutableCommandDefinition.Builder builder = new ExecutableCommandDefinition.Builder();
+        SlashCommand cmd = ReflectionUtil.getAnnotation(method, SlashCommand.class);
+        ExecutableSlashCommandDefinition.Builder builder = new ExecutableSlashCommandDefinition.Builder();
         builder.setApplicationCommand(cmd);
 
         if (ReflectionUtil.isAnnotationPresent(method, SubCommandGroup.class)) {
             SubCommandGroup cmdGroup = ReflectionUtil.getAnnotation(method, SubCommandGroup.class);
-            builder.setSubCommandGroupNames(cmdGroup.name().split(" "));
+            builder.setSubCommandGroup(cmdGroup);
         }
 
         if (ReflectionUtil.isAnnotationPresent(method, SubCommand.class)) {

lib/src/main/java/net/tomatentum/marinara/registry/InteractionRegistry.java

@@ -5,11 +5,11 @@ import java.util.ArrayList;
 import java.util.List;
 import java.util.Optional;
 
-import net.tomatentum.marinara.handler.InteractionHandler;
+import net.tomatentum.marinara.interaction.InteractionHandler;
 import net.tomatentum.marinara.interaction.InteractionType;
-import net.tomatentum.marinara.interaction.commands.ApplicationCommandDefinition;
-import net.tomatentum.marinara.interaction.commands.ExecutableCommandDefinition;
-import net.tomatentum.marinara.interaction.methods.CommandInteractionMethod;
+import net.tomatentum.marinara.interaction.commands.SlashCommandDefinition;
+import net.tomatentum.marinara.interaction.commands.ExecutableSlashCommandDefinition;
+import net.tomatentum.marinara.interaction.methods.SlashCommandInteractionMethod;
 import net.tomatentum.marinara.interaction.methods.InteractionMethod;
 import net.tomatentum.marinara.wrapper.LibraryWrapper;
 
@@ -18,34 +18,37 @@ public class InteractionRegistry {
     private LibraryWrapper wrapper;
 
     public InteractionRegistry(LibraryWrapper wrapper) {
+        this.interactionMethods = new ArrayList<>();
         this.wrapper = wrapper;
         wrapper.subscribeInteractions(this::handle);
     }
 
     public void addInteractions(InteractionHandler interactionHandler) {
         for (Method method : interactionHandler.getClass().getMethods()) {
-            interactionMethods.add(InteractionMethod.create(method, interactionHandler, wrapper));
+            InteractionMethod iMethod = InteractionMethod.create(method, interactionHandler, wrapper);
+            if (iMethod != null)
+                this.interactionMethods.add(iMethod);
         }
     }
 
     public void registerCommands() {
-        List<ApplicationCommandDefinition> defs = new ArrayList<>();
-        List<ExecutableCommandDefinition> execDefs = interactionMethods.stream()
-            .filter((x) -> x.getClass().isAssignableFrom(CommandInteractionMethod.class))
-            .map((x) -> ((CommandInteractionMethod)x).getCommandDefinition())
+        List<SlashCommandDefinition> defs = new ArrayList<>();
+        List<ExecutableSlashCommandDefinition> execDefs = interactionMethods.stream()
+            .filter((x) -> x.getClass().isAssignableFrom(SlashCommandInteractionMethod.class))
+            .map((x) -> ((SlashCommandInteractionMethod)x).getCommandDefinition())
             .toList();
 
         execDefs.forEach((def) -> {
-            Optional<ApplicationCommandDefinition> appDef = defs.stream()
-                .filter((x) -> x.getApplicationCommand().equals(def.applicationCommand()))
+            Optional<SlashCommandDefinition> appDef = defs.stream()
+                .filter((x) -> x.getSlashCommand().equals(def.applicationCommand()))
                 .findFirst();
             if (appDef.isPresent())
                 appDef.get().addExecutableCommand(def);
             else
-                defs.add(new ApplicationCommandDefinition(def.applicationCommand()).addExecutableCommand(def));
+                defs.add(new SlashCommandDefinition(def.applicationCommand()).addExecutableCommand(def));
         });
 
-        defs.forEach(wrapper::registerApplicationCommand);
+        wrapper.registerSlashCommands(defs.toArray(new SlashCommandDefinition[0]));
     }
 
     public void handle(Object context) {

lib/src/main/java/net/tomatentum/marinara/util/ReflectionUtil.java

@@ -3,7 +3,7 @@ package net.tomatentum.marinara.util;
 import java.lang.annotation.Annotation;
 import java.lang.reflect.Method;
 
-import net.tomatentum.marinara.interaction.commands.annotation.ApplicationCommand;
+import net.tomatentum.marinara.interaction.commands.annotation.SlashCommand;
 import net.tomatentum.marinara.interaction.commands.annotation.SubCommand;
 
 public final class ReflectionUtil {
@@ -22,16 +22,16 @@ public final class ReflectionUtil {
     }
 
     public static void checkValidCommandMethod(Method method) {
-        if (method.isAnnotationPresent(ApplicationCommand.class) && 
-            method.getDeclaringClass().isAnnotationPresent(ApplicationCommand.class)) {
+        if (method.isAnnotationPresent(SlashCommand.class) && 
+            method.getDeclaringClass().isAnnotationPresent(SlashCommand.class)) {
             throw new RuntimeException(method.getName() + ": Can't have ApplicationCommand Annotation on Class and Method");
         }
 
-        if (!isAnnotationPresent(method, ApplicationCommand.class))
+        if (!isAnnotationPresent(method, SlashCommand.class))
             throw new RuntimeException(method.getName() + ": Missing ApplicationCommand Annotation on either Class or Method");
 
-        if (!(method.isAnnotationPresent(SubCommand.class) && 
-            isAnnotationPresent(method, ApplicationCommand.class))) {
+        if ((method.isAnnotationPresent(SubCommand.class) && 
+            !isAnnotationPresent(method, SlashCommand.class))) {
             throw new RuntimeException(method.getName() + ": Missing ApplicationCommand Annotation on either Method or Class");
         }
     }

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

@@ -4,9 +4,9 @@ import java.util.ArrayList;
 import java.util.List;
 import java.util.function.Consumer;
 
-import net.tomatentum.marinara.interaction.commands.ApplicationCommandDefinition;
-import net.tomatentum.marinara.interaction.commands.ExecutableCommandDefinition;
-import net.tomatentum.marinara.interaction.commands.option.OptionType;
+import net.tomatentum.marinara.interaction.commands.SlashCommandDefinition;
+import net.tomatentum.marinara.interaction.commands.ExecutableSlashCommandDefinition;
+import net.tomatentum.marinara.interaction.commands.option.SlashCommandOptionType;
 import net.tomatentum.marinara.interaction.InteractionType;
 
 public abstract class LibraryWrapper {
@@ -17,7 +17,6 @@ public abstract class LibraryWrapper {
         interactionSubscriber = new ArrayList<>();
     }
 
-    public abstract void registerApplicationCommand(ApplicationCommandDefinition def); 
 
     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 Object convertCommandOption(Object context, OptionType type, String optionName);
-    public abstract ExecutableCommandDefinition getCommandDefinition(Object context);
+
+    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);
 }

settings.gradle.kts

@@ -11,4 +11,7 @@ plugins {
 }
 
 rootProject.name = "Marinara"
-include("lib")
+include(":lib")
+include(":wrapper-javacord")
+
+project(":wrapper-javacord").projectDir = file("wrapper/javacord")

wrapper/javacord/build.gradle.kts

@@ -0,0 +1,39 @@
+/*
+ * This file was generated by the Gradle 'init' task.
+ *
+ * This generated file contains a sample Java library project to get you started.
+ * For more details on building Java & JVM projects, please refer to https://docs.gradle.org/8.8/userguide/building_java_projects.html in the Gradle documentation.
+ */
+
+plugins {
+    // Apply the java-library plugin for API and implementation separation.
+    `java-library`
+}
+
+repositories {
+    // Use Maven Central for resolving dependencies.
+    mavenCentral()
+}
+
+dependencies {
+    // Use JUnit Jupiter for testing.
+    testImplementation(libs.junit.jupiter)
+
+    testRuntimeOnly("org.junit.platform:junit-platform-launcher")
+    implementation(libs.log4j)
+    implementation(libs.javacord)
+    implementation(libs.geantyref)
+    implementation(project(":lib"))
+}
+
+// Apply a specific Java toolchain to ease working on different environments.
+java {
+    toolchain {
+        languageVersion = JavaLanguageVersion.of(21)
+    }
+}
+
+tasks.named<Test>("test") {
+    // Use JUnit Platform for unit tests.
+    useJUnitPlatform()
+}

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

@@ -0,0 +1,186 @@
+package net.tomatentum.marinara.wrapper.javacord;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Map;
+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;
+
+import io.leangen.geantyref.AnnotationFormatException;
+import io.leangen.geantyref.TypeFactory;
+import net.tomatentum.marinara.interaction.InteractionType;
+import net.tomatentum.marinara.interaction.commands.ExecutableSlashCommandDefinition;
+import net.tomatentum.marinara.interaction.commands.SlashCommandDefinition;
+import net.tomatentum.marinara.interaction.commands.annotation.SlashCommand;
+import net.tomatentum.marinara.interaction.commands.annotation.SlashCommandOption;
+import net.tomatentum.marinara.interaction.commands.annotation.SubCommand;
+import net.tomatentum.marinara.interaction.commands.annotation.SubCommandGroup;
+import net.tomatentum.marinara.interaction.commands.option.SlashCommandOptionType;
+import net.tomatentum.marinara.wrapper.LibraryWrapper;
+
+public class JavacordWrapper extends LibraryWrapper {
+
+    private DiscordApi api;
+
+    public JavacordWrapper(DiscordApi api) {
+        this.api = api;
+        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<>();
+        Set<SlashCommandBuilder> globalCommands = new HashSet<>();
+        for (SlashCommandDefinition slashCommandDefinition : defs) {
+            SlashCommandBuilder builder = convertSlashCommand(slashCommandDefinition);
+            if (slashCommandDefinition.getFullSlashCommand().serverIds().length > 0) {
+                for (long serverId : slashCommandDefinition.getFullSlashCommand().serverIds()) {
+                    serverCommands.putIfAbsent(serverId, new HashSet<>());
+                    serverCommands.get(serverId).add(builder);
+                }
+            }else
+                globalCommands.add(builder);
+        }
+
+        for (long serverId : serverCommands.keySet()) {
+            api.bulkOverwriteServerApplicationCommands(serverId, serverCommands.get(serverId));
+        }
+        api.bulkOverwriteGlobalApplicationCommands(globalCommands);
+    }
+
+    @Override
+    public Object convertCommandOption(Object context, SlashCommandOptionType type, String optionName) {
+        if (!(context instanceof SlashCommandInteraction))
+            return null;
+        SlashCommandInteraction interaction = (SlashCommandInteraction) context;
+        if (!interaction.getArguments().isEmpty())
+            return getOptionValue(interaction.getOptionByName(optionName).get(), type);
+
+        SlashCommandInteractionOption subCommandOption = interaction.getOptions().getFirst();
+
+        if (!subCommandOption.getOptions().isEmpty())
+            subCommandOption = subCommandOption.getOptions().getFirst();
+
+        return getOptionValue(subCommandOption.getOptionByName(optionName).get(), type);
+    }
+
+    @Override
+    public ExecutableSlashCommandDefinition getCommandDefinition(Object context) {
+        if (!(context instanceof SlashCommandInteraction))
+            return null;
+
+        SlashCommandInteraction interaction = (SlashCommandInteraction) context;
+        ExecutableSlashCommandDefinition.Builder builder = new ExecutableSlashCommandDefinition.Builder();
+        List<SlashCommandInteractionOption> options = interaction.getOptions();
+        try {
+            builder.setApplicationCommand(TypeFactory.annotation(SlashCommand.class, Map.of("name", interaction.getCommandName())));
+            if (!options.getFirst().getArguments().isEmpty()) {
+                builder.setSubCommandGroup(TypeFactory.annotation(SubCommandGroup.class, Map.of("name", options.getFirst().getName())));
+                builder.setSubCommand(TypeFactory.annotation(SubCommand.class, Map.of("name", options.getFirst().getOptions().getFirst().getName())));
+            }else
+                builder.setSubCommand(TypeFactory.annotation(SubCommand.class, Map.of("name", options.getFirst().getName())));
+        } catch (AnnotationFormatException e) {
+            e.printStackTrace();
+        }
+
+        return builder.build();
+    }
+
+    private SlashCommandBuilder convertSlashCommand(SlashCommandDefinition def) {
+        List<org.javacord.api.interaction.SlashCommandOption> options = new ArrayList<>();
+        SlashCommand cmd = def.getFullSlashCommand();
+        if (!def.isRootCommand()) {
+            Arrays.stream(def.getSubCommands(null)).map(this::convertSubCommandDef).forEach(options::add);
+            Arrays.stream(def.getSubCommandGroups()).map((x) -> convertSubCommandGroupDef(def, x)).forEach(options::add);
+        }else {
+            Arrays.stream(cmd.options()).map(this::convertOptionDef).forEach(options::add);
+        }
+
+        return org.javacord.api.interaction.SlashCommand.with(cmd.name(), cmd.description(), options);
+    }
+
+    private org.javacord.api.interaction.SlashCommandOption convertSubCommandGroupDef(SlashCommandDefinition def, SubCommandGroup subGroup) {
+        SubCommand[] subCommands = def.getSubCommands(subGroup.name());
+        org.javacord.api.interaction.SlashCommandOption[] convertedSubCommands = (org.javacord.api.interaction.SlashCommandOption[]) Arrays.stream(subCommands).map(this::convertSubCommandDef).toArray();
+        return org.javacord.api.interaction.SlashCommandOption.createWithOptions(org.javacord.api.interaction.SlashCommandOptionType.SUB_COMMAND_GROUP, subGroup.name(), subGroup.description(), Arrays.asList(convertedSubCommands));
+    }
+
+    private org.javacord.api.interaction.SlashCommandOption convertSubCommandDef(SubCommand sub) {
+        List<org.javacord.api.interaction.SlashCommandOption> convertedOptions = new ArrayList<>();
+        Arrays.stream(sub.options()).map(this::convertOptionDef).forEach(convertedOptions::add);
+        return org.javacord.api.interaction.SlashCommandOption.createWithOptions(org.javacord.api.interaction.SlashCommandOptionType.SUB_COMMAND, sub.name(), sub.description(), convertedOptions);
+    }
+
+    private org.javacord.api.interaction.SlashCommandOption convertOptionDef(SlashCommandOption option) {
+        org.javacord.api.interaction.SlashCommandOptionType type = Enum.valueOf(org.javacord.api.interaction.SlashCommandOptionType.class, option.type().toString());
+        return org.javacord.api.interaction.SlashCommandOption.create(type, option.name(), option.description(), option.required());
+    }
+
+    private Object getOptionValue(SlashCommandInteractionOption option, SlashCommandOptionType type) {
+        switch (type) {
+            case ATTACHMENT:
+                return option.getAttachmentValue().get();
+            case BOOLEAN:
+                return option.getBooleanValue().get();
+            case CHANNEL:
+                return option.getChannelValue().get();
+            case DECIMAL:
+                return option.getDecimalValue().get();
+            case LONG:
+                return option.getLongValue().get();
+            case MENTIONABLE:
+                return option.getMentionableValue().get();
+            case ROLE:
+                return option.getRoleValue().get();
+            case STRING:
+                return option.getStringValue().get();
+            case USER:
+                return option.getUserValue().get();
+            default:
+                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.marinara.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/SlashCommandTest.java

@@ -0,0 +1,53 @@
+package net.tomatentum.marinara.test;
+
+import org.javacord.api.DiscordApi;
+import org.javacord.api.DiscordApiBuilder;
+import org.junit.jupiter.api.AfterAll;
+import org.junit.jupiter.api.BeforeAll;
+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.SlashCommandInteractionMock;
+import net.tomatentum.marinara.wrapper.LibraryWrapper;
+import net.tomatentum.marinara.wrapper.javacord.JavacordWrapper;
+@TestInstance(Lifecycle.PER_CLASS)
+public class SlashCommandTest {
+
+    String DISCORD_TOKEN = System.getenv("DISCORD_TEST_TOKEN");
+    DiscordApi api;
+
+    @BeforeAll
+    void setUp() {
+        api = new DiscordApiBuilder()
+        .setToken(DISCORD_TOKEN)
+        .login().join();
+    }
+
+    @AfterAll
+    void tearDown() {
+        api.disconnect();
+        api = null;
+    }
+
+    @Test
+    void testSlashCommand() {
+        Marinara marinara = Marinara.load(new JavacordWrapper(api));
+        marinara.getRegistry().addInteractions(new TestCommand());
+        marinara.getRegistry().registerCommands();
+        System.out.println("Success!");
+    }
+    
+    @Test
+    void testSlashCommandExecution() {
+        LibraryWrapper wrapper = new JavacordWrapper(api);
+        Marinara marinara = Marinara.load(wrapper);
+        marinara.getRegistry().addInteractions(new TestCommand());
+
+        wrapper.handleInteraction(new SlashCommandInteractionMock());
+    }
+
+    
+
+}

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/TestCommand.java

@@ -0,0 +1,31 @@
+package net.tomatentum.marinara.test;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+import org.javacord.api.interaction.SlashCommandInteraction;
+
+import net.tomatentum.marinara.interaction.InteractionHandler;
+import net.tomatentum.marinara.interaction.commands.annotation.SlashCommand;
+import net.tomatentum.marinara.interaction.commands.annotation.SlashCommandOption;
+import net.tomatentum.marinara.interaction.commands.option.SlashCommandOptionType;
+
+public class TestCommand implements InteractionHandler {
+    @SlashCommand(
+        name = "test", 
+        description = "testingen",
+        serverIds = {
+            1037753048602255440L
+        },
+        options = {
+            @SlashCommandOption(
+                name = "foo",
+                description = "foo bar is very fooby",
+                type = SlashCommandOptionType.STRING
+            )
+        }
+        )
+    public void exec(SlashCommandInteraction interaction, String test) {
+        assertEquals(test, "test");
+        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

@@ -0,0 +1,146 @@
+package net.tomatentum.marinara.test.mocks;
+
+import java.util.Arrays;
+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.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.DiscordLocale;
+import org.javacord.api.interaction.InteractionType;
+import org.javacord.api.interaction.SlashCommandInteraction;
+import org.javacord.api.interaction.SlashCommandInteractionOption;
+import org.javacord.api.interaction.callback.InteractionFollowupMessageBuilder;
+import org.javacord.api.interaction.callback.InteractionImmediateResponseBuilder;
+import org.javacord.api.interaction.callback.InteractionOriginalResponseUpdater;
+
+public class SlashCommandInteractionMock implements SlashCommandInteraction{
+
+    @Override
+    public long getCommandId() {
+        throw new UnsupportedOperationException("Unimplemented method 'getCommandId'");
+    }
+
+    @Override
+    public String getCommandIdAsString() {
+        throw new UnsupportedOperationException("Unimplemented method 'getCommandIdAsString'");
+    }
+
+    @Override
+    public String getCommandName() {
+        return "test";
+    }
+
+    @Override
+    public Optional<Long> getRegisteredCommandServerId() {
+        throw new UnsupportedOperationException("Unimplemented method 'getRegisteredCommandServerId'");
+    }
+
+    @Override
+    public long getApplicationId() {
+        throw new UnsupportedOperationException("Unimplemented method 'getApplicationId'");
+    }
+
+    @Override
+    public InteractionType getType() {
+        return InteractionType.APPLICATION_COMMAND;
+    }
+
+    @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() {
+        throw new UnsupportedOperationException("Unimplemented method 'getServer'");
+    }
+
+    @Override
+    public Optional<TextChannel> getChannel() {
+        throw new UnsupportedOperationException("Unimplemented method 'getChannel'");
+    }
+
+    @Override
+    public User getUser() {
+        throw new UnsupportedOperationException("Unimplemented method 'getUser'");
+    }
+
+    @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'");
+    }
+
+    @Override
+    public List<SlashCommandInteractionOption> getOptions() {
+        return Arrays.asList(new SlashCommandInteractionOptionMock());
+    }
+
+    @Override
+    public List<SlashCommandInteractionOption> getArguments() {
+        return Arrays.asList(new SlashCommandInteractionOptionMock());
+    }
+
+    @Override
+    public String getFullCommandName() {
+        return "test";
+    }
+    
+}

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

@@ -0,0 +1,97 @@
+package net.tomatentum.marinara.test.mocks;
+
+import java.util.Collections;
+import java.util.List;
+import java.util.Optional;
+import java.util.concurrent.CompletableFuture;
+
+import org.javacord.api.entity.Attachment;
+import org.javacord.api.entity.Mentionable;
+import org.javacord.api.entity.channel.ServerChannel;
+import org.javacord.api.entity.permission.Role;
+import org.javacord.api.entity.user.User;
+import org.javacord.api.interaction.SlashCommandInteractionOption;
+
+public class SlashCommandInteractionOptionMock implements SlashCommandInteractionOption{
+
+    @Override
+    public List<SlashCommandInteractionOption> getArguments() {
+        return Collections.emptyList();
+    }
+
+    @Override
+    public String getName() {
+        return "foo";
+    }
+
+    @Override
+    public Optional<Boolean> isFocused() {
+        throw new UnsupportedOperationException("Unimplemented method 'isFocused'");
+    }
+
+    @Override
+    public Optional<String> getStringRepresentationValue() {
+        throw new UnsupportedOperationException("Unimplemented method 'getStringRepresentationValue'");
+    }
+
+    @Override
+    public Optional<String> getStringValue() {
+        return Optional.of("test");
+    }
+
+    @Override
+    public Optional<Long> getLongValue() {
+        throw new UnsupportedOperationException("Unimplemented method 'getLongValue'");
+    }
+
+    @Override
+    public Optional<Boolean> getBooleanValue() {
+        throw new UnsupportedOperationException("Unimplemented method 'getBooleanValue'");
+    }
+
+    @Override
+    public Optional<User> getUserValue() {
+        throw new UnsupportedOperationException("Unimplemented method 'getUserValue'");
+    }
+
+    @Override
+    public Optional<CompletableFuture<User>> requestUserValue() {
+        throw new UnsupportedOperationException("Unimplemented method 'requestUserValue'");
+    }
+
+    @Override
+    public Optional<ServerChannel> getChannelValue() {
+        throw new UnsupportedOperationException("Unimplemented method 'getChannelValue'");
+    }
+
+    @Override
+    public Optional<Attachment> getAttachmentValue() {
+        throw new UnsupportedOperationException("Unimplemented method 'getAttachmentValue'");
+    }
+
+    @Override
+    public Optional<Role> getRoleValue() {
+        throw new UnsupportedOperationException("Unimplemented method 'getRoleValue'");
+    }
+
+    @Override
+    public Optional<Mentionable> getMentionableValue() {
+        throw new UnsupportedOperationException("Unimplemented method 'getMentionableValue'");
+    }
+
+    @Override
+    public Optional<Double> getDecimalValue() {
+        throw new UnsupportedOperationException("Unimplemented method 'getDecimalValue'");
+    }
+
+    @Override
+    public Optional<CompletableFuture<Mentionable>> requestMentionableValue() {
+        throw new UnsupportedOperationException("Unimplemented method 'requestMentionableValue'");
+    }
+
+    @Override
+    public List<SlashCommandInteractionOption> getOptions() {
+        return Collections.emptyList();
+    }
+    
+}

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'");
+    }
+    
+}