@mostfeatured/dbi 0.2.16 → 0.2.18

package/src/types/Event.ts

@@ -1,145 +0,0 @@
-import Discord from "discord.js";
-import { NamespaceEnums, NamespaceData } from "../../generated/namespaceData";
-import { DBI, TDBIClientData } from "../DBI";
-import { DBILocale } from "./other/Locale";
-export interface ClientEvents {
-  applicationCommandPermissionsUpdate: { data: Discord.ApplicationCommandPermissionsUpdateData };
-  cacheSweep: { message: string };
-  channelCreate: { channel: Discord.NonThreadGuildBasedChannel };
-  channelDelete: { channel: Discord.DMChannel | Discord.NonThreadGuildBasedChannel };
-  channelPinsUpdate: { channel: Discord.TextBasedChannel, date: Date };
-  channelUpdate: {
-    oldChannel: Discord.DMChannel | Discord.NonThreadGuildBasedChannel,
-    newChannel: Discord.DMChannel | Discord.NonThreadGuildBasedChannel,
-  };
-  debug: { message: string };
-  warn: { message: string };
-  emojiCreate: { emoji: Discord.GuildEmoji };
-  emojiDelete: { emoji: Discord.GuildEmoji };
-  emojiUpdate: { oldEmoji: Discord.GuildEmoji, newEmoji: Discord.GuildEmoji };
-  error: { error: Error };
-  guildBanAdd: { ban: Discord.GuildBan };
-  guildBanRemove: { ban: Discord.GuildBan };
-  guildCreate: { guild: Discord.Guild };
-  guildDelete: { guild: Discord.Guild };
-  guildUnavailable: { guild: Discord.Guild };
-  guildIntegrationsUpdate: { guild: Discord.Guild };
-  guildMemberAdd: { member: Discord.GuildMember };
-  guildMemberAvailable: { member: Discord.GuildMember | Discord.PartialGuildMember };
-  guildMemberRemove: { member: Discord.GuildMember | Discord.PartialGuildMember };
-  guildMembersChunk: {
-    members: Discord.Collection<Discord.Snowflake, Discord.GuildMember>,
-    guild: Discord.Guild,
-    data: { count: number; index: number; nonce: string | undefined },
-  };
-  guildMemberUpdate: { oldMember: Discord.GuildMember | Discord.PartialGuildMember, newMember: Discord.GuildMember };
-  guildUpdate: { oldGuild: Discord.Guild, newGuild: Discord.Guild };
-  inviteCreate: { invite: Discord.Invite };
-  inviteDelete: { invite: Discord.Invite };
-  messageCreate: { message: Discord.Message };
-  messageDelete: { message: Discord.Message | Discord.PartialMessage };
-  messageReactionRemoveAll: {
-    message: Discord.Message | Discord.PartialMessage,
-    reactions: Discord.Collection<string | Discord.Snowflake, Discord.MessageReaction>,
-  };
-  messageReactionRemoveEmoji: { reaction: Discord.MessageReaction | Discord.PartialMessageReaction };
-  messageDeleteBulk: { messages: Discord.Collection<Discord.Snowflake, Discord.Message | Discord.PartialMessage>, channel: Discord.TextBasedChannel };
-  messageReactionAdd: { reaction: Discord.MessageReaction | Discord.PartialMessageReaction, user: Discord.User | Discord.PartialUser };
-  messageReactionRemove: { reaction: Discord.MessageReaction | Discord.PartialMessageReaction, user: Discord.User | Discord.PartialUser };
-  messageUpdate: { oldMessage: Discord.Message | Discord.PartialMessage, newMessage: Discord.Message | Discord.PartialMessage };
-  presenceUpdate: { oldPresence: Discord.Presence | null, newPresence: Discord.Presence };
-  clientReady: { client: Discord.Client<true> };
-  invalidated: {};
-  roleCreate: { role: Discord.Role };
-  roleDelete: { role: Discord.Role };
-  roleUpdate: { oldRole: Discord.Role, newRole: Discord.Role };
-  threadCreate: { thread: Discord.AnyThreadChannel, newlyCreated: boolean };
-  threadDelete: { thread: Discord.AnyThreadChannel };
-  threadListSync: { threads: Discord.Collection<Discord.Snowflake, Discord.AnyThreadChannel>, guild: Discord.Guild };
-  threadMemberUpdate: { oldMember: Discord.ThreadMember, newMember: Discord.ThreadMember };
-  threadMembersUpdate: {
-    addedMembers: Discord.Collection<Discord.Snowflake, Discord.ThreadMember>,
-    removedMembers: Discord.Collection<Discord.Snowflake, Discord.ThreadMember | Discord.PartialThreadMember>,
-    thread: Discord.AnyThreadChannel,
-  };
-  threadUpdate: { oldThread: Discord.AnyThreadChannel, newThread: Discord.AnyThreadChannel };
-  typingStart: { typing: Discord.Typing };
-  userUpdate: { oldUser: Discord.User | Discord.PartialUser, newUser: Discord.User };
-  voiceStateUpdate: { oldState: Discord.VoiceState, newState: Discord.VoiceState };
-  webhooksUpdate: { channel: Discord.TextChannel | Discord.NewsChannel | Discord.VoiceChannel };
-  interactionCreate: { interaction: Discord.Interaction };
-  shardDisconnect: { closeEvent: Discord.CloseEvent, shardId: number };
-  shardError: { error: Error, shardId: number };
-  shardReady: { shardId: number, unavailableGuilds: Set<Discord.Snowflake> | undefined };
-  shardReconnecting: { shardId: number };
-  shardResume: { shardId: number, replayedEvents: number };
-  stageInstanceCreate: { stageInstance: Discord.StageInstance };
-  stageInstanceUpdate: { oldStageInstance: Discord.StageInstance | null, newStageInstance: Discord.StageInstance };
-  stageInstanceDelete: { stageInstance: Discord.StageInstance };
-  stickerCreate: { sticker: Discord.Sticker };
-  stickerDelete: { sticker: Discord.Sticker };
-  stickerUpdate: { oldSticker: Discord.Sticker, newSticker: Discord.Sticker };
-  guildScheduledEventCreate: { guildScheduledEvent: Discord.GuildScheduledEvent };
-  guildScheduledEventUpdate: {
-    oldGuildScheduledEvent: Discord.GuildScheduledEvent | null,
-    newGuildScheduledEvent: Discord.GuildScheduledEvent,
-  };
-  guildScheduledEventDelete: { guildScheduledEvent: Discord.GuildScheduledEvent };
-  guildScheduledEventUserAdd: { guildScheduledEvent: Discord.GuildScheduledEvent, user: Discord.User };
-  guildScheduledEventUserRemove: { guildScheduledEvent: Discord.GuildScheduledEvent, user: Discord.User };
-  autoModerationRuleCreate: { autoModerationRule: Discord.AutoModerationRule; };
-  autoModerationRuleDelete: { autoModerationRule: Discord.AutoModerationRule; };
-  autoModerationRuleUpdate: { oldAutoModerationRule: Discord.AutoModerationRule | null; newAutoModerationRule: Discord.AutoModerationRule; };
-  guildAuditLogEntryCreate: { auditLogEntry: Discord.GuildAuditLogsEntry, guild: Discord.Guild };
-}
-
-export type DBIEventCombinations<TNamespace extends NamespaceEnums> = {
-  [K in keyof (ClientEvents & NamespaceData[TNamespace]["customEvents"])]: {
-    name: K,
-    onExecute: (ctx: (ClientEvents & NamespaceData[TNamespace]["customEvents"])[K] & { other: Record<string, any>, locale?: { guild: DBILocale<TNamespace> }, eventName: string, nextClient: TDBIClientData<TNamespace> }) => Promise<any> | any
-  }
-}[keyof (ClientEvents) | keyof NamespaceData[TNamespace]["customEvents"]];
-
-export type TDBIEventOmitted<TNamespace extends NamespaceEnums> = Omit<DBIEvent<TNamespace>, "type" | "name" | "onExecute" | "client" | "dbi" | "toggle" | "disabled" | "at"> & { disabled?: boolean } & DBIEventCombinations<TNamespace>;
-
-export type TDBIEventOrder = {
-  await?: boolean;
-  delayBefore?: number;
-  delayAfter?: number;
-}
-
-export class DBIEvent<TNamespace extends NamespaceEnums> {
-  readonly type: "Event";
-  other?: Record<string, any>;
-  triggerType?: "OneByOne" | "OneByOneGlobal" | "Random" | "First";
-  id?: string;
-  name: string;
-  onExecute: (...args: any[]) => any;
-  ordered?: TDBIEventOrder;
-  dbi: DBI<TNamespace>;
-  disabled: boolean = false;
-  flag?: string;
-  at?: number;
-  ttl?: number;
-  constructor(dbi: DBI<TNamespace>, cfg: TDBIEventOmitted<TNamespace>) {
-    this.dbi = dbi;
-    this.type = "Event";
-    this.id = cfg.id;
-    this.other = cfg.other;
-    this.name = cfg.name as any;
-    this.onExecute = cfg.onExecute;
-    this.ordered = cfg.ordered;
-    this.triggerType = cfg.triggerType ?? "OneByOneGlobal";
-    this.disabled ??= cfg.disabled;
-    this.flag = cfg.flag;
-    this.at = Date.now();
-    this.ttl = cfg.ttl;
-  }
-
-  toggle(disabled?: boolean) {
-    if (disabled === undefined) this.disabled = !this.disabled;
-    else this.disabled = disabled;
-    return this;
-  }
-
-}

package/src/types/Interaction.ts

@@ -1,100 +0,0 @@
-import Discord from "discord.js";
-import { NamespaceEnums, NamespaceData } from "../../generated/namespaceData";
-import { DBI } from "../DBI";
-import { DBIButton } from "./Components/Button";
-import { DBIChatInput } from "./ChatInput/ChatInput";
-import { DBILocale } from "./other/Locale";
-import { DBIMessageContextMenu } from "./other/MessageContextMenu";
-import { DBIModal } from "./Components/Modal";
-import { DBIStringSelectMenu } from "./Components/StringSelectMenu";
-import { DBIUserContextMenu } from "./other/UserContextMenu";
-import { DBIHTMLComponentsV2 } from "./Components/HTMLComponentsV2";
-
-export type TDBIInteractions<TNamespace extends NamespaceEnums> = DBIChatInput<TNamespace> | DBIButton<TNamespace> | DBIStringSelectMenu<TNamespace> | DBIMessageContextMenu<TNamespace> | DBIUserContextMenu<TNamespace> | DBIModal<TNamespace> | DBIHTMLComponentsV2<TNamespace>;
-
-export interface IDBIBaseExecuteCtx<TNamespace extends NamespaceEnums> {
-  interaction:
-  | Discord.ChatInputCommandInteraction
-  | Discord.UserContextMenuCommandInteraction
-  | Discord.MessageContextMenuCommandInteraction
-  | Discord.ModalSubmitInteraction
-  | Discord.AutocompleteInteraction
-  | Discord.AnySelectMenuInteraction
-  | Discord.ButtonInteraction;
-  locale: {
-    user: DBILocale<TNamespace>,
-    guild?: DBILocale<TNamespace>
-  }
-  dbi: DBI<TNamespace>;
-  dbiInteraction: TDBIInteractions<TNamespace>;
-  setRateLimit(type: TDBIRateLimitTypes, duration: number): Promise<any>;
-  other: Record<string, any>;
-  clientNamespace: NamespaceData[TNamespace]["clientNamespaces"];
-  v2: boolean;
-}
-
-export type TDBIReferencedData = ({ [key: string]: any, $ref: string, $unRef(): boolean } | string | number);
-
-export type TDBIInteractionTypes =
-  | "ChatInput"
-  | "UserContextMenu"
-  | "MessageContextMenu"
-  | "Modal"
-  | "Autocomplete"
-  | "StringSelectMenu"
-  | "UserSelectMenu"
-  | "ChannelSelectMenu"
-  | "MentionableSelectMenu"
-  | "RoleSelectMenu"
-  | "Button"
-  | "HTMLComponentsV2";
-
-export type TDBIRateLimitTypes =
-  | "User"
-  | "Channel"
-  | "Guild"
-  | "Member"
-  | "Message";
-
-
-export type DBIRateLimit = {
-  type: TDBIRateLimitTypes;
-  /**
-   * Duration in milliseconds.
-   */
-  duration: number;
-}
-
-export class DBIBaseInteraction<TNamespace extends NamespaceEnums> {
-  constructor(dbi: DBI<TNamespace>, cfg: Omit<DBIBaseInteraction<TNamespace>, "dbi" | "at">) {
-    this.dbi = dbi;
-    this.name = cfg.name;
-    this.description = cfg.description;
-    this.onExecute = cfg.onExecute;
-    this.type = cfg.type;
-    this.options = cfg.options;
-    this.other = cfg.other;
-    this.publish = cfg.publish ?? dbi.data.clients.first()?.namespace;
-    this.rateLimits = cfg.rateLimits ?? [];
-    this.flag = cfg.flag;
-    this.at = Date.now();
-    this.ttl = cfg.ttl;
-  }
-
-  publish?: NamespaceData[TNamespace]["clientNamespaces"];
-  dbi: DBI<TNamespace>;
-  name: string;
-  description: string;
-  readonly type: TDBIInteractionTypes;
-  options?: any | any[];
-  other?: Record<string, any> & { messageCommand?: { aliases?: string[], ignore?: boolean } };
-  rateLimits?: DBIRateLimit[];
-  flag?: string;
-  ttl?: number;
-  at?: number;
-  toJSON(overrides?: any): any { }
-
-  onExecute?(ctx: IDBIBaseExecuteCtx<TNamespace>): Promise<void> | void {
-
-  }
-}

package/src/types/other/CustomEvent.ts

@@ -1,19 +0,0 @@
-import { NamespaceEnums, NamespaceData } from "../../../generated/namespaceData";
-import { DBI } from "../../DBI";
-
-export type TDBICustomEventOmitted<TNamespace extends NamespaceEnums, CEventName extends keyof NamespaceData[TNamespace]["customEvents"] = keyof NamespaceData[TNamespace]["customEvents"]> = Omit<DBICustomEvent<TNamespace, CEventName>, "type" | "dbi" | "toJSON" | "trigger">;
-export class DBICustomEvent<TNamespace extends NamespaceEnums, CEventName extends keyof NamespaceData[TNamespace]["customEvents"] = keyof NamespaceData[TNamespace]["customEvents"]> {
-  dbi: DBI<TNamespace>;
-  name: CEventName;
-  map: {[key: string]: string};
-  type: string;
-  trigger(args: NamespaceData[TNamespace]["customEvents"][CEventName]) {
-    return this.dbi.data.clients.first().client.emit(this.name as string, { ...args, _DIRECT_: true});
-  }
-  constructor(dbi: DBI<TNamespace>, cfg: TDBICustomEventOmitted<TNamespace, CEventName>) {
-    this.dbi = dbi;
-    this.name = cfg.name;
-    this.map = cfg.map;
-    this.type = "CustomEvent";
-  }
-}

package/src/types/other/FakeMessageInteraction.ts

@@ -1,408 +0,0 @@
-import { Message, MessagePayload, ApplicationCommandType, ChatInputCommandInteraction, Locale, APIInteractionGuildMember, GuildMember, PermissionsBitField, CacheType, CommandInteractionOptionResolver, CommandOptionDataTypeResolvable, ApplicationCommandOptionType, User, Attachment, InteractionEditReplyOptions, InteractionReplyOptions } 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>();
-  args: import("plsargs/src/Result").Result;
-  usedCommandName: string;
-  fullCommandName: string;
-  options: any;
-  dbiChatInput: TDBIInteractions<NamespaceEnums>;
-  dbiChatInputOptions: any[];
-  fake: boolean = true;
-  _hoistedOptions: any;
-  _initialized: boolean = false;
-  _lastAction: string | undefined;
-
-  constructor(public dbi: DBI<NamespaceEnums>, public message: Message, chatInput: TDBIInteractions<NamespaceEnums>, public locale: string, commandName: string, public 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);
-
-      this.args = args;
-
-      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, {
-            name: option.name,
-            type: option.type,
-            value: atchs.at(attachmentIndex)?.url,
-            attachment: atchs.at(attachmentIndex++)
-          })
-          continue;
-        }
-        const value = option.messageCommands?.rest ? args._.slice(i).join(" ") : (args.get(option.name) ?? args.get(i - attachmentIndex - namedValueSize));
-        if (args.has(option.name)) namedValueSize++;
-
-        const interactionChoicesLocale = this.dbi.data.interactionLocales.get(self.dbiChatInput.name)?.data?.[locale]?.options[option.name]?.choices;
-
-        const localizedChoices = option.choices?.length ? option.choices.map(choice => ({
-          ...choice,
-          name: interactionChoicesLocale?.[choice.value] ?? choice.name
-        })) : option._choices;
-
-        this.parsedArgs.set(option.name, {
-          name: option.name,
-          type: option.type,
-          value:
-            localizedChoices?.find(c => c.value === value || c.name === value)?.value ??
-            option.choices?.find(c => c.value === value || c.name === value)?.value ??
-            value
-        });
-      }
-    }
-
-    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); }
-        };
-      },
-      get _hoistedOptions() {
-        return self._hoistedOptions;
-      },
-      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 | 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;
-        });
-        // @ts-ignore
-        if (channelType && channel?.type !== channelType && !channelType?.includes?.(channel?.type)) 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;
-      },
-      getUserId(name: string) {
-        const rawValue = self.getRawOptionValue(name);
-        if (!rawValue) return null;
-        return rawValue.replace(/<@!?|>/g, "");
-      },
-      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;
-      },
-      getMemberId(name: string) {
-        const rawValue = self.getRawOptionValue(name);
-        if (!rawValue) return null;
-        return rawValue.replace(/<@!?|>/g, "");
-      },
-      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;
-      },
-      getRoleId(name: string) {
-        const rawValue = self.getRawOptionValue(name);
-        if (!rawValue) return null;
-        return rawValue.replace(/<@&|>/g, "");
-      },
-      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;
-      },
-      getMentionableId(name: string) {
-        const rawValue = self.getRawOptionValue(name);
-        if (!rawValue) return null;
-        return rawValue.replace(/<@(!|&)?|>/g, "");
-      },
-      getMessage() {
-        return self.message;
-      },
-      getAttachment(name: string) {
-        let d = self.parsedArgs.get(name);
-        return d?.attachment ?? null;
-      },
-      getChannelId(name: string) {
-        const rawValue = self.getRawOptionValue(name);
-        if (!rawValue) return null;
-        let value = rawValue.replace(/<#|>/g, "");
-        return value;
-      }
-    }
-  }
-
-  init() {
-    if (this._initialized) return;
-    this._initialized = true;
-    this._hoistedOptionsInit();
-  }
-
-  _hoistedOptionsInit() {
-    this._hoistedOptions = [...this.parsedArgs.values()].map(arg => {
-      switch (arg.type) {
-        case ApplicationCommandOptionType.String: {
-          return { ...this.options.get(arg.name), value: this.options.getString(arg.name) };
-        }
-        case ApplicationCommandOptionType.Integer: {
-          return { ...this.options.get(arg.name), value: this.options.getInteger(arg.name) };
-        }
-        case ApplicationCommandOptionType.Number: {
-          return { ...this.options.get(arg.name), value: this.options.getNumber(arg.name) };
-        }
-        case ApplicationCommandOptionType.Boolean: {
-          return { ...this.options.get(arg.name), value: this.options.getBoolean(arg.name) };
-        }
-        case ApplicationCommandOptionType.User: {
-          return { ...this.options.get(arg.name), value: this.options.getUser(arg.name)?.id };
-        }
-        case ApplicationCommandOptionType.Channel: {
-          return { ...this.options.get(arg.name), value: this.options.getChannel(arg.name)?.id };
-        }
-        case ApplicationCommandOptionType.Role: {
-          return { ...this.options.get(arg.name), value: this.options.getRole(arg.name)?.id };
-        }
-        case ApplicationCommandOptionType.Mentionable: {
-          return { ...this.options.get(arg.name), value: this.options.getMentionable(arg.name)?.id };
-        }
-        case ApplicationCommandOptionType.Attachment: {
-          return { ...this.options.get(arg.name), value: this.options.getAttachment(arg.name)?.url };
-        }
-        case ApplicationCommandOptionType.Subcommand: {
-          return { ...this.options.get(arg.name), value: this.options.getSubcommand() };
-        }
-        case ApplicationCommandOptionType.SubcommandGroup: {
-          return { ...this.options.get(arg.name), value: this.options.getSubcommandGroup() };
-        }
-      }
-    });
-  }
-
-  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 (this.repliedMessage) throw new Error("Already deferred reply.");
-    this.repliedMessage = await this.message.reply(options?.content ?? (await this.dbi.config.defaults.messageCommands.deferReplyContent({
-      // @ts-ignore
-      dbiInteraction: this.dbiChatInput,
-      interaction: this,
-      locale: {
-        user: this.dbi.data.locales.get(this.locale) ||
-          this.dbi.data.locales.get(this.dbi.config.defaults.locale.name),
-        guild: this.message.guild?.preferredLocale
-          ? this.dbi.data.locales.get(
-            this.message.guild?.preferredLocale?.split("-")?.at(0)
-          ) || this.dbi.data.locales.get(this.dbi.config.defaults.locale.name)
-          : null,
-      }
-    })));
-    this.deferred = true;
-    this._lastAction = "deferReply";
-    return this.repliedMessage;
-  }
-
-  async deleteReply() {
-    if (!this.repliedMessage) throw new Error("No deferred reply.");
-    await this.repliedMessage.delete();
-    this.repliedMessage = undefined;
-    this._lastAction = "deleteReply";
-  }
-
-  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);
-    }
-    this._lastAction = "followUp";
-    return this.lastFollowUp;
-  }
-
-  async editReply(content: string | MessagePayload | InteractionEditReplyOptions) {
-    if (!this.repliedMessage) throw new Error("No deferred reply.");
-    if (typeof content !== "string" && this._lastAction === "deferReply" && typeof (content as any).content === "undefined") {
-      (content as any).content = null;
-    }
-    await this.repliedMessage.edit(content);
-    this._lastAction = "editReply";
-    return this.repliedMessage;
-  }
-
-  async reply(content: string | MessagePayload | InteractionReplyOptions): Promise<any> {
-    if (this.repliedMessage) throw new Error("Already deferred reply.");
-    this.repliedMessage = await this.message.reply(content as any);
-    this._lastAction = "reply";
-    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,
-  name: string
-}