@mostfeatured/dbi 0.0.81 → 0.0.82

package/src/methods/handleMessageCommands.ts

@@ -0,0 +1,310 @@
+import { ApplicationCommandType, ChatInputCommandInteraction, Message, MessagePayload, ApplicationCommandOptionType } from "discord.js";
+import { NamespaceEnums } from "../../generated/namespaceData";
+import { DBI } from "../DBI";
+import { FakeMessageInteraction } from "../types/other/FakeMessageInteraction";
+import { TDBILocaleString } from "../types/other/Locale";
+
+const INTEGER_REGEX = /^-?\d+$/;
+const NUMBER_REGEX = /^-?\d+(?:\.\d+)?$/;
+
+export type TDBIMessageCommandArgumentErrorTypes = "MissingRequiredOption" | "MinLength" | "MaxLength" | "InvalidChoice" | "InvalidInteger" | "MinInteger" | "MaxInteger" | "InvalidNumber" | "MinNumber" | "MaxNumber" | "InvalidBoolean" | "InvalidUser" | "InvalidChannel" | "InvalidRole" | "InvalidMentionable" | "InvalidCompleteChoice";
+
+export async function handleMessageCommands(dbi: DBI<NamespaceEnums>, message: Message) {
+  const chatInputs = dbi.data.interactions.filter(i => i.type === "ChatInput");
+  const prefixes = dbi.config.messageCommands.prefixes ?? [];
+  if (!prefixes.length) return;
+  const content = message.content;
+  const usedPrefix = prefixes.find(p => content.startsWith(p));
+  if (!usedPrefix) return;
+  const contentWithoutPrefix = content.slice(usedPrefix?.length ?? 0);
+  const contentLower = contentWithoutPrefix.toLowerCase();
+
+  let locale: string = message.guild.preferredLocale?.split("-")?.at(0) || dbi.config.defaults.locale as any;
+  let usedAlias: string | undefined;
+  let chatInput = chatInputs.find(i => {
+    let found = contentLower.startsWith(i.name);
+    if (found) return true;
+    let alias = i.other?.messageCommand?.aliases?.find(a => contentLower.startsWith(a));
+    if (alias) {
+      usedAlias = alias;
+      return true;
+    }
+    return false;
+  });
+  let commandName = usedAlias ?? chatInput?.name;
+
+  if (!chatInput) {
+    fLoop: for (const [localeInterName, localeData] of dbi.data.interactionLocales) {
+      for (const [localeName, translation] of Object.entries(localeData.data || {})) {
+        if (contentLower.startsWith(translation.name)) {
+          commandName = translation.name;
+          locale = localeName;
+          chatInput = chatInputs.find(i => i.name === localeData.name);
+          break fLoop;
+        }
+      }
+    }
+  }
+
+  if (!chatInput) return;
+
+  const interaction = new FakeMessageInteraction(dbi, message, chatInput, locale, commandName, usedPrefix);
+
+  if (chatInput.options.length) {
+    let errorType: TDBIMessageCommandArgumentErrorTypes;
+    let lastOption: any;
+    let lastValue: any;
+    let lastExtra: any;
+    let lastIndex: number;
+    for (let i = 0; i < chatInput.options.length; i++) {
+      lastIndex = i;
+      const option: any = interaction.dbiChatInputOptions[i];
+      const value = interaction.parsedArgs.get(option.name)?.value;
+
+      lastOption = option;
+      lastValue = value;
+
+      switch (option.type) {
+        case ApplicationCommandOptionType.String: {
+          if (option.autocomplete && option.onComplete) {
+            let choices = await option.onComplete({
+              interaction,
+              value
+            });
+            if (!choices.length) choices = await option.onComplete({
+              interaction,
+              value: ""
+            });
+            if (choices.length > 20) throw new Error("Autocomplete returned more than 20 choices.");
+            lastExtra = choices;
+            if (!choices.find(c => c.name === value || c.value === value)) {
+              if (value) {
+                errorType = "InvalidCompleteChoice";
+                break;
+              } else if (option.required && !value) {
+                errorType = "MissingRequiredOption";
+                break;
+              }
+            }
+            option._choices = choices;
+          }
+
+          if (option.choices) {
+            const localeData = dbi.data.interactionLocales.get(chatInput.name)?.data;
+            const choicesLocaleData = localeData?.[locale as TDBILocaleString]?.options?.[option.name]?.choices;
+            if (!option.choices.find(c => c.name === value || c.value === value || (choicesLocaleData?.[c.value] && choicesLocaleData?.[c.value] === value))) {
+              lastExtra = option.choices.map(c => ({ name: choicesLocaleData?.[c.value] ?? c.name, value: c.value }));
+              if (value) {
+                errorType = "InvalidChoice";
+                break;
+              } else if (option.required && !value) {
+                errorType = "MissingRequiredOption";
+                break;
+              }
+            }
+            break;
+          }
+
+          if (option.minLength && value.length < option.minLength) {
+            errorType = "MinLength";
+            break;
+          }
+          if (option.maxLength && value.length > option.maxLength) {
+            errorType = "MaxLength";
+            break;
+          }
+
+          break;
+        }
+        case ApplicationCommandOptionType.Integer: {
+          let parsedInt = parseInt(value);
+
+          if (option.autocomplete && option.onComplete) {
+            let choices = await option.onComplete({
+              interaction,
+              value
+            });
+            if (!choices.length) choices = await option.onComplete({
+              interaction,
+              value: ""
+            });
+            if (choices.length > 20) throw new Error("Autocomplete returned more than 20 choices.");
+            lastExtra = choices;
+            if (!choices.find(c => c.value === parsedInt || c.name === value)) {
+              if (value) {
+                errorType = "InvalidCompleteChoice";
+                break;
+              } else if (option.required && !value) {
+                errorType = "MissingRequiredOption";
+                break;
+              }
+            }
+            option._choices = choices;
+            break;
+          }
+
+          if (option.choices) {
+            const localeData = dbi.data.interactionLocales.get(chatInput.name)?.data;
+            const choicesLocaleData = localeData?.[locale as TDBILocaleString]?.options?.[option.name]?.choices;
+            if (!option.choices.find(c => c.value === parsedInt || c.name === value || (choicesLocaleData?.[c.value] && choicesLocaleData?.[c.value] === value))) {
+              lastExtra = option.choices.map(c => ({ name: choicesLocaleData?.[c.value] ?? c.name, value: c.value }));
+              if (value) {
+                errorType = "InvalidChoice";
+                break;
+              } else if (option.required && !value) {
+                errorType = "MissingRequiredOption";
+                break;
+              }
+            }
+            break;
+          }
+
+          if (!INTEGER_REGEX.test(value)) {
+            errorType = "InvalidInteger";
+            break;
+          }
+          
+          if (option.minValue && parsedInt < option.minValue) {
+            errorType = "MinInteger";
+            break;
+          }
+
+          if (option.maxValue && parsedInt > option.maxValue) {
+            errorType = "MaxInteger";
+            break;
+          }
+
+          break;
+        }
+        case ApplicationCommandOptionType.Number: {
+          let parsedFloat = parseFloat(value);
+
+          if (option.autocomplete && option.onComplete) {
+            let choices = await option.onComplete({
+              interaction,
+              value
+            });
+            if (!choices.length) choices = await option.onComplete({
+              interaction,
+              value: ""
+            });
+            if (choices.length > 20) throw new Error("Autocomplete returned more than 20 choices.");
+            lastExtra = choices;
+            if (!choices.find(c => c.value === parsedFloat || c.name === value)) {
+              if (value) {
+                errorType = "InvalidCompleteChoice";
+                break;
+              } else if (option.required && !value) {
+                errorType = "MissingRequiredOption";
+                break;
+              }
+            }
+            option._choices = choices;
+            break;
+          }
+
+          if (option.choices) {
+            const localeData = dbi.data.interactionLocales.get(chatInput.name)?.data;
+            const choicesLocaleData = localeData?.[locale as TDBILocaleString]?.options?.[option.name]?.choices;
+            if (!option.choices.find(c => c.value === parsedFloat || c.name === value || (choicesLocaleData?.[c.value] && choicesLocaleData?.[c.value] === value))) {
+              lastExtra = option.choices.map(c => ({ name: choicesLocaleData?.[c.value] ?? c.name, value: c.value }));
+              if (value) {
+                errorType = "InvalidChoice";
+                break;
+              } else if (option.required && !value) {
+                errorType = "MissingRequiredOption";
+                break;
+              }
+            }
+            break;
+          }
+
+          if (!NUMBER_REGEX.test(value)) {
+            errorType = "InvalidNumber";
+            break;
+          }
+
+          if (option.minValue && parsedFloat < option.minValue) {
+            errorType = "MinNumber";
+            break;
+          }
+
+          if (option.maxValue && parsedFloat > option.maxValue) {
+            errorType = "MaxNumber";
+            break;
+          }
+          break;
+        }
+        case ApplicationCommandOptionType.Boolean: {
+          let boolKeys = Object.keys(dbi.config.messageCommands.typeAliases.booleans);
+          if (!boolKeys.includes(value.toLowerCase())) {
+            errorType = "InvalidBoolean";
+            break;
+          }
+          break;
+        }
+        case ApplicationCommandOptionType.User: {
+          if (!interaction.options.getUser(option.name)) {
+            errorType = "InvalidUser";
+            break;
+          }
+          break;
+        }
+        case ApplicationCommandOptionType.Channel: {
+          if (!interaction.options.getChannel(option.name, null, option.channelTypes)) {
+            errorType = "InvalidChannel";
+            break;
+          }
+          break;
+        }
+        case ApplicationCommandOptionType.Role: {
+          if (!interaction.options.getRole(option.name)) {
+            errorType = "InvalidRole";
+            break;
+          }
+          break;
+        }
+        case ApplicationCommandOptionType.Mentionable: {
+          if (!interaction.options.getMentionable(option.name)) {
+            errorType = "InvalidMentionable";
+            break;
+          }
+          break;
+        }
+        case ApplicationCommandOptionType.Attachment: {
+          if (option.required && !value) {
+            errorType = "MissingRequiredOption";
+          }
+          break;
+        }
+      }
+
+      if (errorType) {
+        break;
+      } else {
+        lastExtra = null;
+        lastIndex = null;
+        lastOption = null;
+        lastValue = null;
+      }
+    }
+
+    if (errorType) {
+      let res = await dbi.events.trigger("messageCommandArgumentError", {
+        interaction,
+        message,
+        error: {
+          type: errorType,
+          option: lastOption,
+          extra: lastExtra,
+          index: lastIndex
+        },
+        value: lastValue
+      });
+      if (!res) return;
+    }
+  }
+
+
+  dbi.data.clients.first().client.emit("interactionCreate", interaction as any);
+}

package/src/methods/hookInteractionListeners.ts

@@ -7,9 +7,8 @@ const componentTypes = ["Button", "StringSelectMenu", "UserSelectMenu", "RoleSel
 
 export function hookInteractionListeners(dbi: DBI<NamespaceEnums>): () => any {
   async function handle(inter: Discord.Interaction<"cached">) {
-
     const dbiInter =
-      dbi.data.interactions.find(i => {
+      (inter as any).dbiChatInput ?? dbi.data.interactions.find(i => {
         let isUsesCustomId = (inter.isButton() || inter.isAnySelectMenu() || inter.isModalSubmit());
         let parsedId = isUsesCustomId ? parseCustomId(dbi, (inter as any).customId) : null;
         return (

package/src/types/ChatInput/ChatInputOptions.ts

@@ -19,7 +19,7 @@ export class DBIChatInputOptions<TNamespace extends NamespaceEnums> {
   constructor(dbi: DBI<TNamespace>) {
     this.dbi = dbi;
   }
-  stringAutocomplete(cfg: TDBIBaseOption & TDBIMinMaxLength & { onComplete(ctx: IDBICompleteCtx<TNamespace, string>): Promise<TDBIValueName<string>[]> }) {
+  stringAutocomplete(cfg: TDBIBaseOption & TDBIMinMaxLength & { onComplete(ctx: IDBICompleteCtx<TNamespace, string>): Promise<TDBIValueName<string>[]> | TDBIValueName<string>[] }) {
     return {
       type: Discord.ApplicationCommandOptionType.String,
       name: cfg.name,
@@ -60,7 +60,7 @@ export class DBIChatInputOptions<TNamespace extends NamespaceEnums> {
     };
   }
 
-  numberAutocomplete(cfg: TDBIBaseOption & TDBIMinMaxValue & { onComplete(ctx: IDBICompleteCtx<TNamespace, string>): Promise<TDBIValueName<number>[]> }) {
+  numberAutocomplete(cfg: TDBIBaseOption & TDBIMinMaxValue & { onComplete(ctx: IDBICompleteCtx<TNamespace, string>): Promise<TDBIValueName<number>[]> | TDBIValueName<number>[] }) {
     return {
       type: Discord.ApplicationCommandOptionType.Number,
       name: cfg.name,
@@ -102,7 +102,7 @@ export class DBIChatInputOptions<TNamespace extends NamespaceEnums> {
     };
   }
 
-  integerAutocomplete(cfg: TDBIBaseOption & TDBIMinMaxValue & { onComplete(ctx: IDBICompleteCtx<TNamespace, string>): Promise<TDBIValueName<number>[]> }) {
+  integerAutocomplete(cfg: TDBIBaseOption & TDBIMinMaxValue & { onComplete(ctx: IDBICompleteCtx<TNamespace, string>): Promise<TDBIValueName<number>[]> | TDBIValueName<number>[] }) {
     return {
       type: Discord.ApplicationCommandOptionType.Integer,
       name: cfg.name,

package/src/types/Interaction.ts

@@ -81,7 +81,7 @@ export class DBIBaseInteraction<TNamespace extends NamespaceEnums> {
   description: string;
   readonly type: TDBIInteractionTypes;
   options?: any | any[];
-  other?: Record<string, any>;
+  other?: Record<string, any> & { messageCommand: { aliases: string[] } };
   rateLimits?: DBIRateLimit[];
   toJSON(overrides: any): any { }
 

package/src/types/other/FakeMessageInteraction.ts

@@ -0,0 +1,294 @@
+import { Message, MessagePayload, ApplicationCommandType, ChatInputCommandInteraction, Locale, APIInteractionGuildMember, GuildMember, PermissionsBitField, CacheType, CommandInteractionOptionResolver, CommandOptionDataTypeResolvable, ApplicationCommandOptionType, User, Attachment } from 'discord.js';
+import { TDBIInteractions } from '../Interaction';
+import { plsParseArgs } from "plsargs";
+import { DBI } from '../../DBI';
+import { NamespaceEnums } from "../../../generated/namespaceData";
+import { ChannelType } from "discord-api-types/v10";
+
+export class FakeMessageInteraction /* implements ChatInputCommandInteraction */ {
+  channelId: string;
+  commandName: string;
+  appPermissions: any;
+  applicationId: string;
+  channel: any; 
+  command: any;
+  commandGuildId: string;
+  commandId: any; 
+  commandType: ApplicationCommandType.ChatInput;
+  // awaitModalSubmit: (...arr: any[]) => any;
+  // fetchReply: () => Promise<any>;
+  deferred: boolean = false;
+  client: any; 
+  createdAt: Date;
+  ephemeral: boolean = false;
+  createdTimestamp: number;
+  guild: any; 
+  guildId: string;
+  guildLocale: Locale;
+  id: string;
+  user: User;
+  private repliedMessage: Message | undefined;
+  private lastFollowUp: Message | undefined;
+  member: GuildMember | APIInteractionGuildMember;
+  memberPermissions: Readonly<PermissionsBitField>;
+  parsedArgs = new Map<string, FakeMessageInteractionArgument>();
+  usedCommandName: string;
+  fullCommandName: string;
+  options: any;
+  dbiChatInput: TDBIInteractions<string | number>;
+  dbiChatInputOptions: any[];
+  fake: boolean = true;
+
+  constructor(private dbi: DBI<NamespaceEnums>, private message: Message, chatInput: TDBIInteractions<string | number>, public locale: string, commandName: string, private usedPrefix: string) {
+    const self = this;
+    
+    this.channelId = message.channel.id;
+    this.commandName = chatInput.name.split(" ").at(0);
+    this.appPermissions = message.guild?.members.me.permissionsIn(message.channel as any) ?? new PermissionsBitField(8n);
+    this.applicationId = message.client.user.id;
+    this.channel = message.channel as any;
+    this.commandGuildId = message.guild.id;
+    this.commandType = ApplicationCommandType.ChatInput;
+    
+    this.client = message.client;
+    this.createdAt = message.createdAt;
+    this.createdTimestamp = message.createdTimestamp;
+    this.guild = message.guild;
+    this.guildId = message.guild?.id;
+    this.guildLocale = message.guild?.preferredLocale;
+    this.id = message.guild?.commands.cache.find((cmd) => cmd.name === this.commandName)?.id ?? message.client.application.commands.cache.find((cmd) => cmd.name === this.commandName)?.id ?? "-1";
+    this.locale = message.guild?.preferredLocale;
+    this.member = message.member;
+    this.memberPermissions = message.member?.permissions;
+    this.user = message.author;
+
+    this.usedCommandName = commandName;
+    this.fullCommandName = chatInput.name;
+    this.dbiChatInput = chatInput;
+    this.dbiChatInputOptions = chatInput.options ? chatInput.options.map(i => ({ ...i })) : []; 
+
+    {
+      const argContent = message.content.slice(usedPrefix.length + commandName.length).replace(/ +/, " ").trim();
+      const args = plsParseArgs(argContent);
+
+      const options = chatInput.options ?? [];
+      const atchs = [...message.attachments.values()];
+      for (let i = 0, attachmentIndex = 0, namedValueSize = 0; i < options.length; i++) {
+        const option = options[i];
+        if (!option) break;
+        if (option.type === ApplicationCommandOptionType.Attachment) {
+          this.parsedArgs.set(option.name, {
+            type: option.type,
+            value: atchs.at(attachmentIndex)?.url,
+            attachment: atchs.at(attachmentIndex++)
+          })
+          continue;
+        }
+        const arg = args.get(option.name) ?? args.get(i - attachmentIndex - namedValueSize);
+        if (args.get(option.name)) namedValueSize++;
+        this.parsedArgs.set(option.name, {
+          type: option.type,
+          value: arg
+        });
+      }
+
+      console.log(this.parsedArgs)
+    }
+
+    this.options = {
+      get(name: string) {
+        const rawValue = self.getRawOptionValue(name);
+        if (!rawValue) return null;
+        return {
+          value: rawValue,
+          get boolean() { return self.options.getBoolean(name); },
+          get channel() { return self.options.getChannel(name); },
+          get string() { return self.options.getString(name); },
+          get integer() { return self.options.getInteger(name); },
+          get number() { return self.options.getNumber(name); },
+          get user() { return self.options.getUser(name); },
+          get member() { return self.options.getMember(name); },
+          get role() { return self.options.getRole(name); },
+          get mentionable() { return self.options.getMentionable(name); },
+          get attachment() { return self.options.getAttachment(name); }
+        };
+      },
+      getSubcommand() {
+        let splitted = self.fullCommandName.split(" ");
+        if (splitted.length === 1) return null;
+        return splitted.at(-1);
+      },
+      getSubcommandGroup() {
+        let splitted = self.fullCommandName.split(" ");
+        if (splitted.length === 3) return splitted[1];
+        return null;
+      },
+      getBoolean(name: string) {
+        const rawValue = self.getRawOptionValue(name);
+        if (!rawValue) return null;
+        return !!self.dbi.config.messageCommands.typeAliases.booleans[rawValue.toLowerCase()];
+      },
+      getChannel(name: string, _: any, channelType?: ChannelType) {
+        const rawValue = self.getRawOptionValue(name);
+        if (!rawValue) return null;
+        let value = rawValue.replace(/<#|>/g, "");
+        let channel = self.message.client.channels.cache.get(value);
+        if (!channel) channel = self.message.client.channels.cache.find(c => {
+          if (self.guildId && (c as any).guildId && (c as any).guildId !== self.guildId) return false;
+          return (c as any).name === value;
+        });
+        if (channelType && channel?.type !== channelType) return null;
+        return channel;
+      },
+      getString(name: string) {
+        const dbiOption = self.getClonedDBIOption(name);
+        let rawValue = `${self.getRawOptionValue(name)}`;
+        let choices = dbiOption.choices ?? dbiOption._choices;
+        if (choices) return choices.find(c => c.value === rawValue || c.name === rawValue)?.value ?? rawValue;
+        return rawValue;
+      },
+      getInteger(name: string) {
+        const dbiOption = self.getClonedDBIOption(name);
+        let rawValue = self.getRawOptionValue(name);
+        let parsedValue = parseInt(rawValue);
+        let choices = dbiOption.choices ?? dbiOption._choices;
+        if (choices) return choices.find(c => c.value === parsedValue || c.name === rawValue)?.value ?? rawValue;
+        return rawValue;
+      },
+      getNumber(name: string) {
+        const dbiOption = self.getClonedDBIOption(name);
+        let rawValue = self.getRawOptionValue(name);
+        let parsedValue = parseFloat(rawValue);
+        let choices = dbiOption.choices ?? dbiOption._choices;
+        if (choices) return choices.find(c => c.value === parsedValue || c.name === rawValue)?.value ?? rawValue;
+        return rawValue;
+      },
+      getUser(name: string) {
+        const rawValue = self.getRawOptionValue(name);
+        if (!rawValue) return null;
+        let value = rawValue.replace(/<@!?|>/g, "");
+        let user = self.message.client.users.cache.get(value);
+        if (!user) user = self.message.client.users.cache.find(u => u.username === value || u.tag === value);
+        return user;
+      },
+      getMember(name: string) {
+        const rawValue = self.getRawOptionValue(name);
+        if (!rawValue) return null;
+        let value = rawValue.replace(/<@!?|>/g, "");
+        let member = self.message.guild?.members.cache.get(value);
+        if (!member) member = self.message.guild?.members.cache.find(m => m.user.username === value || m.user.tag === value);
+        return member;
+      },
+      getRole(name: string) {
+        const rawValue = self.getRawOptionValue(name);
+        if (!rawValue) return null;
+        let value = rawValue.replace(/<@&|>/g, "");
+        let role = self.message.guild?.roles.cache.get(value);
+        if (!role) role = self.message.guild?.roles.cache.find(r => r.name === value);
+        return role;
+      },
+      getMentionable(name: string) {
+        const rawValue = self.getRawOptionValue(name);
+        if (!rawValue) return null;
+        let value = rawValue.replace(/<@(!|&)?|>/g, "");
+        let user = self.message.client.users.cache.get(value);
+        if (!user) user = self.message.client.users.cache.find(u => u.username === value || u.tag === value);
+        if (user) return user;
+        let member = self.message.guild?.members.cache.get(value);
+        if (!member) member = self.message.guild?.members.cache.find(m => m.user.username === value || m.user.tag === value);
+        if (member) return member;
+        let role = self.message.guild?.roles.cache.get(value);
+        if (!role) role = self.message.guild?.roles.cache.find(r => r.name === value);
+        if (role) return role;
+        return null;
+      },
+      getMessage() {
+        return self.message;
+      },
+      getAttachment(name: string) {
+        let d = self.parsedArgs.get(name);
+        return d?.attachment ?? null;
+      }
+    }
+  }
+
+  private getRawOptionValue(name: string): any {
+    return this.parsedArgs.get(name)?.value;
+  }
+
+  private getClonedDBIOption(name: string): any {
+    return this.dbiChatInputOptions.find(o => o.name === name);
+  }
+
+  inGuild() {
+    return true;
+  }
+
+  async deferReply(options: any): Promise<any> {
+    // if (options.ephemeral) throw new Error("Ephemeral replies are not supported in message commands.");
+    if (this.repliedMessage) throw new Error("Already deferred reply.");
+    this.repliedMessage = await this.message.reply(options.content ?? "Loading...");
+    this.deferred = true;
+    return this.repliedMessage;
+  }
+
+  async deleteReply() {
+    if (!this.repliedMessage) throw new Error("No deferred reply.");
+    await this.repliedMessage.delete();
+    this.repliedMessage = undefined;
+  }
+
+  async followUp(content: string | MessagePayload) {
+    if (!this.repliedMessage) throw new Error("No deferred reply.");
+    if (!this.lastFollowUp) {
+      this.lastFollowUp = await this.repliedMessage.reply(content);
+    } else {
+      this.lastFollowUp = await this.lastFollowUp.reply(content);
+    }
+    return this.lastFollowUp;
+  }
+
+  async editReply(content: string | MessagePayload) {
+    if (!this.repliedMessage) throw new Error("No deferred reply.");
+    await this.repliedMessage.edit(content);
+    return this.repliedMessage;
+  }
+
+  async reply(content: string | MessagePayload): Promise<any> {
+    if (this.repliedMessage) throw new Error("Already deferred reply.");
+    this.repliedMessage = await this.message.reply(content);
+    return this.repliedMessage;
+  }
+
+  async awaitModalSubmit() {
+    throw new Error("Method not implemented.");
+  };
+
+  async fetchReply() {
+    return this.repliedMessage?.id && await this.message.channel.messages.fetch(this.repliedMessage.id);
+  };
+
+  isAnySelectMenu() { return false; }
+  isAutocomplete() { return false; }
+  isButton() { return false; }
+  isChannelSelectMenu() { return false; }
+  isChatInputCommand() { return true; }
+  isCommand() { return true; }
+  isContextMenuCommand() { return false; }
+  isMentionableSelectMenu() { return false; }
+  isMessageComponent() { return false; }
+  isMessageContextMenuCommand() { return false; }
+  isModalSubmit() { return false; }
+  isRepliable() { return true; }
+  isRoleSelectMenu() { return false; }
+  isStringSelectMenu() { return false; }
+  isUserContextMenuCommand() { return false; }
+  isUserSelectMenu() { return false; }
+  isSelectMenu() { return false; }
+}
+
+interface FakeMessageInteractionArgument {
+  type: ApplicationCommandOptionType,
+  value: any,
+  attachment?: Attachment
+}