@open-discord-bots/framework 0.2.17 → 0.3.1

package/src/api/modules/responder.ts

@@ -6,7 +6,8 @@ import * as discord from "discord.js"
 import { ODWorkerManager, ODWorkerCallback, ODWorker } from "./worker.js"
 import { ODDebugger } from "./console.js"
 import { ODClientManager, ODContextMenu, ODSlashCommand, ODTextCommand, ODTextCommandInteractionOption } from "./client.js"
-import { ODDropdownData, ODMessageBuildResult, ODMessageBuildSentResult, ODModalBuildResult } from "./builder.js"
+import { ODDropdownData, ODMessageBuildResult, ODModalBuildResult } from "./builder.js"
+import { ODMessageComponentBuildResult } from "./component.js"
 
 /**## ODResponderImplementation `class`
  * This is an Open Discord responder implementation.
@@ -15,7 +16,7 @@ import { ODDropdownData, ODMessageBuildResult, ODMessageBuildSentResult, ODModal
  * 
  * This class can't be used stand-alone & needs to be extended from!
  */
-export class ODResponderImplementation<Instance,Origin extends string,Params,WorkerIds extends string = string> extends ODManagerData {
+export abstract class ODResponderImplementation<Instance,Origin extends string,Params,WorkerIds extends string = string> extends ODManagerData {
     /**The manager that has all workers of this implementation */
     workers: ODWorkerManager<Instance,Origin,Params,WorkerIds>
     /**The `commandName` or `customId` needs to match this string or regex for this responder to be executed. */
@@ -28,15 +29,28 @@ export class ODResponderImplementation<Instance,Origin extends string,Params,Wor
         if (callback) this.workers.add(new ODWorker(callbackId ? callbackId : id,priority ?? 0,callback))
     }
     /**Execute all workers & return the result. */
-    async respond(instance:Instance, origin:Origin, params:Params): Promise<void> {
-        throw new ODSystemError("Tried to build an unimplemented ODResponderImplementation")
-    }
+    abstract respond(instance:Instance, origin:Origin, params:Params): Promise<void>
 }
 
 /**## ODResponderTimeoutErrorCallback `type`
  * This is the callback for the responder timeout function. It will be executed when something went wrong or the action takes too much time.
  */
-export type ODResponderTimeoutErrorCallback<Instance, Origin extends "slash"|"text"|"button"|"dropdown"|"modal"|"other"|"context-menu"|"autocomplete"> = (instance:Instance, origin:Origin) => void|Promise<void>
+export type ODResponderTimeoutErrorCallback<Instance, Origin extends "slash"|"text"|"button"|"dropdown"|"modal"|"other"|"context-menu"|"autocomplete"> = (instance:Instance, origin:Origin) => ODResponderSendResult<boolean>|Promise<ODResponderSendResult<boolean>>
+
+/**## ODResponderSendResult `type`
+ * The result from a sent message using responders. Can be used to edit, view & save the message that got created.
+ */
+export type ODResponderSendResult<InGuild extends boolean> = {
+    /**Did the message get sent successfully? */
+    success:true,
+    /**The message that got sent. */
+    message:discord.Message<InGuild>
+} | {
+    /**Did the message get sent successfully? */
+    success:boolean,
+    /**The message that got sent. */
+    message:null
+}
 
 /**## ODResponderManager `class`
  * This is an Open Discord responder manager.
@@ -83,6 +97,30 @@ export class ODResponderManager<
     }
 }
 
+/**## ODBaseResponderInstance `class`
+ * A base class for creating responder instances.
+ */
+export abstract class ODBaseResponderInstance {
+    /**Get the final `messageCreateOptions` from a returned build result from builders/components. */
+    protected getMessageFromBuildResult(build:ODMessageBuildResult|ODMessageComponentBuildResult,type:"interaction"|"message"){
+        const msgFlags: number[] = []
+        let msgData: discord.MessageCreateOptions
+        if ('message' in build){
+            //USING BUILDERS (deprecated)
+            msgData = build.message
+            if (build.ephemeral) msgFlags.push(discord.MessageFlags.Ephemeral)
+        }else{
+            //USING COMPONENTS
+            msgData = build.msg
+            if (type == "interaction" && build.ephemeral) msgFlags.push(discord.MessageFlags.Ephemeral) //disabled with regular messages
+            if (build.componentsV2) msgFlags.push(discord.MessageFlags.IsComponentsV2)
+            if (build.supressEmbeds) msgFlags.push(discord.MessageFlags.SuppressEmbeds)
+            if (build.supressNotifications) msgFlags.push(discord.MessageFlags.SuppressNotifications)
+        }
+        return Object.assign(msgData,{flags:msgFlags})
+    }
+}
+
 /**## ODCommandResponderManagerIdConstraint `type`
  * The constraint/layout for id mappings/interfaces of the `ODCommandResponderManager` class.
  */
@@ -104,38 +142,38 @@ export type ODCommandResponderManagerIdConstraint = Record<string,{origin:"slash
  */
 export class ODCommandResponderManager<IdList extends ODCommandResponderManagerIdConstraint = ODCommandResponderManagerIdConstraint> extends ODManager<ODCommandResponder<"slash"|"text",any>> {
     /**An alias to the Open Discord client manager. */
-    #client: ODClientManager
+    private client: ODClientManager
     /**The callback executed when the default workers take too much time to reply. */
-    #timeoutErrorCallback: ODResponderTimeoutErrorCallback<ODCommandResponderInstance,"slash"|"text">|null = null
+    private timeoutErrorCallback: ODResponderTimeoutErrorCallback<ODCommandResponderInstance,"slash"|"text">|null = null
     /**The amount of milliseconds before the timeout error callback is executed. */
-    #timeoutMs: number|null = null
+    private timeoutMs: number|null = null
     
     constructor(debug:ODDebugger, debugname:string, client:ODClientManager){
         super(debug,debugname)
-        this.#client = client
+        this.client = client
     }
 
     /**Set the message to send when the response times out! */
     setTimeoutErrorCallback(callback:ODResponderTimeoutErrorCallback<ODCommandResponderInstance,"slash"|"text">|null, ms:number|null){
-        this.#timeoutErrorCallback = callback
-        this.#timeoutMs = ms
+        this.timeoutErrorCallback = callback
+        this.timeoutMs = ms
     }
 
     add(data:ODCommandResponder<"slash"|"text",any>, overwrite?:boolean){
         const res = super.add(data,overwrite)
         
         //add the callback to the slash command manager
-        this.#client.slashCommands.onInteraction(data.match,(interaction,cmd) => {
+        this.client.slashCommands.onInteraction(data.match,(interaction,cmd) => {
             const newData = this.get(data.id)
             if (!newData) return
-            newData.respond(new ODCommandResponderInstance(interaction,cmd,this.#timeoutErrorCallback,this.#timeoutMs),"slash",{})
+            newData.respond(new ODCommandResponderInstance(interaction,cmd,this.timeoutErrorCallback,this.timeoutMs),"slash",{})
         })
 
         //add the callback to the text command manager
-        this.#client.textCommands.onInteraction(data.prefix,data.match,(interaction,cmd,options) => {
+        this.client.textCommands.onInteraction(data.prefix,data.match,(interaction,cmd,options) => {
             const newData = this.get(data.id)
             if (!newData) return
-            newData.respond(new ODCommandResponderInstance(interaction,cmd,this.#timeoutErrorCallback,this.#timeoutMs,options),"text",{})
+            newData.respond(new ODCommandResponderInstance(interaction,cmd,this.timeoutErrorCallback,this.timeoutMs,options),"text",{})
         })
 
         return res
@@ -170,31 +208,31 @@ export class ODCommandResponderManager<IdList extends ODCommandResponderManagerI
  */
 export class ODCommandResponderInstanceOptions {
     /**The interaction to get data from. */
-    #interaction: discord.ChatInputCommandInteraction|discord.Message
+    private interaction: discord.ChatInputCommandInteraction|discord.Message
     /**The command which is related to the interaction. */
-    #cmd:ODSlashCommand|ODTextCommand
+    private cmd:ODSlashCommand|ODTextCommand
     /**A list of options which have been parsed by the text command parser. */
-    #options: ODTextCommandInteractionOption[]
+    private options: ODTextCommandInteractionOption[]
 
     constructor(interaction:discord.ChatInputCommandInteraction|discord.Message, cmd:ODSlashCommand|ODTextCommand, options?:ODTextCommandInteractionOption[]){
-        this.#interaction = interaction
-        this.#cmd = cmd
-        this.#options = options ?? []
+        this.interaction = interaction
+        this.cmd = cmd
+        this.options = options ?? []
     }
 
     /**Get a string option. */
     getString(name:string,required:true): string
     getString(name:string,required:false): string|null
     getString(name:string,required:boolean){
-        if (this.#interaction instanceof discord.ChatInputCommandInteraction){
+        if (this.interaction instanceof discord.ChatInputCommandInteraction){
             try {
-                return this.#interaction.options.getString(name,required)
+                return this.interaction.options.getString(name,required)
             }catch{
                 throw new ODSystemError("ODCommandResponderInstanceOptions:getString() slash command option not found!")
             }
 
-        }else if (this.#interaction instanceof discord.Message){
-            const opt = this.#options.find((opt) => opt.type == "string" && opt.name == name)
+        }else if (this.interaction instanceof discord.Message){
+            const opt = this.options.find((opt) => opt.type == "string" && opt.name == name)
             if (opt && typeof opt.value == "string") return opt.value
             else return null
 
@@ -204,15 +242,15 @@ export class ODCommandResponderInstanceOptions {
     getBoolean(name:string,required:true): boolean
     getBoolean(name:string,required:false): boolean|null
     getBoolean(name:string,required:boolean){
-        if (this.#interaction instanceof discord.ChatInputCommandInteraction){
+        if (this.interaction instanceof discord.ChatInputCommandInteraction){
             try {
-                return this.#interaction.options.getBoolean(name,required)
+                return this.interaction.options.getBoolean(name,required)
             }catch{
                 throw new ODSystemError("ODCommandResponderInstanceOptions:getBoolean() slash command option not found!")
             }
 
-        }else if (this.#interaction instanceof discord.Message){
-            const opt = this.#options.find((opt) => opt.type == "boolean" && opt.name == name)
+        }else if (this.interaction instanceof discord.Message){
+            const opt = this.options.find((opt) => opt.type == "boolean" && opt.name == name)
             if (opt && typeof opt.value == "boolean") return opt.value
             else return null
 
@@ -222,15 +260,15 @@ export class ODCommandResponderInstanceOptions {
     getNumber(name:string,required:true): number
     getNumber(name:string,required:false): number|null
     getNumber(name:string,required:boolean){
-        if (this.#interaction instanceof discord.ChatInputCommandInteraction){
+        if (this.interaction instanceof discord.ChatInputCommandInteraction){
             try {
-                return this.#interaction.options.getNumber(name,required)
+                return this.interaction.options.getNumber(name,required)
             }catch{
                 throw new ODSystemError("ODCommandResponderInstanceOptions:getNumber() slash command option not found!")
             }
 
-        }else if (this.#interaction instanceof discord.Message){
-            const opt = this.#options.find((opt) => opt.type == "number" && opt.name == name)
+        }else if (this.interaction instanceof discord.Message){
+            const opt = this.options.find((opt) => opt.type == "number" && opt.name == name)
             if (opt && typeof opt.value == "number") return opt.value
             else return null
 
@@ -240,15 +278,15 @@ export class ODCommandResponderInstanceOptions {
     getChannel(name:string,required:true): discord.TextChannel|discord.VoiceChannel|discord.StageChannel|discord.NewsChannel|discord.MediaChannel|discord.ForumChannel|discord.CategoryChannel
     getChannel(name:string,required:false): discord.TextChannel|discord.VoiceChannel|discord.StageChannel|discord.NewsChannel|discord.MediaChannel|discord.ForumChannel|discord.CategoryChannel|null
     getChannel(name:string,required:boolean){
-        if (this.#interaction instanceof discord.ChatInputCommandInteraction){
+        if (this.interaction instanceof discord.ChatInputCommandInteraction){
             try {
-                return this.#interaction.options.getChannel(name,required)
+                return this.interaction.options.getChannel(name,required)
             }catch{
                 throw new ODSystemError("ODCommandResponderInstanceOptions:getChannel() slash command option not found!")
             }
 
-        }else if (this.#interaction instanceof discord.Message){
-            const opt = this.#options.find((opt) => opt.type == "channel" && opt.name == name)
+        }else if (this.interaction instanceof discord.Message){
+            const opt = this.options.find((opt) => opt.type == "channel" && opt.name == name)
             if (opt && (opt.value instanceof discord.TextChannel || opt.value instanceof discord.VoiceChannel || opt.value instanceof discord.StageChannel || opt.value instanceof discord.NewsChannel || opt.value instanceof discord.MediaChannel || opt.value instanceof discord.ForumChannel || opt.value instanceof discord.CategoryChannel)) return opt.value
             else return null
 
@@ -258,15 +296,15 @@ export class ODCommandResponderInstanceOptions {
     getRole(name:string,required:true): discord.Role
     getRole(name:string,required:false): discord.Role|null
     getRole(name:string,required:boolean){
-        if (this.#interaction instanceof discord.ChatInputCommandInteraction){
+        if (this.interaction instanceof discord.ChatInputCommandInteraction){
             try {
-                return this.#interaction.options.getRole(name,required)
+                return this.interaction.options.getRole(name,required)
             }catch{
                 throw new ODSystemError("ODCommandResponderInstanceOptions:getRole() slash command option not found!")
             }
 
-        }else if (this.#interaction instanceof discord.Message){
-            const opt = this.#options.find((opt) => opt.type == "role" && opt.name == name)
+        }else if (this.interaction instanceof discord.Message){
+            const opt = this.options.find((opt) => opt.type == "role" && opt.name == name)
             if (opt && opt.value instanceof discord.Role) return opt.value
             else return null
 
@@ -276,15 +314,15 @@ export class ODCommandResponderInstanceOptions {
     getUser(name:string,required:true): discord.User
     getUser(name:string,required:false): discord.User|null
     getUser(name:string,required:boolean){
-        if (this.#interaction instanceof discord.ChatInputCommandInteraction){
+        if (this.interaction instanceof discord.ChatInputCommandInteraction){
             try {
-                return this.#interaction.options.getUser(name,required)
+                return this.interaction.options.getUser(name,required)
             }catch{
                 throw new ODSystemError("ODCommandResponderInstanceOptions:getUser() slash command option not found!")
             }
 
-        }else if (this.#interaction instanceof discord.Message){
-            const opt = this.#options.find((opt) => opt.type == "user" && opt.name == name)
+        }else if (this.interaction instanceof discord.Message){
+            const opt = this.options.find((opt) => opt.type == "user" && opt.name == name)
             if (opt && opt.value instanceof discord.User) return opt.value
             else return null
 
@@ -294,17 +332,17 @@ export class ODCommandResponderInstanceOptions {
     getGuildMember(name:string,required:true): discord.GuildMember
     getGuildMember(name:string,required:false): discord.GuildMember|null
     getGuildMember(name:string,required:boolean){
-        if (this.#interaction instanceof discord.ChatInputCommandInteraction){
+        if (this.interaction instanceof discord.ChatInputCommandInteraction){
             try {
-                const member = this.#interaction.options.getMember(name)
+                const member = this.interaction.options.getMember(name)
                 if (!member && required) throw new ODSystemError("ODCommandResponderInstanceOptions:getGuildMember() slash command option not found!")
                 return member
             }catch{
                 throw new ODSystemError("ODCommandResponderInstanceOptions:getGuildMember() slash command option not found!")
             }
 
-        }else if (this.#interaction instanceof discord.Message){
-            const opt = this.#options.find((opt) => opt.type == "guildmember" && opt.name == name)
+        }else if (this.interaction instanceof discord.Message){
+            const opt = this.options.find((opt) => opt.type == "guildmember" && opt.name == name)
             if (opt && opt.value instanceof discord.GuildMember) return opt.value
             else return null
 
@@ -314,15 +352,15 @@ export class ODCommandResponderInstanceOptions {
     getMentionable(name:string,required:true): discord.User|discord.GuildMember|discord.Role
     getMentionable(name:string,required:false): discord.User|discord.GuildMember|discord.Role|null
     getMentionable(name:string,required:boolean){
-        if (this.#interaction instanceof discord.ChatInputCommandInteraction){
+        if (this.interaction instanceof discord.ChatInputCommandInteraction){
             try {
-                return this.#interaction.options.getMentionable(name,required)
+                return this.interaction.options.getMentionable(name,required)
             }catch{
                 throw new ODSystemError("ODCommandResponderInstanceOptions:getGuildMember() slash command option not found!")
             }
 
-        }else if (this.#interaction instanceof discord.Message){
-            const opt = this.#options.find((opt) => opt.type == "mentionable" && opt.name == name)
+        }else if (this.interaction instanceof discord.Message){
+            const opt = this.options.find((opt) => opt.type == "mentionable" && opt.name == name)
             if (opt && (opt.value instanceof discord.User || opt.value instanceof discord.GuildMember || opt.value instanceof discord.Role)) return opt.value
             else return null
 
@@ -331,16 +369,16 @@ export class ODCommandResponderInstanceOptions {
     /**Get a subgroup. */
     getSubGroup(): string|null
     getSubGroup(){
-        if (this.#interaction instanceof discord.ChatInputCommandInteraction){
+        if (this.interaction instanceof discord.ChatInputCommandInteraction){
             try {
-                return this.#interaction.options.getSubcommandGroup(true)
+                return this.interaction.options.getSubcommandGroup(true)
             }catch{
                 throw new ODSystemError("ODCommandResponderInstanceOptions:getSubGroup() slash command option not found!")
             }
 
-        }else if (this.#interaction instanceof discord.Message && this.#cmd instanceof ODTextCommand){
+        }else if (this.interaction instanceof discord.Message && this.cmd instanceof ODTextCommand){
             //0: name, 1:sub/group, 2:sub
-            const splittedName: string[] = this.#cmd.builder.name.split(" ")
+            const splittedName: string[] = this.cmd.builder.name.split(" ")
             return splittedName[1] ?? null
 
         }else return null
@@ -348,16 +386,16 @@ export class ODCommandResponderInstanceOptions {
     /**Get a subcommand. */
     getSubCommand(): string|null
     getSubCommand(){
-        if (this.#interaction instanceof discord.ChatInputCommandInteraction){
+        if (this.interaction instanceof discord.ChatInputCommandInteraction){
             try {
-                return this.#interaction.options.getSubcommand(true)
+                return this.interaction.options.getSubcommand(true)
             }catch{
                 throw new ODSystemError("ODCommandResponderInstanceOptions:getSubCommand() slash command option not found!")
             }
 
-        }else if (this.#interaction instanceof discord.Message && this.#cmd instanceof ODTextCommand){
+        }else if (this.interaction instanceof discord.Message && this.cmd instanceof ODTextCommand){
             //0: name, 1:sub/group, 2:sub
-            const splittedName: string[] = this.#cmd.builder.name.split(" ")
+            const splittedName: string[] = this.cmd.builder.name.split(" ")
             
             //return the second subcommand when there is a subgroup
             if (splittedName.length > 2){
@@ -374,7 +412,7 @@ export class ODCommandResponderInstanceOptions {
  * 
  * An instance is an active slash interaction or used text command. You can reply to the command using `reply()` for both slash & text commands.
  */
-export class ODCommandResponderInstance {
+export class ODCommandResponderInstance extends ODBaseResponderInstance {
     /**The interaction which is the source of this instance. */
     interaction: discord.ChatInputCommandInteraction|discord.Message
     /**The command wich is the source of this instance. */
@@ -395,6 +433,7 @@ export class ODCommandResponderInstance {
     channel: discord.TextBasedChannel
 
     constructor(interaction:discord.ChatInputCommandInteraction|discord.Message, cmd:ODSlashCommand|ODTextCommand, errorCallback:ODResponderTimeoutErrorCallback<ODCommandResponderInstance,"slash"|"text">|null, timeoutMs:number|null, options?:ODTextCommandInteractionOption[]){
+        super()
         if (!interaction.channel) throw new ODSystemError("ODCommandResponderInstance: Unable to find interaction channel!")
         this.interaction = interaction
         this.cmd = cmd
@@ -410,11 +449,16 @@ export class ODCommandResponderInstance {
             if (!this.didReply){
                 try {
                     if (!errorCallback){
-                        this.reply({id:new ODId("looks-like-we-got-an-error-here"), ephemeral:true, message:{
+                        this.reply({id:new ODId("opendiscord:unknown-error"), ephemeral:true, message:{
                             content:":x: **Something went wrong while replying to this command!**"
                         }})
                     }else{
-                        await errorCallback(this,(this.type == "interaction") ? "slash" : "text")
+                        const errorResponse = await errorCallback(this,(this.type == "interaction") ? "slash" : "text")
+                        
+                        //auto-delete timeout error message after 5sec when text-based
+                        if (errorResponse.success && this.type == "message") setTimeout(() => {
+                            if (errorResponse.message?.deletable) errorResponse.message?.delete()
+                        },5000)
                     }
                     
                 }catch(err){
@@ -425,21 +469,21 @@ export class ODCommandResponderInstance {
     }
 
     /**Reply to this command. */
-    async reply(msg:ODMessageBuildResult): Promise<ODMessageBuildSentResult<boolean>> {
+    async reply(build:ODMessageBuildResult|ODMessageComponentBuildResult): Promise<ODResponderSendResult<boolean>> {
         try {
-            const msgFlags: number[] = msg.ephemeral ? [discord.MessageFlags.Ephemeral] : []
+            const finalMessage = this.getMessageFromBuildResult(build,this.type)
             if (this.type == "interaction" && this.interaction instanceof discord.ChatInputCommandInteraction){
                 if (this.interaction.replied || this.interaction.deferred){
-                    const sent = await this.interaction.editReply(Object.assign(msg.message,{flags:msgFlags}))
+                    const sent = await this.interaction.editReply(finalMessage)
                     this.didReply = true
                     return {success:true,message:sent}
                 }else{
-                    const sent = await this.interaction.reply(Object.assign(msg.message,{flags:msgFlags}))
+                    const sent = await this.interaction.reply(finalMessage)
                     this.didReply = true
                     return {success:true,message:await sent.fetch()}
                 }
             }else if (this.type == "message" && this.interaction instanceof discord.Message && this.interaction.channel.type != discord.ChannelType.GroupDM){
-                const sent = await this.interaction.channel.send(msg.message)
+                const sent = await this.interaction.channel.send(finalMessage)
                 this.didReply = true
                 return {success:true,message:sent}
             }else return {success:false,message:null}
@@ -507,37 +551,37 @@ export type ODButtonResponderManagerIdConstraint = Record<string,{origin:"button
  */
 export class ODButtonResponderManager<IdList extends ODButtonResponderManagerIdConstraint = ODButtonResponderManagerIdConstraint> extends ODManager<ODButtonResponder<"button",any>> {
     /**An alias to the Open Discord client manager. */
-    #client: ODClientManager
+    private client: ODClientManager
     /**The callback executed when the default workers take too much time to reply. */
-    #timeoutErrorCallback: ODResponderTimeoutErrorCallback<ODButtonResponderInstance,"button">|null = null
+    private timeoutErrorCallback: ODResponderTimeoutErrorCallback<ODButtonResponderInstance,"button">|null = null
     /**The amount of milliseconds before the timeout error callback is executed. */
-    #timeoutMs: number|null = null
+    private timeoutMs: number|null = null
     /**A list of listeners which will listen to the raw interactionCreate event from discord.js */
-    #listeners: ((interaction:discord.ButtonInteraction) => void)[] = []
+    private listeners: ((interaction:discord.ButtonInteraction) => void)[] = []
 
     constructor(debug:ODDebugger, debugname:string, client:ODClientManager){
         super(debug,debugname)
-        this.#client = client
+        this.client = client
 
-        this.#client.client.on("interactionCreate",(interaction) => {
+        this.client.client.on("interactionCreate",(interaction) => {
             if (!interaction.isButton()) return
-            this.#listeners.forEach((cb) => cb(interaction))
+            this.listeners.forEach((cb) => cb(interaction))
         })
     }
 
     /**Set the message to send when the response times out! */
     setTimeoutErrorCallback(callback:ODResponderTimeoutErrorCallback<ODButtonResponderInstance,"button">|null, ms:number|null){
-        this.#timeoutErrorCallback = callback
-        this.#timeoutMs = ms
+        this.timeoutErrorCallback = callback
+        this.timeoutMs = ms
     }
 
     add(data:ODButtonResponder<"button",any>, overwrite?:boolean){
         const res = super.add(data,overwrite)
         
-        this.#listeners.push((interaction) => {
+        this.listeners.push((interaction) => {
             const newData = this.get(data.id)
             if (!newData) return
-            if ((typeof newData.match == "string") ? interaction.customId == newData.match : newData.match.test(interaction.customId)) newData.respond(new ODButtonResponderInstance(interaction,this.#timeoutErrorCallback,this.#timeoutMs),"button",{})
+            if ((typeof newData.match == "string") ? interaction.customId == newData.match : newData.match.test(interaction.customId)) newData.respond(new ODButtonResponderInstance(interaction,this.timeoutErrorCallback,this.timeoutMs),"button",{})
         })
 
         return res
@@ -570,7 +614,7 @@ export class ODButtonResponderManager<IdList extends ODButtonResponderManagerIdC
  * 
  * An instance is an active button interaction. You can reply to the button using `reply()`.
  */
-export class ODButtonResponderInstance {
+export class ODButtonResponderInstance extends ODBaseResponderInstance {
     /**The interaction which is the source of this instance. */
     interaction: discord.ButtonInteraction
     /**Did a worker already reply to this instance/interaction? */
@@ -587,6 +631,7 @@ export class ODButtonResponderInstance {
     message: discord.Message
 
     constructor(interaction:discord.ButtonInteraction, errorCallback:ODResponderTimeoutErrorCallback<ODButtonResponderInstance,"button">|null, timeoutMs:number|null){
+        super()
         if (!interaction.channel) throw new ODSystemError("ODButtonResponderInstance: Unable to find interaction channel!")
         this.interaction = interaction
         this.user = interaction.user
@@ -599,7 +644,7 @@ export class ODButtonResponderInstance {
             if (!this.didReply){
                 try {
                     if (!errorCallback){
-                        this.reply({id:new ODId("looks-like-we-got-an-error-here"), ephemeral:true, message:{
+                        this.reply({id:new ODId("opendiscord:unknown-error"), ephemeral:true, message:{
                             content:":x: **Something went wrong while replying to this button!**"
                         }})
                     }else{
@@ -614,15 +659,15 @@ export class ODButtonResponderInstance {
     }
 
     /**Reply to this button. */
-    async reply(msg:ODMessageBuildResult): Promise<ODMessageBuildSentResult<boolean>> {
-        try{
-            const msgFlags: number[] = msg.ephemeral ? [discord.MessageFlags.Ephemeral] : []
+    async reply(build:ODMessageBuildResult|ODMessageComponentBuildResult): Promise<ODResponderSendResult<boolean>> {
+        try {
+            const finalMessage = this.getMessageFromBuildResult(build,"interaction")
             if (this.interaction.replied || this.interaction.deferred){
-                const sent = await this.interaction.editReply(Object.assign(msg.message,{flags:msgFlags}))
+                const sent = await this.interaction.editReply(finalMessage)
                 this.didReply = true
                 return {success:true,message:sent}
             }else{
-                const sent = await this.interaction.reply(Object.assign(msg.message,{flags:msgFlags}))
+                const sent = await this.interaction.reply(finalMessage)
                 this.didReply = true
                 return {success:true,message:await sent.fetch()}
             }
@@ -631,15 +676,15 @@ export class ODButtonResponderInstance {
         }
     }
     /**Update the message of this button. */
-    async update(msg:ODMessageBuildResult): Promise<ODMessageBuildSentResult<boolean>> {
-        try{
-            const msgFlags: number[] = msg.ephemeral ? [discord.MessageFlags.Ephemeral] : []
+    async update(build:ODMessageBuildResult|ODMessageComponentBuildResult): Promise<ODResponderSendResult<boolean>> {
+        try {
+            const finalMessage = this.getMessageFromBuildResult(build,"interaction")
             if (this.interaction.replied || this.interaction.deferred){
-                const sent = await this.interaction.editReply(Object.assign(msg.message,{flags:msgFlags}))
+                const sent = await this.interaction.editReply(finalMessage)
                 this.didReply = true
                 return {success:true,message:await sent.fetch()}
             }else{
-                const sent = await this.interaction.update(Object.assign(msg.message,{flags:msgFlags}))
+                const sent = await this.interaction.update(finalMessage)
                 this.didReply = true
                 return {success:true,message:await sent.fetch()}
             }
@@ -731,37 +776,37 @@ export type ODDropdownResponderManagerIdConstraint = Record<string,{origin:"drop
  */
 export class ODDropdownResponderManager<IdList extends ODDropdownResponderManagerIdConstraint = ODDropdownResponderManagerIdConstraint> extends ODManager<ODDropdownResponder<"dropdown",any>> {
     /**An alias to the Open Discord client manager. */
-    #client: ODClientManager
+    private client: ODClientManager
     /**The callback executed when the default workers take too much time to reply. */
-    #timeoutErrorCallback: ODResponderTimeoutErrorCallback<ODDropdownResponderInstance,"dropdown">|null = null
+    private timeoutErrorCallback: ODResponderTimeoutErrorCallback<ODDropdownResponderInstance,"dropdown">|null = null
     /**The amount of milliseconds before the timeout error callback is executed. */
-    #timeoutMs: number|null = null
+    private timeoutMs: number|null = null
     /**A list of listeners which will listen to the raw interactionCreate event from discord.js */
-    #listeners: ((interaction:discord.AnySelectMenuInteraction) => void)[] = []
+    private listeners: ((interaction:discord.AnySelectMenuInteraction) => void)[] = []
 
     constructor(debug:ODDebugger, debugname:string, client:ODClientManager){
         super(debug,debugname)
-        this.#client = client
+        this.client = client
 
-        this.#client.client.on("interactionCreate",(interaction) => {
+        this.client.client.on("interactionCreate",(interaction) => {
             if (!interaction.isAnySelectMenu()) return
-            this.#listeners.forEach((cb) => cb(interaction))
+            this.listeners.forEach((cb) => cb(interaction))
         })
     }
 
     /**Set the message to send when the response times out! */
     setTimeoutErrorCallback(callback:ODResponderTimeoutErrorCallback<ODDropdownResponderInstance,"dropdown">|null, ms:number|null){
-        this.#timeoutErrorCallback = callback
-        this.#timeoutMs = ms
+        this.timeoutErrorCallback = callback
+        this.timeoutMs = ms
     }
 
     add(data:ODDropdownResponder<"dropdown",any>, overwrite?:boolean){
         const res = super.add(data,overwrite)
         
-        this.#listeners.push((interaction) => {
+        this.listeners.push((interaction) => {
             const newData = this.get(data.id)
             if (!newData) return
-            if ((typeof newData.match == "string") ? interaction.customId == newData.match : newData.match.test(interaction.customId)) newData.respond(new ODDropdownResponderInstance(interaction,this.#timeoutErrorCallback,this.#timeoutMs),"dropdown",{})
+            if ((typeof newData.match == "string") ? interaction.customId == newData.match : newData.match.test(interaction.customId)) newData.respond(new ODDropdownResponderInstance(interaction,this.timeoutErrorCallback,this.timeoutMs),"dropdown",{})
         })
 
         return res
@@ -796,13 +841,13 @@ export class ODDropdownResponderManager<IdList extends ODDropdownResponderManage
  */
 export class ODDropdownResponderInstanceValues {
     /**The interaction to get data from. */
-    #interaction: discord.AnySelectMenuInteraction
+    private interaction: discord.AnySelectMenuInteraction
     /**The type of this dropdown. */
-    #type: ODDropdownData["type"]
+    private type: ODDropdownData["type"]
 
     constructor(interaction:discord.AnySelectMenuInteraction, type:ODDropdownData["type"]){
-        this.#interaction = interaction
-        this.#type = type
+        this.interaction = interaction
+        this.type = type
 
         if (interaction.isChannelSelectMenu()){
             interaction.values
@@ -812,19 +857,19 @@ export class ODDropdownResponderInstanceValues {
     /**Get the selected values. */
     getStringValues(): string[] {
         try {
-            return this.#interaction.values
+            return this.interaction.values
         }catch{
             throw new ODSystemError("ODDropdownResponderInstanceValues:getStringValues() invalid values!")
         }
     }
     /**Get the selected roles. */
     async getRoleValues(): Promise<discord.Role[]> {
-        if (this.#type != "role") throw new ODSystemError("ODDropdownResponderInstanceValues:getRoleValues() dropdown type isn't role!")
+        if (this.type != "role") throw new ODSystemError("ODDropdownResponderInstanceValues:getRoleValues() dropdown type isn't role!")
         try {
             const result: discord.Role[] = []
-            for (const id of this.#interaction.values){
-                if (!this.#interaction.guild) break
-                const role = await this.#interaction.guild.roles.fetch(id)
+            for (const id of this.interaction.values){
+                if (!this.interaction.guild) break
+                const role = await this.interaction.guild.roles.fetch(id)
                 if (role) result.push(role)
             }
             return result
@@ -834,11 +879,11 @@ export class ODDropdownResponderInstanceValues {
     }
     /**Get the selected users. */
     async getUserValues(): Promise<discord.User[]> {
-        if (this.#type != "role") throw new ODSystemError("ODDropdownResponderInstanceValues:getUserValues() dropdown type isn't user!")
+        if (this.type != "role") throw new ODSystemError("ODDropdownResponderInstanceValues:getUserValues() dropdown type isn't user!")
         try {
             const result: discord.User[] = []
-            for (const id of this.#interaction.values){
-                const user = await this.#interaction.client.users.fetch(id)
+            for (const id of this.interaction.values){
+                const user = await this.interaction.client.users.fetch(id)
                 if (user) result.push(user)
             }
             return result
@@ -848,12 +893,12 @@ export class ODDropdownResponderInstanceValues {
     }
     /**Get the selected channels. */
     async getChannelValues(): Promise<discord.GuildBasedChannel[]> {
-        if (this.#type != "role") throw new ODSystemError("ODDropdownResponderInstanceValues:getChannelValues() dropdown type isn't channel!")
+        if (this.type != "role") throw new ODSystemError("ODDropdownResponderInstanceValues:getChannelValues() dropdown type isn't channel!")
         try {
             const result: discord.GuildBasedChannel[] = []
-            for (const id of this.#interaction.values){
-                if (!this.#interaction.guild) break
-                const guild = await this.#interaction.guild.channels.fetch(id)
+            for (const id of this.interaction.values){
+                if (!this.interaction.guild) break
+                const guild = await this.interaction.guild.channels.fetch(id)
                 if (guild) result.push(guild)
             }
             return result
@@ -868,7 +913,7 @@ export class ODDropdownResponderInstanceValues {
  * 
  * An instance is an active dropdown interaction. You can reply to the dropdown using `reply()`.
  */
-export class ODDropdownResponderInstance {
+export class ODDropdownResponderInstance extends ODBaseResponderInstance {
     /**The interaction which is the source of this instance. */
     interaction: discord.AnySelectMenuInteraction
     /**Did a worker already reply to this instance/interaction? */
@@ -889,6 +934,7 @@ export class ODDropdownResponderInstance {
     message: discord.Message
 
     constructor(interaction:discord.AnySelectMenuInteraction, errorCallback:ODResponderTimeoutErrorCallback<ODDropdownResponderInstance,"dropdown">|null, timeoutMs:number|null){
+        super()
         if (!interaction.channel) throw new ODSystemError("ODDropdownResponderInstance: Unable to find interaction channel!")
         this.interaction = interaction
         if (interaction.isStringSelectMenu()){
@@ -914,7 +960,7 @@ export class ODDropdownResponderInstance {
             if (!this.didReply){
                 try {
                     if (!errorCallback){
-                        this.reply({id:new ODId("looks-like-we-got-an-error-here"), ephemeral:true, message:{
+                        this.reply({id:new ODId("opendiscord:unknown-error"), ephemeral:true, message:{
                             content:":x: **Something went wrong while replying to this dropdown!**"
                         }})
                     }else{
@@ -929,15 +975,15 @@ export class ODDropdownResponderInstance {
     }
 
     /**Reply to this dropdown. */
-    async reply(msg:ODMessageBuildResult): Promise<ODMessageBuildSentResult<boolean>> {
+    async reply(build:ODMessageBuildResult|ODMessageComponentBuildResult): Promise<ODResponderSendResult<boolean>> {
         try {
-            const msgFlags: number[] = msg.ephemeral ? [discord.MessageFlags.Ephemeral] : []
+            const finalMessage = this.getMessageFromBuildResult(build,"interaction")
             if (this.interaction.replied || this.interaction.deferred){
-                const sent = await this.interaction.editReply(Object.assign(msg.message,{flags:msgFlags}))
+                const sent = await this.interaction.editReply(finalMessage)
                 this.didReply = true
                 return {success:true,message:sent}
             }else{
-                const sent = await this.interaction.reply(Object.assign(msg.message,{flags:msgFlags}))
+                const sent = await this.interaction.reply(finalMessage)
                 this.didReply = true
                 return {success:true,message:await sent.fetch()}
             }
@@ -946,15 +992,15 @@ export class ODDropdownResponderInstance {
         }
     }
     /**Update the message of this dropdown. */
-    async update(msg:ODMessageBuildResult): Promise<ODMessageBuildSentResult<boolean>> {
-        try{
-            const msgFlags: number[] = msg.ephemeral ? [discord.MessageFlags.Ephemeral] : []
+    async update(build:ODMessageBuildResult|ODMessageComponentBuildResult): Promise<ODResponderSendResult<boolean>> {
+        try {
+            const finalMessage = this.getMessageFromBuildResult(build,"interaction")
             if (this.interaction.replied || this.interaction.deferred){
-                const sent = await this.interaction.editReply(Object.assign(msg.message,{flags:msgFlags}))
+                const sent = await this.interaction.editReply(finalMessage)
                 this.didReply = true
                 return {success:true,message:await sent.fetch()}
             }else{
-                const sent = await this.interaction.update(Object.assign(msg.message,{flags:msgFlags}))
+                const sent = await this.interaction.update(finalMessage)
                 this.didReply = true
                 return {success:true,message:await sent.fetch()}
             }
@@ -1046,37 +1092,37 @@ export type ODModalResponderManagerIdConstraint = Record<string,{origin:"modal",
  */
 export class ODModalResponderManager<IdList extends ODModalResponderManagerIdConstraint = ODModalResponderManagerIdConstraint> extends ODManager<ODModalResponder<"modal",any>> {
     /**An alias to the Open Discord client manager. */
-    #client: ODClientManager
+    private client: ODClientManager
     /**The callback executed when the default workers take too much time to reply. */
-    #timeoutErrorCallback: ODResponderTimeoutErrorCallback<ODModalResponderInstance,"modal">|null = null
+    private timeoutErrorCallback: ODResponderTimeoutErrorCallback<ODModalResponderInstance,"modal">|null = null
     /**The amount of milliseconds before the timeout error callback is executed. */
-    #timeoutMs: number|null = null
+    private timeoutMs: number|null = null
     /**A list of listeners which will listen to the raw interactionCreate event from discord.js */
-    #listeners: ((interaction:discord.ModalSubmitInteraction) => void)[] = []
+    private listeners: ((interaction:discord.ModalSubmitInteraction) => void)[] = []
 
     constructor(debug:ODDebugger, debugname:string, client:ODClientManager){
         super(debug,debugname)
-        this.#client = client
+        this.client = client
 
-        this.#client.client.on("interactionCreate",(interaction) => {
+        this.client.client.on("interactionCreate",(interaction) => {
             if (!interaction.isModalSubmit()) return
-            this.#listeners.forEach((cb) => cb(interaction))
+            this.listeners.forEach((cb) => cb(interaction))
         })
     }
 
     /**Set the message to send when the response times out! */
     setTimeoutErrorCallback(callback:ODResponderTimeoutErrorCallback<ODModalResponderInstance,"modal">|null, ms:number|null){
-        this.#timeoutErrorCallback = callback
-        this.#timeoutMs = ms
+        this.timeoutErrorCallback = callback
+        this.timeoutMs = ms
     }
 
     add(data:ODModalResponder<"modal",any>, overwrite?:boolean){
         const res = super.add(data,overwrite)
         
-        this.#listeners.push((interaction) => {
+        this.listeners.push((interaction) => {
             const newData = this.get(data.id)
             if (!newData) return
-            if ((typeof newData.match == "string") ? interaction.customId == newData.match : newData.match.test(interaction.customId)) newData.respond(new ODModalResponderInstance(interaction,this.#timeoutErrorCallback,this.#timeoutMs),"modal",{})
+            if ((typeof newData.match == "string") ? interaction.customId == newData.match : newData.match.test(interaction.customId)) newData.respond(new ODModalResponderInstance(interaction,this.timeoutErrorCallback,this.timeoutMs),"modal",{})
         })
 
         return res
@@ -1111,10 +1157,10 @@ export class ODModalResponderManager<IdList extends ODModalResponderManagerIdCon
  */
 export class ODModalResponderInstanceValues {
     /**The interaction to get data from. */
-    #interaction: discord.ModalSubmitInteraction
+    private interaction: discord.ModalSubmitInteraction
 
     constructor(interaction:discord.ModalSubmitInteraction){
-        this.#interaction = interaction
+        this.interaction = interaction
     }
 
     /**Get the value of a text field. */
@@ -1122,7 +1168,7 @@ export class ODModalResponderInstanceValues {
     getTextField(name:string,required:false): string|null
     getTextField(name:string,required:boolean){
         try {
-            const data = this.#interaction.fields.getField(name,discord.ComponentType.TextInput)
+            const data = this.interaction.fields.getField(name,discord.ComponentType.TextInput)
             if (!data && required) throw new ODSystemError("ODModalResponderInstanceValues:getTextField() field not found!")
             return (data) ? data.value : null
         }catch{
@@ -1136,7 +1182,7 @@ export class ODModalResponderInstanceValues {
  * 
  * An instance is an active modal interaction. You can reply to the modal using `reply()`.
  */
-export class ODModalResponderInstance {
+export class ODModalResponderInstance extends ODBaseResponderInstance {
     /**The interaction which is the source of this instance. */
     interaction: discord.ModalSubmitInteraction
     /**Did a worker already reply to this instance/interaction? */
@@ -1153,6 +1199,7 @@ export class ODModalResponderInstance {
     channel: discord.TextBasedChannel|null
 
     constructor(interaction:discord.ModalSubmitInteraction, errorCallback:ODResponderTimeoutErrorCallback<ODModalResponderInstance,"modal">|null, timeoutMs:number|null){
+        super()
         this.interaction = interaction
         this.values = new ODModalResponderInstanceValues(interaction)
         this.user = interaction.user
@@ -1164,7 +1211,7 @@ export class ODModalResponderInstance {
             if (!this.didReply){
                 try {
                     if (!errorCallback){
-                        this.reply({id:new ODId("looks-like-we-got-an-error-here"), ephemeral:true, message:{
+                        this.reply({id:new ODId("opendiscord:unknown-error"), ephemeral:true, message:{
                             content:":x: **Something went wrong while replying to this modal!**"
                         }})
                     }else{
@@ -1179,10 +1226,10 @@ export class ODModalResponderInstance {
     }
 
     /**Reply to this modal. */
-    async reply(msg:ODMessageBuildResult): Promise<ODMessageBuildSentResult<boolean>> {
-        try{
-            const msgFlags: number[] = msg.ephemeral ? [discord.MessageFlags.Ephemeral] : []
-            const sent = await this.interaction.followUp(Object.assign(msg.message,{flags:msgFlags}))
+    async reply(build:ODMessageBuildResult|ODMessageComponentBuildResult): Promise<ODResponderSendResult<boolean>> {
+        try {
+            const finalMessage = this.getMessageFromBuildResult(build,"interaction")
+            const sent = await this.interaction.followUp(finalMessage)
             this.didReply = true
             return {success:true,message:sent}
         }catch{
@@ -1190,15 +1237,15 @@ export class ODModalResponderInstance {
         }
     }
     /**Update the message of this modal. */
-    async update(msg:ODMessageBuildResult): Promise<ODMessageBuildSentResult<boolean>> {
-        try{
-            const msgFlags: number[] = msg.ephemeral ? [discord.MessageFlags.Ephemeral] : []
+    async update(build:ODMessageBuildResult|ODMessageComponentBuildResult): Promise<ODResponderSendResult<boolean>> {
+        try {
+            const finalMessage = this.getMessageFromBuildResult(build,"interaction")
             if (this.interaction.replied || this.interaction.deferred){
-                const sent = await this.interaction.editReply(Object.assign(msg.message,{flags:msgFlags}))
+                const sent = await this.interaction.editReply(finalMessage)
                 this.didReply = true
                 return {success:true,message:await sent.fetch()}
             }else{
-                const sent = await this.interaction.reply(Object.assign(msg.message,{flags:msgFlags}))
+                const sent = await this.interaction.reply(finalMessage)
                 this.didReply = true
                 return {success:true,message:await sent.fetch()}
             }
@@ -1253,30 +1300,30 @@ export type ODContextMenuResponderManagerIdConstraint = Record<string,{origin:"c
  */
 export class ODContextMenuResponderManager<IdList extends ODContextMenuResponderManagerIdConstraint = ODContextMenuResponderManagerIdConstraint> extends ODManager<ODContextMenuResponder<"context-menu",any>> {
     /**An alias to the Open Discord client manager. */
-    #client: ODClientManager
+    private client: ODClientManager
     /**The callback executed when the default workers take too much time to reply. */
-    #timeoutErrorCallback: ODResponderTimeoutErrorCallback<ODContextMenuResponderInstance,"context-menu">|null = null
+    private timeoutErrorCallback: ODResponderTimeoutErrorCallback<ODContextMenuResponderInstance,"context-menu">|null = null
     /**The amount of milliseconds before the timeout error callback is executed. */
-    #timeoutMs: number|null = null
+    private timeoutMs: number|null = null
 
     constructor(debug:ODDebugger, debugname:string, client:ODClientManager){
         super(debug,debugname)
-        this.#client = client
+        this.client = client
     }
 
     /**Set the message to send when the response times out! */
     setTimeoutErrorCallback(callback:ODResponderTimeoutErrorCallback<ODContextMenuResponderInstance,"context-menu">|null, ms:number|null){
-        this.#timeoutErrorCallback = callback
-        this.#timeoutMs = ms
+        this.timeoutErrorCallback = callback
+        this.timeoutMs = ms
     }
 
     add(data:ODContextMenuResponder<"context-menu",any>, overwrite?:boolean){
         const res = super.add(data,overwrite)
         
-        this.#client.contextMenus.onInteraction(data.match,(interaction,cmd) => {
+        this.client.contextMenus.onInteraction(data.match,(interaction,cmd) => {
             const newData = this.get(data.id)
             if (!newData) return
-            newData.respond(new ODContextMenuResponderInstance(interaction,cmd,this.#timeoutErrorCallback,this.#timeoutMs),"context-menu",{})
+            newData.respond(new ODContextMenuResponderInstance(interaction,cmd,this.timeoutErrorCallback,this.timeoutMs),"context-menu",{})
         })
 
         return res
@@ -1309,7 +1356,7 @@ export class ODContextMenuResponderManager<IdList extends ODContextMenuResponder
  * 
  * An instance is an active context menu interaction. You can reply to the context menu using `reply()`.
  */
-export class ODContextMenuResponderInstance {
+export class ODContextMenuResponderInstance extends ODBaseResponderInstance {
     /**The interaction which is the source of this instance. */
     interaction: discord.ContextMenuCommandInteraction
     /**Did a worker already reply to this instance/interaction? */
@@ -1328,6 +1375,7 @@ export class ODContextMenuResponderInstance {
     target: discord.Message|discord.User
 
     constructor(interaction:discord.ContextMenuCommandInteraction, menu:ODContextMenu, errorCallback:ODResponderTimeoutErrorCallback<ODContextMenuResponderInstance,"context-menu">|null, timeoutMs:number|null){
+        super()
         if (!interaction.channel) throw new ODSystemError("ODContextMenuResponderInstance: Unable to find interaction channel!")
         this.interaction = interaction
         this.menu = menu
@@ -1343,7 +1391,7 @@ export class ODContextMenuResponderInstance {
             if (!this.didReply){
                 try {
                     if (!errorCallback){
-                        this.reply({id:new ODId("looks-like-we-got-an-error-here"), ephemeral:true, message:{
+                        this.reply({id:new ODId("opendiscord:unknown-error"), ephemeral:true, message:{
                             content:":x: **Something went wrong while replying to this context menu!**"
                         }})
                     }else{
@@ -1358,15 +1406,15 @@ export class ODContextMenuResponderInstance {
     }
 
     /**Reply to this context menu. */
-    async reply(msg:ODMessageBuildResult): Promise<ODMessageBuildSentResult<boolean>> {
-        try{
-            const msgFlags: number[] = msg.ephemeral ? [discord.MessageFlags.Ephemeral] : []
+    async reply(build:ODMessageBuildResult|ODMessageComponentBuildResult): Promise<ODResponderSendResult<boolean>> {
+        try {
+            const finalMessage = this.getMessageFromBuildResult(build,"interaction")
             if (this.interaction.replied || this.interaction.deferred){
-                const sent = await this.interaction.editReply(Object.assign(msg.message,{flags:msgFlags}))
+                const sent = await this.interaction.editReply(finalMessage)
                 this.didReply = true
                 return {success:true,message:sent}
             }else{
-                const sent = await this.interaction.reply(Object.assign(msg.message,{flags:msgFlags}))
+                const sent = await this.interaction.reply(finalMessage)
                 this.didReply = true
                 return {success:true,message:await sent.fetch()}
             }
@@ -1375,11 +1423,11 @@ export class ODContextMenuResponderInstance {
         }
     }
     /**Update the message of this context menu. */
-    async update(msg:ODMessageBuildResult): Promise<ODMessageBuildSentResult<boolean>> {
-        try{
-            const msgFlags: number[] = msg.ephemeral ? [discord.MessageFlags.Ephemeral] : []
+    async update(build:ODMessageBuildResult|ODMessageComponentBuildResult): Promise<ODResponderSendResult<boolean>> {
+        try {
+            const finalMessage = this.getMessageFromBuildResult(build,"interaction")
             if (this.interaction.replied || this.interaction.deferred){
-                const sent = await this.interaction.editReply(Object.assign(msg.message,{flags:msgFlags}))
+                const sent = await this.interaction.editReply(finalMessage)
                 this.didReply = true
                 return {success:true,message:await sent.fetch()}
             }else throw new ODSystemError("Unable to update context menu interaction!")
@@ -1439,30 +1487,30 @@ export type ODAutocompleteResponderManagerIdConstraint = Record<string,{origin:"
  */
 export class ODAutocompleteResponderManager<IdList extends ODAutocompleteResponderManagerIdConstraint = ODAutocompleteResponderManagerIdConstraint> extends ODManager<ODAutocompleteResponder<"autocomplete",any>> {
     /**An alias to the Open Discord client manager. */
-    #client: ODClientManager
+    private client: ODClientManager
     /**The callback executed when the default workers take too much time to reply. */
-    #timeoutErrorCallback: ODResponderTimeoutErrorCallback<ODAutocompleteResponderInstance,"autocomplete">|null = null
+    private timeoutErrorCallback: ODResponderTimeoutErrorCallback<ODAutocompleteResponderInstance,"autocomplete">|null = null
     /**The amount of milliseconds before the timeout error callback is executed. */
-    #timeoutMs: number|null = null
+    private timeoutMs: number|null = null
 
     constructor(debug:ODDebugger, debugname:string, client:ODClientManager){
         super(debug,debugname)
-        this.#client = client
+        this.client = client
     }
 
     /**Set the message to send when the response times out! */
     setTimeoutErrorCallback(callback:ODResponderTimeoutErrorCallback<ODAutocompleteResponderInstance,"autocomplete">|null, ms:number|null){
-        this.#timeoutErrorCallback = callback
-        this.#timeoutMs = ms
+        this.timeoutErrorCallback = callback
+        this.timeoutMs = ms
     }
 
     add(data:ODAutocompleteResponder<"autocomplete",any>, overwrite?:boolean){
         const res = super.add(data,overwrite)
         
-        this.#client.autocompletes.onInteraction(data.cmdMatch,data.match,(interaction) => {
+        this.client.autocompletes.onInteraction(data.cmdMatch,data.match,(interaction) => {
             const newData = this.get(data.id)
             if (!newData) return
-            newData.respond(new ODAutocompleteResponderInstance(interaction,this.#timeoutErrorCallback,this.#timeoutMs),"autocomplete",{})
+            newData.respond(new ODAutocompleteResponderInstance(interaction,this.timeoutErrorCallback,this.timeoutMs),"autocomplete",{})
         })
 
         return res
@@ -1495,7 +1543,7 @@ export class ODAutocompleteResponderManager<IdList extends ODAutocompleteRespond
  * 
  * An instance is an active autocomplete interaction. You can reply to the autocomplete using `reply()`.
  */
-export class ODAutocompleteResponderInstance {
+export class ODAutocompleteResponderInstance extends ODBaseResponderInstance {
     /**The interaction which is the source of this instance. */
     interaction: discord.AutocompleteInteraction
     /**Did a worker already respond to this instance/interaction? */
@@ -1512,6 +1560,7 @@ export class ODAutocompleteResponderInstance {
     target: discord.AutocompleteFocusedOption
 
     constructor(interaction:discord.AutocompleteInteraction, errorCallback:ODResponderTimeoutErrorCallback<ODAutocompleteResponderInstance,"autocomplete">|null, timeoutMs:number|null){
+        super()
         if (!interaction.channel) throw new ODSystemError("ODAutocompleteResponderInstance: Unable to find interaction channel!")
         this.interaction = interaction
         this.user = interaction.user
@@ -1522,7 +1571,7 @@ export class ODAutocompleteResponderInstance {
         
         setTimeout(async () => {
             if (!this.didRespond){
-                process.emit("uncaughtException",new ODSystemError("Autocomplete responder instance failed to respond widthin 2.5sec!"))
+                process.emit("uncaughtException",new ODSystemError("Autocomplete responder instance failed to respond within 2.5sec!"))
             }
         },timeoutMs ?? 2500)
     }