gradle/libs.versions.toml

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

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

@@ -1,13 +1,24 @@
 package net.tomatentum.marinara;
 
+import java.lang.reflect.Constructor;
+
 import net.tomatentum.marinara.registry.InteractionRegistry;
 import net.tomatentum.marinara.wrapper.LibraryWrapper;
 
 public class Marinara {
     
-    public static <T extends LibraryWrapper> Marinara load(LibraryWrapper wrapper) {
+    public static <T extends LibraryWrapper> Marinara load(Class<T> clazz) {
-        InteractionRegistry registry = new InteractionRegistry(wrapper);
+        try {
-        return new Marinara(registry);
+            Constructor<T> ctor = clazz.getConstructor();
+            ctor.setAccessible(true);
+            T wrapper = ctor.newInstance();
+            InteractionRegistry registry = new InteractionRegistry(wrapper);
+            return new Marinara(registry);
+        }catch (Exception ex) {
+            System.err.println(ex);
+            System.exit(100);
+            return null;
+        }
     }
 
     private InteractionRegistry registry;

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

@@ -12,7 +12,7 @@ import net.tomatentum.marinara.interaction.commands.annotation.SubCommandGroup;
 public class SlashCommandDefinition {
     private List<ExecutableSlashCommandDefinition> executableDefinitons;
     private SlashCommand slashCommand;
-    private boolean isRootCommand;
+    private boolean isRootCommand = false;
 
     public SlashCommandDefinition(SlashCommand applicationCommand) {
         this.executableDefinitons = new ArrayList<>();
@@ -23,15 +23,17 @@ public class SlashCommandDefinition {
         if (def.applicationCommand() != null) {
             if (slashCommand == null)
                 this.slashCommand = def.applicationCommand();
-            if (!this.slashCommand.name().equals(def.applicationCommand().name()))
+            if (!this.slashCommand.equals(def.applicationCommand()))
                 throw new IllegalArgumentException(def + ": has a non matching Application Command description. Please edit it to equal all other descriptions or remove it to use other definitions descriptions");
         }
-
+        if (isRootCommand) {
-        if (executableDefinitons.isEmpty())
+            if (!def.isRootCommand())
-            this.isRootCommand = def.isRootCommand();
+                throw new IllegalArgumentException(def + ": cannot have subcommands and rootcommand definitions together");
-
+            long subCommandAmount = executableDefinitons.stream()
-        if ((isRootCommand && !def.isRootCommand()) || (!isRootCommand && def.isRootCommand())) {
+                .filter((x) -> !x.isRootCommand())
-            throw new IllegalArgumentException(def + ": cannot have subcommands and rootcommand definitions together");
+                .count();
+            if (subCommandAmount > 0)
+                throw new IllegalArgumentException(def + ": cannot have subcommands and rootcommand definitions together");
         }
         
         executableDefinitons.add(def);
@@ -51,7 +53,7 @@ public class SlashCommandDefinition {
                 subCommandGroupMap.put(x.name(), x);
         });
 
-        return subCommandGroupMap.values().toArray(new SubCommandGroup[0]);
+        return (SubCommandGroup[]) subCommandGroupMap.values().toArray();
     }
 
     public SubCommand[] getSubCommands(String groupName) {
@@ -74,7 +76,7 @@ public class SlashCommandDefinition {
                 subCommandMap.put(x.name(), x);
         });
 
-        return subCommandMap.values().toArray(new SubCommand[0]);
+        return (SubCommand[]) subCommandMap.values().toArray();
     }
 
     public SlashCommand getFullSlashCommand() {

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

@@ -1,6 +1,5 @@
 package net.tomatentum.marinara.interaction.methods;
 
-import java.lang.reflect.InvocationTargetException;
 import java.lang.reflect.Method;
 import java.security.InvalidParameterException;
 import java.util.ArrayList;
@@ -53,8 +52,8 @@ public abstract class InteractionMethod {
         }
         method.setAccessible(true);
         try {
-            method.invoke(handler, parameters.toArray());
+            method.invoke(handler, parameters);
-        }catch (IllegalAccessException | InvocationTargetException ex) {
+        }catch (Exception ex) {
             throw new RuntimeException(ex);
         }
     }

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

@@ -18,16 +18,13 @@ public class InteractionRegistry {
     private LibraryWrapper wrapper;
 
     public InteractionRegistry(LibraryWrapper wrapper) {
-        this.interactionMethods = new ArrayList<>();
         this.wrapper = wrapper;
         wrapper.subscribeInteractions(this::handle);
     }
 
     public void addInteractions(InteractionHandler interactionHandler) {
         for (Method method : interactionHandler.getClass().getMethods()) {
-            InteractionMethod iMethod = InteractionMethod.create(method, interactionHandler, wrapper);
+            interactionMethods.add(InteractionMethod.create(method, interactionHandler, wrapper));
-            if (iMethod != null)
-                this.interactionMethods.add(iMethod);
         }
     }
 

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

@@ -30,8 +30,8 @@ public final class ReflectionUtil {
         if (!isAnnotationPresent(method, SlashCommand.class))
             throw new RuntimeException(method.getName() + ": Missing ApplicationCommand Annotation on either Class or Method");
 
-        if ((method.isAnnotationPresent(SubCommand.class) && 
+        if (!(method.isAnnotationPresent(SubCommand.class) && 
-            !isAnnotationPresent(method, SlashCommand.class))) {
+            isAnnotationPresent(method, SlashCommand.class))) {
             throw new RuntimeException(method.getName() + ": Missing ApplicationCommand Annotation on either Method or Class");
         }
     }

settings.gradle.kts

@@ -12,4 +12,3 @@ plugins {
 
 rootProject.name = "Marinara"
 include("lib")
-include("wrapper:javacord")

wrapper/javacord/build.gradle.kts

@@ -1,39 +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`
-}
-
-repositories {
-    // Use Maven Central for resolving dependencies.
-    mavenCentral()
-}
-
-dependencies {
-    // Use JUnit Jupiter for testing.
-    testImplementation(libs.junit.jupiter)
-
-    testRuntimeOnly("org.junit.platform:junit-platform-launcher")
-    implementation(libs.log4j)
-    implementation(libs.javacord)
-    implementation(libs.geantyref)
-    implementation(project(":lib"))
-}
-
-// Apply a specific Java toolchain to ease working on different environments.
-java {
-    toolchain {
-        languageVersion = JavaLanguageVersion.of(21)
-    }
-}
-
-tasks.named<Test>("test") {
-    // Use JUnit Platform for unit tests.
-    useJUnitPlatform()
-}

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

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

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

@@ -1,53 +0,0 @@
-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.marinare.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/TestCommand.java

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

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

@@ -1,147 +0,0 @@
-package net.tomatentum.marinara.test.mocks;
-
-import java.util.Arrays;
-import java.util.Collections;
-import java.util.EnumSet;
-import java.util.List;
-import java.util.Optional;
-import java.util.concurrent.CompletableFuture;
-
-import org.javacord.api.DiscordApi;
-import org.javacord.api.entity.channel.TextChannel;
-import org.javacord.api.entity.message.component.HighLevelComponent;
-import org.javacord.api.entity.permission.PermissionType;
-import org.javacord.api.entity.server.Server;
-import org.javacord.api.entity.user.User;
-import org.javacord.api.interaction.DiscordLocale;
-import org.javacord.api.interaction.InteractionType;
-import org.javacord.api.interaction.SlashCommandInteraction;
-import org.javacord.api.interaction.SlashCommandInteractionOption;
-import org.javacord.api.interaction.callback.InteractionFollowupMessageBuilder;
-import org.javacord.api.interaction.callback.InteractionImmediateResponseBuilder;
-import org.javacord.api.interaction.callback.InteractionOriginalResponseUpdater;
-
-public class SlashCommandInteractionMock implements SlashCommandInteraction{
-
-    @Override
-    public long getCommandId() {
-        throw new UnsupportedOperationException("Unimplemented method 'getCommandId'");
-    }
-
-    @Override
-    public String getCommandIdAsString() {
-        throw new UnsupportedOperationException("Unimplemented method 'getCommandIdAsString'");
-    }
-
-    @Override
-    public String getCommandName() {
-        return "test";
-    }
-
-    @Override
-    public Optional<Long> getRegisteredCommandServerId() {
-        throw new UnsupportedOperationException("Unimplemented method 'getRegisteredCommandServerId'");
-    }
-
-    @Override
-    public long getApplicationId() {
-        throw new UnsupportedOperationException("Unimplemented method 'getApplicationId'");
-    }
-
-    @Override
-    public InteractionType getType() {
-        return InteractionType.APPLICATION_COMMAND;
-    }
-
-    @Override
-    public InteractionImmediateResponseBuilder createImmediateResponder() {
-        throw new UnsupportedOperationException("Unimplemented method 'createImmediateResponder'");
-    }
-
-    @Override
-    public CompletableFuture<InteractionOriginalResponseUpdater> respondLater() {
-        throw new UnsupportedOperationException("Unimplemented method 'respondLater'");
-    }
-
-    @Override
-    public CompletableFuture<InteractionOriginalResponseUpdater> respondLater(boolean ephemeral) {
-        throw new UnsupportedOperationException("Unimplemented method 'respondLater'");
-    }
-
-    @Override
-    public CompletableFuture<Void> respondWithModal(String customId, String title,
-            List<HighLevelComponent> components) {
-        throw new UnsupportedOperationException("Unimplemented method 'respondWithModal'");
-    }
-
-    @Override
-    public InteractionFollowupMessageBuilder createFollowupMessageBuilder() {
-        throw new UnsupportedOperationException("Unimplemented method 'createFollowupMessageBuilder'");
-    }
-
-    @Override
-    public Optional<Server> getServer() {
-        throw new UnsupportedOperationException("Unimplemented method 'getServer'");
-    }
-
-    @Override
-    public Optional<TextChannel> getChannel() {
-        throw new UnsupportedOperationException("Unimplemented method 'getChannel'");
-    }
-
-    @Override
-    public User getUser() {
-        throw new UnsupportedOperationException("Unimplemented method 'getUser'");
-    }
-
-    @Override
-    public String getToken() {
-        throw new UnsupportedOperationException("Unimplemented method 'getToken'");
-    }
-
-    @Override
-    public int getVersion() {
-        throw new UnsupportedOperationException("Unimplemented method 'getVersion'");
-    }
-
-    @Override
-    public DiscordLocale getLocale() {
-        throw new UnsupportedOperationException("Unimplemented method 'getLocale'");
-    }
-
-    @Override
-    public Optional<DiscordLocale> getServerLocale() {
-        throw new UnsupportedOperationException("Unimplemented method 'getServerLocale'");
-    }
-
-    @Override
-    public Optional<EnumSet<PermissionType>> getBotPermissions() {
-        throw new UnsupportedOperationException("Unimplemented method 'getBotPermissions'");
-    }
-
-    @Override
-    public DiscordApi getApi() {
-        throw new UnsupportedOperationException("Unimplemented method 'getApi'");
-    }
-
-    @Override
-    public long getId() {
-        throw new UnsupportedOperationException("Unimplemented method 'getId'");
-    }
-
-    @Override
-    public List<SlashCommandInteractionOption> getOptions() {
-        return Arrays.asList(new SlashCommandInteractionOptionMock());
-    }
-
-    @Override
-    public List<SlashCommandInteractionOption> getArguments() {
-        return Arrays.asList(new SlashCommandInteractionOptionMock());
-    }
-
-    @Override
-    public String getFullCommandName() {
-        return "test";
-    }
-    
-}

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

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