@mostfeatured/dbi 0.1.13 → 0.1.15

package/src/DBI.ts

@@ -69,14 +69,24 @@ export interface DBIStore {
   has(key: string): Promise<boolean>;
 }
 
-export type DBIClientData<TNamespace extends NamespaceEnums> = {
+export type TDBIClientData<TNamespace extends NamespaceEnums> = {
   namespace: NamespaceData[TNamespace]["clientNamespaces"];
   token: string;
   options: Discord.ClientOptions;
   client: Discord.Client<true>;
 };
 
-export interface DBIConfig {
+export type TDBIMessageCommandsActionCtx<TNamespace extends NamespaceEnums> = {
+  interaction: FakeMessageInteraction;
+  dbiInteraction: DBIChatInput<TNamespace>;
+  locale: { guild?: DBILocale<TNamespace>; user: DBILocale<TNamespace> };
+}
+
+export type TDBIMessageCommandsPrefixesCtx = {
+  message: Discord.Message;
+};
+
+export interface DBIConfig<TNamespace extends NamespaceEnums> {
   discord: {
     namespace: string;
     token: string;
@@ -87,7 +97,7 @@ export interface DBIConfig {
     directMessages: boolean;
     defaultMemberPermissions: Discord.PermissionsString[];
     messageCommands: {
-      deferReplyContent(interaction: FakeMessageInteraction): MessagePayload | string | Promise<MessagePayload | string>;
+      deferReplyContent(ctx: TDBIMessageCommandsActionCtx<TNamespace>): MessagePayload | string | Promise<MessagePayload | string>;
     };
   };
 
@@ -113,14 +123,14 @@ export interface DBIConfig {
 
   strict: boolean;
   messageCommands?: {
-    prefixes: string[];
+    prefixes(ctx: TDBIMessageCommandsPrefixesCtx): string[] | Promise<string[]>;
     typeAliases: {
       booleans: Record<string, boolean>;
     };
   };
 }
 
-export interface DBIConfigConstructor {
+export interface DBIConfigConstructor<TNamespace extends NamespaceEnums> {
   discord:
   | {
     token: string;
@@ -137,7 +147,7 @@ export interface DBIConfigConstructor {
     directMessages?: boolean;
     defaultMemberPermissions?: Discord.PermissionsString[];
     messageCommands?: {
-      deferReplyContent?: MessagePayload | string | ((interaction: FakeMessageInteraction) => MessagePayload | string | Promise<MessagePayload | string>);
+      deferReplyContent?: MessagePayload | string | ((ctx: TDBIMessageCommandsActionCtx<TNamespace>) => MessagePayload | string | Promise<MessagePayload | string>);
     };
   };
 
@@ -169,7 +179,7 @@ export interface DBIConfigConstructor {
   strict?: boolean;
 
   messageCommands?: {
-    prefixes: string[];
+    prefixes: string[] | ((ctx: TDBIMessageCommandsPrefixesCtx) => string[] | Promise<string[]>);
     typeAliases?: {
       /**
        * Example: {"yes": true, "no": false}
@@ -245,7 +255,7 @@ export class DBI<
   TOtherData = Record<string, any>
 > {
   namespace: TNamespace;
-  config: DBIConfig;
+  config: DBIConfig<TNamespace>;
   data: {
     interactions: Discord.Collection<string, TDBIInteractions<TNamespace>>;
     events: Discord.Collection<string, DBIEvent<TNamespace>>;
@@ -258,14 +268,14 @@ export class DBI<
     registers: Set<(...args: any[]) => any>;
     registerUnloaders: Set<(...args: any[]) => any>;
     refs: Map<string, { at: number; value: any; ttl?: number }>;
-    clients: DBIClientData<TNamespace>[] & {
-      next(key?: string): DBIClientData<TNamespace>;
-      random(): DBIClientData<TNamespace>;
-      random(size: number): DBIClientData<TNamespace>[];
-      first(): DBIClientData<TNamespace>;
+    clients: TDBIClientData<TNamespace>[] & {
+      next(key?: string): TDBIClientData<TNamespace>;
+      random(): TDBIClientData<TNamespace>;
+      random(size: number): TDBIClientData<TNamespace>[];
+      first(): TDBIClientData<TNamespace>;
       get(
         namespace: NamespaceData[TNamespace]["clientNamespaces"]
-      ): DBIClientData<TNamespace>;
+      ): TDBIClientData<TNamespace>;
       indexes: Record<string, number>;
     };
   };
@@ -273,7 +283,7 @@ export class DBI<
   cluster?: Sharding.ClusterClient<Discord.Client>;
   private _loaded: boolean;
   private _hooked: boolean;
-  constructor(namespace: TNamespace, config: DBIConfigConstructor) {
+  constructor(namespace: TNamespace, config: DBIConfigConstructor<TNamespace>) {
     this.namespace = namespace as any;
     const self = this;
 
@@ -306,11 +316,14 @@ export class DBI<
     };
 
     if (config.messageCommands) {
-      if (config.strict && !config.messageCommands?.prefixes?.length)
-        throw new Error("No message command prefixes provided.");
+      const { prefixes, typeAliases } = config.messageCommands;
+
+      if (Array.isArray(prefixes) && this.config.strict && !prefixes.length)
+        throw new Error("No prefixes provided.");
 
-      let { typeAliases } = config.messageCommands;
+      const prefixesFn = typeof prefixes === "function" ? prefixes : () => prefixes;
 
+      config.messageCommands.prefixes = prefixesFn;
       config.messageCommands.typeAliases = {
         booleans: typeAliases.booleans ?? {
           true: true,
@@ -955,7 +968,7 @@ export class DBI<
 
   client<TClientName extends NamespaceData[TNamespace]["clientNamespaces"]>(
     name?: TClientName
-  ): DBIClientData<TNamespace> {
+  ): TDBIClientData<TNamespace> {
     return name ? this.data.clients.get(name) : this.data.clients.first();
   }
   /**

package/src/Events.ts

@@ -1,12 +1,13 @@
 import { NamespaceEnums, NamespaceData } from "../generated/namespaceData";
 import { DBI } from "./DBI";
 import { TDBIMessageCommandArgumentErrorTypes } from "./methods/handleMessageCommands";
+import { DBIChatInput } from "./types/ChatInput/ChatInput";
 import { TDBIValueName } from "./types/ChatInput/ChatInputOptions";
 import { ClientEvents, DBIEvent } from "./types/Event";
 import { IDBIBaseExecuteCtx, TDBIRateLimitTypes } from "./types/Interaction";
 import { FakeMessageInteraction } from "./types/other/FakeMessageInteraction";
 import { DBILocale } from "./types/other/Locale";
-import Discord from "discord.js";
+import Discord, { PermissionsString } from "discord.js";
 
 export type TDBIEventNames =
   | "beforeInteraction"
@@ -16,7 +17,9 @@ export type TDBIEventNames =
   | "afterEvent"
   | "interactionError"
   | "eventError"
-  | "messageCommandArgumentError";
+  | "messageCommandArgumentError"
+  | "messageCommandDirectMessageUsageError"
+  | "messageCommandDefaultMemberPermissionsError";
 
 export type TDBIEventHandlerCtx<TNamespace extends NamespaceEnums> = {
   [K in keyof (ClientEvents & NamespaceData[TNamespace]["customEvents"])]: {
@@ -46,7 +49,7 @@ export class Events<TNamespace extends NamespaceEnums> {
 
   async trigger(name: TDBIEventNames, data: any): Promise<boolean> {
     let handlers = this.handlers[name];
-    if (!handlers) return true;
+    if (!handlers?.length) return true;
     for (let i = 0; i < handlers.length; i++) {
       const handler = handlers[i];
       let returned = await handler(data);
@@ -113,6 +116,30 @@ export class Events<TNamespace extends NamespaceEnums> {
       };
       value: any;
       locale: { guild?: DBILocale<TNamespace>; user: DBILocale<TNamespace> };
+      dbiInteraction: DBIChatInput<TNamespace>;
+    }) => Promise<boolean> | boolean,
+    options?: { once: boolean }
+  ): () => any;
+
+  on(
+    eventName: "messageCommandDefaultMemberPermissionsError",
+    handler: (data: {
+      message: Discord.Message;
+      interaction: FakeMessageInteraction;
+      locale: { guild?: DBILocale<TNamespace>; user: DBILocale<TNamespace> };
+      permissions: PermissionsString[];
+      dbiInteraction: DBIChatInput<TNamespace>;
+    }) => Promise<boolean> | boolean,
+    options?: { once: boolean }
+  ): () => any;
+
+  on(
+    eventName: "messageCommandDirectMessageUsageError",
+    handler: (data: {
+      message: Discord.Message;
+      interaction: FakeMessageInteraction;
+      locale: { guild?: DBILocale<TNamespace>; user: DBILocale<TNamespace> };
+      dbiInteraction: DBIChatInput<TNamespace>;
     }) => Promise<boolean> | boolean,
     options?: { once: boolean }
   ): () => any;

package/src/index.ts

@@ -10,7 +10,7 @@ import { recursiveUnload } from "./utils/recursiveUnload";
 
 export const generatedPath = path.resolve(__dirname, "../generated");
 
-export function createDBI<TNamespace extends NamespaceEnums, TOtherType = Record<string, any>>(namespace: TNamespace, cfg: DBIConfigConstructor): DBI<TNamespace, TOtherType> {
+export function createDBI<TNamespace extends NamespaceEnums, TOtherType = Record<string, any>>(namespace: TNamespace, cfg: DBIConfigConstructor<TNamespace>): DBI<TNamespace, TOtherType> {
   return new DBI<TNamespace, TOtherType>(namespace, cfg);
 };
 

package/src/methods/handleMessageCommands.ts

@@ -38,8 +38,8 @@ export async function handleMessageCommands(
   const chatInputs = dbi.data.interactions.filter(
     (i) => i.type === "ChatInput"
   );
-  const prefixes = dbi.config.messageCommands.prefixes ?? [];
-  if (!prefixes.length) return;
+  const prefixes = await dbi.config.messageCommands.prefixes({ message });
+  if (!prefixes?.length) return;
   const content = message.content;
   const usedPrefix = prefixes.find((p) => content.startsWith(p));
   if (!usedPrefix) return;
@@ -91,6 +91,45 @@ export async function handleMessageCommands(
     usedPrefix
   );
 
+  const builtLocale = {
+    user:
+      dbi.data.locales.get(interaction.locale) ||
+      dbi.data.locales.get(dbi.config.defaults.locale),
+    guild: message.guild?.preferredLocale
+      ? dbi.data.locales.get(
+        message.guild?.preferredLocale?.split("-")?.at(0)
+      ) || dbi.data.locales.get(dbi.config.defaults.locale)
+      : null,
+  };
+
+  const { defaultMemberPermissions, directMessages } = chatInput as any;
+
+  if (typeof directMessages !== "undefined" && !directMessages && !message.guild) {
+    const res = await dbi.events.trigger(
+      "messageCommandDirectMessageUsageError", {
+      interaction,
+      message,
+      locale: builtLocale,
+      dbiInteraction: chatInput
+    });
+    if (!res) return;
+  }
+
+  if (Array.isArray(defaultMemberPermissions) && message.guild && message.member) {
+    const perms = message.member.permissions.toArray();
+    if (!defaultMemberPermissions.every((p) => perms.includes(p))) {
+      const res = await dbi.events.trigger(
+        "messageCommandDefaultMemberPermissionsError", {
+        interaction,
+        message,
+        locale: builtLocale,
+        dbiInteraction: chatInput,
+        permissions: defaultMemberPermissions
+      });
+      if (!res) return;
+    }
+  }
+
   if (chatInput.options.length) {
     let errorType: TDBIMessageCommandArgumentErrorTypes;
     let lastOption: any;
@@ -354,7 +393,7 @@ export async function handleMessageCommands(
         case ApplicationCommandOptionType.User: {
           await message.client.users
             .fetch(interaction.options.getUserId(option.name))
-            .catch(() => {});
+            .catch(() => { });
           if (option.required && !interaction.options.getUser(option.name)) {
             errorType = "InvalidUser";
             break;
@@ -364,7 +403,7 @@ export async function handleMessageCommands(
         case ApplicationCommandOptionType.Channel: {
           await message.client.channels
             .fetch(interaction.options.getChannelId(option.name))
-            .catch(() => {});
+            .catch(() => { });
           if (
             option.required &&
             !interaction.options.getChannel(
@@ -381,7 +420,7 @@ export async function handleMessageCommands(
         case ApplicationCommandOptionType.Role: {
           await message.guild.roles
             .fetch(interaction.options.getRoleId(option.name))
-            .catch(() => {});
+            .catch(() => { });
           if (option.required && !interaction.options.getRole(option.name)) {
             errorType = "InvalidRole";
             break;
@@ -390,9 +429,9 @@ export async function handleMessageCommands(
         }
         case ApplicationCommandOptionType.Mentionable: {
           let mentionableId = interaction.options.getMentionableId(option.name);
-          await message.guild.roles.fetch(mentionableId).catch(() => {});
-          await message.client.channels.fetch(mentionableId).catch(() => {});
-          await message.client.users.fetch(mentionableId).catch(() => {});
+          await message.guild.roles.fetch(mentionableId).catch(() => { });
+          await message.client.channels.fetch(mentionableId).catch(() => { });
+          await message.client.users.fetch(mentionableId).catch(() => { });
           if (
             option.required &&
             !interaction.options.getMentionable(option.name)
@@ -424,16 +463,7 @@ export async function handleMessageCommands(
       let res = await dbi.events.trigger("messageCommandArgumentError", {
         interaction,
         message,
-        locale: {
-          user:
-            dbi.data.locales.get(interaction.locale) ||
-            dbi.data.locales.get(dbi.config.defaults.locale),
-          guild: message.guild?.preferredLocale
-            ? dbi.data.locales.get(
-                message.guild?.preferredLocale?.split("-")?.at(0)
-              ) || dbi.data.locales.get(dbi.config.defaults.locale)
-            : null,
-        },
+        locale: builtLocale,
         error: {
           type: errorType,
           option: lastOption,
@@ -441,6 +471,7 @@ export async function handleMessageCommands(
           index: lastIndex,
         },
         value: lastValue,
+        dbiInteraction: chatInput,
       });
       if (!res) return;
     }

package/src/methods/hookEventListeners.ts

@@ -1,6 +1,7 @@
 import { Guild } from "discord.js";
 import { NamespaceEnums } from "../../generated/namespaceData";
 import { DBI } from "../DBI";
+import { TDBIEventOrder } from "../types/Event";
 
 export function hookEventListeners(dbi: DBI<NamespaceEnums>): () => any {
 
@@ -40,26 +41,28 @@ export function hookEventListeners(dbi: DBI<NamespaceEnums>): () => any {
     let locale = guildLocale ? { guild: guildLocale } : null;
 
 
-    let ordered = [];
-    let unOrdered = [];
+    let awaitedEvents = [];
+    let unAwaitedEvents = [];
     for (let i = 0; i < dbi.data.events.size; i++) {
       const value = dbi.data.events.at(i);
       if (value.name == eventName) {
-        if (value.ordered) {
-          ordered.push(value);
+        if (value.ordered?.await) {
+          awaitedEvents.push(value);
         } else {
-          unOrdered.push(value);
+          unAwaitedEvents.push(value);
         }
       }
     }
 
     let arg = { eventName, ...ctxArgs, other, locale };
 
-    for (let i = 0; i < unOrdered.length; i++) {
-      const value = unOrdered[i];
+    for (let i = 0; i < unAwaitedEvents.length; i++) {
+      const value = unAwaitedEvents[i];
 
       if (value?.disabled) continue;
 
+      if (value.ordered?.delayBefore) await new Promise(resolve => setTimeout(resolve, value.ordered.delayBefore));
+
       if (!(await dbi.events.trigger("beforeEvent", { ...arg, dbiEvent: value }))) continue;
 
       if (dbi.config.strict) {
@@ -73,15 +76,18 @@ export function hookEventListeners(dbi: DBI<NamespaceEnums>): () => any {
           dbi.events.trigger("eventError", { ...arg, error, dbiEvent: value });
         }
       }
+      if (value.ordered?.delayAfter) await new Promise(resolve => setTimeout(resolve, value.ordered.delayAfter));
     }
 
-    for (let i = 0; i < ordered.length; i++) {
-      const value = ordered[i];
+    for (let i = 0; i < awaitedEvents.length; i++) {
+      const value = awaitedEvents[i];
 
       if (value?.disabled) continue;
 
       if (!(await dbi.events.trigger("beforeEvent", { ...arg, dbiEvent: value }))) continue;
 
+      if (value.ordered?.delayBefore) await new Promise(resolve => setTimeout(resolve, value.ordered.delayBefore));
+
       if (dbi.config.strict) {
         await value.onExecute({ ...arg, nextClient: getClientByEvent(value) });
       } else {
@@ -93,6 +99,7 @@ export function hookEventListeners(dbi: DBI<NamespaceEnums>): () => any {
           await dbi.events.trigger("eventError", { ...arg, error, dbiEvent: value });
         }
       }
+      if (value.ordered?.delayAfter) await new Promise(resolve => setTimeout(resolve, value.ordered.delayAfter));
     }
 
     dbi.events.trigger("afterEvent", arg)

package/src/methods/publishInteractions.ts

@@ -4,7 +4,7 @@ import { REST } from "@discordjs/rest";
 import { Routes, RESTGetAPIUserResult, RESTPutAPIApplicationCommandsJSONBody, ApplicationCommandType, ApplicationCommandOptionType } from "discord-api-types/v9";
 import { reducePermissions } from "../utils/permissions";
 import snakecaseKeys from "snakecase-keys";
-import { DBI, DBIClientData } from "../DBI";
+import { DBI, TDBIClientData } from "../DBI";
 import { DBIInteractionLocale } from "../types/other/InteractionLocale";
 import { NamespaceEnums } from "../../generated/namespaceData";
 import { ApplicationRoleConnectionMetadataType, ApplicationRoleConnectionMetadata } from "../types/ApplicationRoleConnectionMetadata";
@@ -13,7 +13,7 @@ const PUBLISHABLE_TYPES = ["ChatInput", "UserContextMenu", "MessageContextMenu"]
 const ORIGINAL_LOCALES = ["da", "de", "en-GB", "en-US", "es-ES", "fr", "hr", "it", "lt", "hu", "nl", "no", "pl", "pt-BR", "ro", "fi", "sv-SE", "vi", "tr", "cs", "el", "bg", "ru", "uk", "hi", "th", "zh-CN", "ja", "zh-TW", "ko"];
 
 export async function publishInteractions(
-  clients: DBIClientData<NamespaceEnums>[],
+  clients: TDBIClientData<NamespaceEnums>[],
   interactions: Discord.Collection<string, DBIChatInput<NamespaceEnums>>,
   interactionsLocales: Discord.Collection<string, DBIInteractionLocale>,
   publishType: "Guild" | "Global",
@@ -22,7 +22,7 @@ export async function publishInteractions(
   interactions = interactions.filter(i => PUBLISHABLE_TYPES.includes(i.type));
   interactions = interactions.sort((a, b) => b.name.split(" ").length - a.name.split(" ").length);
 
-  let body: {[k: string]: RESTPutAPIApplicationCommandsJSONBody} =
+  let body: { [k: string]: RESTPutAPIApplicationCommandsJSONBody } =
     interactions.reduce((all, current) => {
       if (current.publish && !all[current.publish]) all[current.publish] = [];
       switch (current.type) {
@@ -165,16 +165,16 @@ export async function publishInteractions(
       }
 
       return all;
-    }, {} as {[k: string]: any});
-    
+    }, {} as { [k: string]: any });
+
 
   for (let i = 0; i < clients.length; i++) {
     const client = clients[i];
     const rest = new REST({ version: "10" });
     rest.setToken(client.token);
-  
+
     const me: RESTGetAPIUserResult = await rest.get(Routes.user()) as any;
-  
+
     switch (publishType) {
       case "Guild": {
         await rest.put(Routes.applicationGuildCommands(me.id, guildId), { body: body[client.namespace] || [] });
@@ -186,7 +186,7 @@ export async function publishInteractions(
       }
     }
   }
-  
+
 }
 
 export function localeifyOptions(options: any[], localeData: any): any[] {
@@ -237,7 +237,7 @@ export function formatLocale(locale: DBIInteractionLocale): any {
           if (!optionLocale.choiceLocales) optionLocale.choiceLocales = {};
           if (!optionLocale.choiceLocales[choiceOriginalName]) optionLocale.choiceLocales[choiceOriginalName] = {};
           let choiceLocale = optionLocale.choiceLocales[choiceOriginalName];
-          
+
           choiceLocale[longLocale] = choiceName;
         });
 
@@ -246,7 +246,7 @@ export function formatLocale(locale: DBIInteractionLocale): any {
       })
     });
   });
-  
+
   return {
     nameLocales,
     allNameLocales,

package/src/types/Components/ChannelSelectMenu.ts

@@ -24,7 +24,7 @@ export class DBIChannelSelectMenu<TNamespace extends NamespaceEnums> extends DBI
     });
   }
 
-  declare options: SelectMenuDefaultOptions;
+  declare options?: SelectMenuDefaultOptions;
 
   override onExecute(ctx: IDBIChannelSelectMenuExecuteCtx<TNamespace>): Promise<void> | void { };
 

package/src/types/Components/MentionableSelectMenu.ts

@@ -24,7 +24,7 @@ export class DBIMentionableSelectMenu<TNamespace extends NamespaceEnums> extends
     });
   }
 
-  declare options: SelectMenuDefaultOptions;
+  declare options?: SelectMenuDefaultOptions;
 
   override onExecute(ctx: IDBIMentionableSelectMenuExecuteCtx<TNamespace>): Promise<void> | void { };
 

package/src/types/Components/Modal.ts

@@ -28,7 +28,7 @@ export class DBIModal<TNamespace extends NamespaceEnums> extends DBIBaseInteract
     });
   }
 
-  declare options: ModalComponentData;
+  declare options?: ModalComponentData;
 
   override onExecute(ctx: IDBIModalExecuteCtx<TNamespace>): Promise<void> | void { };
 

package/src/types/Components/RoleSelectMenu.ts

@@ -24,7 +24,7 @@ export class DBIRoleSelectMenu<TNamespace extends NamespaceEnums> extends DBIBas
     });
   }
 
-  declare options: SelectMenuDefaultOptions;
+  declare options?: SelectMenuDefaultOptions;
 
   override onExecute(ctx: IDBIRoleSelectMenuExecuteCtx<TNamespace>): Promise<void> | void { };
 

package/src/types/Components/StringSelectMenu.ts

@@ -24,7 +24,7 @@ export class DBIStringSelectMenu<TNamespace extends NamespaceEnums> extends DBIB
     });
   }
 
-  declare options: SelectMenuDefaultOptions;
+  declare options?: SelectMenuDefaultOptions;
 
   override onExecute(ctx: IDBIStringSelectMenuExecuteCtx<TNamespace>): Promise<void> | void { };
 

package/src/types/Components/UserSelectMenu.ts

@@ -24,7 +24,7 @@ export class DBIUserSelectMenu<TNamespace extends NamespaceEnums> extends DBIBas
     });
   }
 
-  declare options: SelectMenuDefaultOptions;
+  declare options?: SelectMenuDefaultOptions;
 
   override onExecute(ctx: IDBIUserSelectMenuExecuteCtx<TNamespace>): Promise<void> | void { };
 

package/src/types/Event.ts

@@ -1,6 +1,6 @@
 import Discord from "discord.js";
 import { NamespaceEnums, NamespaceData } from "../../generated/namespaceData";
-import { DBI, DBIClientData } from "../DBI";
+import { DBI, TDBIClientData } from "../DBI";
 import { DBILocale } from "./other/Locale";
 export interface ClientEvents {
   applicationCommandPermissionsUpdate: { data: Discord.ApplicationCommandPermissionsUpdateData };
@@ -96,12 +96,18 @@ export interface ClientEvents {
 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: DBIClientData<TNamespace> }) => Promise<any> | any
+    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>;
@@ -109,7 +115,7 @@ export class DBIEvent<TNamespace extends NamespaceEnums> {
   id?: string;
   name: string;
   onExecute: (...args: any[]) => any;
-  ordered?: boolean;
+  ordered?: TDBIEventOrder;
   dbi: DBI<TNamespace>;
   disabled: boolean = false;
   flag?: string;
@@ -122,7 +128,7 @@ export class DBIEvent<TNamespace extends NamespaceEnums> {
     this.other = cfg.other;
     this.name = cfg.name as any;
     this.onExecute = cfg.onExecute;
-    this.ordered = cfg.ordered ?? false;
+    this.ordered = cfg.ordered;
     this.triggerType = cfg.triggerType ?? "OneByOneGlobal";
     this.disabled ??= cfg.disabled;
     this.flag = cfg.flag;

package/src/types/other/FakeMessageInteraction.ts

@@ -43,7 +43,7 @@ export class FakeMessageInteraction /* implements ChatInputCommandInteraction */
   _initialized: boolean = false;
   _lastAction: string | undefined;
 
-  constructor(private dbi: DBI<NamespaceEnums>, private message: Message, chatInput: TDBIInteractions<NamespaceEnums>, public locale: string, commandName: string, private usedPrefix: string) {
+  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;
@@ -319,7 +319,20 @@ export class FakeMessageInteraction /* implements ChatInputCommandInteraction */
 
   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(this)));
+    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),
+        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)
+          : null,
+      }
+    })));
     this.deferred = true;
     this._lastAction = "deferReply";
     return this.repliedMessage;