@open-discord-bots/framework 0.3.14 → 0.3.15

package/src/api/modules/responder.ts

@@ -1,1625 +0,0 @@
-///////////////////////////////////////
-//RESPONDER MODULE
-///////////////////////////////////////
-import { ODId, ODManager, ODValidId, ODSystemError, ODManagerData, ODNoGeneric } from "./base.js"
-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, ODModalBuildResult } from "./builder.js"
-import { ODMessageComponentBuildResult } from "./component.js"
-
-/**## ODResponderImplementation `class`
- * This is an Open Discord responder implementation.
- * 
- * It is a basic implementation of the `ODWorkerManager` used by all `ODResponder` classes.
- * 
- * This class can't be used stand-alone & needs to be extended from!
- */
-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. */
-    match: string|RegExp
-
-    constructor(id:ODValidId, match:string|RegExp, callback?:ODWorkerCallback<Instance,Origin,Params>, priority?:number, callbackId?:ODValidId){
-        super(id)
-        this.match = match
-        this.workers = new ODWorkerManager("descending")
-        if (callback) this.workers.add(new ODWorker(callbackId ? callbackId : id,priority ?? 0,callback))
-    }
-    /**Execute all workers & return the result. */
-    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) => 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>,
-    /**Was the message sent as ephemeral? */
-    ephemeral:boolean
-} | {
-    /**Did the message get sent successfully? */
-    success:false
-}
-
-/**## ODResponderManager `class`
- * This is an Open Discord responder manager.
- * 
- * It contains all Open Discord responders. Responders can respond to an interaction, button, dropdown, modal or command.
- * 
- * Using the Open Discord responder system has a few advantages compared to vanilla discord.js:
- * - plugins can extend/edit replies
- * - automatically reply on error
- * - independent workers (with priority)
- * - fail-safe design using try-catch
- * - write code once => reply to both slash & text commands at the same time!
- * - know where the request came from & parse options/subcommands & without errors!
- * - And so much more!
- */
-export class ODResponderManager<
-    CommandIdList extends ODCommandResponderManagerIdConstraint = ODCommandResponderManagerIdConstraint,
-    ButtonIdList extends ODButtonResponderManagerIdConstraint = ODButtonResponderManagerIdConstraint,
-    DropdownIdList extends ODDropdownResponderManagerIdConstraint = ODDropdownResponderManagerIdConstraint,
-    ModalIdList extends ODModalResponderManagerIdConstraint = ODModalResponderManagerIdConstraint,
-    ContextMenuIdList extends ODContextMenuResponderManagerIdConstraint = ODContextMenuResponderManagerIdConstraint,
-    AutocompleteIdList extends ODAutocompleteResponderManagerIdConstraint = ODAutocompleteResponderManagerIdConstraint
-> {
-    /**A manager for all (text & slash) command responders. */
-    commands: ODCommandResponderManager<CommandIdList>
-    /**A manager for all button responders. */
-    buttons: ODButtonResponderManager<ButtonIdList>
-    /**A manager for all dropdown/select menu responders. */
-    dropdowns: ODDropdownResponderManager<DropdownIdList>
-    /**A manager for all modal responders. */
-    modals: ODModalResponderManager<ModalIdList>
-    /**A manager for all context menu responders. */
-    contextMenus: ODContextMenuResponderManager<ContextMenuIdList>
-    /**A manager for all autocomplete responders. */
-    autocomplete: ODAutocompleteResponderManager<AutocompleteIdList>
-
-    constructor(debug:ODDebugger, client:ODClientManager){
-        this.commands = new ODCommandResponderManager(debug,"command responder",client)
-        this.buttons = new ODButtonResponderManager(debug,"button responder",client)
-        this.dropdowns = new ODDropdownResponderManager(debug,"dropdown responder",client)
-        this.modals = new ODModalResponderManager(debug,"modal responder",client)
-        this.contextMenus = new ODContextMenuResponderManager(debug,"context menu responder",client)
-        this.autocomplete = new ODAutocompleteResponderManager(debug,"autocomplete responder",client)
-    }
-}
-
-/**## 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.
- */
-export type ODCommandResponderManagerIdConstraint = Record<string,{origin:"slash"|"text",params:object,workers:string}>
-
-/**## ODCommandResponderManager `class`
- * This is an Open Discord command responder manager.
- * 
- * It contains all Open Discord command responders. These can respond to text & slash commands.
- * 
- * Using the Open Discord responder system has a few advantages compared to vanilla discord.js:
- * - plugins can extend/edit replies
- * - automatically reply on error
- * - independent workers (with priority)
- * - fail-safe design using try-catch
- * - write code once => reply to both slash & text commands at the same time!
- * - know where the request came from & parse options/subcommands & without errors!
- * - And so much more!
- */
-export class ODCommandResponderManager<IdList extends ODCommandResponderManagerIdConstraint = ODCommandResponderManagerIdConstraint> extends ODManager<ODCommandResponder<"slash"|"text",any>> {
-    /**An alias to the Open Discord client manager. */
-    private client: ODClientManager
-    /**The callback executed when the default workers take too much time to reply. */
-    private timeoutErrorCallback: ODResponderTimeoutErrorCallback<ODCommandResponderInstance,"slash"|"text">|null = null
-    /**The amount of milliseconds before the timeout error callback is executed. */
-    private timeoutMs: number|null = null
-    
-    constructor(debug:ODDebugger, debugname:string, client:ODClientManager){
-        super(debug,debugname)
-        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
-    }
-
-    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) => {
-            const newData = this.get(data.id)
-            if (!newData) return
-            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) => {
-            const newData = this.get(data.id)
-            if (!newData) return
-            newData.respond(new ODCommandResponderInstance(interaction,cmd,this.timeoutErrorCallback,this.timeoutMs,options),"text",{})
-        })
-
-        return res
-    }
-
-    get<CommandResponderId extends keyof ODNoGeneric<IdList>>(id:CommandResponderId): ODCommandResponder<IdList[CommandResponderId]["origin"],IdList[CommandResponderId]["params"],IdList[CommandResponderId]["workers"]>
-    get(id:ODValidId): ODCommandResponder<"slash"|"text",any>|null
-    
-    get(id:ODValidId): ODCommandResponder<"slash"|"text",any>|null {
-        return super.get(id)
-    }
-
-    remove<CommandResponderId extends keyof ODNoGeneric<IdList>>(id:CommandResponderId): ODCommandResponder<IdList[CommandResponderId]["origin"],IdList[CommandResponderId]["params"],IdList[CommandResponderId]["workers"]>
-    remove(id:ODValidId): ODCommandResponder<"slash"|"text",any>|null
-    
-    remove(id:ODValidId): ODCommandResponder<"slash"|"text",any>|null {
-        return super.remove(id)
-    }
-
-    exists(id:keyof ODNoGeneric<IdList>): boolean
-    exists(id:ODValidId): boolean
-    
-    exists(id:ODValidId): boolean {
-        return super.exists(id)
-    }
-}
-
-/**## ODCommandResponderInstanceOptions `class`
- * This is an Open Discord command responder instance options manager.
- * 
- * This class will manage all options & subcommands from slash & text commands.
- */
-export class ODCommandResponderInstanceOptions {
-    /**The interaction to get data from. */
-    private interaction: discord.ChatInputCommandInteraction|discord.Message
-    /**The command which is related to the interaction. */
-    private cmd:ODSlashCommand|ODTextCommand
-    /**A list of options which have been parsed by the text command parser. */
-    private options: ODTextCommandInteractionOption[]
-
-    constructor(interaction:discord.ChatInputCommandInteraction|discord.Message, cmd:ODSlashCommand|ODTextCommand, options?:ODTextCommandInteractionOption[]){
-        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){
-            try {
-                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)
-            if (opt && typeof opt.value == "string") return opt.value
-            else return null
-
-        }else return null
-    }
-    /**Get a boolean option. */
-    getBoolean(name:string,required:true): boolean
-    getBoolean(name:string,required:false): boolean|null
-    getBoolean(name:string,required:boolean){
-        if (this.interaction instanceof discord.ChatInputCommandInteraction){
-            try {
-                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)
-            if (opt && typeof opt.value == "boolean") return opt.value
-            else return null
-
-        }else return null
-    }
-    /**Get a number option. */
-    getNumber(name:string,required:true): number
-    getNumber(name:string,required:false): number|null
-    getNumber(name:string,required:boolean){
-        if (this.interaction instanceof discord.ChatInputCommandInteraction){
-            try {
-                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)
-            if (opt && typeof opt.value == "number") return opt.value
-            else return null
-
-        }else return null
-    }
-    /**Get a channel option. */
-    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){
-            try {
-                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)
-            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
-
-        }else return null
-    }
-    /**Get a role option. */
-    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){
-            try {
-                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)
-            if (opt && opt.value instanceof discord.Role) return opt.value
-            else return null
-
-        }else return null
-    }
-    /**Get a user option. */
-    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){
-            try {
-                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)
-            if (opt && opt.value instanceof discord.User) return opt.value
-            else return null
-
-        }else return null
-    }
-    /**Get a guild member option. */
-    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){
-            try {
-                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)
-            if (opt && opt.value instanceof discord.GuildMember) return opt.value
-            else return null
-
-        }else return null
-    }
-    /**Get a mentionable option. */
-    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){
-            try {
-                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)
-            if (opt && (opt.value instanceof discord.User || opt.value instanceof discord.GuildMember || opt.value instanceof discord.Role)) return opt.value
-            else return null
-
-        }else return null
-    }
-    /**Get a subgroup. */
-    getSubGroup(): string|null
-    getSubGroup(){
-        if (this.interaction instanceof discord.ChatInputCommandInteraction){
-            try {
-                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){
-            //0: name, 1:sub/group, 2:sub
-            const splittedName: string[] = this.cmd.builder.name.split(" ")
-            return splittedName[1] ?? null
-
-        }else return null
-    }
-    /**Get a subcommand. */
-    getSubCommand(): string|null
-    getSubCommand(){
-        if (this.interaction instanceof discord.ChatInputCommandInteraction){
-            try {
-                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){
-            //0: name, 1:sub/group, 2:sub
-            const splittedName: string[] = this.cmd.builder.name.split(" ")
-            
-            //return the second subcommand when there is a subgroup
-            if (splittedName.length > 2){
-                return splittedName[2] ?? null
-            }else return splittedName[1] ?? null
-
-        }else return null
-    }
-}
-
-
-/**## ODCommandResponderInstance `class`
- * This is an Open Discord command responder instance.
- * 
- * 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 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. */
-    cmd:ODSlashCommand|ODTextCommand
-    /**The type/source of instance. (from text or slash command) */
-    type: "message"|"interaction"
-    /**Switches to `true` when a worker replies, edits or defers interaction. Will stop the timeout error from being shown. */
-    protected ignoreResponderTimeout: boolean = false
-    /**The manager for all options of this command. */
-    options: ODCommandResponderInstanceOptions
-    /**The user who triggered this command. */
-    user: discord.User
-    /**The guild member who triggered this command. */
-    member: discord.GuildMember|null
-    /**The guild where this command was triggered. */
-    guild: discord.Guild|null
-    /**The channel where this command was triggered. */
-    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
-        this.type = (interaction instanceof discord.Message) ? "message" : "interaction"
-        this.options = new ODCommandResponderInstanceOptions(interaction,cmd,options)
-        this.user = (interaction instanceof discord.Message) ? interaction.author : interaction.user
-        this.member = (interaction.member instanceof discord.GuildMember) ? interaction.member : null
-        this.guild = interaction.guild
-        this.channel = interaction.channel
-
-
-        setTimeout(async () => {
-            if (this.ignoreResponderTimeout) return
-            try {
-                if (!errorCallback){
-                    this.reply({id:new ODId("opendiscord:unknown-error"), ephemeral:true, message:{
-                        content:":x: **Something went wrong while replying to this command!**"
-                    }})
-                }else{
-                    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){
-                process.emit("uncaughtException",err)
-            }
-        },timeoutMs ?? 2500)
-    }
-
-    /**Reply to this command. */
-    async reply(build:ODMessageBuildResult|ODMessageComponentBuildResult): Promise<ODResponderSendResult<boolean>> {
-        try {
-            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(finalMessage)
-                    this.ignoreResponderTimeout = true
-                    return {success:true,message:sent,ephemeral:build.ephemeral}
-                }else{
-                    const sent = await this.interaction.reply(finalMessage)
-                    this.ignoreResponderTimeout = true
-                    return {success:true,message:await sent.fetch(),ephemeral:build.ephemeral}
-                }
-            }else if (this.type == "message" && this.interaction instanceof discord.Message && this.interaction.channel.type != discord.ChannelType.GroupDM){
-                const sent = await this.interaction.channel.send(finalMessage)
-                this.ignoreResponderTimeout = true
-                return {success:true,message:sent,ephemeral:false}
-            }else return {success:false}
-        }catch{
-            return {success:false}
-        }
-    }
-    /**Defer this command. */
-    async defer(ephemeral:boolean){
-        this.ignoreResponderTimeout = true
-        if (this.type != "interaction" || !(this.interaction instanceof discord.ChatInputCommandInteraction)) return false
-        if (this.interaction.deferred || this.interaction.replied) return false
-        const msgFlags: number[] = ephemeral ? [discord.MessageFlags.Ephemeral] : []
-        await this.interaction.deferReply({flags:msgFlags})
-        return true
-    }
-    /**Show a modal as reply to this command. */
-    async modal(modal:ODModalBuildResult){
-        this.ignoreResponderTimeout = true
-        if (this.type != "interaction" || !(this.interaction instanceof discord.ChatInputCommandInteraction)) return false
-        if (this.interaction.deferred || this.interaction.replied) return false
-        await this.interaction.showModal(modal.modal)
-        return true
-    }
-}
-
-/**## ODCommandResponder `class`
- * This is an Open Discord command responder.
- * 
- * This class manages all workers which are executed when the related command is triggered.
- */
-export class ODCommandResponder<Origin extends "slash"|"text",Params,WorkerIds extends string = string> extends ODResponderImplementation<ODCommandResponderInstance,Origin,Params,WorkerIds> {
-    /**The prefix of the text command needs to match this */
-    prefix: string
-    
-    constructor(id:ODValidId, prefix:string, match:string|RegExp, callback?:ODWorkerCallback<ODCommandResponderInstance,Origin,Params>, priority?:number, callbackId?:ODValidId){
-        super(id,match,callback,priority,callbackId)
-        this.prefix = prefix
-    }
-
-    /**Respond to this command */
-    async respond(instance:ODCommandResponderInstance, origin:Origin, params:Params){
-        //wait for workers to finish
-        await this.workers.executeWorkers(instance,origin,params)
-    }
-}
-
-/**## ODButtonResponderManagerIdConstraint `type`
- * The constraint/layout for id mappings/interfaces of the `ODButtonResponderManager` class.
- */
-export type ODButtonResponderManagerIdConstraint = Record<string,{origin:"button",params:object,workers:string}>
-
-/**## ODButtonResponderManager `class`
- * This is an Open Discord button responder manager.
- * 
- * It contains all Open Discord button responders. These can respond to button interactions.
- * 
- * Using the Open Discord responder system has a few advantages compared to vanilla discord.js:
- * - plugins can extend/edit replies
- * - automatically reply on error
- * - independent workers (with priority)
- * - fail-safe design using try-catch
- * - know where the request came from!
- * - And so much more!
- */
-export class ODButtonResponderManager<IdList extends ODButtonResponderManagerIdConstraint = ODButtonResponderManagerIdConstraint> extends ODManager<ODButtonResponder<"button",any>> {
-    /**An alias to the Open Discord client manager. */
-    private client: ODClientManager
-    /**The callback executed when the default workers take too much time to reply. */
-    private timeoutErrorCallback: ODResponderTimeoutErrorCallback<ODButtonResponderInstance,"button">|null = null
-    /**The amount of milliseconds before the timeout error callback is executed. */
-    private timeoutMs: number|null = null
-    /**A list of listeners which will listen to the raw interactionCreate event from discord.js */
-    private listeners: ((interaction:discord.ButtonInteraction) => void)[] = []
-
-    constructor(debug:ODDebugger, debugname:string, client:ODClientManager){
-        super(debug,debugname)
-        this.client = client
-
-        this.client.client.on("interactionCreate",(interaction) => {
-            if (!interaction.isButton()) return
-            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
-    }
-
-    add(data:ODButtonResponder<"button",any>, overwrite?:boolean){
-        const res = super.add(data,overwrite)
-        
-        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",{})
-        })
-
-        return res
-    }
-
-    get<ButtonResponderId extends keyof ODNoGeneric<IdList>>(id:ButtonResponderId): ODButtonResponder<IdList[ButtonResponderId]["origin"],IdList[ButtonResponderId]["params"],IdList[ButtonResponderId]["workers"]>
-    get(id:ODValidId): ODButtonResponder<"button",any>|null
-    
-    get(id:ODValidId): ODButtonResponder<"button",any>|null {
-        return super.get(id)
-    }
-
-    remove<ButtonResponderId extends keyof ODNoGeneric<IdList>>(id:ButtonResponderId): ODButtonResponder<IdList[ButtonResponderId]["origin"],IdList[ButtonResponderId]["params"],IdList[ButtonResponderId]["workers"]>
-    remove(id:ODValidId): ODButtonResponder<"button",any>|null
-    
-    remove(id:ODValidId): ODButtonResponder<"button",any>|null {
-        return super.remove(id)
-    }
-
-    exists(id:keyof ODNoGeneric<IdList>): boolean
-    exists(id:ODValidId): boolean
-    
-    exists(id:ODValidId): boolean {
-        return super.exists(id)
-    }
-}
-
-/**## ODButtonResponderInstance `class`
- * This is an Open Discord button responder instance.
- * 
- * An instance is an active button interaction. You can reply to the button using `reply()`.
- */
-export class ODButtonResponderInstance extends ODBaseResponderInstance {
-    /**The interaction which is the source of this instance. */
-    interaction: discord.ButtonInteraction
-    /**Switches to `true` when a worker replies, edits or defers interaction. Will stop the timeout error from being shown. */
-    protected ignoreResponderTimeout: boolean = false
-    /**The user who triggered this button. */
-    user: discord.User
-    /**The guild member who triggered this button. */
-    member: discord.GuildMember|null
-    /**The guild where this button was triggered. */
-    guild: discord.Guild|null
-    /**The channel where this button was triggered. */
-    channel: discord.TextBasedChannel
-    /**The message this button originates from. */
-    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
-        this.member = (interaction.member instanceof discord.GuildMember) ? interaction.member : null
-        this.guild = interaction.guild
-        this.channel = interaction.channel
-        this.message = interaction.message
-        
-        setTimeout(async () => {
-            if (this.ignoreResponderTimeout) return
-            try {
-                if (!errorCallback){
-                    this.reply({id:new ODId("opendiscord:unknown-error"), ephemeral:true, message:{
-                        content:":x: **Something went wrong while replying to this button!**"
-                    }})
-                }else{
-                    await errorCallback(this,"button")
-                }
-                
-            }catch(err){
-                process.emit("uncaughtException",err)
-            }
-        },timeoutMs ?? 2500)
-    }
-
-    /**Reply to this button. */
-    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(finalMessage)
-                this.ignoreResponderTimeout = true
-                return {success:true,message:sent,ephemeral:build.ephemeral}
-            }else{
-                const sent = await this.interaction.reply(finalMessage)
-                this.ignoreResponderTimeout = true
-                return {success:true,message:await sent.fetch(),ephemeral:build.ephemeral}
-            }
-        }catch{
-            return {success:false}
-        }
-    }
-    /**Update the message of this button. */
-    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(finalMessage)
-                this.ignoreResponderTimeout = true
-                return {success:true,message:await sent.fetch(),ephemeral:build.ephemeral}
-            }else{
-                const sent = await this.interaction.update(finalMessage)
-                this.ignoreResponderTimeout = true
-                return {success:true,message:await sent.fetch(),ephemeral:build.ephemeral}
-            }
-        }catch{
-            return {success:false}
-        }
-    }
-    /**Defer this button. */
-    async defer(type:"reply"|"update", ephemeral:boolean){
-        this.ignoreResponderTimeout = true
-        if (this.interaction.deferred || this.interaction.replied) return false
-        if (type == "reply"){
-            const msgFlags: number[] = ephemeral ? [discord.MessageFlags.Ephemeral] : []
-            await this.interaction.deferReply({flags:msgFlags})
-        }else{
-            await this.interaction.deferUpdate()
-        }
-        return true
-    }
-    /**Show a modal as reply to this button. */
-    async modal(modal:ODModalBuildResult){
-        this.ignoreResponderTimeout = true
-        if (this.interaction.deferred || this.interaction.replied) return false
-        await this.interaction.showModal(modal.modal)
-        return true
-    }
-
-    /**Get a component from the original message of this button. */
-    getMessageComponent(type:"button",id:string|RegExp): discord.ButtonComponent|null
-    getMessageComponent(type:"string-dropdown",id:string|RegExp): discord.StringSelectMenuComponent|null
-    getMessageComponent(type:"user-dropdown",id:string|RegExp): discord.UserSelectMenuComponent|null
-    getMessageComponent(type:"channel-dropdown",id:string|RegExp): discord.ChannelSelectMenuComponent|null
-    getMessageComponent(type:"role-dropdown",id:string|RegExp): discord.RoleSelectMenuComponent|null
-    getMessageComponent(type:"mentionable-dropdown",id:string|RegExp): discord.MentionableSelectMenuComponent|null
-
-    getMessageComponent(type:"button"|"string-dropdown"|"user-dropdown"|"channel-dropdown"|"role-dropdown"|"mentionable-dropdown", id:string|RegExp): discord.ButtonComponent|discord.StringSelectMenuComponent|discord.RoleSelectMenuComponent|discord.ChannelSelectMenuComponent|discord.MentionableSelectMenuComponent|discord.UserSelectMenuComponent|null {
-        let result: discord.ButtonComponent|discord.StringSelectMenuComponent|discord.RoleSelectMenuComponent|discord.ChannelSelectMenuComponent|discord.MentionableSelectMenuComponent|discord.UserSelectMenuComponent|null = null
-        this.message.components.forEach((row) => {
-            if (row.type != discord.ComponentType.ActionRow) return
-            row.components.forEach((component) => {
-                if (type == "button" && component.type == discord.ComponentType.Button && component.customId && ((typeof id == "string") ? component.customId == id : id.test(component.customId))) result = component
-                else if (type == "string-dropdown" && component.type == discord.ComponentType.StringSelect && component.customId && ((typeof id == "string") ? component.customId == id : id.test(component.customId))) result = component
-                else if (type == "user-dropdown" && component.type == discord.ComponentType.UserSelect && component.customId && ((typeof id == "string") ? component.customId == id : id.test(component.customId))) result = component
-                else if (type == "channel-dropdown" && component.type == discord.ComponentType.ChannelSelect && component.customId && ((typeof id == "string") ? component.customId == id : id.test(component.customId))) result = component
-                else if (type == "role-dropdown" && component.type == discord.ComponentType.RoleSelect && component.customId && ((typeof id == "string") ? component.customId == id : id.test(component.customId))) result = component
-                else if (type == "mentionable-dropdown" && component.type == discord.ComponentType.MentionableSelect && component.customId && ((typeof id == "string") ? component.customId == id : id.test(component.customId))) result = component
-            })
-        })
-
-        return result
-    }
-
-    /**Get the first embed of the original message if it exists. */
-    getMessageEmbed(): discord.Embed|null {
-        return this.message.embeds[0] ?? null
-    }
-}
-
-/**## ODButtonResponder `class`
- * This is an Open Discord button responder.
- * 
- * This class manages all workers which are executed when the related button is triggered.
- */
-export class ODButtonResponder<Origin extends string,Params,WorkerIds extends string = string> extends ODResponderImplementation<ODButtonResponderInstance,Origin,Params,WorkerIds> {
-    /**Respond to this button */
-    async respond(instance:ODButtonResponderInstance, origin:Origin, params:Params){
-        //wait for workers to finish
-        await this.workers.executeWorkers(instance,origin,params)
-    }
-}
-
-/**## ODDropdownResponderManagerIdConstraint `type`
- * The constraint/layout for id mappings/interfaces of the `ODDropdownResponderManager` class.
- */
-export type ODDropdownResponderManagerIdConstraint = Record<string,{origin:"dropdown",params:object,workers:string}>
-
-/**## ODDropdownResponderManager `class`
- * This is an Open Discord dropdown responder manager.
- * 
- * It contains all Open Discord dropdown responders. These can respond to dropdown interactions.
- * 
- * Using the Open Discord responder system has a few advantages compared to vanilla discord.js:
- * - plugins can extend/edit replies
- * - automatically reply on error
- * - independent workers (with priority)
- * - fail-safe design using try-catch
- * - know where the request came from!
- * - And so much more!
- */
-export class ODDropdownResponderManager<IdList extends ODDropdownResponderManagerIdConstraint = ODDropdownResponderManagerIdConstraint> extends ODManager<ODDropdownResponder<"dropdown",any>> {
-    /**An alias to the Open Discord client manager. */
-    private client: ODClientManager
-    /**The callback executed when the default workers take too much time to reply. */
-    private timeoutErrorCallback: ODResponderTimeoutErrorCallback<ODDropdownResponderInstance,"dropdown">|null = null
-    /**The amount of milliseconds before the timeout error callback is executed. */
-    private timeoutMs: number|null = null
-    /**A list of listeners which will listen to the raw interactionCreate event from discord.js */
-    private listeners: ((interaction:discord.AnySelectMenuInteraction) => void)[] = []
-
-    constructor(debug:ODDebugger, debugname:string, client:ODClientManager){
-        super(debug,debugname)
-        this.client = client
-
-        this.client.client.on("interactionCreate",(interaction) => {
-            if (!interaction.isAnySelectMenu()) return
-            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
-    }
-
-    add(data:ODDropdownResponder<"dropdown",any>, overwrite?:boolean){
-        const res = super.add(data,overwrite)
-        
-        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",{})
-        })
-
-        return res
-    }
-
-    get<DropdownResponderId extends keyof ODNoGeneric<IdList>>(id:DropdownResponderId): ODDropdownResponder<IdList[DropdownResponderId]["origin"],IdList[DropdownResponderId]["params"],IdList[DropdownResponderId]["workers"]>
-    get(id:ODValidId): ODDropdownResponder<"dropdown",any>|null
-    
-    get(id:ODValidId): ODDropdownResponder<"dropdown",any>|null {
-        return super.get(id)
-    }
-
-    remove<DropdownResponderId extends keyof ODNoGeneric<IdList>>(id:DropdownResponderId): ODDropdownResponder<IdList[DropdownResponderId]["origin"],IdList[DropdownResponderId]["params"],IdList[DropdownResponderId]["workers"]>
-    remove(id:ODValidId): ODDropdownResponder<"dropdown",any>|null
-    
-    remove(id:ODValidId): ODDropdownResponder<"dropdown",any>|null {
-        return super.remove(id)
-    }
-
-    exists(id:keyof ODNoGeneric<IdList>): boolean
-    exists(id:ODValidId): boolean
-    
-    exists(id:ODValidId): boolean {
-        return super.exists(id)
-    }
-}
-
-/**## ODDropdownResponderInstanceValues `class`
- * This is an Open Discord dropdown responder instance values manager.
- * 
- * This class will manage all values from the dropdowns & select menus.
- */
-export class ODDropdownResponderInstanceValues {
-    /**The interaction to get data from. */
-    private interaction: discord.AnySelectMenuInteraction
-    /**The type of this dropdown. */
-    private type: ODDropdownData["type"]
-
-    constructor(interaction:discord.AnySelectMenuInteraction, type:ODDropdownData["type"]){
-        this.interaction = interaction
-        this.type = type
-
-        if (interaction.isChannelSelectMenu()){
-            interaction.values
-        }
-    }
-
-    /**Get the selected values. */
-    getStringValues(): string[] {
-        try {
-            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!")
-        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)
-                if (role) result.push(role)
-            }
-            return result
-        }catch{
-            throw new ODSystemError("ODDropdownResponderInstanceValues:getRoleValues() invalid values!")
-        }
-    }
-    /**Get the selected users. */
-    async getUserValues(): Promise<discord.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)
-                if (user) result.push(user)
-            }
-            return result
-        }catch{
-            throw new ODSystemError("ODDropdownResponderInstanceValues:getUserValues() invalid values!")
-        }
-    }
-    /**Get the selected channels. */
-    async getChannelValues(): Promise<discord.GuildBasedChannel[]> {
-        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)
-                if (guild) result.push(guild)
-            }
-            return result
-        }catch{
-            throw new ODSystemError("ODDropdownResponderInstanceValues:getChannelValues() invalid values!")
-        }
-    }
-}
-
-/**## ODDropdownResponderInstance `class`
- * This is an Open Discord dropdown responder instance.
- * 
- * An instance is an active dropdown interaction. You can reply to the dropdown using `reply()`.
- */
-export class ODDropdownResponderInstance extends ODBaseResponderInstance {
-    /**The interaction which is the source of this instance. */
-    interaction: discord.AnySelectMenuInteraction
-    /**Switches to `true` when a worker replies, edits or defers interaction. Will stop the timeout error from being shown. */
-    protected ignoreResponderTimeout: boolean = false
-    /**The dropdown type. */
-    type: ODDropdownData["type"]
-    /**The manager for all values of this dropdown. */
-    values: ODDropdownResponderInstanceValues
-    /**The user who triggered this dropdown. */
-    user: discord.User
-    /**The guild member who triggered this dropdown. */
-    member: discord.GuildMember|null
-    /**The guild where this dropdown was triggered. */
-    guild: discord.Guild|null
-    /**The channel where this dropdown was triggered. */
-    channel: discord.TextBasedChannel
-    /**The message this dropdown originates from. */
-    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()){
-            this.type = "string"
-        }else if (interaction.isRoleSelectMenu()){
-            this.type = "role"
-        }else if (interaction.isUserSelectMenu()){
-            this.type = "user"
-        }else if (interaction.isChannelSelectMenu()){
-            this.type = "channel"
-        }else if (interaction.isMentionableSelectMenu()){
-            this.type = "mentionable"
-        }else throw new ODSystemError("ODDropdownResponderInstance: invalid dropdown type!")
-        
-        this.values = new ODDropdownResponderInstanceValues(interaction,this.type)
-        this.user = interaction.user
-        this.member = (interaction.member instanceof discord.GuildMember) ? interaction.member : null
-        this.guild = interaction.guild
-        this.channel = interaction.channel
-        this.message = interaction.message
-        
-        setTimeout(async () => {
-            if (this.ignoreResponderTimeout) return
-            try {
-                if (!errorCallback){
-                    this.reply({id:new ODId("opendiscord:unknown-error"), ephemeral:true, message:{
-                        content:":x: **Something went wrong while replying to this dropdown!**"
-                    }})
-                }else{
-                    await errorCallback(this,"dropdown")
-                }
-                
-            }catch(err){
-                process.emit("uncaughtException",err)
-            }
-        },timeoutMs ?? 2500)
-    }
-
-    /**Reply to this dropdown. */
-    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(finalMessage)
-                this.ignoreResponderTimeout = true
-                return {success:true,message:sent,ephemeral:build.ephemeral}
-            }else{
-                const sent = await this.interaction.reply(finalMessage)
-                this.ignoreResponderTimeout = true
-                return {success:true,message:await sent.fetch(),ephemeral:build.ephemeral}
-            }
-        }catch{
-            return {success:false}
-        }
-    }
-    /**Update the message of this dropdown. */
-    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(finalMessage)
-                this.ignoreResponderTimeout = true
-                return {success:true,message:await sent.fetch(),ephemeral:build.ephemeral}
-            }else{
-                const sent = await this.interaction.update(finalMessage)
-                this.ignoreResponderTimeout = true
-                return {success:true,message:await sent.fetch(),ephemeral:build.ephemeral}
-            }
-        }catch{
-            return {success:false}
-        }
-    }
-    /**Defer this dropdown. */
-    async defer(type:"reply"|"update", ephemeral:boolean){
-        this.ignoreResponderTimeout = true
-        if (this.interaction.deferred || this.interaction.replied) return false
-        if (type == "reply"){
-            const msgFlags: number[] = ephemeral ? [discord.MessageFlags.Ephemeral] : []
-            await this.interaction.deferReply({flags:msgFlags})
-        }else{
-            await this.interaction.deferUpdate()
-        }
-        return true
-    }
-    /**Show a modal as reply to this dropdown. */
-    async modal(modal:ODModalBuildResult){
-        this.ignoreResponderTimeout = true
-        if (this.interaction.deferred || this.interaction.replied) return false
-        await this.interaction.showModal(modal.modal)
-        return true
-    }
-
-    /**Get a component from the original message of this dropdown. */
-    getMessageComponent(type:"button",id:string|RegExp): discord.ButtonComponent|null
-    getMessageComponent(type:"string-dropdown",id:string|RegExp): discord.StringSelectMenuComponent|null
-    getMessageComponent(type:"user-dropdown",id:string|RegExp): discord.UserSelectMenuComponent|null
-    getMessageComponent(type:"channel-dropdown",id:string|RegExp): discord.ChannelSelectMenuComponent|null
-    getMessageComponent(type:"role-dropdown",id:string|RegExp): discord.RoleSelectMenuComponent|null
-    getMessageComponent(type:"mentionable-dropdown",id:string|RegExp): discord.MentionableSelectMenuComponent|null
-
-    getMessageComponent(type:"button"|"string-dropdown"|"user-dropdown"|"channel-dropdown"|"role-dropdown"|"mentionable-dropdown", id:string|RegExp): discord.ButtonComponent|discord.StringSelectMenuComponent|discord.RoleSelectMenuComponent|discord.ChannelSelectMenuComponent|discord.MentionableSelectMenuComponent|discord.UserSelectMenuComponent|null {
-        let result: discord.ButtonComponent|discord.StringSelectMenuComponent|discord.RoleSelectMenuComponent|discord.ChannelSelectMenuComponent|discord.MentionableSelectMenuComponent|discord.UserSelectMenuComponent|null = null
-        this.message.components.forEach((row) => {
-            if (row.type != discord.ComponentType.ActionRow) return
-            row.components.forEach((component) => {
-                if (type == "button" && component.type == discord.ComponentType.Button && component.customId && ((typeof id == "string") ? component.customId == id : id.test(component.customId))) result = component
-                else if (type == "string-dropdown" && component.type == discord.ComponentType.StringSelect && component.customId && ((typeof id == "string") ? component.customId == id : id.test(component.customId))) result = component
-                else if (type == "user-dropdown" && component.type == discord.ComponentType.UserSelect && component.customId && ((typeof id == "string") ? component.customId == id : id.test(component.customId))) result = component
-                else if (type == "channel-dropdown" && component.type == discord.ComponentType.ChannelSelect && component.customId && ((typeof id == "string") ? component.customId == id : id.test(component.customId))) result = component
-                else if (type == "role-dropdown" && component.type == discord.ComponentType.RoleSelect && component.customId && ((typeof id == "string") ? component.customId == id : id.test(component.customId))) result = component
-                else if (type == "mentionable-dropdown" && component.type == discord.ComponentType.MentionableSelect && component.customId && ((typeof id == "string") ? component.customId == id : id.test(component.customId))) result = component
-            })
-        })
-
-        return result
-    }
-
-    /**Get the first embed of the original message if it exists. */
-    getMessageEmbed(): discord.Embed|null {
-        return this.message.embeds[0] ?? null
-    }
-}
-
-/**## ODDropdownResponder `class`
- * This is an Open Discord dropdown responder.
- * 
- * This class manages all workers which are executed when the related dropdown is triggered.
- */
-export class ODDropdownResponder<Origin extends string,Params,WorkerIds extends string = string> extends ODResponderImplementation<ODDropdownResponderInstance,Origin,Params,WorkerIds> {
-    /**Respond to this dropdown */
-    async respond(instance:ODDropdownResponderInstance, origin:Origin, params:Params){
-        //wait for workers to finish
-        await this.workers.executeWorkers(instance,origin,params)
-    }
-}
-
-/**## ODModalResponderManagerIdConstraint `type`
- * The constraint/layout for id mappings/interfaces of the `ODModalResponderManager` class.
- */
-export type ODModalResponderManagerIdConstraint = Record<string,{origin:"modal",params:object,workers:string}>
-
-/**## ODModalResponderManager `class`
- * This is an Open Discord modal responder manager.
- * 
- * It contains all Open Discord modal responders. These can respond to modal interactions.
- * 
- * Using the Open Discord responder system has a few advantages compared to vanilla discord.js:
- * - plugins can extend/edit replies
- * - automatically reply on error
- * - independent workers (with priority)
- * - fail-safe design using try-catch
- * - know where the request came from!
- * - And so much more!
- */
-export class ODModalResponderManager<IdList extends ODModalResponderManagerIdConstraint = ODModalResponderManagerIdConstraint> extends ODManager<ODModalResponder<"modal",any>> {
-    /**An alias to the Open Discord client manager. */
-    private client: ODClientManager
-    /**The callback executed when the default workers take too much time to reply. */
-    private timeoutErrorCallback: ODResponderTimeoutErrorCallback<ODModalResponderInstance,"modal">|null = null
-    /**The amount of milliseconds before the timeout error callback is executed. */
-    private timeoutMs: number|null = null
-    /**A list of listeners which will listen to the raw interactionCreate event from discord.js */
-    private listeners: ((interaction:discord.ModalSubmitInteraction) => void)[] = []
-
-    constructor(debug:ODDebugger, debugname:string, client:ODClientManager){
-        super(debug,debugname)
-        this.client = client
-
-        this.client.client.on("interactionCreate",(interaction) => {
-            if (!interaction.isModalSubmit()) return
-            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
-    }
-
-    add(data:ODModalResponder<"modal",any>, overwrite?:boolean){
-        const res = super.add(data,overwrite)
-        
-        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",{})
-        })
-
-        return res
-    }
-
-    get<ModalResponderId extends keyof ODNoGeneric<IdList>>(id:ModalResponderId): ODModalResponder<IdList[ModalResponderId]["origin"],IdList[ModalResponderId]["params"],IdList[ModalResponderId]["workers"]>
-    get(id:ODValidId): ODModalResponder<"modal",any>|null
-    
-    get(id:ODValidId): ODModalResponder<"modal",any>|null {
-        return super.get(id)
-    }
-
-    remove<ModalResponderId extends keyof ODNoGeneric<IdList>>(id:ModalResponderId): ODModalResponder<IdList[ModalResponderId]["origin"],IdList[ModalResponderId]["params"],IdList[ModalResponderId]["workers"]>
-    remove(id:ODValidId): ODModalResponder<"modal",any>|null
-    
-    remove(id:ODValidId): ODModalResponder<"modal",any>|null {
-        return super.remove(id)
-    }
-
-    exists(id:keyof ODNoGeneric<IdList>): boolean
-    exists(id:ODValidId): boolean
-    
-    exists(id:ODValidId): boolean {
-        return super.exists(id)
-    }
-}
-
-/**## ODModalResponderInstanceValues `class`
- * This is an Open Discord modal responder instance values manager.
- * 
- * This class will manage all fields from the modals.
- */
-export class ODModalResponderInstanceValues {
-    /**The interaction to get data from. */
-    private interaction: discord.ModalSubmitInteraction
-
-    constructor(interaction:discord.ModalSubmitInteraction){
-        this.interaction = interaction
-    }
-
-    /**Get the value of a text field. */
-    getTextField(name:string,required:true): string
-    getTextField(name:string,required:false): string|null
-    getTextField(name:string,required:boolean){
-        try {
-            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{
-            throw new ODSystemError("ODModalResponderInstanceValues:getTextField() field not found!")
-        }
-    }
-}
-
-/**## ODModalResponderInstance `class`
- * This is an Open Discord modal responder instance.
- * 
- * An instance is an active modal interaction. You can reply to the modal using `reply()`.
- */
-export class ODModalResponderInstance extends ODBaseResponderInstance {
-    /**The interaction which is the source of this instance. */
-    interaction: discord.ModalSubmitInteraction
-    /**Switches to `true` when a worker replies, edits or defers interaction. Will stop the timeout error from being shown. */
-    protected ignoreResponderTimeout: boolean = false
-    /**The manager for all fields of this modal. */
-    values: ODModalResponderInstanceValues
-    /**The user who triggered this modal. */
-    user: discord.User
-    /**The guild member who triggered this modal. */
-    member: discord.GuildMember|null
-    /**The guild where this modal was triggered. */
-    guild: discord.Guild|null
-    /**The channel where this modal was triggered. */
-    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
-        this.member = (interaction.member instanceof discord.GuildMember) ? interaction.member : null
-        this.guild = interaction.guild
-        this.channel = interaction.channel
-        
-        setTimeout(async () => {
-            if (this.ignoreResponderTimeout) return
-            try {
-                if (!errorCallback){
-                    this.reply({id:new ODId("opendiscord:unknown-error"), ephemeral:true, message:{
-                        content:":x: **Something went wrong while replying to this modal!**"
-                    }})
-                }else{
-                    await errorCallback(this,"modal")
-                }
-                
-            }catch(err){
-                process.emit("uncaughtException",err)
-            }
-        },timeoutMs ?? 2500)
-    }
-
-    /**Reply to this modal. */
-    async reply(build:ODMessageBuildResult|ODMessageComponentBuildResult): Promise<ODResponderSendResult<boolean>> {
-        try {
-            const finalMessage = this.getMessageFromBuildResult(build,"interaction")
-            const sent = await this.interaction.followUp(finalMessage)
-            this.ignoreResponderTimeout = true
-            return {success:true,message:sent,ephemeral:build.ephemeral}
-        }catch{
-            return {success:false}
-        }
-    }
-    /**Update the message of this modal. */
-    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(finalMessage)
-                this.ignoreResponderTimeout = true
-                return {success:true,message:await sent.fetch(),ephemeral:build.ephemeral}
-            }else{
-                const sent = await this.interaction.reply(finalMessage)
-                this.ignoreResponderTimeout = true
-                return {success:true,message:await sent.fetch(),ephemeral:build.ephemeral}
-            }
-        }catch{
-            return {success:false}
-        }
-    }
-    /**Defer this modal. */
-    async defer(type:"reply"|"update", ephemeral:boolean){
-        this.ignoreResponderTimeout = true
-        if (this.interaction.deferred || this.interaction.replied) return false
-        if (type == "reply"){
-            const msgFlags: number[] = ephemeral ? [discord.MessageFlags.Ephemeral] : []
-            await this.interaction.deferReply({flags:msgFlags})
-        }else{
-            await this.interaction.deferUpdate()
-        }
-        return true
-    }
-}
-
-/**## ODModalResponder `class`
- * This is an Open Discord modal responder.
- * 
- * This class manages all workers which are executed when the related modal is triggered.
- */
-export class ODModalResponder<Origin extends string,Params,WorkerIds extends string = string> extends ODResponderImplementation<ODModalResponderInstance,Origin,Params,WorkerIds> {
-    /**Respond to this modal */
-    async respond(instance:ODModalResponderInstance, origin:Origin, params:Params){
-        //wait for workers to finish
-        await this.workers.executeWorkers(instance,origin,params)
-    }
-}
-
-/**## ODContextMenuResponderManagerIdConstraint `type`
- * The constraint/layout for id mappings/interfaces of the `ODContextMenuResponderManager` class.
- */
-export type ODContextMenuResponderManagerIdConstraint = Record<string,{origin:"context-menu",params:object,workers:string}>
-
-/**## ODContextMenuResponderManager `class`
- * This is an Open Discord context menu responder manager.
- * 
- * It contains all Open Discord context menu responders. These can respond to user/message context menu interactions.
- * 
- * Using the Open Discord responder system has a few advantages compared to vanilla discord.js:
- * - plugins can extend/edit replies
- * - automatically reply on error
- * - independent workers (with priority)
- * - fail-safe design using try-catch
- * - know where the request came from!
- * - And so much more!
- */
-export class ODContextMenuResponderManager<IdList extends ODContextMenuResponderManagerIdConstraint = ODContextMenuResponderManagerIdConstraint> extends ODManager<ODContextMenuResponder<"context-menu",any>> {
-    /**An alias to the Open Discord client manager. */
-    private client: ODClientManager
-    /**The callback executed when the default workers take too much time to reply. */
-    private timeoutErrorCallback: ODResponderTimeoutErrorCallback<ODContextMenuResponderInstance,"context-menu">|null = null
-    /**The amount of milliseconds before the timeout error callback is executed. */
-    private timeoutMs: number|null = null
-
-    constructor(debug:ODDebugger, debugname:string, client:ODClientManager){
-        super(debug,debugname)
-        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
-    }
-
-    add(data:ODContextMenuResponder<"context-menu",any>, overwrite?:boolean){
-        const res = super.add(data,overwrite)
-        
-        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",{})
-        })
-
-        return res
-    }
-
-    get<ModalResponderId extends keyof ODNoGeneric<IdList>>(id:ModalResponderId): ODContextMenuResponder<IdList[ModalResponderId]["origin"],IdList[ModalResponderId]["params"],IdList[ModalResponderId]["workers"]>
-    get(id:ODValidId): ODContextMenuResponder<"context-menu",any>|null
-    
-    get(id:ODValidId): ODContextMenuResponder<"context-menu",any>|null {
-        return super.get(id)
-    }
-
-    remove<ModalResponderId extends keyof ODNoGeneric<IdList>>(id:ModalResponderId): ODContextMenuResponder<IdList[ModalResponderId]["origin"],IdList[ModalResponderId]["params"],IdList[ModalResponderId]["workers"]>
-    remove(id:ODValidId): ODContextMenuResponder<"context-menu",any>|null
-    
-    remove(id:ODValidId): ODContextMenuResponder<"context-menu",any>|null {
-        return super.remove(id)
-    }
-
-    exists(id:keyof ODNoGeneric<IdList>): boolean
-    exists(id:ODValidId): boolean
-    
-    exists(id:ODValidId): boolean {
-        return super.exists(id)
-    }
-}
-
-/**## ODContextMenuResponderInstance `class`
- * This is an Open Discord context menu responder instance.
- * 
- * An instance is an active context menu interaction. You can reply to the context menu using `reply()`.
- */
-export class ODContextMenuResponderInstance extends ODBaseResponderInstance {
-    /**The interaction which is the source of this instance. */
-    interaction: discord.ContextMenuCommandInteraction
-    /**Switches to `true` when a worker replies, edits or defers interaction. Will stop the timeout error from being shown. */
-    protected ignoreResponderTimeout: boolean = false
-    /**The context menu wich is the source of this instance. */
-    menu:ODContextMenu
-    /**The user who triggered this context menu. */
-    user: discord.User
-    /**The guild member who triggered this context menu. */
-    member: discord.GuildMember|null
-    /**The guild where this context menu was triggered. */
-    guild: discord.Guild|null
-    /**The channel where this context menu was triggered. */
-    channel: discord.TextBasedChannel
-    /**The target of this context menu (user or message). */
-    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
-        this.user = interaction.user
-        this.member = (interaction.member instanceof discord.GuildMember) ? interaction.member : null
-        this.guild = interaction.guild
-        this.channel = interaction.channel
-        if (interaction.isMessageContextMenuCommand()) this.target = interaction.targetMessage
-        else if (interaction.isUserContextMenuCommand()) this.target = interaction.targetUser
-        else throw new ODSystemError("ODContextMenuResponderInstance: Invalid context menu type. Should be of the type User/Message!")
-        
-        setTimeout(async () => {
-            if (this.ignoreResponderTimeout) return
-            try {
-                if (!errorCallback){
-                    this.reply({id:new ODId("opendiscord:unknown-error"), ephemeral:true, message:{
-                        content:":x: **Something went wrong while replying to this context menu!**"
-                    }})
-                }else{
-                    await errorCallback(this,"context-menu")
-                }
-                
-            }catch(err){
-                process.emit("uncaughtException",err)
-            }
-        },timeoutMs ?? 2500)
-    }
-
-    /**Reply to this context menu. */
-    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(finalMessage)
-                this.ignoreResponderTimeout = true
-                return {success:true,message:sent,ephemeral:build.ephemeral}
-            }else{
-                const sent = await this.interaction.reply(finalMessage)
-                this.ignoreResponderTimeout = true
-                return {success:true,message:await sent.fetch(),ephemeral:build.ephemeral}
-            }
-        }catch{
-            return {success:false}
-        }
-    }
-    /**Update the message of this context menu. */
-    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(finalMessage)
-                this.ignoreResponderTimeout = true
-                return {success:true,message:await sent.fetch(),ephemeral:build.ephemeral}
-            }else throw new ODSystemError("Unable to update context menu interaction!")
-        }catch{
-            return {success:false}
-        }
-    }
-    /**Defer this context menu. */
-    async defer(type:"reply", ephemeral:boolean){
-        this.ignoreResponderTimeout = true
-        if (this.interaction.deferred || this.interaction.replied) return false
-        if (type == "reply"){
-            const msgFlags: number[] = ephemeral ? [discord.MessageFlags.Ephemeral] : []
-            await this.interaction.deferReply({flags:msgFlags})
-        }
-        return true
-    }
-    /**Show a modal as reply to this context menu. */
-    async modal(modal:ODModalBuildResult){
-        this.ignoreResponderTimeout = true
-        if (this.interaction.deferred || this.interaction.replied) return false
-        await this.interaction.showModal(modal.modal)
-        return true
-    }
-}
-
-/**## ODContextMenuResponder `class`
- * This is an Open Discord context menu responder.
- * 
- * This class manages all workers which are executed when the related context menu is triggered.
- */
-export class ODContextMenuResponder<Origin extends string,Params,WorkerIds extends string = string> extends ODResponderImplementation<ODContextMenuResponderInstance,Origin,Params,WorkerIds> {
-    /**Respond to this button */
-    async respond(instance:ODContextMenuResponderInstance, origin:Origin, params:Params){
-        //wait for workers to finish
-        await this.workers.executeWorkers(instance,origin,params)
-    }
-}
-
-/**## ODAutocompleteResponderManagerIdConstraint `type`
- * The constraint/layout for id mappings/interfaces of the `ODAutocompleteResponderManager` class.
- */
-export type ODAutocompleteResponderManagerIdConstraint = Record<string,{origin:"autocomplete",params:object,workers:string}>
-
-/**## ODAutocompleteResponderManager `class`
- * This is an Open Discord autocomplete responder manager.
- * 
- * It contains all Open Discord autocomplete responders. These can respond to autocomplete interactions.
- * 
- * Using the Open Discord responder system has a few advantages compared to vanilla discord.js:
- * - plugins can extend/edit replies
- * - automatically reply on error
- * - independent workers (with priority)
- * - fail-safe design using try-catch
- * - know where the request came from!
- * - And so much more!
- */
-export class ODAutocompleteResponderManager<IdList extends ODAutocompleteResponderManagerIdConstraint = ODAutocompleteResponderManagerIdConstraint> extends ODManager<ODAutocompleteResponder<"autocomplete",any>> {
-    /**An alias to the Open Discord client manager. */
-    private client: ODClientManager
-    /**The callback executed when the default workers take too much time to reply. */
-    private timeoutErrorCallback: ODResponderTimeoutErrorCallback<ODAutocompleteResponderInstance,"autocomplete">|null = null
-    /**The amount of milliseconds before the timeout error callback is executed. */
-    private timeoutMs: number|null = null
-
-    constructor(debug:ODDebugger, debugname:string, client:ODClientManager){
-        super(debug,debugname)
-        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
-    }
-
-    add(data:ODAutocompleteResponder<"autocomplete",any>, overwrite?:boolean){
-        const res = super.add(data,overwrite)
-        
-        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",{})
-        })
-
-        return res
-    }
-
-    get<AutocompleteResponderId extends keyof ODNoGeneric<IdList>>(id:AutocompleteResponderId): ODAutocompleteResponder<IdList[AutocompleteResponderId]["origin"],IdList[AutocompleteResponderId]["params"],IdList[AutocompleteResponderId]["workers"]>
-    get(id:ODValidId): ODAutocompleteResponder<"autocomplete",any>|null
-    
-    get(id:ODValidId): ODAutocompleteResponder<"autocomplete",any>|null {
-        return super.get(id)
-    }
-
-    remove<AutocompleteResponderId extends keyof ODNoGeneric<IdList>>(id:AutocompleteResponderId): ODAutocompleteResponder<IdList[AutocompleteResponderId]["origin"],IdList[AutocompleteResponderId]["params"],IdList[AutocompleteResponderId]["workers"]>
-    remove(id:ODValidId): ODAutocompleteResponder<"autocomplete",any>|null
-    
-    remove(id:ODValidId): ODAutocompleteResponder<"autocomplete",any>|null {
-        return super.remove(id)
-    }
-
-    exists(id:keyof ODNoGeneric<IdList>): boolean
-    exists(id:ODValidId): boolean
-    
-    exists(id:ODValidId): boolean {
-        return super.exists(id)
-    }
-}
-
-/**## ODAutocompleteResponderInstance `class`
- * This is an Open Discord autocomplete responder instance.
- * 
- * An instance is an active autocomplete interaction. You can reply to the autocomplete using `reply()`.
- */
-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? */
-    didRespond: boolean = false
-    /**The user who triggered this autocomplete. */
-    user: discord.User
-    /**The guild member who triggered this autocomplete. */
-    member: discord.GuildMember|null
-    /**The guild where this autocomplete was triggered. */
-    guild: discord.Guild|null
-    /**The channel where this autocomplete was triggered. */
-    channel: discord.TextBasedChannel
-    /**The target slash command option of this autocomplete. */
-    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
-        this.member = (interaction.member instanceof discord.GuildMember) ? interaction.member : null
-        this.guild = interaction.guild
-        this.channel = interaction.channel
-        this.target = interaction.options.getFocused(true)
-        
-        setTimeout(async () => {
-            if (!this.didRespond){
-                process.emit("uncaughtException",new ODSystemError("Autocomplete responder instance failed to respond within 2.5sec!"))
-            }
-        },timeoutMs ?? 2500)
-    }
-
-    /**Reply to this autocomplete. */
-    async autocomplete(choices:(string|discord.ApplicationCommandOptionChoiceData)[]): Promise<{success:boolean}> {
-        const newChoices: (discord.ApplicationCommandOptionChoiceData)[] = choices.map((raw) => {
-            if (typeof raw == "string") return {name:raw,value:raw}
-            else return raw
-        })
-        
-        try{
-            if (this.interaction.responded){
-                return {success:false}
-            }else{
-                await this.interaction.respond(newChoices)
-                this.didRespond = true
-                return {success:true}
-            }
-        }catch(err){
-            process.emit("uncaughtException",err)
-            return {success:false}
-        }
-    }
-    /**Reply to this autocomplete, but filter choices based on the input of the user. */
-    async filteredAutocomplete(choices:(string|discord.ApplicationCommandOptionChoiceData)[]): Promise<{success:boolean}> {
-        const newChoices: (discord.ApplicationCommandOptionChoiceData)[] = choices.map((raw) => {
-            if (typeof raw == "string") return {name:raw,value:raw}
-            else return raw
-        })
-
-        const filteredChoices = newChoices.filter((choice) => choice.name.startsWith(this.target.value) || choice.value.toString().startsWith(this.target.value)).slice(0,25)
-        return await this.autocomplete(filteredChoices)
-    }
-}
-
-/**## ODAutocompleteResponder `class`
- * This is an Open Discord autocomplete responder.
- * 
- * This class manages all workers which are executed when the related autocomplete is triggered.
- */
-export class ODAutocompleteResponder<Origin extends string,Params,WorkerIds extends string = string> extends ODResponderImplementation<ODAutocompleteResponderInstance,Origin,Params,WorkerIds> {
-    /**The slash command of the autocomplete should match the following regex. */
-    cmdMatch: string|RegExp
-    
-    constructor(id:ODValidId,cmdMatch:string|RegExp,match:string|RegExp,callback?:ODWorkerCallback<ODAutocompleteResponderInstance,Origin,Params>,priority?:number,callbackId?:ODValidId){
-        super(id,match,callback,priority,callbackId)
-        this.cmdMatch = cmdMatch
-    }
-    
-    /**Respond to this autocomplete interaction. */
-    async respond(instance:ODAutocompleteResponderInstance, origin:Origin, params:Params){
-        //wait for workers to finish
-        await this.workers.executeWorkers(instance,origin,params)
-    }
-}