@mostfeatured/dbi 0.0.1

package/src/methods/hookInteractionListeners.ts

@@ -0,0 +1,118 @@
+import { DBI } from "../DBI";
+import Discord from "discord.js";
+import { parseCustomId } from "../utils/customId";
+
+export function hookInteractionListeners(dbi: DBI): () => any {
+  async function handle(inter: Discord.Interaction<Discord.CacheType>) {
+
+    const dbiInter =
+      dbi.data.interactions.find(i => {
+        let isUsesCustomId = (inter.isButton() || inter.isSelectMenu() || inter.isModalSubmit());
+        let parsedId = isUsesCustomId ? parseCustomId(dbi, (inter as any).customId) : null;
+        return (
+          (
+            i.type == "ChatInput"
+            && (inter.isChatInputCommand() || inter.isAutocomplete())
+            && i.name == [inter.commandName, inter.options.getSubcommandGroup(false), inter.options.getSubcommand(false)].filter(i => !!i).join(" ")
+          )
+          ||
+          (
+            (i.type == "MessageContextMenu" || i.type == "UserContextMenu")
+            && (inter.isMessageContextMenuCommand() || inter.isUserContextMenuCommand())
+            && inter.commandName == i.name
+          )
+          ||
+          (
+            (i.type == "Button" || i.type == "SelectMenu" || i.type == "Modal")
+            && isUsesCustomId
+            && parsedId.name == i.name
+          )
+        )
+      });
+    
+    if (!dbiInter) return;
+    
+    if (inter.isAutocomplete()) {
+      let focussed = inter.options.getFocused(true);
+      let option = (dbiInter.options as any[]).find(i => i.name == focussed.name);
+      if (option?.onComplete) {
+        let response = await option.onComplete({
+          value: focussed.value,
+          interaction: inter,
+          dbi
+        });
+        await inter.respond(response);
+      }
+      return;
+    }
+
+    let userLocaleName = inter.locale.split("-")[0];
+    let userLocale = dbi.data.locales.has(userLocaleName) ? dbi.data.locales.get(userLocaleName) : dbi.data.locales.get(dbi.config.defaults.locale);
+
+    let guildLocaleName = inter.guild ? inter.guild.preferredLocale.split("-")[0] : null;
+    let guildLocale = guildLocaleName ? (dbi.data.locales.has(guildLocaleName) ? dbi.data.locales.get(guildLocaleName) : dbi.data.locales.get(dbi.config.defaults.locale)) : null;
+
+    let locale = {
+      user: userLocale,
+      guild: guildLocale
+    };
+
+    let data = (inter.isButton() || inter.isSelectMenu() || inter.isModalSubmit()) ? parseCustomId(dbi, inter.customId).data : undefined;
+
+    let rateLimitKeyMap = {
+      "User": `${inter.user.id}`,
+      "Channel": `${inter.channelId || "Channel"}`,
+      "Guild": `${inter.guildId || "Guild"}`,
+      "Member": `${inter.user.id}_${inter.guildId || "Guild"}`,
+      "Message": `${(inter as any)?.message?.id}`
+    }
+
+    for (const type in rateLimitKeyMap) {
+      let key = `RateLimit:${rateLimitKeyMap[type]}`;
+      let val = await dbi.config.store.get(key);
+      if (val && Date.now() > val.at + val.duration) {
+        await dbi.config.store.del(key);
+        val = null;
+      }
+      if (val) {
+        dbi.events.trigger("interactionRateLimit", {
+          dbi,
+          interaction: inter,
+          locale,
+          data,
+          rateLimit: {
+            type: key,
+            ...val
+          }
+        })
+        return;
+      }
+    }
+
+    async function setRateLimit(type: string, duration: number) {
+      await dbi.config.store.set(`RateLimit:${rateLimitKeyMap[type]}`, { at: Date.now(), duration });
+    }
+
+    let other = {};
+
+    if (!(await dbi.events.trigger("beforeInteraction", { dbi, interaction: inter, locale, setRateLimit, data, other }))) return;
+
+    await dbiInter.onExecute({
+      dbi,
+      // @ts-ignore
+      interaction: inter as any,
+      locale,
+      setRateLimit,
+      data,
+      other
+    });
+    
+    dbi.events.trigger("afterInteraction", { dbi, interaction: inter, locale, setRateLimit, data, other });
+  }
+
+  dbi.client.on("interactionCreate", handle);
+
+  return () => { 
+    dbi.client.off("interactionCreate", handle);
+  };
+}

package/src/methods/publishInteractions.ts

@@ -0,0 +1,158 @@
+import Discord from "discord.js";
+import { DBIChatInput } from "../types/ChatInput/ChatInput";
+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";
+
+const PUBLISHABLE_TYPES = ["ChatInput", "UserContextMenu", "MessageContextMenu"];
+
+export async function publishInteractions(
+  clientToken: string,
+  interactions: Discord.Collection<string, DBIChatInput>,
+  publishType: "Guild" | "Global",
+  guildId?: string
+) {
+  interactions = interactions.filter(i => PUBLISHABLE_TYPES.includes(i.type));
+
+  const rest = new REST({ version: "9" });
+  rest.setToken(clientToken);
+
+  const me: RESTGetAPIUserResult = await rest.get(Routes.user()) as any;
+  
+  const body: RESTPutAPIApplicationCommandsJSONBody =
+    interactions.reduce((all, current) => {
+      switch (current.type) {
+        case "ChatInput": {
+          let nameSplitted = current.name.split(" ");
+          switch (nameSplitted.length) {
+            case 1: {
+              all.push({
+                type: ApplicationCommandType.ChatInput,
+                description: current.description,
+                name: nameSplitted[0],
+                default_member_permissions: reducePermissions(current.defaultMemberPermissions).toString(),
+                dm_permission: current.directMessages,
+                options: snakecaseKeys(current.options || [])
+              });
+              break;
+            }
+            case 2: {
+              let baseItem = all.find(i => i.name == current.name.split(" ")[0] && i.type == "ChatInput");
+              let option = {
+                type: ApplicationCommandOptionType.Subcommand,
+                name: nameSplitted[1],
+                description: current.description,
+                default_member_permissions: reducePermissions(current.defaultMemberPermissions).toString(),
+                dm_permission: current.directMessages,
+                options: snakecaseKeys(current.options || [])
+              };
+              if (!baseItem) {
+                all.push({
+                  type: ApplicationCommandType.ChatInput,
+                  name: nameSplitted[0],
+                  description: "...",
+                  options: [
+                    option
+                  ]
+                });
+              } else {
+                baseItem.options.push(option);
+              }
+              break;
+            }
+            case 3: {
+              let level1Item = all.find(i => i.name == current.name.split(" ")[0] && i.type == "ChatInput");
+              if (!level1Item) {
+                all.push({
+                  type: ApplicationCommandType.ChatInput,
+                  name: nameSplitted[0],
+                  description: "...",
+                  options: [
+                    {
+                      type: ApplicationCommandOptionType.SubcommandGroup,
+                      name: nameSplitted[1],
+                      description: "...",
+                      options: [
+                        {
+                          type: ApplicationCommandOptionType.Subcommand,
+                          name: nameSplitted[2],
+                          description: current.description,
+                          default_member_permissions: reducePermissions(current.defaultMemberPermissions).toString(),
+                          dm_permission: current.directMessages,
+                          options: snakecaseKeys(current.options || [])
+                        }
+                      ]
+                    }
+                  ]
+                });
+              } else {
+                let level2Item = level1Item.options.find(i => i.name == current.name.split(" ")[1] && i.type == "ChatInput");
+                if (!level2Item) {
+                  level1Item.options.push({
+                    type: ApplicationCommandOptionType.SubcommandGroup,
+                    name: nameSplitted[1],
+                    description: "...",
+                    options: [
+                      {
+                        type: ApplicationCommandOptionType.Subcommand,
+                        name: nameSplitted[2],
+                        description: current.description,
+                        default_member_permissions: reducePermissions(current.defaultMemberPermissions).toString(),
+                        dm_permission: current.directMessages,
+                        options: snakecaseKeys(current.options || [])
+                      }
+                    ]
+                  })
+                } else {
+                  level2Item.options.push({
+                    type: ApplicationCommandOptionType.Subcommand,
+                    name: nameSplitted[2],
+                    description: current.description,
+                    default_member_permissions: reducePermissions(current.defaultMemberPermissions).toString(),
+                    dm_permission: current.directMessages,
+                    options: snakecaseKeys(current.options || [])
+                  });
+                }
+              }
+              break;
+            }
+          }
+          break;
+        }
+        case "MessageContextMenu": {
+          all.push({
+            type: ApplicationCommandType.Message,
+            name: current.name,
+            default_member_permissions: reducePermissions(current.defaultMemberPermissions).toString(),
+            dm_permission: current.directMessages
+          });
+          break;
+        }
+        case "UserContextMenu": {
+          all.push({
+            type: ApplicationCommandType.User,
+            name: current.name,
+            default_member_permissions: reducePermissions(current.defaultMemberPermissions).toString(),
+            dm_permission: current.directMessages
+          });
+          break;
+        }
+      }
+
+      return all;
+    }, []);
+  
+  
+  switch (publishType) {
+    case "Global": {
+      await rest.put(Routes.applicationGuildCommands(me.id, guildId), { body });
+      break;
+    }
+    case "Guild": {
+      await rest.put(Routes.applicationCommands(me.id), { body });
+      break;
+    }
+  }
+  
+}

package/src/types/Button.ts

@@ -0,0 +1,32 @@
+import Discord from "discord.js";
+import { DBI } from "../DBI";
+import { DBIBaseInteraction, IDBIBaseExecuteCtx } from "./Interaction";
+import { customIdBuilder } from "../utils/customId";
+
+export interface IDBIButtonExecuteCtx extends IDBIBaseExecuteCtx {
+  interaction: Discord.ButtonInteraction<Discord.CacheType>;
+  data: ({ [key: string]: any, $ref: string, $unRef(): boolean } | string | number)[];
+}
+
+export type TDBIButtonOmitted = Omit<DBIButton, "type" | "description" | "dbi" | "toJSON">;
+
+export class DBIButton extends DBIBaseInteraction {
+  constructor(dbi: DBI, args: TDBIButtonOmitted) {
+    super(dbi, {
+      ...(args as any),
+      type: "Button",
+    });
+  }
+
+  declare options: Omit<Discord.ButtonComponentData, "customId" | "type">;
+
+  override onExecute(ctx: IDBIButtonExecuteCtx): Promise<any> | any { };
+
+  toJSON(...customData: (string | number | object)[]): Discord.ButtonComponentData {
+    return {
+      ...this.options,
+      customId: customIdBuilder(this.dbi, this.name, customData),
+      type: Discord.ComponentType.Button
+    } as any;
+  };
+}

package/src/types/ChatInput/ChatInput.ts

@@ -0,0 +1,24 @@
+import Discord from "discord.js";
+import { DBI } from "../../DBI";
+import { DBIBaseInteraction, IDBIBaseExecuteCtx } from "../Interaction";
+
+export interface IDBIChatInputExecuteCtx extends IDBIBaseExecuteCtx {
+  interaction: Discord.ChatInputCommandInteraction<Discord.CacheType>;
+}
+
+export type TDBIChatInputOmitted = Omit<DBIChatInput, "type" | "dbi">;
+
+export class DBIChatInput extends DBIBaseInteraction {
+  constructor(dbi: DBI, cfg: TDBIChatInputOmitted) {
+    super(dbi, {
+      ...(cfg as any),
+      type: "ChatInput",
+      name: cfg.name.toLowerCase(),
+      options: Array.isArray(cfg.options) ? cfg.options : []
+    });
+  }
+  directMessages?: boolean;
+  defaultMemberPermissions?: Discord.PermissionsString[];
+  declare options?: any[];
+  override onExecute(ctx: IDBIChatInputExecuteCtx) {}
+}

package/src/types/ChatInput/ChatInputOptions.ts

@@ -0,0 +1,168 @@
+import Discord from "discord.js";
+import { IDBIBaseExecuteCtx } from "../Interaction";
+
+type TValueName<T> = { value: T, name: string };
+type TNameDescription = { name: string, description: string, required?: boolean };
+
+type TMinMaxLength = { maxLength?: number, minLength?: number };
+type TMinMaxValue = { maxValue?: number, minValue?: number };
+
+export interface IDBICompleteCtx extends IDBIBaseExecuteCtx {
+  interaction: Discord.AutocompleteInteraction;
+  value: string | number;
+}
+
+export class DBIChatInputOptions {
+  static stringAutocomplete(cfg: TNameDescription & TMinMaxLength & { onComplete(ctx: IDBICompleteCtx): Promise<TValueName<string>[]> }) {
+    return {
+      type: Discord.ApplicationCommandOptionType.String,
+      name: cfg.name,
+      autocomplete: true,
+      onComplete: cfg.onComplete,
+      description: cfg.description,
+      maxLength: cfg.maxLength,
+      minLength: cfg.minLength,
+      required: cfg.required
+    };
+  }
+  static stringChoices(cfg: TNameDescription & TMinMaxLength & { choices: TValueName<string>[] }) {
+    return {
+      type: Discord.ApplicationCommandOptionType.String,
+      name: cfg.name,
+      choices: cfg.choices,
+      description: cfg.description,
+      maxLength: cfg.maxLength,
+      minLength: cfg.minLength,
+      required: cfg.required
+    };
+  }
+
+  static string(cfg: TNameDescription & TMinMaxLength) {
+    return {
+      type: Discord.ApplicationCommandOptionType.String,
+      name: cfg.name,
+      description: cfg.description,
+      maxLength: cfg.maxLength,
+      minLength: cfg.minLength,
+      required: cfg.required
+    };
+  }
+
+  static numberAutocomplete(cfg: TNameDescription & TMinMaxValue & { onComplete(ctx: IDBICompleteCtx): Promise<TValueName<number>[]> }) {
+    return {
+      type: Discord.ApplicationCommandOptionType.Number,
+      name: cfg.name,
+      autocomplete: true,
+      onComplete: cfg.onComplete,
+      description: cfg.description,
+      maxValue: cfg.maxValue,
+      minValue: cfg.minValue,
+      required: cfg.required
+    };
+  }
+
+  static numberChoices(cfg: TNameDescription & TMinMaxValue & { choices: TValueName<number>[] }) {
+    return {
+      type: Discord.ApplicationCommandOptionType.Number,
+      name: cfg.name,
+      choices: cfg.choices,
+      description: cfg.description,
+      maxValue: cfg.maxValue,
+      minValue: cfg.minValue,
+      required: cfg.required
+    };
+  }
+
+  static number(cfg: TNameDescription & TMinMaxValue) {
+    return {
+      type: Discord.ApplicationCommandOptionType.Number,
+      name: cfg.name,
+      description: cfg.description,
+      maxValue: cfg.maxValue,
+      minValue: cfg.minValue,
+      required: cfg.required
+    };
+  }
+
+  static integerAutocomplete(cfg: TNameDescription & TMinMaxValue & { onComplete(ctx: IDBICompleteCtx): Promise<TValueName<number>[]> }) {
+    return {
+      type: Discord.ApplicationCommandOptionType.Integer,
+      name: cfg.name,
+      autocomplete: true,
+      onComplete: cfg.onComplete,
+      description: cfg.description,
+      maxValue: cfg.maxValue,
+      minValue: cfg.minValue,
+      required: cfg.required
+    };
+  }
+
+  static integerChoices(cfg: TNameDescription & TMinMaxValue & { choices: TValueName<number>[] }) {
+    return {
+      type: Discord.ApplicationCommandOptionType.Integer,
+      name: cfg.name,
+      choices: cfg.choices,
+      description: cfg.description,
+      maxValue: cfg.maxValue,
+      minValue: cfg.minValue,
+      required: cfg.required
+    };
+  }
+
+  static integer(cfg: TNameDescription & TMinMaxValue) {
+    return {
+      type: Discord.ApplicationCommandOptionType.Integer,
+      name: cfg.name,
+      description: cfg.description,
+      maxValue: cfg.maxValue,
+      minValue: cfg.minValue,
+      required: cfg.required
+    };
+  }
+
+  static boolean(cfg: TNameDescription) {
+    return {
+      type: Discord.ApplicationCommandOptionType.Boolean,
+      name: cfg.name,
+      description: cfg.description,
+      required: cfg.required
+    };
+  }
+
+  static attachment(cfg: TNameDescription) {
+    return {
+      type: Discord.ApplicationCommandOptionType.Attachment,
+      name: cfg.name,
+      description: cfg.description,
+      required: cfg.required
+    };
+  }
+
+  static channel(cfg: TNameDescription & { channelTypes: Discord.ChannelType[] }) {
+    return {
+      type: Discord.ApplicationCommandOptionType.Channel,
+      name: cfg.name,
+      description: cfg.description,
+      channelTypes: cfg.channelTypes,
+      required: cfg.required
+    };
+  }
+
+  static mentionable(cfg: TNameDescription) {
+    return {
+      type: Discord.ApplicationCommandOptionType.Mentionable,
+      name: cfg.name,
+      description: cfg.description,
+      required: cfg.required
+    };
+  }
+
+  static user(cfg: TNameDescription) {
+    return {
+      type: Discord.ApplicationCommandOptionType.User,
+      name: cfg.name,
+      description: cfg.description,
+      required: cfg.required
+    };
+  }
+}

package/src/types/Event.ts

@@ -0,0 +1,115 @@
+import Discord from "discord.js";
+import { DBI } from "../DBI";
+
+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 };
+  ready: { 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 };
+  webhookUpdate: { 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 };
+}
+
+export type DBIEventCombinations = {
+  [K in keyof ClientEvents]: {
+    name: K,
+    onExecute: (ctx: ClientEvents[K] & { other: Record<string, any> }) => Promise<any> | any
+  }
+}[keyof ClientEvents];
+
+export type TDBIEventOmitted = Omit<DBIEvent, "type" | "name" | "onExecute" | "client" | "dbi"> & DBIEventCombinations;
+
+export class DBIEvent {
+  readonly type: "Event";
+  other?: Record<string, any>;
+  id?: string;
+  name: string;
+  onExecute: (...args: any[]) => any;
+  dbi: DBI;
+  constructor(dbi: DBI, cfg: TDBIEventOmitted) {
+    this.dbi = dbi;
+    this.type = "Event";
+    this.id = cfg.id;
+    this.other = cfg.other;
+    this.name = cfg.name;
+    this.onExecute = cfg.onExecute;
+  }
+}

package/src/types/Interaction.ts

@@ -0,0 +1,69 @@
+import Discord from "discord.js";
+import { DBI } from "../DBI";
+import { DBILocale } from "./Locale";
+
+export interface IDBIBaseExecuteCtx {
+  interaction:
+    | Discord.ChatInputCommandInteraction
+    | Discord.UserContextMenuCommandInteraction
+    | Discord.MessageContextMenuCommandInteraction
+    | Discord.ModalSubmitInteraction
+    | Discord.AutocompleteInteraction
+    | Discord.SelectMenuInteraction
+    | Discord.ButtonInteraction;
+  locale: {
+    user: DBILocale,
+    guild?: DBILocale
+  }
+  dbi: DBI;
+  setRateLimit(type: TDBIRateLimitTypes, duration: number): Promise<any>;
+  other: Record<string, any>;
+}
+
+export type TDBIInteractionTypes =
+  | "ChatInput"
+  | "UserContextMenu"
+  | "MessageContextMenu"
+  | "Modal"
+  | "Autocomplete"
+  | "SelectMenu"
+  | "Button";
+
+export type TDBIRateLimitTypes =
+  | "User"
+  | "Channel"
+  | "Guild"
+  | "Member"
+  | "Message";
+
+
+export type DBIRateLimit = {
+  type: TDBIRateLimitTypes;
+  /**
+   * Duration in milliseconds.
+   */
+  duration: number;
+}
+
+export class DBIBaseInteraction {
+  constructor(dbi: DBI, cfg: Omit<DBIBaseInteraction, "dbi">) {
+    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;
+  }
+
+  dbi: DBI;
+  name: string;
+  description: string;
+  readonly type: TDBIInteractionTypes;
+  options?: any | any[];
+  other?: Record<string, any>;
+  rateLimits?: DBIRateLimit[];
+  onExecute(ctx: IDBIBaseExecuteCtx): Promise<any> | any {
+
+  }
+}