.gitea/workflows/gradle-build.yaml

@@ -38,10 +38,7 @@ jobs:
       run: chmod +x gradlew; ./gradlew assemble
 
     - name: Move artifacts
-      run: |
+      run: mkdir artifacts; mv lib/build/libs/*.jar artifacts; mv wrapper/javacord/build/libs/*.jar artifacts;
-        mkdir artifacts; mv lib/build/libs/*.jar artifacts; 
-        mv wrapper/javacord/build/libs/*.jar artifacts; 
-        mv wrapper/discord4j/build/libs/*.jar artifacts;
 
     - name: Upload artifact
       uses: christopherhx/gitea-upload-artifact@v4

.gitea/workflows/gradle-publish-dev.yaml

@@ -1,40 +0,0 @@
-name: Publish
-
-on:
-  push:
-    branches: [dev]
-
-jobs:
-  Gradle-Publish:
-    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 Dev
-        env:
-          GITEA_TOKEN: ${{ secrets.PUBLISH_PACKAGE_TOKEN }}
-        run: chmod +x gradlew; ./gradlew publishAllPublicationsToGiteaRepository 

.gitea/workflows/gradle-publish.yaml

@@ -1,11 +1,11 @@
-name: Publish
+name: Test
 
 on:
   push:
     branches: [master]
 
 jobs:
-  Gradle-Publish:
+  Gradle-Test:
     runs-on: ubuntu-latest
 
     steps:
@@ -34,7 +34,7 @@ jobs:
           restore-keys: |
             ${{ runner.os }}-gradle-
 
-      - name: Publish Release
+      - name: Publish
         env:
           GITEA_TOKEN: ${{ secrets.PUBLISH_PACKAGE_TOKEN }}
-        run: chmod +x gradlew; ./gradlew publishAllPublicationsToGiteaRepository -Prelease
+        run: chmod +x gradlew; ./gradlew publishAllPublicationsToGiteaRepository

.gitea/workflows/gradle-test.yaml

@@ -44,7 +44,6 @@ jobs:
           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/;
-          [ -d wrapper/discord4j/build/test-results/test/ ] && mv wrapper/discord4j/build/test-results/test/*.xml test-results/;
 
       - name: Upload Test Result
         uses: christopherhx/gitea-upload-artifact@v4

.gitignore

@@ -6,4 +6,3 @@ build
 .vscode
 lib/bin
 wrapper/javacord/bin
-wrapper/discord4j/bin

build.gradle.kts

@@ -8,19 +8,6 @@ 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."
-    plugins.withType<JavaPlugin> {
-        tasks.withType<Jar>().configureEach {
-            archiveBaseName.set("marinara-" + archiveBaseName.get())
-        }
-    }
-
-    repositories {
-        // Use Maven Central for resolving dependencies.
-        mavenCentral()
-        maven {
-            url = uri("https://git.tomatentum.net/api/packages/tueem/maven")
-        }
-    }
 }
 
 subprojects {
@@ -31,8 +18,6 @@ subprojects {
         publishing {
             publications {
                 create<MavenPublication>("maven") {
-                    if (!project.hasProperty("release"))
-                        artifactId = project.getName() + "-dev"
                     from(components["java"])
                 }
             }

gradle/libs.versions.toml

@@ -3,19 +3,12 @@
 
 [versions]
 junit-jupiter = "5.10.2"
-slf4j = "2.0.17"
+log4j = "2.24.1"
 javacord = "3.8.0"
-discord4j = "3.2.7"
 geantyref = "2.0.0"
-mockito = "5.15.2"
-cutin = "0.2.0"
 
 [libraries]
 junit-jupiter = { module = "org.junit.jupiter:junit-jupiter", version.ref = "junit-jupiter" }
-slf4j = { module = "org.slf4j:slf4j-api", version.ref = "slf4j"}
+log4j = { module = "org.apache.logging.log4j:log4j-core", version.ref = "log4j"}
-slf4j-simple = { module = "org.slf4j:slf4j-simple", version.ref = "slf4j"}
 javacord = { module = "org.javacord:javacord", version.ref = "javacord"}
-discord4j = { module = "com.discord4j:discord4j-core", version.ref = "discord4j"}
 geantyref = { module = "io.leangen.geantyref:geantyref", version.ref = "geantyref"}
-mockito = {module = "org.mockito:mockito-core", version.ref = "mockito"}
-cutin = {module = "net.tomatentum.cutin:lib", version.ref = "cutin"}

lib/build.gradle.kts

@@ -10,20 +10,24 @@ plugins {
     `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.slf4j)
+    implementation(libs.log4j)
-    implementation(libs.geantyref)
+
-    api(libs.cutin)
 }
 
 // Apply a specific Java toolchain to ease working on different environments.
 java {
     toolchain {
-        languageVersion = JavaLanguageVersion.of(23)
+        languageVersion = JavaLanguageVersion.of(21)
     }
 }
 

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

@@ -1,85 +1,22 @@
 package net.tomatentum.marinara;
 
-import java.util.Arrays;
+import net.tomatentum.marinara.registry.InteractionRegistry;
-import java.util.List;
-
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
-
-import net.tomatentum.cutin.MethodExecutor;
-import net.tomatentum.cutin.ProcessorMethodExecutor;
-import net.tomatentum.cutin.container.MethodContainer;
-import net.tomatentum.marinara.checks.CheckExecutionContext;
-import net.tomatentum.marinara.checks.CheckMethodIdentifier;
-import net.tomatentum.marinara.container.InteractionCheckContainer;
-import net.tomatentum.marinara.container.InteractionMethodContainer;
-import net.tomatentum.marinara.interaction.InteractionType;
-import net.tomatentum.marinara.interaction.commands.SlashCommandDefinition;
-import net.tomatentum.marinara.interaction.ident.InteractionIdentifier;
-import net.tomatentum.marinara.interaction.ident.RootCommandIdentifier;
-import net.tomatentum.marinara.interaction.processor.AutocompleteInteractionProcessor;
-import net.tomatentum.marinara.interaction.processor.DirectInteractionProcessor;
-import net.tomatentum.marinara.util.ObjectAggregator;
-import net.tomatentum.marinara.wrapper.IdentifierProvider;
 import net.tomatentum.marinara.wrapper.LibraryWrapper;
 
 public class Marinara {
     
-    private Logger logger = LoggerFactory.getLogger(getClass());
+    public static <T extends LibraryWrapper> Marinara load(LibraryWrapper wrapper) {
-    
+        InteractionRegistry registry = new InteractionRegistry(wrapper);
-    public static Marinara load(LibraryWrapper wrapper) {
+        return new Marinara(registry);
-        return new Marinara(wrapper);
     }
 
-    private LibraryWrapper wrapper;
+    private InteractionRegistry registry;
-    private MethodContainer<CheckMethodIdentifier, CheckExecutionContext> checkContainer;
-    private MethodContainer<InteractionIdentifier, Object> interactionContainer;
-    private MethodExecutor<Object> interactionExecutor;
 
-    private Marinara(LibraryWrapper wrapper) {
+    private Marinara(InteractionRegistry registry) {
-        this.wrapper = wrapper;
+        this.registry = registry;
-        this.checkContainer = new InteractionCheckContainer();
-        this.interactionContainer = new InteractionMethodContainer(getCheckContainer(), getWrapper().getContextObjectProvider());
-        IdentifierProvider provider = wrapper.createIdentifierProvider();
-        ProcessorMethodExecutor<InteractionIdentifier, Object> exec = new ProcessorMethodExecutor<>(getInteractionContainer());
-        exec
-            .addProcessor(new DirectInteractionProcessor(provider, InteractionType.COMMAND, InteractionType.BUTTON))
-            .addProcessor(new AutocompleteInteractionProcessor(getWrapper(), provider));
-        this.interactionExecutor = exec;
-        wrapper.subscribeInteractions(this.interactionExecutor::handle);
-        logger.info("Marinara loaded successfully!");
     }
 
-    //TODO move to future interactionstructure module
+    public InteractionRegistry getRegistry() {
-    public void registerCommands() {
+        return registry;
-        List<InteractionIdentifier> slashIdentifiers = getInteractionContainer().identifiers().stream()
-            .filter(i -> i.type().equals(InteractionType.COMMAND))
-            .toList();
-
-        SlashCommandDefinition[] defs = new ObjectAggregator<InteractionIdentifier, RootCommandIdentifier, SlashCommandDefinition>(
-            i -> Arrays.asList((RootCommandIdentifier)i.rootNode()),
-            SlashCommandDefinition::addIdentifier,
-            SlashCommandDefinition::new)
-            .aggregate(slashIdentifiers)
-            .toArray(SlashCommandDefinition[]::new);
-
-        wrapper.getRegisterer().register(defs);
     }
-
-    public LibraryWrapper getWrapper() {
-        return this.wrapper;
-    }
-
-    public MethodContainer<InteractionIdentifier, Object> getInteractionContainer() {
-        return this.interactionContainer;
-    }
-
-    public MethodContainer<CheckMethodIdentifier, CheckExecutionContext> getCheckContainer() {
-        return this.checkContainer;
-    }
-
-    public MethodExecutor<Object> getInteractionExecutor() {
-        return interactionExecutor;
-    }
-    
 }

lib/src/main/java/net/tomatentum/marinara/checks/AppliedCheck.java

@@ -1,28 +0,0 @@
-package net.tomatentum.marinara.checks;
-
-import java.lang.annotation.Annotation;
-
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
-
-import net.tomatentum.cutin.method.ReflectedMethod;
-
-public record AppliedCheck(
-        Annotation annotation, 
-        ReflectedMethod<CheckMethodIdentifier, CheckExecutionContext> preExec,
-        ReflectedMethod<CheckMethodIdentifier, CheckExecutionContext> postExec
-    ) {
-
-    private static Logger logger = LoggerFactory.getLogger(AppliedCheck.class); 
-
-    public boolean pre(Object context) {
-        logger.debug("Running InteractionCheck preExec {} with annotation {}", preExec(), annotation());
-        return (boolean) preExec().run(new CheckExecutionContext(annotation, context));
-    }
-
-    public void post(Object context) {
-        logger.debug("Running InteractionCheck postExec {} with annotation {}", postExec(), annotation());
-        postExec().run(new CheckExecutionContext(annotation, context));
-    }
-
-}

lib/src/main/java/net/tomatentum/marinara/checks/CheckExecutionContext.java

@@ -1,7 +0,0 @@
-package net.tomatentum.marinara.checks;
-
-import java.lang.annotation.Annotation;
-
-public record CheckExecutionContext(Annotation annotation, Object originalContext) {
-    
-}

lib/src/main/java/net/tomatentum/marinara/checks/CheckMethodIdentifier.java

@@ -1,27 +0,0 @@
-package net.tomatentum.marinara.checks;
-
-import java.lang.reflect.Type;
-
-public record CheckMethodIdentifier(Type annotationType, CheckMethodType type) {
-
-    public enum CheckMethodType {
-        PRE("preExec"),
-        POST("postExec");
-
-        private String methodName;
-
-        private CheckMethodType(String methodName) {
-            this.methodName = methodName;
-        }
-
-        public String methodName() {
-            return this.methodName;
-        }
-    }
-
-    @Override
-    public final String toString() {
-        return "InteractionCheck(%s, %s)".formatted(annotationType, type);
-    }
-    
-}

lib/src/main/java/net/tomatentum/marinara/checks/InteractionCheck.java

@@ -1,10 +0,0 @@
-package net.tomatentum.marinara.checks;
-
-import java.lang.annotation.Annotation;
-
-public interface InteractionCheck<A extends Annotation> {
-
-    public boolean preExec(Object context, A annotation);
-    public void postExec(Object context, A annotation);
-    
-}

lib/src/main/java/net/tomatentum/marinara/checks/InteractionCheckMethod.java

@@ -1,74 +0,0 @@
-package net.tomatentum.marinara.checks;
-
-import java.util.Optional;
-import java.util.Set;
-
-import net.tomatentum.cutin.MethodParser;
-import net.tomatentum.cutin.ReflectedMethodFactory.ParserResults;
-import net.tomatentum.cutin.container.MethodContainer;
-import net.tomatentum.cutin.method.BestCandidateMethod;
-import net.tomatentum.marinara.checks.CheckMethodIdentifier.CheckMethodType;
-import net.tomatentum.marinara.parser.InteractionCheckClassParser;
-
-public class InteractionCheckMethod extends BestCandidateMethod<CheckMethodIdentifier, CheckExecutionContext> {
-
-    private CheckMethodIdentifier identifier;
-
-    public InteractionCheckMethod(
-            String methodName, 
-            Object containingObject,
-            CheckMethodIdentifier identifier
-        ) {
-        super(methodName, containingObject);
-        this.identifier = identifier;
-    }
-
-    @Override
-    public Object getParameter(CheckExecutionContext context, int index) {
-        switch (index) {
-            case 0:
-                return context.originalContext();
-            case 1:
-                return context.annotation();
-            default:
-                return null;
-        }
-    }
-
-    @Override
-    public CheckMethodIdentifier identifier() {
-        return this.identifier;
-    }
-
-    public static class InteractionCheckMethodFactory extends BestCandidateMethod.Factory<CheckMethodIdentifier, CheckExecutionContext> {
-
-        private CheckMethodType type;
-
-        public InteractionCheckMethodFactory(MethodContainer<CheckMethodIdentifier, CheckExecutionContext> methodContainer, CheckMethodType type) {
-            super(methodContainer, type.methodName());
-            this.type = type;
-        }
-
-        @Override
-        public void addParser(Set<MethodParser> parsers) {
-            parsers.add(
-                new InteractionCheckClassParser()
-            );
-        }
-
-        @Override
-        protected Optional<BestCandidateMethod<CheckMethodIdentifier, CheckExecutionContext>> bcProduce(
-                    String methodName,
-                    Object containingObject,
-                    ParserResults parserResults
-                ) {
-
-            CheckMethodIdentifier identifier = new CheckMethodIdentifier(parserResults.get(InteractionCheckClassParser.class), type);
-            if (identifier.annotationType() == null)
-                return null;
-            return Optional.of(new InteractionCheckMethod(methodName, containingObject, identifier));
-        }
-
-    }
-    
-}

lib/src/main/java/net/tomatentum/marinara/container/InteractionCheckContainer.java

@@ -1,19 +0,0 @@
-package net.tomatentum.marinara.container;
-
-import net.tomatentum.cutin.ReflectedMethodFactoryImpl;
-import net.tomatentum.cutin.container.LoneMethodContainer;
-import net.tomatentum.marinara.checks.CheckExecutionContext;
-import net.tomatentum.marinara.checks.CheckMethodIdentifier;
-import net.tomatentum.marinara.checks.CheckMethodIdentifier.CheckMethodType;
-import net.tomatentum.marinara.checks.InteractionCheckMethod.InteractionCheckMethodFactory;
-
-public class InteractionCheckContainer extends LoneMethodContainer<CheckMethodIdentifier, CheckExecutionContext> {
-    
-    public InteractionCheckContainer() {
-        super(new ReflectedMethodFactoryImpl<>());
-        super.factory()
-            .addFactory(new InteractionCheckMethodFactory(this, CheckMethodType.PRE))
-            .addFactory(new InteractionCheckMethodFactory(this, CheckMethodType.POST));
-    }
-
-}

lib/src/main/java/net/tomatentum/marinara/container/InteractionMethodContainer.java

@@ -1,38 +0,0 @@
-package net.tomatentum.marinara.container;
-
-import net.tomatentum.cutin.ReflectedMethodFactory;
-import net.tomatentum.cutin.ReflectedMethodFactoryImpl;
-import net.tomatentum.cutin.container.MethodContainer;
-import net.tomatentum.cutin.container.MultiMethodContainer;
-import net.tomatentum.cutin.method.ReflectedMethod;
-import net.tomatentum.marinara.checks.CheckExecutionContext;
-import net.tomatentum.marinara.checks.CheckMethodIdentifier;
-import net.tomatentum.marinara.interaction.components.methods.ButtonInteractionMethod;
-import net.tomatentum.marinara.interaction.ident.InteractionIdentifier;
-import net.tomatentum.marinara.wrapper.ContextObjectProvider;
-import net.tomatentum.marinara.interaction.methods.AutoCompleteInteractionMethod;
-import net.tomatentum.marinara.interaction.methods.SlashCommandInteractionMethod;
-
-public class InteractionMethodContainer extends MultiMethodContainer<InteractionIdentifier, Object> {
-
-
-    private static ReflectedMethodFactory<InteractionIdentifier, Object> createFactory(MethodContainer<CheckMethodIdentifier, CheckExecutionContext> checkRegistry, ContextObjectProvider cop) {
-        return new ReflectedMethodFactoryImpl<InteractionIdentifier, Object>()
-            .addFactory(new AutoCompleteInteractionMethod.Factory(checkRegistry, cop))
-            .addFactory(new SlashCommandInteractionMethod.Factory(checkRegistry, cop))
-            .addFactory(new ButtonInteractionMethod.Factory(checkRegistry, cop));
-    }
-
-    public InteractionMethodContainer(MethodContainer<CheckMethodIdentifier, CheckExecutionContext> checkRegistry, ContextObjectProvider cop) {
-        super(createFactory(checkRegistry, cop));
-    }
-
-    @Override
-    public MethodContainer<InteractionIdentifier, Object> addMethod(ReflectedMethod<InteractionIdentifier, Object> method) {
-        super.identifiers().stream()
-            .filter(method.identifier()::equals)
-            .forEach(i -> InteractionIdentifier.tryAddDescriptions(i, method.identifier()));
-        return super.addMethod(method);
-    }
-
-}

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

@@ -1,12 +0,0 @@
-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 AutoComplete {
-    public String value();
-}

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

@@ -1,112 +1,99 @@
 package net.tomatentum.marinara.interaction.commands;
 
-import java.util.HashSet;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.HashMap;
 import java.util.List;
-import java.util.Set;
 
-import org.slf4j.Logger;
+import net.tomatentum.marinara.interaction.commands.annotation.SlashCommand;
-import org.slf4j.LoggerFactory;
+import net.tomatentum.marinara.interaction.commands.annotation.SubCommand;
-
+import net.tomatentum.marinara.interaction.commands.annotation.SubCommandGroup;
-import net.tomatentum.marinara.interaction.commands.annotation.CommandChoices;
-import net.tomatentum.marinara.interaction.commands.annotation.SlashCommandOption;
-import net.tomatentum.marinara.interaction.commands.annotation.SlashCommandOption.PlaceHolderEnum;
-import net.tomatentum.marinara.interaction.commands.annotation.SlashCommandOptionChoice;
-import net.tomatentum.marinara.interaction.commands.choice.EnumChoices;
-import net.tomatentum.marinara.interaction.ident.InteractionIdentifier;
-import net.tomatentum.marinara.interaction.ident.RootCommandIdentifier;
-import net.tomatentum.marinara.interaction.ident.SlashCommandIdentifier;
 
 public class SlashCommandDefinition {
-
+    private List<ExecutableSlashCommandDefinition> executableDefinitons;
-    public static SlashCommandOptionChoice[] getActualChoices(SlashCommandOption option) {
+    private SlashCommand slashCommand;
-        CommandChoices choices = option.choices();
-        SlashCommandOptionChoice[] actualChoices = choices.value();
-        if (choices.value().length <= 0 && !choices.cenum().equals(PlaceHolderEnum.class))
-            actualChoices = EnumChoices.of(choices.cenum()).choices();
-        return actualChoices;
-    }
-
-    private Set<InteractionIdentifier> entries;
-    private RootCommandIdentifier rootIdentifier;
     private boolean isRootCommand;
 
-    private Logger logger = LoggerFactory.getLogger(getClass());
+    public SlashCommandDefinition(SlashCommand applicationCommand) {
-
+        this.executableDefinitons = new ArrayList<>();
-    public SlashCommandDefinition(RootCommandIdentifier rootIdentifier) {
+        this.slashCommand = applicationCommand;
-        this.entries = new HashSet<>();
-        this.rootIdentifier = rootIdentifier;
-        this.isRootCommand = false;
     }
 
-    public SlashCommandDefinition addIdentifier(InteractionIdentifier identifier) {
+    public SlashCommandDefinition addExecutableCommand(ExecutableSlashCommandDefinition def) {
-        RootCommandIdentifier rootIdentifier = (RootCommandIdentifier) identifier.rootNode();
+        if (def.applicationCommand() != null) {
-
+            if (slashCommand == null)
-        if (!this.rootIdentifier.equals(rootIdentifier))
+                this.slashCommand = def.applicationCommand();
-            throw new IllegalArgumentException("Root Node did not match.");
+            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 (this.rootIdentifier.description() == null)
-            this.rootIdentifier = rootIdentifier;
-
-        if (!isRootCommand)
-            this.isRootCommand = identifier.parent() == null ? true : false;
-
-        if ((isRootCommand && identifier.parent() != null) || (!isRootCommand && identifier.parent() == null)) {
-            throw new IllegalArgumentException(identifier.toString() + ": cannot have subcommands and rootcommand definitions together");
         }
 
-        entries.add(identifier);
+        if (executableDefinitons.isEmpty())
-        this.logger.debug("Added identifer {} to command {}", identifier, rootIdentifier);
+            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 SlashCommandIdentifier[] getSubCommandGroups() {
+    public SubCommandGroup[] getSubCommandGroups() {
-        if (isRootCommand)
+        List<SubCommandGroup> subCommandGroups = Arrays.stream(getExecutableDefinitons())
-            return null;
+            .filter((x) -> x.subCommandGroup() != null)
-        
+            .map((x) -> x.subCommandGroup())
-        List<InteractionIdentifier> subCommandGroups = entries().stream()
-            .filter(x -> x.parent().parent() != null)
-            .map(x -> x.parent())
             .toList();
 
-        return subCommandGroups.toArray(SlashCommandIdentifier[]::new);
+        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 SlashCommandIdentifier[] getSubCommands() {
+    public SubCommand[] getSubCommands(String groupName) {
-        if (isRootCommand)
+        List<SubCommand> subCommands;
-            return null;
+        if (groupName == null)
-        return entries.stream().filter(x -> x.parent() instanceof RootCommandIdentifier).toArray(SlashCommandIdentifier[]::new);
+            subCommands = Arrays.stream(getExecutableDefinitons())
-    }
+            .filter((x) -> x.subCommandGroup() == null && x.subCommand() != null)
-
+            .map((x) -> x.subCommand())
-    public SlashCommandIdentifier[] getSubCommands(String groupName) {
+            .toList();
-        if (isRootCommand)
+        else 
-            return null;
+            subCommands = Arrays.stream(getExecutableDefinitons())
-
+            .filter((x) -> x.subCommandGroup().name().equals(groupName) && x.subCommand() != null)
-        List<InteractionIdentifier> subCommands = entries().stream()
+            .map((x) -> x.subCommand())
-            .filter(x -> x.parent().parent() != null && x.parent().name().equals(groupName))
-            .map(x -> x.parent().parent())
             .toList();
         
-        return subCommands.toArray(SlashCommandIdentifier[]::new);
+        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]);
     }
 
-    @Override
+    public SlashCommand getFullSlashCommand() {
-    public boolean equals(Object obj) {
+        if (isRootCommand())
-        if (!(obj instanceof SlashCommandDefinition))
+            return getSlashCommand();
-            return false;
+        for (ExecutableSlashCommandDefinition executableSlashCommandDefinition : executableDefinitons) {
-        SlashCommandDefinition other = (SlashCommandDefinition) obj;
+            if (executableSlashCommandDefinition.options().length > 0)
-        return this.rootIdentifier().equals(other.rootIdentifier());
+                return executableSlashCommandDefinition.applicationCommand();
         }
 
-    public long[] serverIds() {
+        return null;
-        return rootIdentifier().serverIds();
     }
 
-    public Set<InteractionIdentifier> entries() {
+    public SlashCommand getSlashCommand() {
-        return this.entries;
+        return slashCommand;
     }
 
-    public RootCommandIdentifier rootIdentifier() {
+    public ExecutableSlashCommandDefinition[] getExecutableDefinitons() {
-        return rootIdentifier;
+        return executableDefinitons.toArray(new ExecutableSlashCommandDefinition[0]);
     }
 
     public boolean isRootCommand() {

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

@@ -1,8 +0,0 @@
-package net.tomatentum.marinara.interaction.commands.annotation;
-
-import net.tomatentum.marinara.interaction.commands.annotation.SlashCommandOption.PlaceHolderEnum;
-
-public @interface CommandChoices {
-    public SlashCommandOptionChoice[] value() default {};
-    public Class<? extends Enum<?>> cenum() default PlaceHolderEnum.class;
-}

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

@@ -1,6 +0,0 @@
-package net.tomatentum.marinara.interaction.commands.annotation;
-
-public @interface Range {
-    public double min() default Double.MIN_VALUE;
-    public double max() default Double.MAX_VALUE;
-}

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

@@ -5,7 +5,6 @@ import java.lang.annotation.Retention;
 import java.lang.annotation.RetentionPolicy;
 import java.lang.annotation.Target;
 
-import net.tomatentum.marinara.interaction.annotation.AutoComplete;
 import net.tomatentum.marinara.interaction.commands.option.SlashCommandOptionType;
 
 @Target({ElementType.ANNOTATION_TYPE})
@@ -15,11 +14,4 @@ public @interface SlashCommandOption {
     public String description() default "";
     public SlashCommandOptionType type() default SlashCommandOptionType.STRING;
     public boolean required() default false;
-    public AutoComplete[] autocompletes() default {};
-    public Range range() default @Range;
-    public CommandChoices choices() default @CommandChoices;
-
-    public enum PlaceHolderEnum {
-
-    }
 }

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

@@ -1,8 +0,0 @@
-package net.tomatentum.marinara.interaction.commands.annotation;
-
-public @interface SlashCommandOptionChoice {
-    public String name();
-    public long longValue() default Long.MAX_VALUE;
-    public double doubleValue() default Double.MAX_VALUE;
-    public String stringValue() default "";
-}

lib/src/main/java/net/tomatentum/marinara/interaction/commands/choice/ChoiceValueProvider.java

@@ -1,5 +0,0 @@
-package net.tomatentum.marinara.interaction.commands.choice;
-
-public interface ChoiceValueProvider<T> {
-    T getChoiceValue();
-}

lib/src/main/java/net/tomatentum/marinara/interaction/commands/choice/EnumChoices.java

@@ -1,78 +0,0 @@
-package net.tomatentum.marinara.interaction.commands.choice;
-
-import java.lang.reflect.InvocationTargetException;
-import java.lang.reflect.Method;
-import java.lang.reflect.ParameterizedType;
-import java.lang.reflect.Type;
-import java.util.ArrayList;
-import java.util.List;
-import java.util.Map;
-
-import io.leangen.geantyref.AnnotationFormatException;
-import io.leangen.geantyref.GenericTypeReflector;
-import io.leangen.geantyref.TypeFactory;
-import net.tomatentum.marinara.interaction.commands.annotation.SlashCommandOptionChoice;
-
-public record EnumChoices(Class<? extends Enum<?>> enumClass, ChoiceType type, SlashCommandOptionChoice[] choices) {
-
-    private static Method method;
-
-    static {
-        try {
-            method = ChoiceValueProvider.class.getMethod("getChoiceValue");
-        } catch (NoSuchMethodException | SecurityException e) {
-            e.printStackTrace();
-        }
-    }
-
-    public static EnumChoices of(Class<? extends Enum<?>> enumClass) {
-        if (!ChoiceValueProvider.class.isAssignableFrom(enumClass))
-            throw new IllegalArgumentException("Provided class needs to implement the ChoiceValueProvider interface.");
-        ChoiceType type = parseChoiceType(enumClass);
-        SlashCommandOptionChoice[] choices = parseChoices(enumClass, type);
-        return new EnumChoices(enumClass, type, choices);
-    }
-
-    private static ChoiceType parseChoiceType(Class<? extends Enum<?>> enumClass) {
-        ParameterizedType type = (ParameterizedType) GenericTypeReflector.getExactSuperType(enumClass, ChoiceValueProvider.class);
-        Type typeParam = type.getActualTypeArguments()[0];
-
-        if (!(typeParam instanceof Class<?>))
-            throw new IllegalArgumentException("ChoiceValueProvider need either a String or Number type parameter.");
-
-        if (Long.class.isAssignableFrom((Class<?>) typeParam))
-            return ChoiceType.INTEGER;
-        if (Double.class.isAssignableFrom((Class<?>) typeParam))
-            return ChoiceType.DOUBLE;
-        if (String.class.isAssignableFrom((Class<?>) typeParam))
-            return ChoiceType.String;
-        throw new IllegalArgumentException("ChoiceValueProvider need either a String, Number or Decimal type parameter.");
-    }
-
-    private static SlashCommandOptionChoice[] parseChoices(Class<? extends Enum<?>> enumClass, ChoiceType type) {
-        Enum<? extends Enum<?>>[] constants = enumClass.getEnumConstants();
-        List<SlashCommandOptionChoice> choices = new ArrayList<>();
-        for (Enum<? extends Enum<?>> enumInstance : constants) {
-            Object value;
-            try {
-                value = method.invoke(enumInstance);
-                if (type.equals(ChoiceType.INTEGER))
-                    choices.add(TypeFactory.annotation(SlashCommandOptionChoice.class, Map.of("name", enumInstance.name(), "longValue", value)));
-                if (type.equals(ChoiceType.DOUBLE))
-                    choices.add(TypeFactory.annotation(SlashCommandOptionChoice.class, Map.of("name", enumInstance.name(), "doubleValue", value)));
-                if (type.equals(ChoiceType.String))
-                    choices.add(TypeFactory.annotation(SlashCommandOptionChoice.class, Map.of("name", enumInstance.name(), "stringValue", value)));
-            } catch (IllegalAccessException | InvocationTargetException | AnnotationFormatException e) {
-                e.printStackTrace();
-                return null;
-            }
-        }
-        return choices.toArray(SlashCommandOptionChoice[]::new);
-    }
-
-    public static enum ChoiceType {
-        String,
-        INTEGER,
-        DOUBLE
-    }
-}

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

@@ -1,16 +0,0 @@
-package net.tomatentum.marinara.interaction.commands.option;
-
-import java.util.Arrays;
-
-import net.tomatentum.marinara.interaction.commands.annotation.SlashCommandOption;
-
-public record AutocompleteOptionData(String name, Object input) {
-    
-    public String[] getAutocompleteRefs(SlashCommandOption[] options) {
-        return Arrays.stream(options)
-            .filter(o -> o.name().equals(this.name()))
-            .flatMap(o -> Arrays.stream(o.autocompletes()))
-            .map(a -> a.value())
-            .toArray(String[]::new);
-    }
-}

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

@@ -1,35 +1,16 @@
 package net.tomatentum.marinara.interaction.commands.option;
 
 public enum SlashCommandOptionType {
-    SUB_COMMAND(1),
+    ATTACHMENT,
-    SUB_COMMAND_GROUP(2),
+    BOOLEAN,
-    STRING(3),
+    CHANNEL,
-    INTEGER(4),
+    DECIMAL,
-    BOOLEAN(5),
+    LONG,
-    USER(6),
+    MENTIONABLE,
-    CHANNEL(7),
+    ROLE,
-    ROLE(8),
+    STRING,
-    MENTIONABLE(9),
+    SUB_COMMAND,
-    DOUBLE(10),
+    SUB_COMMAND_GROUP,
-    ATTACHMENT(11),
+    UNKNOW,
-    UNKNOWN(-1);
+    USER
-
-    private final int value;
-
-    private SlashCommandOptionType(int value) {
-        this.value = value;
-    }
-
-    public int getValue() {
-        return value;
-    }
-
-    public static SlashCommandOptionType fromValue(int value) {
-        for (SlashCommandOptionType type : values()) {
-            if (type.getValue() == value) {
-                return type;
-            }
-        }
-        return UNKNOWN;
-    }
 }

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

@@ -1,93 +0,0 @@
-package net.tomatentum.marinara.interaction.components.methods;
-
-import java.lang.reflect.Method;
-import java.util.List;
-import java.util.Optional;
-import java.util.Set;
-
-import net.tomatentum.cutin.MethodParser;
-import net.tomatentum.cutin.ReflectedMethodFactory.ParserResults;
-import net.tomatentum.cutin.container.MethodContainer;
-import net.tomatentum.cutin.method.ReflectedMethod;
-import net.tomatentum.marinara.checks.AppliedCheck;
-import net.tomatentum.marinara.checks.CheckExecutionContext;
-import net.tomatentum.marinara.checks.CheckMethodIdentifier;
-import net.tomatentum.marinara.interaction.InteractionHandler;
-import net.tomatentum.marinara.interaction.InteractionType;
-import net.tomatentum.marinara.interaction.ident.InteractionIdentifier;
-import net.tomatentum.marinara.interaction.methods.InteractionMethod;
-import net.tomatentum.marinara.parser.ButtonParser;
-import net.tomatentum.marinara.parser.InteractionCheckParser;
-import net.tomatentum.marinara.wrapper.ContextObjectProvider;
-
-public class ButtonInteractionMethod extends InteractionMethod {
-
-    private String customId;
-    private ContextObjectProvider cop;
-
-    private ButtonInteractionMethod(
-            Method method, 
-            InteractionHandler handler,
-            List<AppliedCheck> appliedChecks,
-            String customId, 
-            ContextObjectProvider cop
-        ) {
-        super(method, handler, appliedChecks);
-        this.customId = customId;
-        this.cop = cop;
-    }
-
-    @Override
-    public Object getParameter(Object context, int index) {
-        Class<?> type = method().getParameterTypes()[index];
-        Object superResult = super.getParameter(context, index);
-        if (superResult == null)
-            return this.cop.getComponentContextObject(context, type);
-        else
-            return superResult;
-    }
-
-    @Override
-    public InteractionIdentifier identifier() {
-        return InteractionIdentifier.builder()
-            .name(customId)
-            .description("Button")
-            .type(InteractionType.BUTTON)
-            .build();
-    }
-
-    public static class Factory extends InteractionMethod.Factory {
-
-        private ContextObjectProvider cop;
-
-        public Factory(MethodContainer<CheckMethodIdentifier, CheckExecutionContext> checkContainer, ContextObjectProvider cop) {
-            super(checkContainer);
-            this.cop = cop;
-        }
-
-        @Override
-        public Optional<ReflectedMethod<InteractionIdentifier, Object>> produce(Method method, Object containingObject, ParserResults parserResults) {
-            if (!(containingObject instanceof InteractionHandler)) return Optional.empty();
-            String customId = parserResults.get(ButtonParser.class);
-            if (customId == null) return Optional.empty();
-            return Optional.of(new ButtonInteractionMethod(
-                method, 
-                (InteractionHandler) containingObject,
-                parserResults.get(InteractionCheckParser.class),
-                customId,
-                this.cop
-            ));
-        }
-
-        @Override
-        public void addParser(Set<MethodParser> parser) {
-            super.addParser(parser);
-
-            parser.add(
-                new ButtonParser()
-            );
-        }
-
-    }
-
-}

lib/src/main/java/net/tomatentum/marinara/interaction/ident/InteractionIdentifier.java

@@ -1,146 +0,0 @@
-package net.tomatentum.marinara.interaction.ident;
-
-import java.util.Objects;
-
-import net.tomatentum.marinara.interaction.InteractionType;
-
-public class InteractionIdentifier {
-
-    public static InteractionIdentifier.Builder builder() {
-        return new InteractionIdentifier.Builder();
-    }
-
-    public static RootCommandIdentifier.Builder rootBuilder() {
-        return new RootCommandIdentifier.Builder();
-    }
-
-    public static SlashCommandIdentifier.Builder slashBuilder() {
-        return new SlashCommandIdentifier.Builder();
-    }
-
-    public static InteractionIdentifier createHierarchy(InteractionType type, String... names) {
-        InteractionIdentifier last = null;
-        for (String string : names) {
-            last = builder().name(string).type(type).parent(last).build();
-        }
-        return last;
-    }
-
-    public static void tryAddDescriptions(InteractionIdentifier receiver, InteractionIdentifier provider) {
-        if (receiver == null || provider == null)
-            return;
-
-        if (receiver.description().isBlank())
-            receiver.description = provider.description();
-        tryAddDescriptions(receiver.parent(), provider.parent());
-    }
-
-    private InteractionIdentifier parent;
-    private String name;
-    private String description;
-    private InteractionType type;
-
-    InteractionIdentifier(InteractionIdentifier parent, String name, String description, InteractionType type) {
-        this.parent = parent;
-        this.name = name;
-        this.description = description;
-        this.type = type;
-    }
-
-    public InteractionIdentifier rootNode() { return rootNode(this); }
-
-    private InteractionIdentifier rootNode(InteractionIdentifier identifier) {
-        if (identifier.parent() == null)
-            return identifier;
-        return rootNode(identifier.parent());
-    }
-
-    public String name() {
-        return name;
-    }
-
-    public String description() {
-        return description;
-    }
-
-    public InteractionIdentifier parent() {
-        return parent;
-    }
-
-    public InteractionType type() {
-        return type;
-    }
-
-    @Override
-    public boolean equals(Object obj) {
-        if (!(obj instanceof InteractionIdentifier))
-            return false;
-        InteractionIdentifier ident = (InteractionIdentifier) obj;
-        if (!type().equals(ident.type()))
-            return false;
-        if (!name().equals(ident.name()))
-            return false;
-        return Objects.equals(parent(), ident.parent());
-    }
-
-    @Override
-    public int hashCode() {
-        return Objects.hash(type(), name(), parent());
-    }
-
-    @Override
-    public String toString() {
-        if (parent() == null)
-            return name() + " - " + type();
-        return "%s:%s".formatted(name(), parent().toString());
-    }
-
-    public static class Builder {
-        private InteractionIdentifier parent;
-        private String name;
-        private String description;
-        private InteractionType type;
-
-        public InteractionIdentifier parent() {
-            return parent;
-        }
-
-        public Builder parent(InteractionIdentifier parent) {
-            this.parent = parent;
-            return this;
-        }
-
-        public String name() {
-            return name;
-        }
-
-        public Builder name(String name) {
-            this.name = name;
-            return this;
-        }
-
-        public String description() {
-            return description;
-        }
-
-        public Builder description(String description) {
-            this.description = description;
-            return this;
-        }
-
-        public InteractionType type() {
-            return type;
-        }
-
-        public Builder type(InteractionType type) {
-            this.type = type;
-            return this;
-        }
-
-        public InteractionIdentifier build() {
-            return new InteractionIdentifier(parent, name, description, type);
-        }
-
-    }
-    
-}

lib/src/main/java/net/tomatentum/marinara/interaction/ident/RootCommandIdentifier.java

@@ -1,99 +0,0 @@
-package net.tomatentum.marinara.interaction.ident;
-
-import net.tomatentum.marinara.interaction.InteractionType;
-import net.tomatentum.marinara.interaction.commands.annotation.SlashCommandOption;
-
-public class RootCommandIdentifier extends SlashCommandIdentifier {
-
-    private long[] serverIds;
-
-    public RootCommandIdentifier(
-            InteractionIdentifier parent, 
-            String name, 
-            String description, 
-            InteractionType type,
-            SlashCommandOption[] options, 
-            long[] serverIds) {
-        super(parent, name, description, type, options);
-        this.serverIds = serverIds;
-    }
-
-    public long[] serverIds() {
-        return serverIds;
-    }
-
-    public static class Builder {
-        private InteractionIdentifier parent;
-        private String name;
-        private String description;
-        private SlashCommandOption[] options;
-        private long[] serverIds;
-        private String[] autocompleteRef;
-
-        public InteractionIdentifier parent() {
-            return parent;
-        }
-
-        public Builder parent(InteractionIdentifier parent) {
-            this.parent = parent;
-            return this;
-        }
-
-        public String name() {
-            return name;
-        }
-
-        public Builder name(String name) {
-            this.name = name;
-            return this;
-        }
-
-        public String description() {
-            return this.description;
-        }
-
-        public Builder description(String description) {
-            this.description = description;
-            return this;
-        }
-
-        public SlashCommandOption[] options() {
-            return this.options;
-        }
-
-        public Builder options(SlashCommandOption[] options) {
-            this.options = options;
-            return this;
-        }
-
-        public long[] serverIds() {
-            return this.serverIds;
-        }
-
-        public Builder serverIds(long[] serverIds) {
-            this.serverIds = serverIds;
-            return this;
-        }
-
-        public String[] autocompleteRef() {
-            return this.autocompleteRef;
-        }
-
-        public Builder autocompleteRef(String[] autocompleteRef) {
-            this.autocompleteRef = autocompleteRef;
-            return this;
-        }
-
-        public SlashCommandIdentifier build() {
-            return new RootCommandIdentifier(
-                parent, 
-                name, 
-                description, 
-                InteractionType.COMMAND, 
-                options, 
-                serverIds);
-        }
-
-    }
-    
-}

lib/src/main/java/net/tomatentum/marinara/interaction/ident/SlashCommandIdentifier.java

@@ -1,87 +0,0 @@
-package net.tomatentum.marinara.interaction.ident;
-
-import net.tomatentum.marinara.interaction.InteractionType;
-import net.tomatentum.marinara.interaction.commands.annotation.SlashCommandOption;
-
-public class SlashCommandIdentifier extends InteractionIdentifier {
-
-    private SlashCommandOption[] options;
-
-    protected SlashCommandIdentifier(
-            InteractionIdentifier parent, 
-            String name, 
-            String description,
-            InteractionType type,
-            SlashCommandOption[] options) {
-        super(parent, name, description, type);
-        this.options = options;
-    }
-
-    public SlashCommandOption[] options() {
-        return this.options;
-    }
-
-    public static class Builder {
-        private InteractionIdentifier parent;
-        private String name;
-        private String description;
-        private SlashCommandOption[] options;
-        private String[] autocompleteRef;
-
-        public InteractionIdentifier parent() {
-            return parent;
-        }
-
-        public Builder parent(InteractionIdentifier parent) {
-            this.parent = parent;
-            return this;
-        }
-
-        public String name() {
-            return name;
-        }
-
-        public Builder name(String name) {
-            this.name = name;
-            return this;
-        }
-
-        public String description() {
-            return this.description;
-        }
-
-        public Builder description(String description) {
-            this.description = description;
-            return this;
-        }
-
-        public SlashCommandOption[] options() {
-            return this.options;
-        }
-
-        public Builder options(SlashCommandOption[] options) {
-            this.options = options;
-            return this;
-        }
-
-        public String[] autocompleteRef() {
-            return this.autocompleteRef;
-        }
-
-        public Builder autocompleteRef(String[] autocompleteRef) {
-            this.autocompleteRef = autocompleteRef;
-            return this;
-        }
-
-        public SlashCommandIdentifier build() {
-            return new SlashCommandIdentifier(
-                parent, 
-                name, 
-                description, 
-                InteractionType.COMMAND, 
-                options);
-        }
-
-    }
-    
-}

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

@@ -1,98 +0,0 @@
-package net.tomatentum.marinara.interaction.methods;
-
-import java.lang.reflect.Method;
-import java.util.List;
-import java.util.Optional;
-import java.util.Set;
-
-import net.tomatentum.cutin.MethodParser;
-import net.tomatentum.cutin.ReflectedMethodFactory.ParserResults;
-import net.tomatentum.cutin.container.MethodContainer;
-import net.tomatentum.cutin.method.ReflectedMethod;
-import net.tomatentum.marinara.checks.AppliedCheck;
-import net.tomatentum.marinara.checks.CheckExecutionContext;
-import net.tomatentum.marinara.checks.CheckMethodIdentifier;
-import net.tomatentum.marinara.interaction.InteractionHandler;
-import net.tomatentum.marinara.interaction.InteractionType;
-import net.tomatentum.marinara.interaction.ident.InteractionIdentifier;
-import net.tomatentum.marinara.parser.AutocompleteParser;
-import net.tomatentum.marinara.parser.InteractionCheckParser;
-import net.tomatentum.marinara.wrapper.ContextObjectProvider;
-
-public class AutoCompleteInteractionMethod extends InteractionMethod {
-
-    private String autocompleteRef;
-    private ContextObjectProvider cop;
-
-    private AutoCompleteInteractionMethod(
-            Method method, 
-            InteractionHandler handler,
-            List<AppliedCheck> appliedChecks,
-            String autocompleteRef,
-            ContextObjectProvider cop
-        ) {
-        super(method, handler, appliedChecks);
-        this.autocompleteRef = autocompleteRef;
-        this.cop = cop;
-    }
-
-    @Override
-    public Object getParameter(Object context, int index) {
-        Class<?> type = method().getParameterTypes()[index];
-        Object contextObject = this.cop.getInteractionContextObject(context, type);
-        if (contextObject != null)
-            return contextObject;
-
-        Object autocompleteOptionValue = this.cop.getAutocompleteFocusedOption(context).input();
-        if (type.isInstance(autocompleteOptionValue))
-            return autocompleteOptionValue;
-
-        return super.getParameter(context, index);
-    }
-
-    @Override
-    public InteractionIdentifier identifier() {
-        return InteractionIdentifier.builder()
-            .type(InteractionType.AUTOCOMPLETE)
-            .name(autocompleteRef)
-            .description("AUTOCOMPLETE")
-            .build();
-    }
-
-    public static class Factory extends InteractionMethod.Factory {
-
-        private ContextObjectProvider cop;
-
-        public Factory(MethodContainer<CheckMethodIdentifier, CheckExecutionContext> checkContainer, ContextObjectProvider cop) {
-            super(checkContainer);
-            this.cop = cop;
-        }
-
-        @Override
-        public Optional<ReflectedMethod<InteractionIdentifier, Object>> produce(Method method, Object containingObject, ParserResults parserResults) {
-            if (!(containingObject instanceof InteractionHandler)) return Optional.empty();
-            String[] autocompletes = parserResults.get(AutocompleteParser.class);
-            if (autocompletes.length <= 0) return Optional.empty();
-            
-            return Optional.of(new AutoCompleteInteractionMethod(
-                method, 
-                (InteractionHandler) containingObject,
-                parserResults.get(InteractionCheckParser.class),
-                autocompletes[0],
-                cop
-            ));
-
-        }
-
-        @Override
-        public void addParser(Set<MethodParser> parser) {
-            super.addParser(parser);
-
-            parser.add(
-                new AutocompleteParser()
-            );
-        }
-
-    }
-    
-}

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,72 +1,68 @@
 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 java.util.Set;
 
-import net.tomatentum.cutin.MethodParser;
-import net.tomatentum.cutin.ReflectedMethodFactory;
-import net.tomatentum.cutin.container.MethodContainer;
-import net.tomatentum.cutin.method.ReflectedMethod;
-import net.tomatentum.marinara.checks.AppliedCheck;
-import net.tomatentum.marinara.checks.CheckExecutionContext;
-import net.tomatentum.marinara.checks.CheckMethodIdentifier;
 import net.tomatentum.marinara.interaction.InteractionHandler;
-import net.tomatentum.marinara.interaction.ident.InteractionIdentifier;
+import net.tomatentum.marinara.interaction.InteractionType;
-import net.tomatentum.marinara.parser.InteractionCheckParser;
+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 extends ReflectedMethod<InteractionIdentifier, Object> {
+public abstract class InteractionMethod {
 
-    protected List<AppliedCheck> appliedChecks;
+    public static InteractionMethod create(Method method, InteractionHandler handler, LibraryWrapper wrapper) {
-
+        if (method.isAnnotationPresent(SlashCommand.class) || method.isAnnotationPresent(SubCommand.class))
-    protected InteractionMethod(
+            return new SlashCommandInteractionMethod(method, handler, wrapper);
-        Method method, 
+        if (method.isAnnotationPresent(Button.class))
-        InteractionHandler handler,
+            return new ButtonInteractionMethod(method, handler, wrapper);
-        List<AppliedCheck> appliedChecks
-        ) {
-        super(method, handler);
-        this.appliedChecks = appliedChecks;
-    }
-
-    @Override
-    public Object getParameter(Object context, int index) {
-        if (index == 0)
-            return context;
         return null;
     }
 
-    @Override
+    protected Method method;
-    public Object run(Object context) {
+    protected InteractionHandler handler;
-        Object result = null;
+    protected LibraryWrapper wrapper;
-        if (this.appliedChecks.stream().filter(x -> !x.pre(context)).count() > 0)
-            return null;
 
-        result = super.run(context);
+    protected InteractionMethod(Method method, InteractionHandler handler, LibraryWrapper wrapper) {
-
+        if (!Arrays.asList(handler.getClass().getMethods()).contains(method))
-        this.appliedChecks.forEach(x -> x.post(context));
+            throw new InvalidParameterException("Method does not apply to specified handler");
-
+        this.method = method;
-        return result;
+        this.handler = handler;
+        this.wrapper = wrapper;
     }
 
-    public List<AppliedCheck> appliedChecks() {
+    public abstract Object getParameter(Object parameter, int index);
-        return this.appliedChecks;
+
-    }
+    public abstract boolean canRun(Object context);
-
+
-    public abstract static class Factory implements ReflectedMethodFactory.Factory<InteractionIdentifier, Object> {
+    public abstract InteractionType getType();
-
+
-        private MethodContainer<CheckMethodIdentifier, CheckExecutionContext> checkContainer;
+    public void run(Object context) {
-
+        int parameterCount = method.getParameterCount();
-        protected Factory(MethodContainer<CheckMethodIdentifier, CheckExecutionContext> checkContainer) {
+        List<Object> parameters = new ArrayList<>();
-            this.checkContainer = checkContainer;
+        
-        }
+        for (int i = 0; i < parameterCount; i++) {
-
+            if (i == 0) {
-        @Override
+                parameters.add(context);
-        public void addParser(Set<MethodParser> parser) {
+                continue;
-            parser.add(
+            }
-                new InteractionCheckParser(this.checkContainer)
+            parameters.add(getParameter(context, i-1));
-            );
+        }
+        method.setAccessible(true);
+        try {
+            method.invoke(handler, parameters.toArray());
+        }catch (IllegalAccessException | InvocationTargetException ex) {
+            throw new RuntimeException(ex);
+        }
     }
 
+    public Method getMethod() {
+        return method;
     }
 
 }

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

@@ -1,87 +1,63 @@
 package net.tomatentum.marinara.interaction.methods;
 
 import java.lang.reflect.Method;
-import java.util.List;
-import java.util.Optional;
-import java.util.Set;
 
-import net.tomatentum.cutin.MethodParser;
-import net.tomatentum.cutin.ReflectedMethodFactory.ParserResults;
-import net.tomatentum.cutin.container.MethodContainer;
-import net.tomatentum.cutin.method.ReflectedMethod;
-import net.tomatentum.marinara.checks.AppliedCheck;
-import net.tomatentum.marinara.checks.CheckExecutionContext;
-import net.tomatentum.marinara.checks.CheckMethodIdentifier;
 import net.tomatentum.marinara.interaction.InteractionHandler;
-import net.tomatentum.marinara.interaction.ident.InteractionIdentifier;
+import net.tomatentum.marinara.interaction.InteractionType;
-import net.tomatentum.marinara.interaction.ident.SlashCommandIdentifier;
+import net.tomatentum.marinara.interaction.commands.ExecutableSlashCommandDefinition;
-import net.tomatentum.marinara.parser.InteractionCheckParser;
+import net.tomatentum.marinara.interaction.commands.annotation.SlashCommand;
-import net.tomatentum.marinara.parser.SlashCommandParser;
+import net.tomatentum.marinara.interaction.commands.annotation.SubCommand;
-import net.tomatentum.marinara.wrapper.ContextObjectProvider;
+import net.tomatentum.marinara.interaction.commands.annotation.SubCommandGroup;
+import net.tomatentum.marinara.util.ReflectionUtil;
+import net.tomatentum.marinara.wrapper.LibraryWrapper;
 
 public class SlashCommandInteractionMethod extends InteractionMethod {
 
-    private SlashCommandIdentifier identifier;
+    private ExecutableSlashCommandDefinition commandDefinition;
-    private ContextObjectProvider cop;
 
-    private SlashCommandInteractionMethod(
+    SlashCommandInteractionMethod(Method method, InteractionHandler handler, LibraryWrapper wrapper) {
-            Method method, 
+        super(method, handler, wrapper);
-            InteractionHandler handler,
+        parseMethod();
-            List<AppliedCheck> appliedChecks,
-            SlashCommandIdentifier identifier,
-            ContextObjectProvider cop
-        ) {
-        super(method, handler, appliedChecks);
-        this.identifier = identifier;
-        this.cop = cop;
     }
 
     @Override
     public Object getParameter(Object context, int index) {
-        Object superResult = super.getParameter(context, index);
+        return wrapper.convertCommandOption(context, commandDefinition.options()[index].type(), commandDefinition.options()[index].name());
-        if (superResult == null)
-            return this.cop.convertCommandOption(context, identifier.options()[index-1].name());
-        else
-            return superResult;
     }
 
     @Override
-    public InteractionIdentifier identifier() {
+    public boolean canRun(Object context) {
-        return identifier;
+        ExecutableSlashCommandDefinition other = wrapper.getCommandDefinition(context);
-    }
+        return commandDefinition.equals(other);
-
-    public static class Factory extends InteractionMethod.Factory {
-
-        private ContextObjectProvider cop;
-
-        public Factory(MethodContainer<CheckMethodIdentifier, CheckExecutionContext> checkContainer, ContextObjectProvider cop) {
-            super(checkContainer);
-            this.cop = cop;
     }
 
     @Override
-        public Optional<ReflectedMethod<InteractionIdentifier, Object>> produce(Method method, Object containingObject, ParserResults parserResults) {
+    public InteractionType getType() {
-            if (!(containingObject instanceof InteractionHandler)) return Optional.empty();
+        return InteractionType.COMMAND;
-            SlashCommandIdentifier ident = parserResults.get(SlashCommandParser.class);
-            if (ident == null) return Optional.empty();
-            return Optional.of(new SlashCommandInteractionMethod(
-                method, 
-                (InteractionHandler) containingObject,
-                parserResults.get(InteractionCheckParser.class),
-                ident,
-                cop
-            ));
     }
 
-        @Override
+    public ExecutableSlashCommandDefinition getCommandDefinition() {
-        public void addParser(Set<MethodParser> parser) {
+        return commandDefinition;
-            super.addParser(parser);
+    }
-
-            parser.add(
-                new SlashCommandParser()
-            );
-        }
 
+    private void parseMethod() {
+        ReflectionUtil.checkValidCommandMethod(method);
+
+        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.setSubCommandGroup(cmdGroup);
+        }
+
+        if (ReflectionUtil.isAnnotationPresent(method, SubCommand.class)) {
+            SubCommand subCmd = ReflectionUtil.getAnnotation(method, SubCommand.class);
+            builder.setSubCommand(subCmd);
+        }
+
+        this.commandDefinition = builder.build();
     }
 
 }

lib/src/main/java/net/tomatentum/marinara/interaction/processor/AutocompleteInteractionProcessor.java

@@ -1,54 +0,0 @@
-package net.tomatentum.marinara.interaction.processor;
-
-import java.util.Arrays;
-import java.util.List;
-import java.util.Objects;
-import java.util.Optional;
-import java.util.Set;
-
-import net.tomatentum.cutin.container.MethodContainer;
-import net.tomatentum.marinara.interaction.InteractionType;
-import net.tomatentum.marinara.interaction.ident.InteractionIdentifier;
-import net.tomatentum.marinara.interaction.ident.SlashCommandIdentifier;
-import net.tomatentum.marinara.wrapper.IdentifierProvider;
-import net.tomatentum.marinara.wrapper.LibraryWrapper;
-
-public class AutocompleteInteractionProcessor extends InteractionMethodProcessor {
-
-    private LibraryWrapper wrapper;
-
-    public AutocompleteInteractionProcessor(LibraryWrapper wrapper, IdentifierProvider provider) {
-        super(provider, Set.of(InteractionType.AUTOCOMPLETE));
-        this.wrapper = wrapper;
-    }
-
-    @Override
-    public void processInteraction(Object context, MethodContainer<InteractionIdentifier, Object> container, InteractionIdentifier identifier) {
-        Optional<InteractionIdentifier> oIdent = container.identifiers().stream()
-            .filter(i -> convertToCommandIdentifier(identifier).equals(i))
-            .findFirst();
-        if (oIdent.isPresent() && oIdent.get() instanceof SlashCommandIdentifier sIdent) {
-            List<String> autocompleteRefs = Arrays.asList(this.wrapper.getContextObjectProvider()
-                .getAutocompleteFocusedOption(context).getAutocompleteRefs(sIdent.options()));
-            List<Object> results = container.methods().stream()
-                .filter(m -> m.identifier().type().equals(InteractionType.AUTOCOMPLETE))
-                .filter(m -> autocompleteRefs.contains(m.identifier().name()))
-                .map(m -> m.run(context))
-                .filter(Objects::nonNull)
-                .toList();
-            if (!results.isEmpty())
-                this.wrapper.respondAutocomplete(context, results);
-        }
-    }
-
-    private InteractionIdentifier convertToCommandIdentifier(InteractionIdentifier identifier) {
-        if (Objects.isNull(identifier))
-            return null;
-        return InteractionIdentifier.builder()
-            .type(InteractionType.COMMAND)
-            .name(identifier.name())
-            .parent(convertToCommandIdentifier(identifier.parent()))
-            .build();
-    }
-    
-}

lib/src/main/java/net/tomatentum/marinara/interaction/processor/DirectInteractionProcessor.java

@@ -1,22 +0,0 @@
-package net.tomatentum.marinara.interaction.processor;
-
-import java.util.Set;
-
-import net.tomatentum.cutin.container.MethodContainer;
-import net.tomatentum.marinara.interaction.InteractionType;
-import net.tomatentum.marinara.interaction.ident.InteractionIdentifier;
-import net.tomatentum.marinara.wrapper.IdentifierProvider;
-
-public class DirectInteractionProcessor extends InteractionMethodProcessor {
-
-
-    public DirectInteractionProcessor(IdentifierProvider provider, InteractionType... types) {
-        super(provider, Set.of(types));
-    }
-
-    @Override
-    protected void processInteraction(Object context, MethodContainer<InteractionIdentifier, Object> container, InteractionIdentifier identifier) {
-        container.findFor(identifier).forEach(m -> m.run(context));
-    }
-    
-}

lib/src/main/java/net/tomatentum/marinara/interaction/processor/InteractionMethodProcessor.java

@@ -1,39 +0,0 @@
-package net.tomatentum.marinara.interaction.processor;
-
-import java.util.Set;
-
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
-
-import net.tomatentum.cutin.MethodProcessor;
-import net.tomatentum.cutin.container.MethodContainer;
-import net.tomatentum.marinara.interaction.InteractionType;
-import net.tomatentum.marinara.interaction.ident.InteractionIdentifier;
-import net.tomatentum.marinara.wrapper.IdentifierProvider;
-
-public abstract class InteractionMethodProcessor implements MethodProcessor<InteractionIdentifier, Object> {
-
-    private Logger logger = LoggerFactory.getLogger(getClass());
-
-    private IdentifierProvider provider;
-    private Set<InteractionType> types;
-
-    protected InteractionMethodProcessor(IdentifierProvider provider, Set<InteractionType> types) {
-        this.provider = provider;
-        this.types = types;
-    }
-
-    @Override
-    public void process(Object context, MethodContainer<InteractionIdentifier, Object> container) {
-        InteractionIdentifier identifier = this.provider.provide(context);
-        if (!this.types.contains(identifier.type())) return;
-        logger.debug("Processing {} : {} with context {}", identifier, identifier.type(), context);
-        this.processInteraction(context, container, identifier);
-    }
-
-    protected abstract void processInteraction(
-        Object context, 
-        MethodContainer<InteractionIdentifier, Object> container, 
-        InteractionIdentifier identifier);
-    
-}

lib/src/main/java/net/tomatentum/marinara/parser/AutocompleteParser.java

@@ -1,27 +0,0 @@
-package net.tomatentum.marinara.parser;
-
-import java.lang.reflect.Method;
-import java.util.Arrays;
-
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
-
-import net.tomatentum.cutin.MethodParser;
-import net.tomatentum.cutin.util.ReflectionUtil;
-import net.tomatentum.marinara.interaction.annotation.AutoComplete;
-
-public class AutocompleteParser implements MethodParser {
-
-    private Logger logger = LoggerFactory.getLogger(getClass());
-
-    @Override
-    public Object parse(Method method, Object containingObject) {
-        String[] autoCompletes = Arrays.stream(method.getAnnotationsByType(AutoComplete.class))
-            .map(AutoComplete::value)
-            .toArray(String[]::new);
-        if (autoCompletes.length > 0)
-            logger.trace("Parsed AutoComplete annotations {} for method {}", autoCompletes, ReflectionUtil.getFullMethodName(method));
-        return autoCompletes;
-    }
-    
-}

lib/src/main/java/net/tomatentum/marinara/parser/ButtonParser.java

@@ -1,27 +0,0 @@
-package net.tomatentum.marinara.parser;
-
-import java.lang.reflect.Method;
-
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
-
-import net.tomatentum.cutin.MethodParser;
-import net.tomatentum.cutin.util.ReflectionUtil;
-import net.tomatentum.marinara.interaction.annotation.Button;
-
-public class ButtonParser implements MethodParser {
-    
-    private Logger logger = LoggerFactory.getLogger(getClass());
-
-    public ButtonParser() {
-    }
-
-    @Override
-    public Object parse(Method method, Object containingObject) {
-        Button button = method.getAnnotation(Button.class);
-        if (button == null) return null;
-        logger.trace("Parsed Button annotation {} for method {}", button, ReflectionUtil.getFullMethodName(method));
-        return button.value();
-    }
-    
-}

lib/src/main/java/net/tomatentum/marinara/parser/InteractionCheckClassParser.java

@@ -1,28 +0,0 @@
-package net.tomatentum.marinara.parser;
-
-import java.lang.reflect.Method;
-import java.lang.reflect.ParameterizedType;
-import java.lang.reflect.Type;
-
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
-
-import io.leangen.geantyref.GenericTypeReflector;
-import net.tomatentum.cutin.MethodParser;
-import net.tomatentum.marinara.checks.InteractionCheck;
-
-public class InteractionCheckClassParser implements MethodParser {
-
-    private Logger logger = LoggerFactory.getLogger(getClass());
-
-    @Override
-    public Object parse(Method method, Object containingObject) {
-        ParameterizedType type = (ParameterizedType) GenericTypeReflector.getExactSuperType(containingObject.getClass(), InteractionCheck.class);
-        if (type == null) return null;
-        Type typeParam = type.getActualTypeArguments().length == 1 ? type.getActualTypeArguments()[0] : null;
-        if (typeParam != null)
-            logger.trace("Parsed InteractionCheck Annotation {}", typeParam);
-        return typeParam;
-    }
-    
-}

lib/src/main/java/net/tomatentum/marinara/parser/InteractionCheckParser.java

@@ -1,49 +0,0 @@
-package net.tomatentum.marinara.parser;
-
-import java.lang.annotation.Annotation;
-import java.lang.reflect.Method;
-import java.util.Arrays;
-import java.util.Objects;
-
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
-
-import net.tomatentum.cutin.MethodParser;
-import net.tomatentum.cutin.container.MethodContainer;
-import net.tomatentum.cutin.util.ReflectionUtil;
-import net.tomatentum.marinara.checks.AppliedCheck;
-import net.tomatentum.marinara.checks.CheckExecutionContext;
-import net.tomatentum.marinara.checks.CheckMethodIdentifier;
-import net.tomatentum.marinara.checks.CheckMethodIdentifier.CheckMethodType;
-
-public class InteractionCheckParser implements MethodParser {
-
-    private MethodContainer<CheckMethodIdentifier, CheckExecutionContext> checkContainer;
-
-    private Logger logger = LoggerFactory.getLogger(getClass());
-
-    public InteractionCheckParser(MethodContainer<CheckMethodIdentifier, CheckExecutionContext> checkContainer) {
-        this.checkContainer = checkContainer;
-    }
-
-    @Override
-    public Object parse(Method method, Object containingObject) {
-        Annotation[] annotations = method.getAnnotations();
-        return Arrays.stream(annotations)
-            .map(a -> convertAnnotation(a, method))
-            .filter(Objects::nonNull)
-            .toList();
-    }
-
-    private AppliedCheck convertAnnotation(Annotation annotation, Method method) {
-            var preExec = this.checkContainer.findFirstFor(new CheckMethodIdentifier(annotation.annotationType(), CheckMethodType.PRE));
-            var postExec = this.checkContainer.findFirstFor(new CheckMethodIdentifier(annotation.annotationType(), CheckMethodType.POST));
-            if (preExec.isPresent() && postExec.isPresent())  {
-                AppliedCheck appliedCheck = new AppliedCheck(annotation, preExec.get(), postExec.get());
-                logger.trace("Parsed InteractionCheck {} for annotation {} for method {}", preExec.get().containingObject(), annotation, ReflectionUtil.getFullMethodName(method));
-                return appliedCheck;
-            }
-            return null;
-    }
-    
-}

lib/src/main/java/net/tomatentum/marinara/parser/SlashCommandParser.java

@@ -1,74 +0,0 @@
-package net.tomatentum.marinara.parser;
-
-import java.lang.reflect.Method;
-
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
-
-import net.tomatentum.cutin.MethodParser;
-import net.tomatentum.cutin.util.ReflectionUtil;
-import net.tomatentum.marinara.interaction.InteractionType;
-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.interaction.ident.InteractionIdentifier;
-
-public class SlashCommandParser implements MethodParser {
-
-    private Logger logger = LoggerFactory.getLogger(getClass());
-
-    public SlashCommandParser() {
-    }
-
-    @Override
-    public Object parse(Method method, Object containingObject) {
-        if (!method.isAnnotationPresent(SlashCommand.class) && !method.isAnnotationPresent(SubCommand.class)) return null;
-        this.checkValidCommandMethod(method);
-
-        SlashCommand cmd = ReflectionUtil.getAnnotation(method, SlashCommand.class);
-        InteractionIdentifier lastIdentifier = InteractionIdentifier.rootBuilder()
-            .name(cmd.name())
-            .description(cmd.description())
-            .options(cmd.options())
-            .serverIds(cmd.serverIds())
-            .build();
-
-        if (ReflectionUtil.isAnnotationPresent(method, SubCommandGroup.class)) {
-            SubCommandGroup cmdGroup = ReflectionUtil.getAnnotation(method, SubCommandGroup.class);
-            lastIdentifier = InteractionIdentifier.builder()
-                .name(cmdGroup.name())
-                .description(cmdGroup.description())
-                .type(InteractionType.COMMAND)
-                .parent(lastIdentifier)
-                .build();
-        }
-
-        if (ReflectionUtil.isAnnotationPresent(method, SubCommand.class)) {
-            SubCommand subCmd = ReflectionUtil.getAnnotation(method, SubCommand.class);
-            lastIdentifier = InteractionIdentifier.slashBuilder()
-                .name(subCmd.name())
-                .description(subCmd.description())
-                .options(subCmd.options())
-                .build();
-        }
-
-        logger.trace("Parsed using SlashCommandParser for method {} with the result: {}", ReflectionUtil.getFullMethodName(method), lastIdentifier);
-        return lastIdentifier;
-    }
-
-    private void checkValidCommandMethod(Method method) {
-        if (method.isAnnotationPresent(SlashCommand.class) && 
-            method.getDeclaringClass().isAnnotationPresent(SlashCommand.class)) {
-            throw new RuntimeException(method.getName() + ": Can't have SlashCommand Annotation on Class and Method");
-        }
-
-        if (!ReflectionUtil.isAnnotationPresent(method, SlashCommand.class))
-            throw new RuntimeException(method.getName() + ": Missing SlashCommand Annotation on either Class or Method");
-
-        if ((method.isAnnotationPresent(SubCommand.class) && 
-            !ReflectionUtil.isAnnotationPresent(method, SlashCommand.class))) {
-            throw new RuntimeException(method.getName() + ": Missing SlashCommand Annotation on either Method or Class");
-        }
-    }
-    
-}

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

@@ -0,0 +1,61 @@
+package net.tomatentum.marinara.registry;
+
+import java.lang.reflect.Method;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Optional;
+
+import net.tomatentum.marinara.interaction.InteractionHandler;
+import net.tomatentum.marinara.interaction.InteractionType;
+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;
+
+public class InteractionRegistry {
+    private List<InteractionMethod> interactionMethods;
+    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()) {
+            InteractionMethod iMethod = InteractionMethod.create(method, interactionHandler, wrapper);
+            if (iMethod != null)
+                this.interactionMethods.add(iMethod);
+        }
+    }
+
+    public void registerCommands() {
+        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<SlashCommandDefinition> appDef = defs.stream()
+                .filter((x) -> x.getSlashCommand().equals(def.applicationCommand()))
+                .findFirst();
+            if (appDef.isPresent())
+                appDef.get().addExecutableCommand(def);
+            else
+                defs.add(new SlashCommandDefinition(def.applicationCommand()).addExecutableCommand(def));
+        });
+
+        wrapper.registerSlashCommands(defs.toArray(new SlashCommandDefinition[0]));
+    }
+
+    public void handle(Object context) {
+        interactionMethods.forEach((m) -> {
+            InteractionType type = wrapper.getInteractionType(context.getClass());
+            if (m.getType().equals(type))
+                m.run(context);
+        });
+    }
+}

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

@@ -1,46 +0,0 @@
-package net.tomatentum.marinara.util;
-
-import java.util.Collection;
-import java.util.HashMap;
-import java.util.Map;
-import java.util.function.BiConsumer;
-import java.util.function.Function;
-import java.util.function.Supplier;
-
-public class ObjectAggregator<O, K, V> {
-    private Function<O, Iterable<K>> keySupplier;
-    private BiConsumer<V, O> valueConsumer;
-    private Function<K, V> defaultGenerator;
-
-    public ObjectAggregator(
-            Function<O, Iterable<K>> keySupplier, 
-            BiConsumer<V, O> valueConsumer, 
-            Function<K, V> defaultGenerator) {
-        this.keySupplier = keySupplier;
-        this.valueConsumer = valueConsumer;
-        this.defaultGenerator = defaultGenerator;
-    }
-
-    public ObjectAggregator(
-            Function<O, Iterable<K>> keySupplier, 
-            BiConsumer<V, O> valueConsumer, 
-            Supplier<V> defaultGenerator) {
-        this.keySupplier = keySupplier;
-        this.valueConsumer = valueConsumer;
-        this.defaultGenerator = _ -> defaultGenerator.get();
-    }
-
-    public Collection<V> aggregate(Iterable<O> iterator) {
-        Map<K, V> map = new HashMap<>();
-        for (O element : iterator) {
-            Iterable<K> keys = this.keySupplier.apply(element);
-            for (K key : keys) {
-                V value = map.getOrDefault(key, this.defaultGenerator.apply(key));
-                this.valueConsumer.accept(value, element);
-                map.putIfAbsent(key, value);
-            }
-        }
-        return map.values();
-    }
-
-}

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

@@ -1,15 +0,0 @@
-package net.tomatentum.marinara.util;
-
-import java.util.ArrayList;
-import java.util.function.Function;
-
-public class ObjectListAggregator<O, K, V> extends ObjectAggregator<O, K, ArrayList<V>> {
-
-    public ObjectListAggregator(Function<O, Iterable<K>> keySupplier, Function<O, V> valueConsumer) {
-        super(keySupplier, 
-        (l, o) -> l.add(valueConsumer.apply(o)),
-        () -> new ArrayList<>());
-    }
-
-    
-}

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

@@ -0,0 +1,39 @@
+package net.tomatentum.marinara.util;
+
+import java.lang.annotation.Annotation;
+import java.lang.reflect.Method;
+
+import net.tomatentum.marinara.interaction.commands.annotation.SlashCommand;
+import net.tomatentum.marinara.interaction.commands.annotation.SubCommand;
+
+public final class ReflectionUtil {
+
+    public static <T extends Annotation> boolean isAnnotationPresent(Method method, Class<T> annotationClass) {
+        if (method.isAnnotationPresent(annotationClass) || method.getDeclaringClass().isAnnotationPresent(annotationClass))
+            return true;
+
+        return false;
+    }
+
+    public static <T extends Annotation> T getAnnotation(Method method, Class<T> annotationClass) {
+        return method.isAnnotationPresent(annotationClass) ? 
+            method.getAnnotation(annotationClass) : 
+            method.getDeclaringClass().getAnnotation(annotationClass);
+    }
+
+    public static void checkValidCommandMethod(Method method) {
+        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, SlashCommand.class))
+            throw new RuntimeException(method.getName() + ": Missing ApplicationCommand Annotation on either Class or Method");
+
+        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/CommandConverter.java

@@ -1,70 +0,0 @@
-package net.tomatentum.marinara.wrapper;
-
-import java.util.ArrayList;
-import java.util.Arrays;
-import java.util.List;
-
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
-
-import net.tomatentum.marinara.interaction.commands.SlashCommandDefinition;
-import net.tomatentum.marinara.interaction.commands.annotation.SlashCommandOption;
-import net.tomatentum.marinara.interaction.commands.annotation.SlashCommandOptionChoice;
-import net.tomatentum.marinara.interaction.ident.InteractionIdentifier;
-import net.tomatentum.marinara.interaction.ident.RootCommandIdentifier;
-import net.tomatentum.marinara.interaction.ident.SlashCommandIdentifier;
-
-public class CommandConverter<A extends Object, O extends Object, C extends Object> {
-
-    public static <A, O, C> CommandConverter<A, O, C> of(Spec<A, O, C> spec) {
-        return new CommandConverter<>(spec);
-    }
-
-    private Logger logger = LoggerFactory.getLogger(getClass());
-
-    private Spec<A, O, C> spec;
-
-    CommandConverter(Spec<A, O, C> spec) {
-        this.spec = spec;
-    }
-    
-    public A convert(SlashCommandDefinition def) {
-        logger.debug("Converting command {}", def);
-        List<O> options = new ArrayList<>();
-        if (!def.isRootCommand()) {
-            Arrays.stream(def.getSubCommands()).map(this::convertSubCommand).forEach(options::add);
-            Arrays.stream(def.getSubCommandGroups()).map(x -> this.convertSubCommandGroup(def, x)).forEach(options::add);
-        }else
-            Arrays.stream(def.rootIdentifier().options()).map(this::convertOption).forEach(options::add);
-
-        return spec.convertCommand(def.rootIdentifier(), options);
-    }
-
-    private O convertSubCommandGroup(SlashCommandDefinition def, InteractionIdentifier identifier) {
-        logger.debug("Converting subCommandGroup {} of {}", identifier, def);
-        SlashCommandIdentifier[] subCommands = def.getSubCommands(identifier.name());
-        List<O> convertedSubCommands = Arrays.stream(subCommands).map(this::convertSubCommand).toList();
-        return spec.convertSubCommandGroup(identifier, convertedSubCommands);
-    }
-
-    private O convertSubCommand(SlashCommandIdentifier identifier) {
-        logger.debug("Converting subCommand {}", identifier);
-        List<O> options = Arrays.stream(identifier.options()).map(this::convertOption).toList();
-        return spec.convertSubCommand(identifier, options);
-    }
-
-    private O convertOption(SlashCommandOption option) {
-        logger.debug("Converting option {}", option);
-        List<C> choices = Arrays.stream(SlashCommandDefinition.getActualChoices(option)).map(spec::convertChoice).toList();
-        return spec.convertOption(option, choices);
-    }
-
-    public static interface Spec<A extends Object, O extends Object, C extends Object> {
-
-        public A convertCommand(RootCommandIdentifier rootIdentifier, List<O>  options);
-        public O convertSubCommandGroup(InteractionIdentifier identifier, List<O> subCommands);
-        public O convertSubCommand(InteractionIdentifier identifier, List<O>  options);
-        public O convertOption(SlashCommandOption option, List<C> choices);
-        public C convertChoice(SlashCommandOptionChoice choice);
-    }
-}

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

@@ -1,55 +0,0 @@
-package net.tomatentum.marinara.wrapper;
-
-import java.util.Arrays;
-import java.util.Set;
-import java.util.stream.Collectors;
-
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
-
-import net.tomatentum.marinara.interaction.commands.SlashCommandDefinition;
-import net.tomatentum.marinara.util.ObjectAggregator;
-
-public class CommandRegisterer<A extends Object> {
-
-    public static <A extends Object> CommandRegisterer<A> of(Strategy<A> strategy, CommandConverter<A, ?, ?> converter) {
-        return new CommandRegisterer<A>(strategy, converter);
-    }
-
-    private Logger logger = LoggerFactory.getLogger(getClass());
-
-    private Strategy<A> strategy;
-    private CommandConverter<A, ?, ?> converter;
-
-    CommandRegisterer(Strategy<A> strategy, CommandConverter<A, ?, ?> converter) {
-        this.strategy = strategy;
-        this.converter = converter;
-    }
-
-    public void register(SlashCommandDefinition[] slashDefs) {
-        Set<ServerCommandList<A>> serverCommands = new ObjectAggregator<SlashCommandDefinition, Long, ServerCommandList<A>>(
-                def -> Arrays.stream(def.serverIds()).boxed().toList(),
-                (l, o) -> {
-                    logger.debug("Added {} for server ({}) registration.", o.rootIdentifier(), l.serverId());
-                    l.add(converter.convert(o));
-                },
-                ServerCommandList::new)
-            .aggregate(Arrays.asList(slashDefs)).stream()
-            .collect(Collectors.toSet());
-
-        Set<A> globalCommands = Arrays.stream(slashDefs)
-            .filter(x -> x.serverIds().length <= 0)
-            .peek(c -> logger.debug("Added {} for global registration.", c.rootIdentifier()))
-            .map(converter::convert)
-            .collect(Collectors.toSet());
-
-        serverCommands.forEach(strategy::registerServer);
-        strategy.registerGlobal(globalCommands);
-        logger.info("Registered all SlashCommands");
-    }
-    
-    public interface Strategy<A extends Object> {
-        void registerServer(ServerCommandList<A> commands);
-        void registerGlobal(Set<A> defs);
-    }
-}

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

@@ -1,13 +0,0 @@
-package net.tomatentum.marinara.wrapper;
-
-import net.tomatentum.marinara.interaction.commands.option.AutocompleteOptionData;
-
-public interface ContextObjectProvider {
-
-    public Object convertCommandOption(Object context, String optionName);
-
-    public Object getComponentContextObject(Object context, Class<?> type);
-    public Object getInteractionContextObject(Object context, Class<?> type);
-
-    public AutocompleteOptionData getAutocompleteFocusedOption(Object context);
-}

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

@@ -1,75 +0,0 @@
-package net.tomatentum.marinara.wrapper;
-
-import java.lang.reflect.ParameterizedType;
-import java.lang.reflect.Type;
-import java.util.Arrays;
-import java.util.HashMap;
-import java.util.List;
-import java.util.Map;
-
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
-
-import io.leangen.geantyref.GenericTypeReflector;
-import net.tomatentum.cutin.util.ReflectionUtil;
-import net.tomatentum.marinara.interaction.ident.InteractionIdentifier;
-
-public class IdentifierProvider {
-
-    public static IdentifierProvider of(Converter<?>... converter) {
-        return new IdentifierProvider(Arrays.asList(converter));
-    }
-
-    private Logger logger = LoggerFactory.getLogger(getClass());
-
-    private Map<Class<?>, Converter<?>> converter;
-
-    private IdentifierProvider(List<Converter<?>> converter) {
-        this.converter = new HashMap<>();
-        for (Converter<?> conv : converter) {
-            if (conv.getClass().getName().contains("$$Lambda"))
-                throw new IllegalArgumentException("Lambdas cannot be used for IdentifierConverter because of Type erasure.");
-            Type type = GenericTypeReflector.getExactSuperType(conv.getClass(), Converter.class);
-            Type parameterType = ((ParameterizedType) type).getActualTypeArguments()[0];
-            if (!(parameterType instanceof Class))
-                throw new IllegalArgumentException("Only full Class types are supported by IdentiferConverters");
-            this.converter.put((Class<?>) parameterType, conv);
-        }
-    }
-
-    public InteractionIdentifier provide(Object context) {
-        Type type = ReflectionUtil.getMostSpecificClass(
-            converter.keySet().stream().filter(x -> x.isAssignableFrom(context.getClass())).toArray(Class<?>[]::new), 
-            context.getClass());
-
-        if (type == null)
-            logger.debug("No Identifier converter found for context {}", context.getClass());
-
-        @SuppressWarnings("unchecked")
-        Converter<Object> conv = (Converter<Object>) converter.get(type);
-
-        InteractionIdentifier result = conv.convert(context);
-        logger.trace("Converted {} to {} using {}", context, result, conv);
-        return result;
-    }
-
-    @FunctionalInterface
-    public interface Converter<T extends Object> {
-        InteractionIdentifier convert(T context);
-    }
-
-    public static class LambdaWrapper<T extends Object> implements Converter<T> {
-
-        private Converter<T> converter;
-
-        LambdaWrapper(Converter<T> converter) {
-            this.converter = converter;
-        }
-
-        @Override
-        public InteractionIdentifier convert(T context) {
-            return this.converter.convert(context);
-        }
-
-    }
-}

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

@@ -3,16 +3,23 @@ package net.tomatentum.marinara.wrapper;
 import java.util.ArrayList;
 import java.util.List;
 import java.util.function.Consumer;
+
+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 {
 
     private List<Consumer<Object>> interactionSubscriber;
 
     protected LibraryWrapper() {
-        this.interactionSubscriber = new ArrayList<>();
+        interactionSubscriber = new ArrayList<>();
     }
 
+
     public void handleInteraction(Object context) {
-        interactionSubscriber.forEach(o -> o.accept(context));
+        interactionSubscriber.forEach((o) -> o.accept(context));
     }
 
     public void subscribeInteractions(Consumer<Object> consumer) {
@@ -22,9 +29,12 @@ public abstract class LibraryWrapper {
         interactionSubscriber.remove(consumer);
     }
 
-    public abstract CommandRegisterer<?> getRegisterer();  
+    public abstract InteractionType getInteractionType(Class<?> clazz);
-    public abstract IdentifierProvider createIdentifierProvider();
-    public abstract ContextObjectProvider getContextObjectProvider();
-    public abstract void respondAutocomplete(Object context, List<Object> options);
 
+    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);
 }

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

@@ -1,16 +0,0 @@
-package net.tomatentum.marinara.wrapper;
-
-import java.util.HashSet;
-
-public class ServerCommandList<A> extends HashSet<A>{
-
-    private long serverId;
-    
-    public ServerCommandList(long serverId) {
-        this.serverId = serverId;
-    }
-
-    public long serverId() {
-        return serverId;
-    }
-}

settings.gradle.kts

@@ -13,9 +13,5 @@ plugins {
 rootProject.name = "Marinara"
 include(":lib")
 include(":wrapper-javacord")
-include(":wrapper-discord4j")
-
 
 project(":wrapper-javacord").projectDir = file("wrapper/javacord")
-project(":wrapper-discord4j").projectDir = file("wrapper/discord4j")
-

wrapper/discord4j/build.gradle.kts

@@ -1,40 +0,0 @@
-/*
- * 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`
-}
-
-dependencies {
-    // Use JUnit Jupiter for testing.
-    testImplementation(libs.junit.jupiter)
-    testImplementation(libs.mockito)
-    testImplementation(libs.discord4j)
-
-    testRuntimeOnly("org.junit.platform:junit-platform-launcher")
-    testImplementation(libs.slf4j.simple)
-
-    implementation(libs.slf4j)
-    implementation(libs.discord4j) {
-        exclude(module="discord4j-voice")
-    }
-    implementation(libs.geantyref)
-    implementation(project(":lib"))
-}
-
-// Apply a specific Java toolchain to ease working on different environments.
-java {
-    toolchain {
-        languageVersion = JavaLanguageVersion.of(23)
-    }
-}
-
-tasks.named<Test>("test") {
-    // Use JUnit Platform for unit tests.
-    useJUnitPlatform()
-}

wrapper/discord4j/src/main/java/net/tomatentum/marinara/wrapper/discord4j/Discord4JContextObjectProvider.java

@@ -1,105 +0,0 @@
-package net.tomatentum.marinara.wrapper.discord4j;
-
-import java.util.List;
-
-import discord4j.core.event.domain.interaction.ChatInputAutoCompleteEvent;
-import discord4j.core.event.domain.interaction.ChatInputInteractionEvent;
-import discord4j.core.event.domain.interaction.ComponentInteractionEvent;
-import discord4j.core.event.domain.interaction.InteractionCreateEvent;
-import discord4j.core.object.command.ApplicationCommandInteractionOption;
-import net.tomatentum.marinara.interaction.commands.option.AutocompleteOptionData;
-import net.tomatentum.marinara.interaction.commands.option.SlashCommandOptionType;
-import net.tomatentum.marinara.wrapper.ContextObjectProvider;
-
-public class Discord4JContextObjectProvider implements ContextObjectProvider {
-
-    @Override
-    public Object convertCommandOption(Object context, String optionName) {
-        if (!(context instanceof ChatInputInteractionEvent))
-            return null;
-        ChatInputInteractionEvent interactionEvent = (ChatInputInteractionEvent) context;
-
-        List<ApplicationCommandInteractionOption> subOptions = Discord4JWrapper.SUB_FILTER.apply(interactionEvent.getOptions());
-
-        if (subOptions.isEmpty())
-            return getOptionValue(interactionEvent.getOption(optionName).get());
-
-
-        ApplicationCommandInteractionOption subCommandOption = interactionEvent.getOptions().getFirst();
-        subOptions = Discord4JWrapper.SUB_FILTER.apply(subCommandOption.getOptions());
-
-        if (!subOptions.isEmpty())
-            subCommandOption = subOptions.getFirst();
-
-        return getOptionValue(interactionEvent.getOption(optionName).get());
-
-    }
-
-    private Object getOptionValue(ApplicationCommandInteractionOption option) {
-        if (!option.getValue().isPresent())
-            return null;
-        SlashCommandOptionType type = getOptionType(option);
-
-        switch (type) {
-            case ATTACHMENT:
-                return option.getValue().get().asAttachment();
-            case BOOLEAN:
-                return option.getValue().get().asBoolean();
-            case CHANNEL:
-                return option.getValue().get().asChannel();
-            case DOUBLE:
-                return option.getValue().get().asDouble();
-            case INTEGER:
-                return option.getValue().get().asLong();
-            case MENTIONABLE:
-                return option.getValue().get().asSnowflake();
-            case ROLE:
-                return option.getValue().get().asRole();
-            case STRING:
-                return option.getValue().get().asString();
-            case USER:
-                return option.getValue().get().asUser();
-            default:
-                return null;
-        }
-    }
-
-    private SlashCommandOptionType getOptionType(ApplicationCommandInteractionOption option) {
-        return SlashCommandOptionType.fromValue(option.getType().getValue());
-    }
-
-    @Override
-    public Object getComponentContextObject(Object context, Class<?> type) {
-        ComponentInteractionEvent componentInteractionEvent = (ComponentInteractionEvent) context;
-        switch (type.getName()) {
-            case "discord4j.core.object.entity.Message":
-                return componentInteractionEvent.getMessage().orElse(null);
-            default:
-                return getInteractionContextObject(context, type);
-        }
-    }
-
-    @Override
-    public Object getInteractionContextObject(Object context, Class<?> type) {
-        InteractionCreateEvent interactionEvent = (InteractionCreateEvent) context;
-        switch (type.getName()) {
-            case "discord4j.core.object.entity.channel.MessageChannel":
-                return interactionEvent.getInteraction().getChannel().block();
-            case "discord4j.core.object.entity.Guild":
-                return interactionEvent.getInteraction().getGuild().block();
-            case "discord4j.core.object.entity.Member":
-                return interactionEvent.getInteraction().getMember().orElse(null);
-            case "discord4j.core.object.entity.User":
-                return interactionEvent.getInteraction().getUser();
-            default:
-                return null;
-        }
-    }
-
-    @Override
-    public AutocompleteOptionData getAutocompleteFocusedOption(Object context) {
-        ApplicationCommandInteractionOption option = ((ChatInputAutoCompleteEvent) context).getFocusedOption();
-        return new AutocompleteOptionData(option.getName(), getOptionValue(option));
-    }
-
-}

wrapper/discord4j/src/main/java/net/tomatentum/marinara/wrapper/discord4j/Discord4JConverterSpec.java

@@ -1,79 +0,0 @@
-package net.tomatentum.marinara.wrapper.discord4j;
-
-import java.util.List;
-
-import discord4j.core.object.command.ApplicationCommandOption.Type;
-import discord4j.discordjson.json.ApplicationCommandOptionChoiceData;
-import discord4j.discordjson.json.ApplicationCommandOptionData;
-import discord4j.discordjson.json.ApplicationCommandRequest;
-import net.tomatentum.marinara.interaction.commands.annotation.SlashCommandOption;
-import net.tomatentum.marinara.interaction.commands.annotation.SlashCommandOptionChoice;
-import net.tomatentum.marinara.interaction.ident.InteractionIdentifier;
-import net.tomatentum.marinara.interaction.ident.RootCommandIdentifier;
-import net.tomatentum.marinara.wrapper.CommandConverter;
-
-public class Discord4JConverterSpec implements CommandConverter.Spec<ApplicationCommandRequest, ApplicationCommandOptionData, ApplicationCommandOptionChoiceData> {
-
-	@Override
-	public ApplicationCommandRequest convertCommand(RootCommandIdentifier rootIdentifier,
-			List<ApplicationCommandOptionData> options) {
-        return ApplicationCommandRequest.builder()
-            .name(rootIdentifier.name())
-            .description(rootIdentifier.description())
-            .options(options)
-            .build();
-	}
-
-	@Override
-	public ApplicationCommandOptionData convertSubCommandGroup(InteractionIdentifier identifier,
-			List<ApplicationCommandOptionData> subCommands) {
-		return ApplicationCommandOptionData.builder()
-			.type(Type.SUB_COMMAND_GROUP.getValue())
-			.name(identifier.name())
-			.description(identifier.description())
-			.options(subCommands)
-			.build();
-	}
-
-	@Override
-	public ApplicationCommandOptionData convertSubCommand(InteractionIdentifier identifier,
-			List<ApplicationCommandOptionData> options) {
-        return ApplicationCommandOptionData.builder()
-            .type(Type.SUB_COMMAND_GROUP.getValue())
-            .name(identifier.name())
-            .description(identifier.description())
-            .options(options)
-            .build();
-	}
-
-	@Override
-	public ApplicationCommandOptionData convertOption(SlashCommandOption option,
-			List<ApplicationCommandOptionChoiceData> choices) {
-		Type type = Type.of(option.type().getValue());
-        return ApplicationCommandOptionData.builder()
-            .type(type.getValue())
-            .name(option.name())
-            .description(option.description())
-            .required(option.required())
-            .autocomplete(option.autocompletes().length > 0)
-			.minLength((int) option.range().min())
-			.minValue(option.range().min())
-			.maxLength((int)option.range().max())
-			.maxValue(option.range().max())
-            .choices(choices)
-            .build();
-	}
-
-	@Override
-	public ApplicationCommandOptionChoiceData convertChoice(SlashCommandOptionChoice choice) {
-		var builder = ApplicationCommandOptionChoiceData.builder().name(choice.name());
-		if (choice.longValue() != Long.MAX_VALUE)
-			builder.value(choice.longValue());
-		if (choice.doubleValue() != Double.MAX_VALUE)
-			builder.value(choice.doubleValue());
-		if (!choice.stringValue().isEmpty())
-			builder.value(choice.stringValue());
-		return builder.build();
-	}
-	
-}

wrapper/discord4j/src/main/java/net/tomatentum/marinara/wrapper/discord4j/Discord4JRegistererStrategy.java

@@ -1,32 +0,0 @@
-package net.tomatentum.marinara.wrapper.discord4j;
-
-import java.util.ArrayList;
-import java.util.Set;
-
-import discord4j.core.GatewayDiscordClient;
-import discord4j.discordjson.json.ApplicationCommandRequest;
-import discord4j.rest.service.ApplicationService;
-import net.tomatentum.marinara.wrapper.CommandRegisterer;
-import net.tomatentum.marinara.wrapper.ServerCommandList;
-
-public class Discord4JRegistererStrategy implements CommandRegisterer.Strategy<ApplicationCommandRequest> {
-
-    private ApplicationService appService;
-    private long applicationId;
-
-    public Discord4JRegistererStrategy(GatewayDiscordClient api) {
-        this.appService = api.getRestClient().getApplicationService();
-        this.applicationId = api.getRestClient().getApplicationId().block();
-    }
-
-    @Override
-    public void registerServer(ServerCommandList<ApplicationCommandRequest> commands) {
-        appService.bulkOverwriteGuildApplicationCommand(applicationId, commands.serverId(), new ArrayList<>(commands));
-
-    }
-
-    @Override
-    public void registerGlobal(Set<ApplicationCommandRequest> defs) {
-        appService.bulkOverwriteGlobalApplicationCommand(applicationId, new ArrayList<>(defs));
-    }
-}

wrapper/discord4j/src/main/java/net/tomatentum/marinara/wrapper/discord4j/Discord4JWrapper.java

@@ -1,86 +0,0 @@
-package net.tomatentum.marinara.wrapper.discord4j;
-
-import java.util.List;
-import java.util.function.UnaryOperator;
-
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
-
-import discord4j.core.GatewayDiscordClient;
-import discord4j.core.event.domain.interaction.ChatInputAutoCompleteEvent;
-import discord4j.core.event.domain.interaction.InteractionCreateEvent;
-import discord4j.core.object.command.ApplicationCommandInteractionOption;
-import discord4j.core.object.command.ApplicationCommandOption.Type;
-import discord4j.discordjson.json.ApplicationCommandOptionChoiceData;
-import discord4j.discordjson.json.ApplicationCommandRequest;
-
-import net.tomatentum.marinara.wrapper.CommandConverter;
-import net.tomatentum.marinara.wrapper.CommandRegisterer;
-import net.tomatentum.marinara.wrapper.ContextObjectProvider;
-import net.tomatentum.marinara.wrapper.IdentifierProvider;
-import net.tomatentum.marinara.wrapper.LibraryWrapper;
-import net.tomatentum.marinara.wrapper.discord4j.identifierconverter.AutocompleteIdentifierConverter;
-import net.tomatentum.marinara.wrapper.discord4j.identifierconverter.ButtonIdentifierConverter;
-import net.tomatentum.marinara.wrapper.discord4j.identifierconverter.SlashCommandIdentifierConverter;
-
-public class Discord4JWrapper extends LibraryWrapper {
-    public static final UnaryOperator<List<ApplicationCommandInteractionOption>> SUB_FILTER = i ->
-        i.stream()
-            .filter(o -> o.getType().equals(Type.SUB_COMMAND) || o.getType().equals(Type.SUB_COMMAND_GROUP))
-            .toList();
-    
-    public static final UnaryOperator<List<ApplicationCommandInteractionOption>> ARG_FILTER = i ->
-            i.stream()
-                .filter(o -> !o.getType().equals(Type.SUB_COMMAND) && !o.getType().equals(Type.SUB_COMMAND_GROUP))
-                .toList();
-
-    private Discord4JContextObjectProvider contextObjectProvider;
-    private CommandRegisterer<ApplicationCommandRequest> commandRegisterer;
-
-    private Logger logger = LoggerFactory.getLogger(getClass());
-
-    public Discord4JWrapper(GatewayDiscordClient api) {
-        this.contextObjectProvider = new Discord4JContextObjectProvider();
-        var converter = CommandConverter.of(new Discord4JConverterSpec());
-
-        if (api != null) {
-            this.commandRegisterer = CommandRegisterer.of(new Discord4JRegistererStrategy(api), converter);
-            api.on(InteractionCreateEvent.class)
-                .subscribe(event -> handleInteraction(event));
-        }else
-            logger.warn("GatewayDiscordClient was null so no Events were subscribed to.");
-            
-        logger.info("Discord4J wrapper loaded!");
-    }
-
-    @Override
-    public CommandRegisterer<?> getRegisterer() {
-        return this.commandRegisterer;
-    }
-
-    @Override
-    public IdentifierProvider createIdentifierProvider() {
-        return IdentifierProvider.of(
-            new SlashCommandIdentifierConverter(),
-            new AutocompleteIdentifierConverter(),
-            new ButtonIdentifierConverter()
-        );
-    }
-
-    @Override
-    public ContextObjectProvider getContextObjectProvider() {
-        return this.contextObjectProvider;
-    }
-
-    @Override
-    public void respondAutocomplete(Object context, List<Object> options) {
-        if (context instanceof ChatInputAutoCompleteEvent event) {
-            List<ApplicationCommandOptionChoiceData> choices = options.stream()
-                .filter(ApplicationCommandOptionChoiceData.class::isInstance)
-                .map(o -> (ApplicationCommandOptionChoiceData)o)
-                .toList();
-            event.respondWithSuggestions(choices);
-        }
-    }
-
-}

wrapper/discord4j/src/main/java/net/tomatentum/marinara/wrapper/discord4j/checks/PermissionCheck.java

@@ -1,42 +0,0 @@
-package net.tomatentum.marinara.wrapper.discord4j.checks;
-
-import java.lang.annotation.ElementType;
-import java.lang.annotation.Retention;
-import java.lang.annotation.RetentionPolicy;
-import java.lang.annotation.Target;
-import java.util.Optional;
-
-import discord4j.core.event.domain.interaction.InteractionCreateEvent;
-import discord4j.core.object.entity.Member;
-import discord4j.rest.util.Permission;
-import discord4j.rest.util.PermissionSet;
-import net.tomatentum.marinara.checks.InteractionCheck;
-
-public class PermissionCheck implements InteractionCheck<PermissionCheck.HasPermission> {
-
-    @Retention(RetentionPolicy.RUNTIME)
-    @Target(ElementType.METHOD)
-    public static @interface HasPermission {
-        public Permission[] value();
-    }
-
-    @Override
-    public boolean preExec(Object context, HasPermission annotation) {
-        throw new UnsupportedOperationException("Unimplemented method 'preExec'");
-    }
-
-    public boolean preExec(InteractionCreateEvent context, HasPermission annotation) {
-        Optional<Member> member = context.getInteraction().getMember();
-        if (member.isEmpty())
-            return false;
-        PermissionSet ownPerms = PermissionSet.of(annotation.value());
-        PermissionSet permSet = member.get().getBasePermissions().block();
-        return permSet.containsAll(ownPerms);
-    }
-
-    @Override
-    public void postExec(Object context, HasPermission annotation) {
-        
-    }
-    
-}

wrapper/discord4j/src/main/java/net/tomatentum/marinara/wrapper/discord4j/identifierconverter/AutocompleteIdentifierConverter.java

@@ -1,40 +0,0 @@
-package net.tomatentum.marinara.wrapper.discord4j.identifierconverter;
-
-import java.util.List;
-
-import discord4j.core.event.domain.interaction.ChatInputAutoCompleteEvent;
-import discord4j.core.object.command.ApplicationCommandInteractionOption;
-import net.tomatentum.marinara.interaction.InteractionType;
-import net.tomatentum.marinara.interaction.ident.InteractionIdentifier;
-import net.tomatentum.marinara.wrapper.IdentifierProvider;
-import net.tomatentum.marinara.wrapper.discord4j.Discord4JWrapper;
-
-public class AutocompleteIdentifierConverter implements IdentifierProvider.Converter<ChatInputAutoCompleteEvent> {
-
-    @Override
-    public InteractionIdentifier convert(ChatInputAutoCompleteEvent context) {
-        InteractionIdentifier last = InteractionIdentifier.builder()
-            .type(InteractionType.AUTOCOMPLETE)
-            .name(context.getCommandName())
-            .build();
-
-        List<ApplicationCommandInteractionOption> options = Discord4JWrapper.SUB_FILTER.apply(context.getOptions());
-        if (!options.isEmpty()) {
-            last = InteractionIdentifier.builder()
-                .type(InteractionType.AUTOCOMPLETE)
-                .name(options.getFirst().getName())
-                .parent(last)
-                .build();
-
-            List<ApplicationCommandInteractionOption> subOptions = Discord4JWrapper.SUB_FILTER.apply(options.getFirst().getOptions());
-            if (!subOptions.isEmpty())
-                last = InteractionIdentifier.builder()
-                    .type(InteractionType.AUTOCOMPLETE)
-                    .name(subOptions.getFirst().getName())
-                    .parent(last)
-                    .build();
-        }
-        return last;
-    }
-    
-}

wrapper/discord4j/src/main/java/net/tomatentum/marinara/wrapper/discord4j/identifierconverter/ButtonIdentifierConverter.java

@@ -1,15 +0,0 @@
-package net.tomatentum.marinara.wrapper.discord4j.identifierconverter;
-
-import discord4j.core.event.domain.interaction.ButtonInteractionEvent;
-import net.tomatentum.marinara.interaction.InteractionType;
-import net.tomatentum.marinara.interaction.ident.InteractionIdentifier;
-import net.tomatentum.marinara.wrapper.IdentifierProvider;
-
-public class ButtonIdentifierConverter implements IdentifierProvider.Converter<ButtonInteractionEvent> {
-
-    @Override
-    public InteractionIdentifier convert(ButtonInteractionEvent context) {
-        return InteractionIdentifier.builder().name(context.getCustomId()).type(InteractionType.BUTTON).build();
-    }
-    
-}

wrapper/discord4j/src/main/java/net/tomatentum/marinara/wrapper/discord4j/identifierconverter/SlashCommandIdentifierConverter.java

@@ -1,40 +0,0 @@
-package net.tomatentum.marinara.wrapper.discord4j.identifierconverter;
-
-import java.util.List;
-
-import discord4j.core.event.domain.interaction.ChatInputInteractionEvent;
-import discord4j.core.object.command.ApplicationCommandInteractionOption;
-import net.tomatentum.marinara.interaction.InteractionType;
-import net.tomatentum.marinara.interaction.ident.InteractionIdentifier;
-import net.tomatentum.marinara.wrapper.IdentifierProvider;
-import net.tomatentum.marinara.wrapper.discord4j.Discord4JWrapper;
-
-public class SlashCommandIdentifierConverter implements IdentifierProvider.Converter<ChatInputInteractionEvent> {
-
-    @Override
-    public InteractionIdentifier convert(ChatInputInteractionEvent context) {
-        InteractionIdentifier last = InteractionIdentifier.builder()
-            .type(InteractionType.COMMAND)
-            .name(context.getCommandName())
-            .build();
-
-        List<ApplicationCommandInteractionOption> options = Discord4JWrapper.SUB_FILTER.apply(context.getOptions());
-        if (!options.isEmpty()) {
-            last = InteractionIdentifier.builder()
-                .type(InteractionType.COMMAND)
-                .name(options.getFirst().getName())
-                .parent(last)
-                .build();
-
-            List<ApplicationCommandInteractionOption> subOptions = Discord4JWrapper.SUB_FILTER.apply(options.getFirst().getOptions());
-            if (!subOptions.isEmpty())
-                last = InteractionIdentifier.builder()
-                    .type(InteractionType.COMMAND)
-                    .name(subOptions.getFirst().getName())
-                    .parent(last)
-                    .build();
-        }
-        return last;
-    }
-    
-}

wrapper/discord4j/src/test/java/net/tomatentum/marinara/test/discord4j/AutoCompleteTest.java

@@ -1,45 +0,0 @@
-package net.tomatentum.marinara.test.discord4j;
-
-import static org.mockito.ArgumentMatchers.any;
-import static org.mockito.Mockito.mock;
-import static org.mockito.Mockito.verify;
-import static org.mockito.Mockito.when;
-
-import java.util.ArrayList;
-import java.util.Optional;
-
-import org.junit.jupiter.api.Test;
-
-import discord4j.core.event.domain.interaction.ChatInputAutoCompleteEvent;
-import discord4j.core.object.command.ApplicationCommandInteractionOption;
-import discord4j.core.object.command.ApplicationCommandInteractionOptionValue;
-import discord4j.core.object.command.ApplicationCommandOption.Type;
-import net.tomatentum.marinara.Marinara;
-import net.tomatentum.marinara.wrapper.LibraryWrapper;
-import net.tomatentum.marinara.wrapper.discord4j.Discord4JWrapper;
-
-class AutoCompleteTest {
-    
-    @Test
-    void testAutocomplete() {
-        ApplicationCommandInteractionOption optionMock = mock();
-        ChatInputAutoCompleteEvent autoCompleteEventMock = mock();
-
-        when(optionMock.getName()).thenReturn("foo");
-        when(optionMock.getType()).thenReturn(Type.STRING);
-        when(optionMock.getValue()).thenReturn(
-            Optional.of(
-                new ApplicationCommandInteractionOptionValue(null, null, Type.STRING.getValue(), "test", null)
-                ));
-
-        when(autoCompleteEventMock.getCommandName()).thenReturn("test");
-        when(autoCompleteEventMock.getOptions()).thenReturn(new ArrayList<>());
-        when(autoCompleteEventMock.getFocusedOption()).thenReturn(optionMock);
-
-        LibraryWrapper wrapper = new Discord4JWrapper(null); //null okay as we don't use the discord API in this test.
-        Marinara marinara = Marinara.load(wrapper);
-        marinara.getInteractionContainer().addAllMethods(new TestAutocomplete());
-        wrapper.handleInteraction(autoCompleteEventMock);
-        verify(autoCompleteEventMock).respondWithSuggestions(any());
-    }
-}

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

@@ -1,29 +0,0 @@
-package net.tomatentum.marinara.test.discord4j;
-
-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 discord4j.core.event.domain.interaction.ButtonInteractionEvent;
-import net.tomatentum.marinara.Marinara;
-import net.tomatentum.marinara.test.discord4j.mocks.CommonMocks;
-import net.tomatentum.marinara.wrapper.LibraryWrapper;
-import net.tomatentum.marinara.wrapper.discord4j.Discord4JWrapper;
-
-@TestInstance(Lifecycle.PER_CLASS)
-class ButtonTest {
-
-    @Test
-    void testButtonExecution() {
-        ButtonInteractionEvent buttonEventMock = CommonMocks.getButtonEventMock("test");
-
-        LibraryWrapper wrapper = new Discord4JWrapper(null); //null okay as we don't use the discord API in this test.
-        Marinara marinara = Marinara.load(wrapper);
-        marinara.getInteractionContainer().addAllMethods(new TestButton());
-        wrapper.handleInteraction(buttonEventMock);
-        assertTrue(TestButton.didRun);
-    }
-    
-}

wrapper/discord4j/src/test/java/net/tomatentum/marinara/test/discord4j/InteractionCheckTest.java

@@ -1,70 +0,0 @@
-package net.tomatentum.marinara.test.discord4j;
-
-import static org.junit.jupiter.api.Assertions.assertFalse;
-import static org.junit.jupiter.api.Assertions.assertTrue;
-import static org.mockito.Mockito.mock;
-import static org.mockito.Mockito.when;
-
-import java.util.Optional;
-
-import org.junit.jupiter.api.Test;
-import org.junit.jupiter.api.TestInstance;
-import org.junit.jupiter.api.TestInstance.Lifecycle;
-
-import discord4j.core.event.domain.interaction.ButtonInteractionEvent;
-import discord4j.core.object.command.Interaction;
-import discord4j.core.object.entity.Member;
-import discord4j.rest.util.Permission;
-import discord4j.rest.util.PermissionSet;
-import net.tomatentum.marinara.Marinara;
-import net.tomatentum.marinara.test.discord4j.mocks.CommonMocks;
-import net.tomatentum.marinara.wrapper.LibraryWrapper;
-import net.tomatentum.marinara.wrapper.discord4j.Discord4JWrapper;
-import net.tomatentum.marinara.wrapper.discord4j.checks.PermissionCheck;
-import reactor.core.publisher.Mono;
-
-@TestInstance(Lifecycle.PER_CLASS)
-class InteractionCheckTest {
-    
-    @Test
-    void testInteractionCheck() {
-        ButtonInteractionEvent buttonEventMock = CommonMocks.getButtonEventMock("test");
-
-        LibraryWrapper wrapper = new Discord4JWrapper(null);
-        Marinara marinara = Marinara.load(wrapper);
-        marinara.getCheckContainer().addAllMethods(new TestInteractionCheck());
-        marinara.getInteractionContainer().addAllMethods(new TestButton());
-        wrapper.handleInteraction(buttonEventMock);
-
-        assertTrue(TestInteractionCheck.preExecuted);
-        assertTrue(TestInteractionCheck.postExecuted);
-        assertTrue(TestButton.didRun);
-    }
-
-    @Test
-    void testPermissionCheck() {
-        Member memberMock = mock();
-        Interaction interactionMock = mock();
-
-        when(memberMock.getBasePermissions()).thenReturn(Mono.just(PermissionSet.none()));
-
-        when(interactionMock.getMember()).thenReturn(Optional.of(memberMock));
-
-        ButtonInteractionEvent buttonEventMock = CommonMocks.getButtonEventMock("permissionCheck", interactionMock);
-
-        LibraryWrapper wrapper = new Discord4JWrapper(null);
-        Marinara marinara = Marinara.load(wrapper);
-        marinara.getCheckContainer().addAllMethods(new PermissionCheck());
-        marinara.getInteractionContainer().addAllMethods(new TestButton());
-
-        wrapper.handleInteraction(buttonEventMock);
-        assertFalse(TestButton.didPermRun);
-        TestButton.didPermRun = false;
-        
-        when(memberMock.getBasePermissions()).thenReturn(Mono.just(PermissionSet.of(Permission.ATTACH_FILES)));
-
-        wrapper.handleInteraction(buttonEventMock);
-        assertTrue(TestButton.didPermRun);
-    }
-
-}

wrapper/discord4j/src/test/java/net/tomatentum/marinara/test/discord4j/SlashCommandTest.java

@@ -1,75 +0,0 @@
-package net.tomatentum.marinara.test.discord4j;
-
-import static org.mockito.Mockito.mock;
-import static org.mockito.Mockito.when;
-
-import java.util.Arrays;
-import java.util.Optional;
-
-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 discord4j.core.DiscordClient;
-import discord4j.core.GatewayDiscordClient;
-import discord4j.core.event.domain.interaction.ChatInputInteractionEvent;
-import discord4j.core.object.command.ApplicationCommandInteractionOption;
-import discord4j.core.object.command.ApplicationCommandInteractionOptionValue;
-import discord4j.core.object.command.ApplicationCommandOption.Type;
-import net.tomatentum.marinara.Marinara;
-import net.tomatentum.marinara.wrapper.LibraryWrapper;
-import net.tomatentum.marinara.wrapper.discord4j.Discord4JWrapper;
-
-@TestInstance(Lifecycle.PER_CLASS)
-class SlashCommandTest {
-
-    private static String DISCORD_TOKEN = System.getenv("DISCORD_TEST_TOKEN");
-    GatewayDiscordClient client;
-
-    @BeforeAll
-    void setUp() {
-        client = DiscordClient.create(DISCORD_TOKEN).login().block();
-    }
-
-    @AfterAll
-    void tearDown() {
-        client.logout().block();
-        client = null;
-    }
-
-    @Test
-    void testSlashCommand() {
-        Marinara marinara = Marinara.load(new Discord4JWrapper(client));
-        marinara.getInteractionContainer().addAllMethods(new TestCommand());
-        marinara.registerCommands();
-        System.out.println("Success!");
-    }
-    
-    @Test
-    void testSlashCommandExecution() {
-        ApplicationCommandInteractionOption optionMock = mock();
-        ChatInputInteractionEvent eventMock = mock();
-
-        when(optionMock.getName()).thenReturn("foo");
-        when(optionMock.getType()).thenReturn(Type.STRING);
-        when(optionMock.getValue()).thenReturn(
-            Optional.of(
-                new ApplicationCommandInteractionOptionValue(null, null, Type.STRING.getValue(), "test", null)
-                ));
-
-        when(eventMock.getCommandName()).thenReturn("test");
-        when(eventMock.getOptions()).thenReturn(Arrays.asList(optionMock));
-        when(eventMock.getOption("foo")).thenReturn(Optional.of(optionMock));
-        
-        LibraryWrapper wrapper = new Discord4JWrapper(client);
-        Marinara marinara = Marinara.load(wrapper);
-        marinara.getInteractionContainer().addAllMethods(new TestCommand());
-
-        wrapper.handleInteraction(eventMock);
-    }
-
-    
-
-}

wrapper/discord4j/src/test/java/net/tomatentum/marinara/test/discord4j/TestAutocomplete.java

@@ -1,37 +0,0 @@
-package net.tomatentum.marinara.test.discord4j;
-
-import static org.junit.jupiter.api.Assertions.assertEquals;
-
-import discord4j.core.event.domain.interaction.ChatInputAutoCompleteEvent;
-import discord4j.core.event.domain.interaction.ChatInputInteractionEvent;
-import discord4j.discordjson.json.ApplicationCommandOptionChoiceData;
-import net.tomatentum.marinara.interaction.InteractionHandler;
-import net.tomatentum.marinara.interaction.annotation.AutoComplete;
-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 TestAutocomplete implements InteractionHandler {
-
-    @SlashCommand(
-        name = "test",
-        options = @SlashCommandOption(
-                name = "foo",
-                type = SlashCommandOptionType.STRING,
-                autocompletes = @AutoComplete("testAuto")
-            )
-        )
-    public void exec(ChatInputInteractionEvent context) {
-        // Not executed just there for autocomplete to work
-    }
-    
-    @AutoComplete("testAuto")
-    public ApplicationCommandOptionChoiceData[] autocomplete(ChatInputAutoCompleteEvent context, String value) {
-        System.out.println("Success!");
-        assertEquals("test", value);
-        return new ApplicationCommandOptionChoiceData[]{
-            ApplicationCommandOptionChoiceData.builder().name("TestValue").value("test").build()
-        };
-    }
-
-}

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

@@ -1,43 +0,0 @@
-package net.tomatentum.marinara.test.discord4j;
-
-import static org.junit.jupiter.api.Assertions.assertNotNull;
-
-import discord4j.core.event.domain.interaction.ButtonInteractionEvent;
-import discord4j.core.object.entity.Guild;
-import discord4j.core.object.entity.Member;
-import discord4j.core.object.entity.Message;
-import discord4j.core.object.entity.User;
-import discord4j.core.object.entity.channel.MessageChannel;
-import discord4j.rest.util.Permission;
-import net.tomatentum.marinara.interaction.InteractionHandler;
-import net.tomatentum.marinara.interaction.annotation.Button;
-import net.tomatentum.marinara.test.discord4j.TestInteractionCheck.TestCheck;
-import net.tomatentum.marinara.wrapper.discord4j.checks.PermissionCheck.HasPermission;
-
-public class TestButton implements InteractionHandler {
-
-
-    public static boolean didRun = false;
-    @Button("test")
-    @TestCheck
-    public void exec(ButtonInteractionEvent interaction, MessageChannel channel, Message message, Member member, User user, Guild server) {
-        assertNotNull(interaction);
-        assertNotNull(channel);
-        assertNotNull(message);
-        assertNotNull(member);
-        assertNotNull(user);
-        assertNotNull(server);
-        didRun = true;
-        System.out.println("Success!");
-    }
-
-    public static boolean didPermRun = false;
-
-    @Button("permissionCheck")
-    @HasPermission({Permission.ATTACH_FILES})
-    public void exec(ButtonInteractionEvent interaction) {
-        didPermRun = true;
-        System.out.println("It worked!");
-    }
-    
-}

wrapper/discord4j/src/test/java/net/tomatentum/marinara/test/discord4j/TestChoiceEnum.java

@@ -1,20 +0,0 @@
-package net.tomatentum.marinara.test.discord4j;
-
-import net.tomatentum.marinara.interaction.commands.choice.ChoiceValueProvider;
-
-public enum TestChoiceEnum implements ChoiceValueProvider<String> {
-    TestValue("testValue"),
-    FooBar("fooBar"),
-    Spongebob("spongebob");
-
-    private String value;
-
-    private TestChoiceEnum(String value) {
-        this.value = value;
-    }
-    @Override
-    public String getChoiceValue() {
-        return value;
-    }
-    
-}

wrapper/discord4j/src/test/java/net/tomatentum/marinara/test/discord4j/TestCommand.java

@@ -1,32 +0,0 @@
-package net.tomatentum.marinara.test.discord4j;
-
-import static org.junit.jupiter.api.Assertions.assertEquals;
-
-import discord4j.core.event.domain.interaction.ChatInputInteractionEvent;
-import net.tomatentum.marinara.interaction.InteractionHandler;
-import net.tomatentum.marinara.interaction.commands.annotation.CommandChoices;
-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,
-                choices = @CommandChoices(cenum = TestChoiceEnum.class)
-            )
-        }
-        )
-    public void exec(ChatInputInteractionEvent event, String test) {
-        assertEquals("test", test);
-        System.out.println("Success!");
-    }
-}

wrapper/discord4j/src/test/java/net/tomatentum/marinara/test/discord4j/TestInteractionCheck.java

@@ -1,37 +0,0 @@
-package net.tomatentum.marinara.test.discord4j;
-
-import static org.junit.jupiter.api.Assertions.assertNotNull;
-
-import java.lang.annotation.ElementType;
-import java.lang.annotation.Retention;
-import java.lang.annotation.RetentionPolicy;
-import java.lang.annotation.Target;
-
-import net.tomatentum.marinara.checks.InteractionCheck;
-
-public class TestInteractionCheck implements InteractionCheck<TestInteractionCheck.TestCheck> {
-
-    public static boolean preExecuted = false;
-    public static boolean postExecuted = false;
-
-    @Target({ElementType.METHOD})
-    @Retention(RetentionPolicy.RUNTIME)
-    public static @interface TestCheck {
-    }
-
-    @Override
-    public boolean preExec(Object context, TestCheck annotation) {
-        assertNotNull(annotation);
-        assertNotNull(context);
-        preExecuted = true;
-        return true;
-    }
-
-    @Override
-    public void postExec(Object context, TestCheck annotation) {
-        assertNotNull(annotation);
-        assertNotNull(context);
-        postExecuted = true;
-    }
-    
-}

wrapper/discord4j/src/test/java/net/tomatentum/marinara/test/discord4j/mocks/CommonMocks.java

@@ -1,55 +0,0 @@
-package net.tomatentum.marinara.test.discord4j.mocks;
-
-import static org.mockito.Mockito.mock;
-import static org.mockito.Mockito.when;
-
-import java.util.Optional;
-
-import discord4j.core.event.domain.interaction.ButtonInteractionEvent;
-import discord4j.core.object.command.Interaction;
-import discord4j.core.object.entity.Guild;
-import discord4j.core.object.entity.Member;
-import discord4j.core.object.entity.Message;
-import discord4j.core.object.entity.User;
-import discord4j.core.object.entity.channel.MessageChannel;
-import reactor.core.publisher.Mono;
-
-public class CommonMocks {
-    public static Interaction getInteractionMock() {
-        Interaction interaction = mock(Interaction.class);
-        Message message = mock(Message.class);
-        MessageChannel channel = mock(MessageChannel.class);
-        Guild guild = mock(Guild.class);
-        User user = mock(User.class);
-        Member member = mock(Member.class);
-
-
-        when(interaction.getMessage()).thenReturn(Optional.of(message));
-        when(interaction.getChannel()).thenReturn(Mono.just(channel));
-        when(interaction.getGuild()).thenReturn(Mono.just(guild));
-        when(interaction.getUser()).thenReturn(user);
-        when(interaction.getMember()).thenReturn(Optional.of(member));
-
-
-        return interaction;
-    }
-
-    public static ButtonInteractionEvent getButtonEventMock(String customId) {
-        ButtonInteractionEvent buttonEventMock = mock(ButtonInteractionEvent.class);
-
-        when(buttonEventMock.getCustomId()).thenReturn(customId);
-        Interaction interactionMock = getInteractionMock();
-        when(buttonEventMock.getInteraction()).thenReturn(interactionMock);
-        Optional<Message> message = interactionMock.getMessage();
-        when (buttonEventMock.getMessage()).thenReturn(message);
-        return buttonEventMock;
-    }
-
-    public static ButtonInteractionEvent getButtonEventMock(String customId, Interaction interaction) {
-        ButtonInteractionEvent buttonEventMock = mock(ButtonInteractionEvent.class);
-
-        when(buttonEventMock.getCustomId()).thenReturn(customId);
-        when(buttonEventMock.getInteraction()).thenReturn(interaction);
-        return buttonEventMock;
-    }
-}

wrapper/discord4j/src/test/resources/simplelogger.properties

@@ -1,7 +0,0 @@
-# SLF4J's SimpleLogger configuration file
-# Simple implementation of Logger that sends all enabled log messages, for all defined loggers, to System.err.
-
-# Default logging detail level for all instances of SimpleLogger.
-# Must be one of ("trace", "debug", "info", "warn", or "error").
-# If not specified, defaults to "info".
-org.slf4j.simpleLogger.defaultLogLevel=trace

wrapper/javacord/build.gradle.kts

@@ -10,15 +10,17 @@ plugins {
     `java-library`
 }
 
+repositories {
+    // Use Maven Central for resolving dependencies.
+    mavenCentral()
+}
+
 dependencies {
     // Use JUnit Jupiter for testing.
     testImplementation(libs.junit.jupiter)
-    testImplementation(libs.mockito)
 
     testRuntimeOnly("org.junit.platform:junit-platform-launcher")
-    testImplementation(libs.slf4j.simple)
+    implementation(libs.log4j)
-
-    implementation(libs.slf4j)
     implementation(libs.javacord)
     implementation(libs.geantyref)
     implementation(project(":lib"))
@@ -27,7 +29,7 @@ dependencies {
 // Apply a specific Java toolchain to ease working on different environments.
 java {
     toolchain {
-        languageVersion = JavaLanguageVersion.of(23)
+        languageVersion = JavaLanguageVersion.of(21)
     }
 }
 

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

@@ -1,112 +0,0 @@
-package net.tomatentum.marinara.wrapper.javacord;
-
-import org.javacord.api.interaction.AutocompleteInteraction;
-import org.javacord.api.interaction.ButtonInteraction;
-import org.javacord.api.interaction.InteractionBase;
-import org.javacord.api.interaction.SlashCommandInteraction;
-import org.javacord.api.interaction.SlashCommandInteractionOption;
-import org.javacord.api.interaction.SlashCommandOptionType;
-
-import net.tomatentum.marinara.interaction.commands.option.AutocompleteOptionData;
-import net.tomatentum.marinara.wrapper.ContextObjectProvider;
-
-public class JavacordContextObjectProvider implements ContextObjectProvider {
-
-    @Override
-    public Object convertCommandOption(Object context, String optionName) {
-        if (!(context instanceof SlashCommandInteraction))
-            return null;
-        SlashCommandInteraction interaction = (SlashCommandInteraction) context;
-        if (!interaction.getArguments().isEmpty())
-            return getOptionValue(interaction.getOptionByName(optionName).orElse(null));
-
-        SlashCommandInteractionOption subCommandOption = interaction.getOptions().getFirst();
-
-        if (!subCommandOption.getOptions().isEmpty())
-            subCommandOption = subCommandOption.getOptions().getFirst();
-
-        return getOptionValue(subCommandOption.getOptionByName(optionName).orElse(null));
-    }
-
-    private Object getOptionValue(SlashCommandInteractionOption option) {
-        SlashCommandOptionType type = getOptionType(option);
-        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.requestMentionableValue().get();
-            case ROLE:
-                return option.getRoleValue().get();
-            case STRING:
-                return option.getStringValue().get();
-            case USER:
-                return option.requestUserValue().get();
-            default:
-                return null;
-        }
-    }
-
-
-    private SlashCommandOptionType getOptionType(SlashCommandInteractionOption option) {
-        if (option.getAttachmentValue().isPresent())
-            return SlashCommandOptionType.ATTACHMENT;
-        if (option.getBooleanValue().isPresent())
-            return SlashCommandOptionType.BOOLEAN;
-        if (option.getChannelValue().isPresent())
-            return SlashCommandOptionType.CHANNEL;
-        if (option.getDecimalValue().isPresent())
-            return SlashCommandOptionType.DECIMAL;
-        if (option.getLongValue().isPresent())
-            return SlashCommandOptionType.LONG;
-        if (option.requestMentionableValue().isPresent())
-            return SlashCommandOptionType.MENTIONABLE;
-        if (option.getRoleValue().isPresent())
-            return SlashCommandOptionType.ROLE;
-        if (option.getStringValue().isPresent())
-            return SlashCommandOptionType.STRING;
-        if (option.requestUserValue().isPresent())
-            return SlashCommandOptionType.USER;
-
-        return SlashCommandOptionType.UNKNOWN;
-    }
-
-    @Override
-    public Object getComponentContextObject(Object context, Class<?> type) {
-        ButtonInteraction button = (ButtonInteraction) context;
-        switch (type.getName()) {
-            case "org.javacord.api.entity.message.Message":
-                return button.getMessage();
-            default:
-                return getInteractionContextObject(context, type);
-        }
-    }
-
-    @Override
-    public Object getInteractionContextObject(Object context, Class<?> type) {
-        InteractionBase button = (InteractionBase) context;
-        switch (type.getName()) {
-            case "org.javacord.api.entity.channel.TextChannel":
-                return button.getChannel().orElse(null);
-            case "org.javacord.api.entity.server.Server":
-                return button.getServer().orElse(null);
-            case "org.javacord.api.entity.user.User":
-                return button.getUser();
-        }
-        return null;
-    }
-
-    @Override
-    public AutocompleteOptionData getAutocompleteFocusedOption(Object context) {
-        SlashCommandInteractionOption option = ((AutocompleteInteraction) context).getFocusedOption();
-        return new AutocompleteOptionData(option.getName(), getOptionValue(option));
-    }
-
-}

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

@@ -1,77 +0,0 @@
-package net.tomatentum.marinara.wrapper.javacord;
-
-import java.util.List;
-
-import org.javacord.api.interaction.SlashCommand;
-import org.javacord.api.interaction.SlashCommandBuilder;
-import org.javacord.api.interaction.SlashCommandOption;
-import org.javacord.api.interaction.SlashCommandOptionBuilder;
-import org.javacord.api.interaction.SlashCommandOptionChoice;
-import org.javacord.api.interaction.SlashCommandOptionChoiceBuilder;
-import org.javacord.api.interaction.SlashCommandOptionType;
-
-import net.tomatentum.marinara.interaction.ident.InteractionIdentifier;
-import net.tomatentum.marinara.interaction.ident.RootCommandIdentifier;
-import net.tomatentum.marinara.wrapper.CommandConverter;
-
-public class JavacordConverterSpec implements CommandConverter.Spec<SlashCommandBuilder, SlashCommandOption, SlashCommandOptionChoice> {
-
-	@Override
-	public SlashCommandBuilder convertCommand(RootCommandIdentifier rootIdentifier, List<SlashCommandOption> options) {
-		return SlashCommand.with(rootIdentifier.name(), rootIdentifier.description(), options);
-	}
-
-	@Override
-	public SlashCommandOption convertSubCommandGroup(InteractionIdentifier identifier,
-			List<SlashCommandOption> subCommands) {
-		return SlashCommandOption.createWithOptions(
-			SlashCommandOptionType.SUB_COMMAND_GROUP, 
-			identifier.name(), 
-			identifier.description(), 
-			subCommands);
-	}
-
-	@Override
-	public SlashCommandOption convertSubCommand(InteractionIdentifier identifier, List<SlashCommandOption> options) {
-		return SlashCommandOption.createWithOptions(
-            SlashCommandOptionType.SUB_COMMAND, 
-            identifier.name(), 
-            identifier.description(), 
-            options);
-	}
-
-	@Override
-	public SlashCommandOption convertOption(
-			net.tomatentum.marinara.interaction.commands.annotation.SlashCommandOption option,
-			List<SlashCommandOptionChoice> choices) {
-		SlashCommandOptionType type = SlashCommandOptionType.fromValue(option.type().getValue());
-		return new SlashCommandOptionBuilder()
-            .setType(type)
-            .setName(option.name())
-            .setDescription(option.description())
-            .setRequired(option.required())
-            .setAutocompletable(option.autocompletes().length > 0)
-			.setMinLength((long) option.range().min())
-			.setDecimalMinValue(option.range().min())
-			.setMaxLength((long) option.range().max())
-			.setDecimalMaxValue(option.range().max())
-            .setChoices(choices)
-			.build();
-	}
-
-	@Override
-	public SlashCommandOptionChoice convertChoice(
-			net.tomatentum.marinara.interaction.commands.annotation.SlashCommandOptionChoice choice) {
-		SlashCommandOptionChoiceBuilder builder = new SlashCommandOptionChoiceBuilder().setName(choice.name());
-		if (choice.longValue() != Long.MAX_VALUE)
-			builder.setValue(choice.longValue());
-		/*
-		not yet available
-		if (choice.doubleValue() != Double.MAX_VALUE)
-			builder.setValue(choice.doubleValue());
-		*/
-		if (!choice.stringValue().isEmpty())
-			builder.setValue(choice.stringValue());
-		return builder.build();
-	}
-}

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

@@ -1,29 +0,0 @@
-package net.tomatentum.marinara.wrapper.javacord;
-
-import java.util.Set;
-
-import org.javacord.api.DiscordApi;
-import org.javacord.api.interaction.SlashCommandBuilder;
-
-import net.tomatentum.marinara.wrapper.CommandRegisterer;
-import net.tomatentum.marinara.wrapper.ServerCommandList;
-
-public class JavacordRegistererStrategy implements CommandRegisterer.Strategy<SlashCommandBuilder> {
-
-    private DiscordApi api;
-
-    public JavacordRegistererStrategy(DiscordApi api) {
-        this.api = api;
-    }
-
-    @Override
-    public void registerServer(ServerCommandList<SlashCommandBuilder> commands) {
-        api.bulkOverwriteServerApplicationCommands(commands.serverId(), commands);
-    }
-
-    @Override
-    public void registerGlobal(Set<SlashCommandBuilder> defs) {
-        api.bulkOverwriteGlobalApplicationCommands(defs);
-    }
-
-}

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

@@ -1,70 +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.AutocompleteInteraction;
+import org.javacord.api.interaction.ApplicationCommandInteraction;
+import org.javacord.api.interaction.ButtonInteraction;
 import org.javacord.api.interaction.SlashCommandBuilder;
-import org.javacord.api.interaction.SlashCommandOptionChoice;
+import org.javacord.api.interaction.SlashCommandInteraction;
-import org.slf4j.Logger;
+import org.javacord.api.interaction.SlashCommandInteractionOption;
-import org.slf4j.LoggerFactory;
 
-import net.tomatentum.marinara.wrapper.CommandConverter;
+import io.leangen.geantyref.AnnotationFormatException;
-import net.tomatentum.marinara.wrapper.CommandRegisterer;
+import io.leangen.geantyref.TypeFactory;
-import net.tomatentum.marinara.wrapper.ContextObjectProvider;
+import net.tomatentum.marinara.interaction.InteractionType;
-import net.tomatentum.marinara.wrapper.IdentifierProvider;
+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;
-import net.tomatentum.marinara.wrapper.javacord.identifierconverter.AutocompleteIdentifierConverter;
-import net.tomatentum.marinara.wrapper.javacord.identifierconverter.ButtonIdentifierConverter;
-import net.tomatentum.marinara.wrapper.javacord.identifierconverter.SlashCommandIdentifierConverter;
 
 public class JavacordWrapper extends LibraryWrapper {
 
-    private JavacordContextObjectProvider contextObjectProvider;
+    private DiscordApi api;
-    private CommandRegisterer<SlashCommandBuilder> commandRegisterer;
-    
-    private Logger logger = LoggerFactory.getLogger(getClass());
 
     public JavacordWrapper(DiscordApi api) {
-        this.contextObjectProvider = new JavacordContextObjectProvider();
+        this.api = api;
-        var converter = CommandConverter.of(new JavacordConverterSpec());
+        api.addInteractionCreateListener((e) -> handleInteraction(e.getInteraction()));
+    }
 
-        if (api != null) {
+    @Override
-            this.commandRegisterer = CommandRegisterer.of(new JavacordRegistererStrategy(api), converter);
+    public InteractionType getInteractionType(Class<?> clazz) {
-            api.addInteractionCreateListener(e -> handleInteraction(e.getInteraction()));
+        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
-            logger.warn("DiscordApi was null so no Events were subscribed to.");
+                globalCommands.add(builder);
-        logger.info("Javacord wrapper loaded!");
+        }
+
+        for (long serverId : serverCommands.keySet()) {
+            api.bulkOverwriteServerApplicationCommands(serverId, serverCommands.get(serverId));
+        }
+        api.bulkOverwriteGlobalApplicationCommands(globalCommands);
     }
 
     @Override
-    public CommandRegisterer<?> getRegisterer() {
+    public Object convertCommandOption(Object context, SlashCommandOptionType type, String optionName) {
-        return this.commandRegisterer;
+        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 IdentifierProvider createIdentifierProvider() {
+    public ExecutableSlashCommandDefinition getCommandDefinition(Object context) {
-        return IdentifierProvider.of(
+        if (!(context instanceof SlashCommandInteraction))
-            new SlashCommandIdentifierConverter(),
+            return null;
-            new AutocompleteIdentifierConverter(),
+
-            new ButtonIdentifierConverter()
+        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 ContextObjectProvider getContextObjectProvider() {
+    public String getButtonId(Object context) {
-        return contextObjectProvider;
+        ButtonInteraction button = (ButtonInteraction) context;
+        return button.getCustomId();
     }
 
     @Override
-    public void respondAutocomplete(Object context, List<Object> options) {
+    public Object getComponentContextObject(Object context, Class<?> type) {
-        if (context instanceof AutocompleteInteraction interaction) {
+        ButtonInteraction button = (ButtonInteraction) context;
-            List<SlashCommandOptionChoice> choices = options.stream()
+        switch (type.getName()) {
-                .filter(SlashCommandOptionChoice.class::isInstance)
+            case "org.javacord.api.entity.channel.TextChannel":
-                .map(o -> (SlashCommandOptionChoice)o)
+                return button.getChannel().orElse(null);
-                .toList();
+            case "org.javacord.api.entity.message.Message":
-            interaction.respondWithChoices(choices);
+                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/main/java/net/tomatentum/marinara/wrapper/javacord/checks/PermissionCheck.java

@@ -1,41 +0,0 @@
-package net.tomatentum.marinara.wrapper.javacord.checks;
-
-import java.lang.annotation.ElementType;
-import java.lang.annotation.Retention;
-import java.lang.annotation.RetentionPolicy;
-import java.lang.annotation.Target;
-import java.util.Optional;
-
-import org.javacord.api.entity.permission.PermissionType;
-import org.javacord.api.entity.server.Server;
-import org.javacord.api.interaction.InteractionBase;
-
-import net.tomatentum.marinara.checks.InteractionCheck;
-
-public class PermissionCheck implements InteractionCheck<PermissionCheck.HasPermission> {
-
-    @Retention(RetentionPolicy.RUNTIME)
-    @Target(ElementType.METHOD)
-    public static @interface HasPermission {
-        public PermissionType[] value();
-    }
-
-    @Override
-    public boolean preExec(Object context, HasPermission annotation) {
-        throw new UnsupportedOperationException("Unimplemented method 'preExec'");
-    }
-
-    public boolean preExec(InteractionBase context, HasPermission annotation) {
-        Optional<Server> server = context.getServer();
-        if (!server.isPresent())
-            return false;
-
-       return server.get().hasPermissions(context.getUser(), annotation.value());
-    }
-
-    @Override
-    public void postExec(Object context, HasPermission annotation) {
-        
-    }
-    
-}

wrapper/javacord/src/main/java/net/tomatentum/marinara/wrapper/javacord/identifierconverter/AutocompleteIdentifierConverter.java

@@ -1,40 +0,0 @@
-package net.tomatentum.marinara.wrapper.javacord.identifierconverter;
-
-import java.util.List;
-
-import org.javacord.api.interaction.AutocompleteInteraction;
-import org.javacord.api.interaction.SlashCommandInteractionOption;
-
-import net.tomatentum.marinara.interaction.InteractionType;
-import net.tomatentum.marinara.interaction.ident.InteractionIdentifier;
-import net.tomatentum.marinara.wrapper.IdentifierProvider;
-
-public class AutocompleteIdentifierConverter implements IdentifierProvider.Converter<AutocompleteInteraction> {
-
-    @Override
-    public InteractionIdentifier convert(AutocompleteInteraction context) {
-        InteractionIdentifier last = InteractionIdentifier.builder()
-            .type(InteractionType.AUTOCOMPLETE)
-            .name(context.getCommandName())
-            .build();
-
-        List<SlashCommandInteractionOption> options = context.getOptions();
-        if (!options.isEmpty()) {
-            last = InteractionIdentifier.builder()
-                .type(InteractionType.AUTOCOMPLETE)
-                .name(options.getFirst().getName())
-                .parent(last)
-                .build();
-
-            List<SlashCommandInteractionOption> subOptions = context.getOptions().getFirst().getOptions();
-            if (!subOptions.isEmpty())
-                last = InteractionIdentifier.builder()
-                    .type(InteractionType.AUTOCOMPLETE)
-                    .name(subOptions.getFirst().getName())
-                    .parent(last)
-                    .build();
-        }
-        return last;
-    }
-    
-}

wrapper/javacord/src/main/java/net/tomatentum/marinara/wrapper/javacord/identifierconverter/ButtonIdentifierConverter.java

@@ -1,16 +0,0 @@
-package net.tomatentum.marinara.wrapper.javacord.identifierconverter;
-
-import org.javacord.api.interaction.ButtonInteraction;
-
-import net.tomatentum.marinara.interaction.InteractionType;
-import net.tomatentum.marinara.interaction.ident.InteractionIdentifier;
-import net.tomatentum.marinara.wrapper.IdentifierProvider;
-
-public class ButtonIdentifierConverter implements IdentifierProvider.Converter<ButtonInteraction> {
-
-    @Override
-    public InteractionIdentifier convert(ButtonInteraction context) {
-        return InteractionIdentifier.builder().name(context.getCustomId()).type(InteractionType.BUTTON).build();
-    }
-    
-}

wrapper/javacord/src/main/java/net/tomatentum/marinara/wrapper/javacord/identifierconverter/SlashCommandIdentifierConverter.java

@@ -1,40 +0,0 @@
-package net.tomatentum.marinara.wrapper.javacord.identifierconverter;
-
-import java.util.List;
-
-import org.javacord.api.interaction.SlashCommandInteraction;
-import org.javacord.api.interaction.SlashCommandInteractionOption;
-
-import net.tomatentum.marinara.interaction.InteractionType;
-import net.tomatentum.marinara.interaction.ident.InteractionIdentifier;
-import net.tomatentum.marinara.wrapper.IdentifierProvider;
-
-public class SlashCommandIdentifierConverter implements IdentifierProvider.Converter<SlashCommandInteraction> {
-
-    @Override
-    public InteractionIdentifier convert(SlashCommandInteraction context) {
-        InteractionIdentifier last = InteractionIdentifier.builder()
-            .type(InteractionType.COMMAND)
-            .name(context.getCommandName())
-            .build();
-
-        List<SlashCommandInteractionOption> options = context.getOptions();
-        if (!options.isEmpty()) {
-            last = InteractionIdentifier.builder()
-                .type(InteractionType.COMMAND)
-                .name(options.getFirst().getName())
-                .parent(last)
-                .build();
-                
-            List<SlashCommandInteractionOption> subOptions = context.getOptions().getFirst().getOptions();
-            if (!subOptions.isEmpty())
-                last = InteractionIdentifier.builder()
-                    .type(InteractionType.COMMAND)
-                    .name(subOptions.getFirst().getName())
-                    .parent(last)
-                    .build();
-        }
-        return last;
-    }
-    
-}

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

@@ -1,4 +1,4 @@
-package net.tomatentum.marinara.test.javacord;
+package net.tomatentum.marinara.test;
 
 import static org.junit.jupiter.api.Assertions.assertTrue;
 
@@ -7,19 +7,20 @@ import org.junit.jupiter.api.TestInstance;
 import org.junit.jupiter.api.TestInstance.Lifecycle;
 
 import net.tomatentum.marinara.Marinara;
-import net.tomatentum.marinara.test.javacord.mocks.CommonMocks;
+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)
-class ButtonTest {
+public class ButtonTest {
 
     @Test
-    void testButtonExecution() {
+    public void testButtonExecution() {
-        LibraryWrapper wrapper = new JavacordWrapper(null); //null okay as we don't use the discord API in this test.
+        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.getInteractionContainer().addAllMethods(new TestButton());
+        marinara.getRegistry().addInteractions(new TestButton());
-        wrapper.handleInteraction(CommonMocks.getButtonInteractionMock("test"));
+        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

@@ -1,25 +1,21 @@
-package net.tomatentum.marinara.test.javacord;
+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.permission.PermissionType;
 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;
-import net.tomatentum.marinara.test.javacord.TestInteractionCheck.TestCheck;
-import net.tomatentum.marinara.wrapper.javacord.checks.PermissionCheck.HasPermission;
 
 public class TestButton implements InteractionHandler {
 
-    public static boolean didRun = false;
 
+    public static boolean didRun = false;
     @Button("test")
-    @TestCheck
     public void exec(ButtonInteraction interaction, TextChannel channel, Message message, User member, Server server) {
         assertNotNull(interaction);
         assertNotNull(channel);
@@ -30,13 +26,4 @@ public class TestButton implements InteractionHandler {
         System.out.println("Success!");
     }
     
-    public static boolean didPermRun = false;
-
-    @Button("permissionCheck")
-    @HasPermission({PermissionType.ADMINISTRATOR})
-    public void exec(ButtonInteraction interaction) {
-        didPermRun = true;
-        System.out.println("It worked!");
-    }
-    
 }

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

@@ -1,17 +1,15 @@
-package net.tomatentum.marinara.test.javacord;
+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.CommandChoices;
 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",
@@ -22,14 +20,12 @@ public class TestCommand implements InteractionHandler {
             @SlashCommandOption(
                 name = "foo",
                 description = "foo bar is very fooby",
-                type = SlashCommandOptionType.STRING,
+                type = SlashCommandOptionType.STRING
-                choices = @CommandChoices(cenum = TestChoiceEnum.class)
             )
         }
         )
     public void exec(SlashCommandInteraction interaction, String test) {
-        assertEquals("test", test);
+        assertEquals(test, "test");
         System.out.println("Success!");
     }
-    
 }

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

@@ -1,40 +0,0 @@
-package net.tomatentum.marinara.test.javacord;
-
-import static org.mockito.ArgumentMatchers.any;
-import static org.mockito.Mockito.mock;
-import static org.mockito.Mockito.verify;
-import static org.mockito.Mockito.when;
-
-import java.util.Collections;
-import java.util.Optional;
-
-import org.javacord.api.interaction.AutocompleteInteraction;
-import org.javacord.api.interaction.SlashCommandInteractionOption;
-import org.junit.jupiter.api.Test;
-
-import net.tomatentum.marinara.Marinara;
-import net.tomatentum.marinara.wrapper.LibraryWrapper;
-import net.tomatentum.marinara.wrapper.javacord.JavacordWrapper;
-
-class AutoCompleteTest {
-    
-    @Test
-    void testAutocomplete() {
-
-        SlashCommandInteractionOption optionMock = mock();
-        AutocompleteInteraction autocompleteInteractionMock = mock();
-
-        when(optionMock.getName()).thenReturn("foo");
-        when(optionMock.getStringValue()).thenReturn(Optional.of("test"));
-
-        when(autocompleteInteractionMock.getCommandName()).thenReturn("test");
-        when(autocompleteInteractionMock.getFocusedOption()).thenReturn(optionMock);
-        when(autocompleteInteractionMock.getOptions()).thenReturn(Collections.emptyList());
-
-        LibraryWrapper wrapper = new JavacordWrapper(null); //null okay as we don't use the discord API in this test.
-        Marinara marinara = Marinara.load(wrapper);
-        marinara.getInteractionContainer().addAllMethods(new TestAutocomplete());
-        wrapper.handleInteraction(autocompleteInteractionMock);
-        verify(autocompleteInteractionMock).respondWithChoices(any());
-    }
-}

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

@@ -1,53 +0,0 @@
-package net.tomatentum.marinara.test.javacord;
-
-import static org.junit.jupiter.api.Assertions.assertFalse;
-import static org.junit.jupiter.api.Assertions.assertTrue;
-import static org.mockito.ArgumentMatchers.any;
-import static org.mockito.Mockito.mock;
-import static org.mockito.Mockito.when;
-
-import org.javacord.api.entity.server.Server;
-import org.javacord.api.interaction.ButtonInteraction;
-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.javacord.mocks.CommonMocks;
-import net.tomatentum.marinara.wrapper.LibraryWrapper;
-import net.tomatentum.marinara.wrapper.javacord.JavacordWrapper;
-import net.tomatentum.marinara.wrapper.javacord.checks.PermissionCheck;
-
-@TestInstance(Lifecycle.PER_CLASS)
-class InteractionCheckTest {
-    
-    @Test
-    void testInteractionCheck() {
-        LibraryWrapper wrapper = new JavacordWrapper(null);
-        Marinara marinara = Marinara.load(wrapper);
-        marinara.getCheckContainer().addAllMethods(new TestInteractionCheck());
-        marinara.getInteractionContainer().addAllMethods(new TestButton());
-        wrapper.handleInteraction(CommonMocks.getButtonInteractionMock("test"));
-        assertTrue(TestInteractionCheck.preExecuted);
-        assertTrue(TestInteractionCheck.postExecuted);
-    }
-
-    @Test
-    void testPermissionCheck() {
-        LibraryWrapper wrapper = new JavacordWrapper(null);
-        Marinara marinara = Marinara.load(wrapper);
-        marinara.getCheckContainer().addAllMethods(new PermissionCheck());
-        marinara.getInteractionContainer().addAllMethods(new TestButton());
-
-        Server serverMock = mock();
-        ButtonInteraction buttonInteractionMock = CommonMocks.getButtonInteractionMock("permissionCheck", serverMock);
-        when(serverMock.hasPermissions(any(), any())).thenReturn(false);
-        wrapper.handleInteraction(buttonInteractionMock);
-        assertFalse(TestButton.didPermRun);
-
-        when(serverMock.hasPermissions(any(), any())).thenReturn(true);
-        wrapper.handleInteraction(buttonInteractionMock);
-        assertTrue(TestButton.didPermRun);
-    }
-
-}

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

@@ -1,71 +0,0 @@
-package net.tomatentum.marinara.test.javacord;
-
-import static org.mockito.Mockito.mock;
-import static org.mockito.Mockito.when;
-
-import java.util.Arrays;
-import java.util.Optional;
-
-import org.javacord.api.DiscordApi;
-import org.javacord.api.DiscordApiBuilder;
-import org.javacord.api.interaction.SlashCommandInteraction;
-import org.javacord.api.interaction.SlashCommandInteractionOption;
-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.wrapper.LibraryWrapper;
-import net.tomatentum.marinara.wrapper.javacord.JavacordWrapper;
-@TestInstance(Lifecycle.PER_CLASS)
-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.getInteractionContainer().addAllMethods(new TestCommand());
-        marinara.registerCommands();
-        System.out.println("Success!");
-    }
-    
-    @Test
-    void testSlashCommandExecution() {
-        LibraryWrapper wrapper = new JavacordWrapper(api);
-        Marinara marinara = Marinara.load(wrapper);
-        marinara.getInteractionContainer().addAllMethods(new TestCommand());
-
-        SlashCommandInteractionOption optionMock = mock();
-        SlashCommandInteraction interactionMock = mock();
-
-        when(optionMock.getName()).thenReturn("foo");
-        when(optionMock.getStringValue()).thenReturn(Optional.of("test"));
-
-        when(interactionMock.getCommandName()).thenReturn("test");
-        when(interactionMock.getOptions()).thenReturn(Arrays.asList(optionMock));
-        when(interactionMock.getArguments()).thenReturn(Arrays.asList(optionMock));
-        when(interactionMock.getOptionByName("foo")).thenReturn(Optional.of(optionMock));
-
-        wrapper.handleInteraction(interactionMock);
-    }
-
-    
-
-}

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

@@ -1,37 +0,0 @@
-package net.tomatentum.marinara.test.javacord;
-
-import static org.junit.jupiter.api.Assertions.assertEquals;
-
-import java.util.Collections;
-
-import org.javacord.api.interaction.AutocompleteInteraction;
-import org.javacord.api.interaction.SlashCommandInteraction;
-
-import net.tomatentum.marinara.interaction.InteractionHandler;
-import net.tomatentum.marinara.interaction.annotation.AutoComplete;
-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 TestAutocomplete implements InteractionHandler {
-    
-    @SlashCommand(
-        name = "test",
-        options = @SlashCommandOption(
-                name = "foo",
-                type = SlashCommandOptionType.STRING,
-                autocompletes = @AutoComplete("testAuto")
-            )
-        )
-    public void exec(SlashCommandInteraction context) {
-        //only here for command definition
-    }
-
-    @AutoComplete("testAuto")
-    public void autocomplete(AutocompleteInteraction context, String value) {
-        System.out.println("Success!");
-        assertEquals("test", value);
-        context.respondWithChoices(Collections.emptyList());
-    }
-
-}

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

@@ -1,20 +0,0 @@
-package net.tomatentum.marinara.test.javacord;
-
-import net.tomatentum.marinara.interaction.commands.choice.ChoiceValueProvider;
-
-public enum TestChoiceEnum implements ChoiceValueProvider<String> {
-    TestValue("testValue"),
-    FooBar("fooBar"),
-    Spongebob("spongebob");
-
-    private String value;
-
-    private TestChoiceEnum(String value) {
-        this.value = value;
-    }
-    @Override
-    public String getChoiceValue() {
-        return value;
-    }
-    
-}

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

@@ -1,37 +0,0 @@
-package net.tomatentum.marinara.test.javacord;
-
-import static org.junit.jupiter.api.Assertions.assertNotNull;
-
-import java.lang.annotation.ElementType;
-import java.lang.annotation.Retention;
-import java.lang.annotation.RetentionPolicy;
-import java.lang.annotation.Target;
-
-import net.tomatentum.marinara.checks.InteractionCheck;
-
-public class TestInteractionCheck implements InteractionCheck<TestInteractionCheck.TestCheck> {
-
-    public static boolean preExecuted = false;
-    public static boolean postExecuted = false;
-
-    @Target({ElementType.METHOD})
-    @Retention(RetentionPolicy.RUNTIME)
-    public static @interface TestCheck {
-    }
-
-    @Override
-    public boolean preExec(Object context, TestCheck annotation) {
-        assertNotNull(annotation);
-        assertNotNull(context);
-        preExecuted = true;
-        return true;
-    }
-
-    @Override
-    public void postExec(Object context, TestCheck annotation) {
-        assertNotNull(annotation);
-        assertNotNull(context);
-        postExecuted = true;
-    }
-    
-}

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

@@ -1,42 +0,0 @@
-package net.tomatentum.marinara.test.javacord.mocks;
-
-import static org.mockito.Mockito.mock;
-import static org.mockito.Mockito.when;
-
-import java.util.Optional;
-
-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;
-
-public class CommonMocks {
-
-    public static ButtonInteraction getButtonInteractionMock(String customId) {
-        ButtonInteraction buttonInteractionMock = mock();
-        
-        when(buttonInteractionMock.getCustomId()).thenReturn(customId);
-        when(buttonInteractionMock.getMessage()).thenReturn(mock(Message.class));
-        when(buttonInteractionMock.getServer()).thenReturn(Optional.of(mock(Server.class)));
-        when(buttonInteractionMock.getChannel()).thenReturn(Optional.of(mock(TextChannel.class)));
-        when(buttonInteractionMock.getUser()).thenReturn(mock(User.class));
-
-
-        return buttonInteractionMock;
-    }
-
-    public static ButtonInteraction getButtonInteractionMock(String customId, Server serverMock) {
-        ButtonInteraction buttonInteractionMock = mock();
-        
-        when(buttonInteractionMock.getCustomId()).thenReturn(customId);
-        when(buttonInteractionMock.getMessage()).thenReturn(mock(Message.class));
-        when(buttonInteractionMock.getServer()).thenReturn(Optional.of(serverMock));
-        when(buttonInteractionMock.getChannel()).thenReturn(Optional.of(mock(TextChannel.class)));
-        when(buttonInteractionMock.getUser()).thenReturn(mock(User.class));
-
-
-        return buttonInteractionMock;
-    }
-    
-}

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